* Rename inputArgument => nbInputArgument (idem for output). See bug #11066. 29/7129/3
Sylvestre Ledru [Sun, 29 Apr 2012 08:41:36 +0000 (10:41 +0200)]
* rename updatestack => ReturnArguments to get ride of the stack word
(discussed with Antoine)
* Update the gateway to use Scilab 5.4.0 code / api
* Update the help to show a latex examples

Change-Id: Icd60920263dd66c5b3aa2895d8c9fe0293b1a263

80 files changed:
scilab/contrib/Makefile.in
scilab/contrib/toolbox_skeleton/sci_gateway/c/sci_csub.c
scilab/contrib/toolbox_skeleton/sci_gateway/c/sci_csum.c
scilab/contrib/toolbox_skeleton/sci_gateway/c/sci_multiplybypi.c
scilab/contrib/toolbox_skeleton/sci_gateway/cpp/sci_cpp_find.cxx
scilab/contrib/toolbox_skeleton/sci_gateway/fortran/sci_fsum.c
scilab/contrib/xcos_toolbox_skeleton/DESCRIPTION
scilab/contrib/xcos_toolbox_skeleton/demos/xcos_toolbox_skeleton.dem.gateway.sce
scilab/contrib/xcos_toolbox_skeleton/macros/TBX_MUT_STYLE.sci
scilab/contrib/xcos_toolbox_skeleton/macros/TBX_SUM_c.sci
scilab/contrib/xcos_toolbox_skeleton/macros/cleanmacros.sce
scilab/contrib/xcos_toolbox_skeleton/sci_gateway/c/sci_tbx_sum.c
scilab/contrib/xcos_toolbox_skeleton/src/c/block_sum.c
scilab/contrib/xcos_toolbox_skeleton/src/c/business.h
scilab/contrib/xcos_toolbox_skeleton/src/c/business_sum.c
scilab/modules/api_scilab/Makefile.in
scilab/modules/api_scilab/help/en_US/boolean/D_booleanExample.xml
scilab/modules/api_scilab/help/en_US/boolean_sparse/D_booleanSparseExample.xml
scilab/modules/api_scilab/help/en_US/double/F_doubleExample.xml
scilab/modules/api_scilab/help/en_US/integer/D_integerExample.xml
scilab/modules/api_scilab/help/en_US/list_management/list_boolean_writing_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_bsparse_writing_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_createlist_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_double_writing_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_integer_writing_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_pointer_writing_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_poly_writing_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_sparse_writing_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_string_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/AssignOutputVariable.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/OutputArgument.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/UpdateStack.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/boolean_reading_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/boolean_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/bsparse_reading_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/bsparse_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/common_getvaraddr_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/common_getvardimension_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/common_getvartype_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/common_iscomplex_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/common_isvarmatrixtype_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/double_reading_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/double_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/int_getmatrixofintegerprecision_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/integer_reading_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/integer_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/pointer_reading_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/pointer_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/poly_getpolyvariablename_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/poly_reading_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/poly_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/sparse_writing_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/string_reading_api.xml
scilab/modules/api_scilab/help/en_US/low_level_functions/string_writing_api.xml
scilab/modules/api_scilab/help/en_US/polynomial/J_polyExample.xml
scilab/modules/api_scilab/help/en_US/sparse/F_sparseExample.xml
scilab/modules/api_scilab/help/en_US/string/G_stringExample.xml
scilab/modules/api_scilab/includes/api_common.h
scilab/modules/api_scilab/includes/api_scilab.h
scilab/modules/api_scilab/src/cpp/api_common.cpp
scilab/modules/api_scilab/tests/unit_tests/booleanExample.c
scilab/modules/api_scilab/tests/unit_tests/booleanSparseExample.c
scilab/modules/api_scilab/tests/unit_tests/common_function_api.c
scilab/modules/api_scilab/tests/unit_tests/doubleExample.c
scilab/modules/api_scilab/tests/unit_tests/double_reading_api.c
scilab/modules/api_scilab/tests/unit_tests/double_writing_api.c
scilab/modules/api_scilab/tests/unit_tests/integer_reading_api.c
scilab/modules/api_scilab/tests/unit_tests/integer_writing_api.c
scilab/modules/api_scilab/tests/unit_tests/list_createlist_api.c
scilab/modules/api_scilab/tests/unit_tests/pointer_reading_api.c
scilab/modules/api_scilab/tests/unit_tests/polyExample.c
scilab/modules/api_scilab/tests/unit_tests/poly_reading_api.c
scilab/modules/api_scilab/tests/unit_tests/poly_writing_api.c
scilab/modules/api_scilab/tests/unit_tests/read_write_boolean_api.c
scilab/modules/api_scilab/tests/unit_tests/read_write_bsparse_api.c
scilab/modules/api_scilab/tests/unit_tests/sparseExample.c
scilab/modules/api_scilab/tests/unit_tests/sparse_writing_api.c
scilab/modules/api_scilab/tests/unit_tests/stringExample.c
scilab/modules/api_scilab/tests/unit_tests/string_reading_api.c
scilab/modules/api_scilab/tests/unit_tests/string_writing_api.c

index cb92bf8..b8c09ef 100644 (file)
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.11.3 from Makefile.am.
+# Makefile.in generated by automake 1.11.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
 
 # Install the contrib_skeleton directory (the template)
 VPATH = @srcdir@
+am__make_dryrun = \
+  { \
+    am__dry=no; \
+    case $$MAKEFLAGS in \
+      *\\[\ \  ]*) \
+        echo 'am--echo: ; @echo "AM"  OK' | $(MAKE) -f - 2>/dev/null \
+          | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
+      *) \
+        for am__flg in $$MAKEFLAGS; do \
+          case $$am__flg in \
+            *=*|--*) ;; \
+            *n*) am__dry=yes; break;; \
+          esac; \
+        done;; \
+    esac; \
+    test $$am__dry = yes; \
+  }
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
@@ -67,6 +84,11 @@ CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
 SOURCES =
 DIST_SOURCES =
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 ALL_LINGUAS = @ALL_LINGUAS@
index 228f266..49bea13 100644 (file)
@@ -105,17 +105,11 @@ int sci_csub(char *fname)
     /* create result on stack */
     m_out = 1;
     n_out = 1;
-    createMatrixOfDouble(pvApiCtx, InputArgument + 1, m_out, n_out, &dOut);
+    createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, m_out, n_out, &dOut);
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
 
-
-    /* This function put on scilab stack, the lhs variable
-    which are at the position lhs(i) on calling stack */
-    /* You need to add UpdateStack here because WITHOUT_ADD_PUTLHSVAR
-    was defined and equal to %t */
-    /* without this, you do not need to add UpdateStack here */
-    UpdateStack();
+    ReturnArguments();
 
     return 0;
 }
index 3fe6b09..c6aa3ce 100644 (file)
@@ -69,16 +69,11 @@ int sci_csum(char *fname)
     csum(&dVarOne, &dVarTwo, &dOut);
 
     /* create result on stack */
-    createScalarDouble(pvApiCtx, InputArgument + 1, dOut);
+    createScalarDouble(pvApiCtx, nbInputArgument + 1, dOut);
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
 
-    /* This function put on scilab stack, the lhs variable
-    which are at the position lhs(i) on calling stack */
-    /* You need to add UpdateStack here because WITHOUT_ADD_PUTLHSVAR
-    was defined and equal to %t */
-    /* without this, you do not need to add UpdateStack here */
-    UpdateStack();
+    ReturnArguments();
 
     return 0;
 }
index 3ee3cf1..63f8a22 100644 (file)
@@ -64,21 +64,16 @@ int sci_multiplybypi(char *fname)
     }
 
     /* Create the matrix as return of the function */
-    createMatrixOfDouble(pvApiCtx, InputArgument + 1, m1, n1, matrixOfDouble);
+    createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, m1, n1, matrixOfDouble);
     if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
 
-    /* This function put on scilab stack, the lhs variable
-    which are at the position lhs(i) on calling stack */
-    /* You need to add UpdateStack here because WITHOUT_ADD_PUTLHSVAR
-    was defined and equal to %t */
-    /* without this, you do not need to add UpdateStack here */
-    UpdateStack();
+    ReturnArguments();
 
     return 0;
 }
index b0b4d04..28fe0b7 100644 (file)
@@ -152,9 +152,9 @@ extern "C"
     int m_out = 1;
     int n_out = 1;
     
-    createMatrixOfDouble(pvApiCtx, InputArgument + 1, m_out, n_out, &dOut);
+    createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, m_out, n_out, &dOut);
     
-    AssignOutputVariable(1) = InputArgument + 1; 
+    AssignOutputVariable(1) = nbInputArgument + 1; 
 
     return 0;
        }
index 337103d..388d2cc 100644 (file)
@@ -106,13 +106,13 @@ int sci_fsum(char *fname)
     /* create result on stack */
     m_out = 1;
     n_out = 1;
-    sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, m_out, n_out, &dOut);
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, m_out, n_out, &dOut);
     if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
 
     return 0;
 }
index 99e45b4..a377330 100644 (file)
@@ -6,19 +6,19 @@ Summary: Add some blocks to a palette
 
 Version: 1.0
 
-Author: Clément DAVID <clement.david@scilab.org>
+Author: Clément DAVID <clement.david@scilab-enterprises.com>
 
-Maintainer: Clément DAVID <clement.david@scilab.org>
+Maintainer: Clément DAVID <clement.david@scilab-enterprises.com>
 
 Category: Xcos
 
-Entity: Digiteo
+Entity: Scilab Enterprises
 
 WebSite: http://www.scilab.org
 
 License: CeCILL
 
-ScilabVersion: >= 5.3
+ScilabVersion: >= 5.4
 
 Depends: 
 
index dad46e2..2375a99 100644 (file)
@@ -1,8 +1,7 @@
 //
 // This file is part of the Xcos skeleton toolbox
 //
-// Copyright (C) 2011 - Scilab Enterprises - Clément DAVID
-// see license.txt for more licensing informations
+// see license.txt for more licensing information
 
 function [x,y,typ]=TBX_MUT_STYLE(job,arg1,arg2)
   x=[];y=[];typ=[]
index 4816244..d20a137 100644 (file)
@@ -1,8 +1,7 @@
 //
 // This file is part of the Xcos skeleton toolbox
 //
-// Copyright (C) 2011 - DIGITEO - Clément DAVID <clement.david@scilab.org>
-// see license.txt for more licensing informations
+// see license.txt for more licensing information
 
 function [x,y,typ]=TBX_SUM_c(job,arg1,arg2)
   x=[];y=[];typ=[]
index 5e62104..e8d1150 100644 (file)
@@ -1,6 +1,4 @@
 // ====================================================================
-// Allan CORNET
-// DIGITEO 2009-2011
 // This file is released under the 3-clause BSD license. See COPYING-BSD.
 // ====================================================================
 function cleanmacros()
index dc5bd6a..95676fd 100644 (file)
@@ -1,81 +1,70 @@
-/*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2011-2011 - DIGITEO - Clément DAVID
- *
- *  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
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+/* This file is released under the 3-clause BSD license. See COPYING-BSD. */
 
 #include "business.h"
-
 #include "api_scilab.h"
 #include "Scierror.h"
 
-int sci_tbx_sum(char *fname) {
-  SciErr sciErr;
-  
-  int *piAddressVarOne = NULL;
-  double dVarOne = 0.0;
-  
-  int *piAddressVarTwo = NULL;
-  double dVarTwo = 0.0;
-  
-  double dOut = 0.0;
-  
-  /* check that we have only 2 input arguments */
-  /* check that we have only 1 output argument */
-  CheckRhs(2,2);
-  CheckLhs(1,1);
-  
+int sci_tbx_sum(char *fname)
+{
+    SciErr sciErr;
+
+    int *piAddressVarOne = NULL;
+    double dVarOne = 0.0;
+
+    int *piAddressVarTwo = NULL;
+    double dVarTwo = 0.0;
+
+    double dOut = 0.0;
+
+    /* check that we have only 2 input arguments */
+    /* check that we have only 1 output argument */
+    CheckInputArgument(pvApiCtx, 2, 2);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
     /* get Address of inputs */
-  sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
-  if(sciErr.iErr)
-  {
-    printError(&sciErr, 0);
-    return 0;
-  }
-  
-  sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
-  if(sciErr.iErr)
-  {
-    printError(&sciErr, 0);
-    return 0;
-  }
-  
-  /* check input type */
-  if ( !isDoubleType(pvApiCtx, piAddressVarOne) )
-  {
-    Scierror(999,"%s: Wrong type for input argument #%d: A scalar expected.\n", fname, 1);
-    return 0;
-  }
-  
-  if ( !isDoubleType(pvApiCtx, piAddressVarTwo) )
-  {
-    Scierror(999,"%s: Wrong type for input argument #%d: A scalar expected.\n", fname, 2);
-    return 0;
-  }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    /* check input type */
+    if ( !isDoubleType(pvApiCtx, piAddressVarOne) )
+    {
+        Scierror(999, "%s: Wrong type for input argument #%d: A scalar expected.\n", fname, 1);
+        return 0;
+    }
+
+    if ( !isDoubleType(pvApiCtx, piAddressVarTwo) )
+    {
+        Scierror(999, "%s: Wrong type for input argument #%d: A scalar expected.\n", fname, 2);
+        return 0;
+    }
+
+    if ( getScalarDouble(pvApiCtx, piAddressVarOne, &dVarOne) )
+    {
+        Scierror(999, "%s: Wrong size for input argument #%d: A scalar expected.\n", fname, 1);
+        return 0;
+    }
+
+    if ( getScalarDouble(pvApiCtx, piAddressVarTwo, &dVarTwo) )
+    {
+        Scierror(999, "%s: Wrong size for input argument #%d: A scalar expected.\n", fname, 2);
+        return 0;
+    }
 
-  if ( getScalarDouble(pvApiCtx, piAddressVarOne, &dVarOne) )
-  {
-    Scierror(999,"%s: Wrong size for input argument #%d: A scalar expected.\n", fname, 1);
-    return 0;
-  }
+    /* call c business function */
+    dOut = business_sum(dVarOne, dVarTwo);
 
-  if ( getScalarDouble(pvApiCtx, piAddressVarTwo, &dVarTwo) )
-  {
-    Scierror(999,"%s: Wrong size for input argument #%d: A scalar expected.\n", fname, 2);
-    return 0;
-  }
-  
-  /* call c business function */  
-  dOut = business_sum(dVarOne, dVarTwo);
-  
-  /* create result on stack */
-  createScalarDouble(pvApiCtx, Rhs + 1, dOut);
-  LhsVar(1) = Rhs + 1; 
+    createScalarDouble(pvApiCtx, nbInputArgument + 1, dOut);
+    AssignOutputVariable(1) = nbInputArgument + 1;
 }
 
index 06c629a..e1e9cdb 100644 (file)
@@ -1,31 +1,23 @@
-/*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2011-2011 - DIGITEO - Clément DAVID
- *
- *  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
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+/* This file is released under the 3-clause BSD license. See COPYING-BSD. */
 
 #include <business.h>
 #include <scicos_block4.h>
 
-void block_sum(scicos_block* block, scicos_flag flag) {
+void block_sum(scicos_block* block, scicos_flag flag)
+{
     double* y;
     double* u1;
     double* u2;
-    
-    if (flag == OutputUpdate) {
+
+    if (flag == OutputUpdate)
+    {
         // output
         y = (double *) block->outptr[0];
-        
+
         // input are indexed in order
         u1 = (double *) block->inptr[0];
         u2 = (double *) block->inptr[1];
-        
+
         // call business layer
         *y = business_sum(*u1, *u2);
     }
index a12b4b2..698c9a3 100644 (file)
@@ -1,14 +1,4 @@
-/*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2011-2011 - DIGITEO - Clément DAVID
- *
- *  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
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+/* This file is released under the 3-clause BSD license. See COPYING-BSD. */
 
 /**
  * @return in1 + in2
index e01b721..b0f01e7 100644 (file)
@@ -1,16 +1,7 @@
-/*
- *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- *  Copyright (C) 2011-2011 - DIGITEO - Clément DAVID
- *
- *  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
- *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+/* This file is released under the 3-clause BSD license. See COPYING-BSD. */
 
-double business_sum(double in, double in2) {
+double business_sum(double in, double in2)
+{
     return in + in2;
 }
 
index 7a2ee65..cbbe898 100644 (file)
@@ -1,4 +1,4 @@
-# Makefile.in generated by automake 1.11.3 from Makefile.am.
+# Makefile.in generated by automake 1.11.5 from Makefile.am.
 # @configure_input@
 
 # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
 
 
 VPATH = @srcdir@
+am__make_dryrun = \
+  { \
+    am__dry=no; \
+    case $$MAKEFLAGS in \
+      *\\[\ \  ]*) \
+        echo 'am--echo: ; @echo "AM"  OK' | $(MAKE) -f - 2>/dev/null \
+          | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
+      *) \
+        for am__flg in $$MAKEFLAGS; do \
+          case $$am__flg in \
+            *=*|--*) ;; \
+            *n*) am__dry=yes; break;; \
+          esac; \
+        done;; \
+    esac; \
+    test $$am__dry = yes; \
+  }
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
@@ -153,6 +170,11 @@ CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
        $(LDFLAGS) -o $@
 SOURCES = $(libsciapi_scilab_la_SOURCES)
 DIST_SOURCES = $(libsciapi_scilab_la_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
 DATA = $(libsciapi_scilab_la_etc_DATA) \
        $(libsciapi_scilab_la_root_DATA)
 HEADERS = $(libsciapi_scilab_la_include_HEADERS)
@@ -585,7 +607,6 @@ clean-noinstLTLIBRARIES:
        done
 install-pkglibLTLIBRARIES: $(pkglib_LTLIBRARIES)
        @$(NORMAL_INSTALL)
-       test -z "$(pkglibdir)" || $(MKDIR_P) "$(DESTDIR)$(pkglibdir)"
        @list='$(pkglib_LTLIBRARIES)'; test -n "$(pkglibdir)" || list=; \
        list2=; for p in $$list; do \
          if test -f $$p; then \
@@ -593,6 +614,8 @@ install-pkglibLTLIBRARIES: $(pkglib_LTLIBRARIES)
          else :; fi; \
        done; \
        test -z "$$list2" || { \
+         echo " $(MKDIR_P) '$(DESTDIR)$(pkglibdir)'"; \
+         $(MKDIR_P) "$(DESTDIR)$(pkglibdir)" || exit 1; \
          echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(pkglibdir)'"; \
          $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(pkglibdir)"; \
        }
@@ -740,8 +763,11 @@ clean-libtool:
        -rm -rf .libs _libs
 install-libsciapi_scilab_la_etcDATA: $(libsciapi_scilab_la_etc_DATA)
        @$(NORMAL_INSTALL)
-       test -z "$(libsciapi_scilab_la_etcdir)" || $(MKDIR_P) "$(DESTDIR)$(libsciapi_scilab_la_etcdir)"
        @list='$(libsciapi_scilab_la_etc_DATA)'; test -n "$(libsciapi_scilab_la_etcdir)" || list=; \
+       if test -n "$$list"; then \
+         echo " $(MKDIR_P) '$(DESTDIR)$(libsciapi_scilab_la_etcdir)'"; \
+         $(MKDIR_P) "$(DESTDIR)$(libsciapi_scilab_la_etcdir)" || exit 1; \
+       fi; \
        for p in $$list; do \
          if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
          echo "$$d$$p"; \
@@ -758,8 +784,11 @@ uninstall-libsciapi_scilab_la_etcDATA:
        dir='$(DESTDIR)$(libsciapi_scilab_la_etcdir)'; $(am__uninstall_files_from_dir)
 install-libsciapi_scilab_la_rootDATA: $(libsciapi_scilab_la_root_DATA)
        @$(NORMAL_INSTALL)
-       test -z "$(libsciapi_scilab_la_rootdir)" || $(MKDIR_P) "$(DESTDIR)$(libsciapi_scilab_la_rootdir)"
        @list='$(libsciapi_scilab_la_root_DATA)'; test -n "$(libsciapi_scilab_la_rootdir)" || list=; \
+       if test -n "$$list"; then \
+         echo " $(MKDIR_P) '$(DESTDIR)$(libsciapi_scilab_la_rootdir)'"; \
+         $(MKDIR_P) "$(DESTDIR)$(libsciapi_scilab_la_rootdir)" || exit 1; \
+       fi; \
        for p in $$list; do \
          if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
          echo "$$d$$p"; \
@@ -776,8 +805,11 @@ uninstall-libsciapi_scilab_la_rootDATA:
        dir='$(DESTDIR)$(libsciapi_scilab_la_rootdir)'; $(am__uninstall_files_from_dir)
 install-libsciapi_scilab_la_includeHEADERS: $(libsciapi_scilab_la_include_HEADERS)
        @$(NORMAL_INSTALL)
-       test -z "$(libsciapi_scilab_la_includedir)" || $(MKDIR_P) "$(DESTDIR)$(libsciapi_scilab_la_includedir)"
        @list='$(libsciapi_scilab_la_include_HEADERS)'; test -n "$(libsciapi_scilab_la_includedir)" || list=; \
+       if test -n "$$list"; then \
+         echo " $(MKDIR_P) '$(DESTDIR)$(libsciapi_scilab_la_includedir)'"; \
+         $(MKDIR_P) "$(DESTDIR)$(libsciapi_scilab_la_includedir)" || exit 1; \
+       fi; \
        for p in $$list; do \
          if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
          echo "$$d$$p"; \
index 2c3de44..e556b92 100644 (file)
@@ -57,7 +57,7 @@ int booleanExample(char *fname,unsigned long fname_len)
             {
                 return 0;
             }
-            iRet = createScalarBoolean(pvApiCtx, InputArgument + 1, iBool);
+            iRet = createScalarBoolean(pvApiCtx, nbInputArgument + 1, iBool);
             if(iRet)
             {
                 return 0;
@@ -76,14 +76,14 @@ int booleanExample(char *fname,unsigned long fname_len)
                 return 0;
             }
 
-            sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, iRows, iCols, piBool);
+            sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
             if(sciErr.iErr)
             {
                 printError(&sciErr, 0);
                 return 0;
             }
         }
-        AssignOutputVariable(1) = InputArgument + 1;
+        AssignOutputVariable(1) = nbInputArgument + 1;
     }
     else
     {
index 0365b6d..4198e70 100644 (file)
@@ -63,7 +63,7 @@ int booleanSparseExample(char *fname,unsigned long fname_len)
                        return iRet;
                }
 
-               sciErr = createBooleanSparseMatrix(pvApiCtx, InputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos);
+               sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos);
                if(sciErr.iErr)
                {
                        freeAllocatedBooleanSparse(piNbItemRow, piColPos);
@@ -72,7 +72,7 @@ int booleanSparseExample(char *fname,unsigned long fname_len)
                }
 
                freeAllocatedBooleanSparse(piNbItemRow, piColPos);
-               AssignOutputVariable(1) = InputArgument + 1;
+               AssignOutputVariable(1) = nbInputArgument + 1;
        }
        return 0;
 }
index be642c9..d51a508 100644 (file)
@@ -50,7 +50,7 @@ int doubleExample(char *fname,unsigned long fname_len)
 
        if(isEmptyMatrix(pvApiCtx, piAddr))
        {
-               iRet = createEmptyMatrix(pvApiCtx, InputArgument + 1);
+               iRet = createEmptyMatrix(pvApiCtx, nbInputArgument + 1);
                if(iRet)
                {
                        return iRet;
@@ -73,7 +73,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarComplexDouble(pvApiCtx, InputArgument + 1, dblReal, dblImg);
+                               iRet = createScalarComplexDouble(pvApiCtx, nbInputArgument + 1, dblReal, dblImg);
                                if(iRet)
                                {
                                        return iRet;
@@ -87,7 +87,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarDouble(pvApiCtx, InputArgument + 1, dblReal);
+                               iRet = createScalarDouble(pvApiCtx, nbInputArgument + 1, dblReal);
                                if(iRet)
                                {
                                        return iRet;
@@ -110,7 +110,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createComplexMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblReal, pdblImg);
+                               sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal, pdblImg);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -126,7 +126,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblReal);
+                               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -135,7 +135,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                        }
                }
 
-        AssignOutputVariable(1) = InputArgument + 1;
+        AssignOutputVariable(1) = nbInputArgument + 1;
        }
 
        return 0;
index a010785..8f1e290 100644 (file)
@@ -71,7 +71,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarInteger8(pvApiCtx, InputArgument + 1, cData);
+                               iRet = createScalarInteger8(pvApiCtx, nbInputArgument + 1, cData);
                                if(iRet)
                                {
                                        return iRet;
@@ -90,7 +90,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfInteger8(pvApiCtx, InputArgument + 1, iRows, iCols, pcData);
+                               sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument + 1, iRows, iCols, pcData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -108,7 +108,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarInteger16(pvApiCtx, InputArgument + 1, sData);
+                               iRet = createScalarInteger16(pvApiCtx, nbInputArgument + 1, sData);
                                if(iRet)
                                {
                                        return iRet;
@@ -127,7 +127,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfInteger16(pvApiCtx, InputArgument + 1, iRows, iCols, psData);
+                               sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 1, iRows, iCols, psData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -145,7 +145,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarInteger32(pvApiCtx, InputArgument + 1, iData);
+                               iRet = createScalarInteger32(pvApiCtx, nbInputArgument + 1, iData);
                                if(iRet)
                                {
                                        return iRet;
@@ -164,7 +164,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 1, iRows, iCols, piData);
+                               sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 1, iRows, iCols, piData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -185,7 +185,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarUnsignedInteger8(pvApiCtx, InputArgument + 1, ucData);
+                               iRet = createScalarUnsignedInteger8(pvApiCtx, nbInputArgument + 1, ucData);
                                if(iRet)
                                {
                                        return iRet;
@@ -204,7 +204,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, InputArgument + 1, iRows, iCols, pucData);
+                               sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 1, iRows, iCols, pucData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -223,7 +223,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarUnsignedInteger16(pvApiCtx, InputArgument + 1, usData);
+                               iRet = createScalarUnsignedInteger16(pvApiCtx, nbInputArgument + 1, usData);
                                if(iRet)
                                {
                                        return iRet;
@@ -242,7 +242,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, InputArgument + 1, iRows, iCols, pusData);
+                               sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 1, iRows, iCols, pusData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -260,7 +260,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarUnsignedInteger32(pvApiCtx, InputArgument + 1, uiData);
+                               iRet = createScalarUnsignedInteger32(pvApiCtx, nbInputArgument + 1, uiData);
                                if(iRet)
                                {
                                        return iRet;
@@ -279,7 +279,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, InputArgument + 1, iRows, iCols, puiData);
+                               sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 1, iRows, iCols, puiData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -296,7 +296,7 @@ int integerExample(char *fname,unsigned long fname_len)
                }
        }
     
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 7c9c85e..70670ff 100644 (file)
@@ -219,54 +219,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -274,21 +274,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -301,14 +301,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 6afcbd8..48366f0 100644 (file)
@@ -155,54 +155,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -210,21 +210,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -237,14 +237,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index b30261e..4a9a154 100644 (file)
@@ -119,54 +119,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -174,21 +174,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -201,14 +201,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 5004470..346a4f3 100644 (file)
@@ -237,54 +237,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -292,21 +292,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -319,14 +319,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 42f150a..1d2bef3 100644 (file)
@@ -241,54 +241,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -296,21 +296,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -323,14 +323,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index bddb3e0..684a71f 100644 (file)
@@ -122,54 +122,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -177,21 +177,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -204,14 +204,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index f316a6f..aa286a1 100644 (file)
@@ -164,54 +164,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -219,21 +219,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -246,14 +246,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index c4de4c4..5caffac 100644 (file)
@@ -175,54 +175,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -230,21 +230,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -257,14 +257,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index df1155a..8a2b7f0 100644 (file)
@@ -138,54 +138,54 @@ int list_createlist(char *fname,unsigned long fname_len)
        int piBool[]            = {1,0,1,0,1,0,1,0,1};
        double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -193,21 +193,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -220,14 +220,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index d1e79a3..434be0c 100644 (file)
@@ -1,62 +1,62 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:id="AssignOutputVariable">
-    <refnamediv>
-        <refname>AssignOutputVariable</refname>
-        <refpurpose>
-            a C gateway function which specifies which parameters created
-            inside the C gateway will be returned as an output argument into
-            Scilab.
-        </refpurpose>
-    </refnamediv>
-    <refsynopsisdiv>
-        <title>Calling Sequence</title>
-        <synopsis>AssignOutputVariable(RankPos) = RankVar;</synopsis>
-    </refsynopsisdiv>
-    <refsection>
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>RankPos</term>
-                <listitem>
-                    <para>as integer providing the rank of the output argument</para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>RankVar</term>
-                <listitem>
-                    <para>
-                        the rank of the parameter created inside the C gateway to be
-                        returned as an Scilab output argument
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-    <refsection>
-        <title>Description</title>
-        <para>
-            A C gateway function which specifies which variables created inside
-            the C interface will be returned as an output argumen into Scilab.
-        </para>
-    </refsection>
-    <refsection>
-        <title>Examples</title>
-        <para>This example takes a matrix of doubles as input and returns:</para>
-        <itemizedlist>
-            <listitem>
-                <para>the number of lines (first output argument)</para>
-            </listitem>
-            <listitem>
-                <para>the number of rows (second output argument)</para>
-            </listitem>
-        </itemizedlist>
-        <para>
-            We create an intermediate Scilab parameter which will handle an
-            integer but will neither be used nor returned as an output
-            argument.
-        </para>
-        <programlisting role="example">
-            <![CDATA[
+  <refnamediv>
+    <refname>AssignOutputVariable</refname>
+    <refpurpose>
+      a C gateway function which specifies which parameters created
+      inside the C gateway will be returned as an output argument into
+      Scilab.
+    </refpurpose>
+  </refnamediv>
+  <refsynopsisdiv>
+    <title>Calling Sequence</title>
+    <synopsis>AssignOutputVariable(RankPos) = RankVar;</synopsis>
+  </refsynopsisdiv>
+  <refsection>
+    <title>Arguments</title>
+    <variablelist>
+      <varlistentry>
+        <term>RankPos</term>
+        <listitem>
+          <para>as integer providing the rank of the output argument</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>RankVar</term>
+        <listitem>
+          <para>
+            the rank of the parameter created inside the C gateway to be
+            returned as an Scilab output argument
+          </para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsection>
+  <refsection>
+    <title>Description</title>
+    <para>
+      A C gateway function which specifies which variables created inside
+      the C interface will be returned as an output argumen into Scilab.
+    </para>
+  </refsection>
+  <refsection>
+    <title>Examples</title>
+    <para>This example takes a matrix of doubles as input and returns:</para>
+    <itemizedlist>
+      <listitem>
+        <para>the number of lines (first output argument)</para>
+      </listitem>
+      <listitem>
+        <para>the number of rows (second output argument)</para>
+      </listitem>
+    </itemizedlist>
+    <para>
+      We create an intermediate Scilab parameter which will handle an
+      integer but will neither be used nor returned as an output
+      argument.
+    </para>
+    <programlisting role="example">
+      <![CDATA[
 #include "api_scilab.h"
 int sci_mysizedouble(char * fname, unsigned long fname_len)
 {
@@ -81,16 +81,16 @@ int sci_mysizedouble(char * fname, unsigned long fname_len)
                return 0;
        }
 
-    sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 1, 1, 1, &m_in_row); // the m_in_row parameter handles the number of lines of the matrix sent as argument
-    sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 2, 1, 1, &m_in_row); // store a same value, but will neither be used nor returned to Scilab
-    sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 3, 1, 1, &n_in_col); // the n_in_col parameter handles the number of columns of the matrix sent as argument
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 1, 1, 1, &m_in_row); // the m_in_row parameter handles the number of lines of the matrix sent as argument
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 2, 1, 1, &m_in_row); // store a same value, but will neither be used nor returned to Scilab
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 3, 1, 1, &n_in_col); // the n_in_col parameter handles the number of columns of the matrix sent as argument
 
-    AssignOutputVariable(1) = InputArgument + 1; // We set the parameter "InputArgument + 1" as an output argument
-    AssignOutputVariable(2) = InputArgument + 3; // We set the parameter "InputArgument + 3" as an output argument
-    UpdateStack();
+    AssignOutputVariable(1) = nbInputArgument + 1; // We set the parameter "nbInputArgument + 1" as an output argument
+    AssignOutputVariable(2) = nbInputArgument + 3; // We set the parameter "nbInputArgument + 3" as an output argument
+    ReturnArguments();
     return 0;
 }
  ]]>
-        </programlisting>
-    </refsection>
+    </programlisting>
+  </refsection>
 </refentry>
index ac8e059..d73331b 100644 (file)
@@ -1,48 +1,48 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:id="OutputArgument" xml:lang="en">
-    <refnamediv>
-        <refname>OutputArgument</refname>
-        <refpurpose>
-            A C gateway function which provides the number of output
-            arguments present in the calling Scilab function
-        </refpurpose>
-    </refnamediv>
-    <refsynopsisdiv>
-        <title>Calling Sequence</title>
-        <synopsis>nb_params = OutputArgument</synopsis>
-    </refsynopsisdiv>
-    <refsection>
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>nb_params</term>
-                <listitem>
-                    <para>
-                        the number of output arguments present in the calling Scilab
-                        function
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-    <refsection>
-        <title>Description</title>
-        <para>
-            OutputArgument provides a C gateway function which provides the number of
-            output arguments present in the calling Scilab function. You must include
-            api_scilab.h to benefit from this function.
-        </para>
-    </refsection>
-    <refsection>
-        <title>Examples</title>
-        <para>
-            In this example, the C gateway function can take several output
-            arguments and prints in the Scilab console the integer corresponding to
-            the number of output arguments detected in the calling Scilab
-            function.
-        </para>
-        <programlisting role="example">
-            <![CDATA[ 
+  <refnamediv>
+    <refname>OutputArgument</refname>
+    <refpurpose>
+      A C gateway function which provides the number of output
+      arguments present in the calling Scilab function
+    </refpurpose>
+  </refnamediv>
+  <refsynopsisdiv>
+    <title>Calling Sequence</title>
+    <synopsis>nb_params = OutputArgument</synopsis>
+  </refsynopsisdiv>
+  <refsection>
+    <title>Arguments</title>
+    <variablelist>
+      <varlistentry>
+        <term>nb_params</term>
+        <listitem>
+          <para>
+            the number of output arguments present in the calling Scilab
+            function
+          </para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsection>
+  <refsection>
+    <title>Description</title>
+    <para>
+      nbOutputArgument provides a C gateway function which provides the number of
+      output arguments present in the calling Scilab function. You must include
+      api_scilab.h to benefit from this function.
+    </para>
+  </refsection>
+  <refsection>
+    <title>Examples</title>
+    <para>
+      In this example, the C gateway function can take several output
+      arguments and prints in the Scilab console the integer corresponding to
+      the number of output arguments detected in the calling Scilab
+      function.
+    </para>
+    <programlisting role="example">
+      <![CDATA[ 
 #include "api_scilab.h"
 #include "sciprint.h"
 
@@ -53,17 +53,17 @@ int sci_mylhs(char * fname)
   return 0;
 }
  ]]>
-        </programlisting>
-    </refsection>
-    <refsection role="see also">
-        <title>See Also</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="InputArgument">InputArgument</link>
-            </member>
-            <member>
-                <link linkend="sciprint">sciprint</link>
-            </member>
-        </simplelist>
-    </refsection>
+    </programlisting>
+  </refsection>
+  <refsection role="see also">
+    <title>See Also</title>
+    <simplelist type="inline">
+      <member>
+        <link linkend="InputArgument">InputArgument</link>
+      </member>
+      <member>
+        <link linkend="sciprint">sciprint</link>
+      </member>
+    </simplelist>
+  </refsection>
 </refentry>
index a1c9f56..5978936 100644 (file)
@@ -1,34 +1,34 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:id="UpdateStack">
-    <refnamediv>
-        <refname>UpdateStack</refname>
-        <refpurpose>
-            A C gateway function which update stack information with your modifications.
-        </refpurpose>
-    </refnamediv>
-    <refsynopsisdiv>
-        <title>Calling Sequence</title>
-        <synopsis>UpdateStack();</synopsis>
-    </refsynopsisdiv>
-    <refsection>
-        <title>Description</title>
-        <para>
-            A C gateway function which update stack information with your modifications.
-        </para>
-    </refsection>
-    <refsection>
-        <title>Examples</title>
-        <para>This example takes a matrix of doubles as input and returns:</para>
-        <itemizedlist>
-            <listitem>
-                <para>the number of lines (first output argument)</para>
-            </listitem>
-            <listitem>
-                <para>the number of rows (second output argument)</para>
-            </listitem>
-        </itemizedlist>
-        <programlisting role="example">
-            <![CDATA[
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:id="ReturnArguments">
+  <refnamediv>
+    <refname>ReturnArguments</refname>
+    <refpurpose>
+      A C gateway function which update stack information with your modifications.
+    </refpurpose>
+  </refnamediv>
+  <refsynopsisdiv>
+    <title>Calling Sequence</title>
+    <synopsis>ReturnArguments();</synopsis>
+  </refsynopsisdiv>
+  <refsection>
+    <title>Description</title>
+    <para>
+      A C gateway function which update stack information with your modifications.
+    </para>
+  </refsection>
+  <refsection>
+    <title>Examples</title>
+    <para>This example takes a matrix of doubles as input and returns:</para>
+    <itemizedlist>
+      <listitem>
+        <para>the number of lines (first output argument)</para>
+      </listitem>
+      <listitem>
+        <para>the number of rows (second output argument)</para>
+      </listitem>
+    </itemizedlist>
+    <programlisting role="example">
+      <![CDATA[
 #include "api_scilab.h"
 int sci_mysizedouble(char * fname, unsigned long fname_len)
 {
@@ -53,16 +53,16 @@ int sci_mysizedouble(char * fname, unsigned long fname_len)
                return 0;
        }
 
-    sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 1, 1, 1, &m_in_row); // the m_in_row parameter handles the number of lines of the matrix sent as argument
-    sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 2, 1, 1, &m_in_row); // store a same value, but will neither be used nor returned to Scilab
-    sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 3, 1, 1, &n_in_col); // the n_in_col parameter handles the number of columns of the matrix sent as argument
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 1, 1, 1, &m_in_row); // the m_in_row parameter handles the number of lines of the matrix sent as argument
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 2, 1, 1, &m_in_row); // store a same value, but will neither be used nor returned to Scilab
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 3, 1, 1, &n_in_col); // the n_in_col parameter handles the number of columns of the matrix sent as argument
 
-    AssignOutputVariable(1) = InputArgument + 1; // We set the parameter "InputArgument + 1" as an output argument
-    AssignOutputVariable(2) = InputArgument + 3; // We set the parameter "InputArgument + 3" as an output argument
-    UpdateStack();
+    AssignOutputVariable(1) = nbInputArgument + 1; // We set the parameter "nbInputArgument + 1" as an output argument
+    AssignOutputVariable(2) = nbInputArgument + 3; // We set the parameter "nbInputArgument + 3" as an output argument
+    ReturnArguments();
     return 0;
 }
  ]]>
-        </programlisting>
-    </refsection>
+    </programlisting>
+  </refsection>
 </refentry>
index fac78fc..3e65706 100644 (file)
@@ -135,14 +135,14 @@ int read_write_boolean(char *fname,unsigned long fname_len)
         piBool[i] = piBool[i] == 0 ? 1 : 0;
     }
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, iRows, iCols, piBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
  ]]>
index 079c0ae..5506d1d 100644 (file)
@@ -196,14 +196,14 @@ int read_write_boolean(char *fname,unsigned long fname_len)
         piBool[i] = piBool[i] == 0 ? 1 : 0;
     }
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, iRows, iCols, piBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
  ]]>
index b206974..41e7ad5 100644 (file)
@@ -185,14 +185,14 @@ int read_write_bsparse(char *fname,unsigned long fname_len)
         iCol += piNbItemRow[i];
     }
 
-    sciErr = createBooleanSparseMatrix(pvApiCtx, InputArgument + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
+    sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
  ]]>
index 9f6b177..88d0e86 100644 (file)
@@ -260,14 +260,14 @@ int read_write_bsparse(char *fname,unsigned long fname_len)
         iCol += piNbItemRow[i];
     }
 
-    sciErr = createBooleanSparseMatrix(pvApiCtx, InputArgument + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
+    sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
  ]]>
index 7d4e3c1..bcc08db 100644 (file)
@@ -91,7 +91,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < InputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -105,7 +105,7 @@ int common_function(char *fname,unsigned long fname_len)
     //1 for true, 0 for false
     iBool = sciErr.iErr == 0 ? 1 : 0;
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -113,7 +113,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 53616eb..f71e957 100644 (file)
@@ -99,7 +99,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < InputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -113,7 +113,7 @@ int common_function(char *fname,unsigned long fname_len)
     //1 for true, 0 for false
     iBool = sciErr.iErr == 0 ? 1 : 0;
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -121,7 +121,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 32ba10d..f7d6cfc 100644 (file)
@@ -94,7 +94,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < InputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -108,7 +108,7 @@ int common_function(char *fname,unsigned long fname_len)
     //1 for true, 0 for false
     iBool = sciErr.iErr == 0 ? 1 : 0;
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -116,7 +116,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index fc66b5e..224cc91 100644 (file)
@@ -83,7 +83,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < InputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -97,7 +97,7 @@ int common_function(char *fname,unsigned long fname_len)
     //1 for true, 0 for false
     iBool = sciErr.iErr == 0 ? 1 : 0;
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -105,7 +105,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 1bdc7e9..2c059f6 100644 (file)
@@ -76,7 +76,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < InputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -90,7 +90,7 @@ int common_function(char *fname,unsigned long fname_len)
     //1 for true, 0 for false
     iBool = sciErr.iErr == 0 ? 1 : 0;
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -98,7 +98,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 4005b67..da04082 100644 (file)
@@ -170,7 +170,7 @@ int read_double(char *fname,unsigned long fname_len)
        //if variable is complex, switch real part and imaginary part otherwise multiply by -1
        if(iComplex)
        {
-               sciErr = createComplexMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblImg, pdblReal);
+               sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblImg, pdblReal);
        }
        else
        {
@@ -178,7 +178,7 @@ int read_double(char *fname,unsigned long fname_len)
                {
                        pdblReal[i] = pdblReal[i] * -1;
                }
-               sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblReal);
+               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal);
        }
 
        if(sciErr.iErr)
@@ -187,7 +187,7 @@ int read_double(char *fname,unsigned long fname_len)
                return 0;
        }
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 958dc8a..b0b7874 100644 (file)
@@ -220,7 +220,7 @@ int write_double(char *fname,unsigned long fname_len)
        //}
        //create a variable from a existing data array
 
-       sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows1, iCols1, pdblReal1);
+       sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows1, iCols1, pdblReal1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -235,7 +235,7 @@ int write_double(char *fname,unsigned long fname_len)
        *************************/
 
        //reserve space in scilab memory and fill it
-       sciErr = allocComplexMatrixOfDouble(pvApiCtx, InputArgument + 2, iRows2, iCols2, &pdblReal2, &pdblImg2);
+       sciErr = allocComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 2, iRows2, iCols2, &pdblReal2, &pdblImg2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -265,8 +265,8 @@ int write_double(char *fname,unsigned long fname_len)
        // /!\ DO NOT FREE MEMORY, in this case, it's the Scilab memory
        //assign allocated variables to Lhs position
 
-    AssignOutputVariable(1) = InputArgument + 1;
-    AssignOutputVariable(2) = InputArgument + 2;
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(2) = nbInputArgument + 2;
 
     return 0;
 }
index 52bdc61..e12e8cf 100644 (file)
@@ -89,7 +89,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < InputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -103,7 +103,7 @@ int common_function(char *fname,unsigned long fname_len)
     //1 for true, 0 for false
     iBool = sciErr.iErr == 0 ? 1 : 0;
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -111,7 +111,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 2a10307..3174f85 100644 (file)
@@ -302,7 +302,7 @@ int read_integer(char *fname,unsigned long fname_len)
        puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
 
        //create new variable
-       sciErr = createMatrixOfInteger8(pvApiCtx, InputArgument + 1, iRows8, iCols8, pcDataOut);
+       sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument + 1, iRows8, iCols8, pcDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -310,7 +310,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, InputArgument + 2, iRowsu8, iColsu8, pucDataOut);
+       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 2, iRowsu8, iColsu8, pucDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -318,7 +318,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger16(pvApiCtx, InputArgument + 3, iRows16, iCols16, psDataOut);
+       sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 3, iRows16, iCols16, psDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -326,7 +326,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, InputArgument + 4, iRowsu16, iColsu16, pusDataOut);
+       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 4, iRowsu16, iColsu16, pusDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -334,7 +334,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 5, iRows32, iCols32, piDataOut);
+       sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 5, iRows32, iCols32, piDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -342,7 +342,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, InputArgument + 6, iRowsu32, iColsu32, puiDataOut);
+       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 6, iRowsu32, iColsu32, puiDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -350,12 +350,12 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = InputArgument + 1;
-       AssignOutputVariable(2) = InputArgument + 2;
-       AssignOutputVariable(3) = InputArgument + 3;
-       AssignOutputVariable(4) = InputArgument + 4;
-       AssignOutputVariable(5) = InputArgument + 5;
-       AssignOutputVariable(6) = InputArgument + 6;
+       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(2) = nbInputArgument + 2;
+       AssignOutputVariable(3) = nbInputArgument + 3;
+       AssignOutputVariable(4) = nbInputArgument + 4;
+       AssignOutputVariable(5) = nbInputArgument + 5;
+       AssignOutputVariable(6) = nbInputArgument + 6;
        return 0;
 }
 
index a5a1f9f..079aa97 100644 (file)
@@ -373,7 +373,7 @@ int read_integer(char *fname,unsigned long fname_len)
        puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
 
        //create new variable
-       sciErr = createMatrixOfInteger8(pvApiCtx, InputArgument + 1, iRows8, iCols8, pcDataOut);
+       sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument + 1, iRows8, iCols8, pcDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -381,7 +381,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, InputArgument + 2, iRowsu8, iColsu8, pucDataOut);
+       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 2, iRowsu8, iColsu8, pucDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -389,7 +389,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger16(pvApiCtx, InputArgument + 3, iRows16, iCols16, psDataOut);
+       sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 3, iRows16, iCols16, psDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -397,7 +397,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, InputArgument + 4, iRowsu16, iColsu16, pusDataOut);
+       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 4, iRowsu16, iColsu16, pusDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -405,7 +405,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 5, iRows32, iCols32, piDataOut);
+       sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 5, iRows32, iCols32, piDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -413,7 +413,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, InputArgument + 6, iRowsu32, iColsu32, puiDataOut);
+       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 6, iRowsu32, iColsu32, puiDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -421,12 +421,12 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = InputArgument + 1;
-       AssignOutputVariable(2) = InputArgument + 2;
-       AssignOutputVariable(3) = InputArgument + 3;
-       AssignOutputVariable(4) = InputArgument + 4;
-       AssignOutputVariable(5) = InputArgument + 5;
-       AssignOutputVariable(6) = InputArgument + 6;
+       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(2) = nbInputArgument + 2;
+       AssignOutputVariable(3) = nbInputArgument + 3;
+       AssignOutputVariable(4) = nbInputArgument + 4;
+       AssignOutputVariable(5) = nbInputArgument + 5;
+       AssignOutputVariable(6) = nbInputArgument + 6;
        return 0;
 }
 
index 6b4eef8..63e2fcf 100644 (file)
@@ -81,16 +81,16 @@ int read_pointer(char *fname,unsigned long fname_len)
        CheckInputArgument(pvApiCtx, 0, 1);
     CheckOutputArgument(pvApiCtx, 1, 1);
 
-       if(InputArgument == 0)
+       if(nbInputArgument == 0)
        {//create mode
                double* pdblData    = (double*)malloc(sizeof(double) * 2 * 2);
                pdblData[0]                     = 1;
                pdblData[1]                     = 3;
                pdblData[2]                     = 2;
                pdblData[3]                     = 4;
-               sciErr = createPointer(pvApiCtx, InputArgument + 1, (void*)pdblData);
+               sciErr = createPointer(pvApiCtx, nbInputArgument + 1, (void*)pdblData);
        }
-       else if(InputArgument == 1)
+       else if(nbInputArgument == 1)
        {//read mode
                int iType                       = 0;
                int* piAddr                     = NULL;
@@ -109,7 +109,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                        return 0;
                }
                pdblData = (double*)pvPtr;
-               sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, 2, 2, pdblData);
+               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, 2, 2, pdblData);
        }
        else
        {
@@ -120,7 +120,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                printError(&sciErr, 0);
                return 0;
        }
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 5f86e69..84eab95 100644 (file)
@@ -137,16 +137,16 @@ int read_pointer(char *fname,unsigned long fname_len)
        CheckInputArgument(pvApiCtx, 0, 1);
     CheckOutputArgument(pvApiCtx, 1, 1);
 
-       if(InputArgument == 0)
+       if(nbInputArgument == 0)
        {//create mode
                double* pdblData    = (double*)malloc(sizeof(double) * 2 * 2);
                pdblData[0]                     = 1;
                pdblData[1]                     = 3;
                pdblData[2]                     = 2;
                pdblData[3]                     = 4;
-               sciErr = createPointer(pvApiCtx, InputArgument + 1, (void*)pdblData);
+               sciErr = createPointer(pvApiCtx, nbInputArgument + 1, (void*)pdblData);
        }
-       else if(InputArgument == 1)
+       else if(nbInputArgument == 1)
        {//read mode
                int iType                       = 0;
                int* piAddr                     = NULL;
@@ -165,7 +165,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                        return 0;
                }
                pdblData = (double*)pvPtr;
-               sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, 2, 2, pdblData);
+               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, 2, 2, pdblData);
        }
        else
        {
@@ -176,7 +176,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                printError(&sciErr, 0);
                return 0;
        }
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 395777e..63945bb 100644 (file)
@@ -202,7 +202,7 @@ int read_poly(char *fname,unsigned long fname_len)
                }
        }
 
-       sciErr = createComplexMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+       sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -220,7 +220,7 @@ int read_poly(char *fname,unsigned long fname_len)
        free(pdblReal);
        free(pdblImg);
        //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index d176ba0..ae8d84a 100644 (file)
@@ -238,7 +238,7 @@ int read_poly(char *fname,unsigned long fname_len)
                }
        }
 
-       sciErr = createComplexMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+       sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -256,7 +256,7 @@ int read_poly(char *fname,unsigned long fname_len)
        free(pdblReal);
        free(pdblImg);
        //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 8b6ec7d..7549460 100644 (file)
@@ -151,7 +151,7 @@ int write_poly(char *fname,unsigned long fname_len)
     pdblReal[4]             = pdblPoly4;
     pdblReal[5]             = pdblPoly5;
 
-    sciErr = createMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
+    sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -159,7 +159,7 @@ int write_poly(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
  ]]>
index fab317c..fd2ecb1 100644 (file)
@@ -245,14 +245,14 @@ int write_sparse(char *fname,unsigned long fname_len)
        double pdblSImg[]       = {4,3,2,1};
        int iNbItem                     = 4;
 
-       sciErr = createComplexSparseMatrix(pvApiCtx, InputArgument + 1, 3, 10, iNbItem, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrix(pvApiCtx, nbInputArgument + 1, 3, 10, iNbItem, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 56a01b3..b43d349 100644 (file)
@@ -202,7 +202,7 @@ int read_string(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfString(pvApiCtx, InputArgument + 1, iRowsOut, iColsOut, &pstOut);
+       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument + 1, iRowsOut, iColsOut, &pstOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -219,7 +219,7 @@ int read_string(char *fname,unsigned long fname_len)
 
        free(pstData);
        free(pstOut);
-       AssignOutputVariable(1) = InputArgument + 1;
+       AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 55de27f..16aeded 100644 (file)
@@ -125,7 +125,7 @@ int write_string(char *fname,unsigned long fname_len)
        pstData[5]              = string23;
 
        //create the variable
-       sciErr = createMatrixOfString(pvApiCtx, InputArgument + 1, iRows, iCols, pstData);
+       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument + 1, iRows, iCols, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -135,7 +135,7 @@ int write_string(char *fname,unsigned long fname_len)
        //free container
        free(pstData);
        //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
        return 0;
 }
  ]]>
index 0b627a3..b66c818 100644 (file)
@@ -14,8 +14,8 @@
   <refnamediv>
     <refname>polynomial example</refname>
     <refpurpose>
-            Polynom use case.
-        </refpurpose>
+      Polynom use case.
+    </refpurpose>
   </refnamediv>
   <refsection>
     <title>Description</title>
@@ -28,7 +28,7 @@
     <!--Func_list: polyExample-->
     <title>Gateway Source</title>
     <programlisting role="code_gateway">
-        <![CDATA[ 
+      <![CDATA[ 
 int polyExample(char *fname,unsigned long fname_len)
 {
        SciErr sciErr;
@@ -73,7 +73,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createComplexMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal, &pdblImg);
+                               sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal, &pdblImg);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
@@ -92,7 +92,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal);
+                               sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedSinglePoly(pdblReal);
@@ -120,7 +120,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createComplexMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+                               sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
@@ -139,7 +139,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
+                               sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
@@ -151,7 +151,7 @@ int polyExample(char *fname,unsigned long fname_len)
                        }
                }
 
-        AssignOutputVariable(1) = InputArgument + 1;
+        AssignOutputVariable(1) = nbInputArgument + 1;
        }
        else
        {
@@ -159,7 +159,8 @@ int polyExample(char *fname,unsigned long fname_len)
        }
        return 0;
 }
- ]]></programlisting>
+ ]]>
+    </programlisting>
   </refsection>
   <refsection>
     <title>Scilab test script</title>
index 1faa9ff..510895e 100644 (file)
@@ -66,7 +66,7 @@ int sparseExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       sciErr = createComplexSparseMatrix(pvApiCtx, InputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
+                       sciErr = createComplexSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
                        if(sciErr.iErr)
                        {
                                freeAllocatedComplexSparseMatrix(piNbItemRow, piColPos, pdblReal, pdblImg);
@@ -85,7 +85,7 @@ int sparseExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       sciErr = createSparseMatrix(pvApiCtx, InputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
+                       sciErr = createSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
                        if(sciErr.iErr)
                        {
                                freeAllocatedSparseMatrix(piNbItemRow, piColPos, pdblReal);
@@ -95,7 +95,7 @@ int sparseExample(char *fname,unsigned long fname_len)
 
                        freeAllocatedSparseMatrix(piNbItemRow, piColPos, pdblReal);
                }
-               AssignOutputVariable(1) = InputArgument + 1;
+               AssignOutputVariable(1) = nbInputArgument + 1;
        }
        else
        {
index a4b6e82..4d0662d 100644 (file)
@@ -60,7 +60,7 @@ int stringExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       iRet = createSingleString(pvApiCtx, InputArgument + 1, pstData);
+                       iRet = createSingleString(pvApiCtx, nbInputArgument + 1, pstData);
                        if(iRet)
                        {
                                freeAllocatedSingleString(pstData);
@@ -82,7 +82,7 @@ int stringExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       sciErr = createMatrixOfString(pvApiCtx, InputArgument + 1, iRows, iCols, pstData);
+                       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument + 1, iRows, iCols, pstData);
                        if(sciErr.iErr)
                        {
                                freeAllocatedMatrixOfString(iRows, iCols, pstData);
@@ -93,7 +93,7 @@ int stringExample(char *fname,unsigned long fname_len)
                        freeAllocatedMatrixOfString(iRows, iCols, pstData);
                }
                
-        AssignOutputVariable(1) = InputArgument + 1;
+        AssignOutputVariable(1) = nbInputArgument + 1;
        }
        else
        {
index 9550988..2b694ee 100644 (file)
 extern "C" {
 #endif
 
-       /**
-        * The error management structure
-        *
-        */
+    /**
+     * The error management structure
+     *
+     */
 
 #define MESSAGE_STACK_SIZE 5
 
-typedef struct api_Err
-{
-       int iErr; /**< The error ID */
-       int iMsgCount; /**< Error level */
-       char* pstMsg[MESSAGE_STACK_SIZE]; /**< The error message */
-} SciErr;
+    typedef struct api_Err
+    {
+        int iErr; /**< The error ID */
+        int iMsgCount; /**< Error level */
+        char* pstMsg[MESSAGE_STACK_SIZE]; /**< The error message */
+    } SciErr;
 
-typedef struct api_Ctx
-{
-       char* pstName; /**< Function name */
-} StrCtx, *pStrCtx;
+    typedef struct api_Ctx
+    {
+        char* pstName; /**< Function name */
+    } StrCtx, *pStrCtx;
 
 #ifdef _MSC_VER
-       #ifndef API_SCILAB_EXPORTS
-               __declspec( dllimport ) StrCtx* pvApiCtx;
-    #else
-               extern StrCtx* pvApiCtx;
-       #endif
+#ifndef API_SCILAB_EXPORTS
+    __declspec( dllimport ) StrCtx* pvApiCtx;
 #else
-       extern StrCtx* pvApiCtx;
+    extern StrCtx* pvApiCtx;
+#endif
+#else
+    extern StrCtx* pvApiCtx;
 #endif
 
 #include "api_scilab.h"
-/* generics functions */
+    /* generics functions */
+
+    int* getNbInputArgument(void* _pvCtx);
+#define nbInputArgument (*getNbInputArgument(pvApiCtx))
 
-int* getInputArgument(void* _pvCtx);
-#define InputArgument (*getInputArgument(pvApiCtx))
-    
 #ifdef Rhs
 #undef Rhs
 #endif
-#define Rhs (*getInputArgument(pvApiCtx))
+#define Rhs (*getNbInputArgument(pvApiCtx))
 
-int* getOutputArgument(void* _pvCtx);
-#define OutputArgument (*getOutputArgument(pvApiCtx))
+    int* getNbOutputArgument(void* _pvCtx);
+#define nbOutputArgument (*getNbOutputArgument(pvApiCtx))
 #ifdef Lhs
 #undef Lhs
 #endif
-#define Lhs (*getOutputArgument(pvApiCtx))
+#define Lhs (*getNbOutputArgument(pvApiCtx))
 
-int* assignOutputVariable(void* _pvCtx, int _iVal);
+    int* assignOutputVariable(void* _pvCtx, int _iVal);
 #define AssignOutputVariable(x) (*assignOutputVariable(pvApiCtx, x))
 #ifdef LhsVar
 #undef LhsVar
 #endif
 #define LhsVar(x) (*assignOutputVariable(pvApiCtx, x))
 
-int updateStack(void* _pvCtx);
-#define UpdateStack() if (! updateStack(pvApiCtx)) { return 0; }
+    int returnArguments(void* _pvCtx);
+#define ReturnArguments() if (! returnArguments(pvApiCtx)) { return 0; }
 #ifdef PutLhsVar
 #undef PutLhsVar
 #endif
-#define PutLhsVar() if (! updateStack(pvApiCtx)) { return 0; }
-
-/**
- * Check input argument count
- * @param[in] _iMin min value
- * @param[in] _iMax : max value
- * @return if _iMin >= rhs >= _iMax
- */
-int checkInputArgument(void* _pvCtx, int _iMin, int _iMax);
+#define PutLhsVar() if (! returnArguments(pvApiCtx)) { return 0; }
+
+    /**
+     * Check input argument count
+     * @param[in] _iMin min value
+     * @param[in] _iMax : max value
+     * @return if _iMin >= rhs >= _iMax
+     */
+    int checkInputArgument(void* _pvCtx, int _iMin, int _iMax);
 #define CheckInputArgument(ctx, min, max) \
     if(checkInputArgument(ctx, min, max) == 0) \
     { \
@@ -102,37 +102,37 @@ int checkInputArgument(void* _pvCtx, int _iMin, int _iMax);
     { \
         return 0; \
     }
-/**
- * Check input argument count
- * @param[in] _iMin min value
- * @return if rhs >= _iMin
- */
-int checkInputArgumentAtLeast(void* _pvCtx, int _iMin);
+    /**
+     * Check input argument count
+     * @param[in] _iMin min value
+     * @return if rhs >= _iMin
+     */
+    int checkInputArgumentAtLeast(void* _pvCtx, int _iMin);
 #define CheckInputArgumentAtLeast(ctx, min) \
     if(checkInputArgumentAtLeast(ctx, min) == 0) \
     { \
         return 0; \
     }
 
-/**
- * Check input argument count
- * @param[in] _iMax : max value
- * @return if rhs <= max
- */
-int checkInputArgumentAtMost(void* _pvCtx, int _iMax);
+    /**
+     * Check input argument count
+     * @param[in] _iMax : max value
+     * @return if rhs <= max
+     */
+    int checkInputArgumentAtMost(void* _pvCtx, int _iMax);
 #define CheckInputArgumentAtMost(ctx, max) \
     if(checkInputArgumentAtMost(ctx, max) == 0) \
     { \
         return 0; \
     }
 
-/**
- * Check output argument count
- * @param[in] _iMin min value
- * @param[in] _iMax : max value
- * @return if _iMin >= lhs >= _iMax
- */
-int checkOutputArgument(void* _pvCtx, int _iMin, int _iMax);
+    /**
+     * Check output argument count
+     * @param[in] _iMin min value
+     * @param[in] _iMax : max value
+     * @return if _iMin >= lhs >= _iMax
+     */
+    int checkOutputArgument(void* _pvCtx, int _iMin, int _iMax);
 #define CheckOutputArgument(ctx, min, max) \
     if(checkOutputArgument(ctx, min, max) == 0) \
     { \
@@ -147,267 +147,267 @@ int checkOutputArgument(void* _pvCtx, int _iMin, int _iMax);
         return 0; \
     }
 
-/**
- * Check output argument count
- * @param[in] _iMin min value
- * @return if lhs >= _iMin
- */
-int checkOutputArgumentAtLeast(void* _pvCtx, int _iMin);
+    /**
+     * Check output argument count
+     * @param[in] _iMin min value
+     * @return if lhs >= _iMin
+     */
+    int checkOutputArgumentAtLeast(void* _pvCtx, int _iMin);
 #define CheckOutputArgumentAtLeast(ctx, min) \
     if(checkOutputArgumentAtLeast(ctx, min) == 0) \
     { \
         return 0; \
     }
 
-/**
- * Check output argument count
- * @param[in] _iMax : max value
- * @return if lhs <= max
- */
-int checkOutputArgumentAtMost(void* _pvCtx, int _iMax);
+    /**
+     * Check output argument count
+     * @param[in] _iMax : max value
+     * @return if lhs <= max
+     */
+    int checkOutputArgumentAtMost(void* _pvCtx, int _iMax);
 #define CheckOutputArgumentAtMost(ctx, max) \
     if(checkOutputArgumentAtMost(ctx, max) == 0) \
     { \
         return 0; \
     }
 
-int callOverloadFunction(void* _pvCtx, int _iVar, char* _pstName, unsigned int _iNameLen);
+    int callOverloadFunction(void* _pvCtx, int _iVar, char* _pstName, unsigned int _iNameLen);
 #define CallOverloadFunction(x) callOverloadFunction(pvApiCtx, x, fname, strlen(fname))
 #ifdef OverLoad
 #undef OverLoad
 #endif
 #define OverLoad(x) callOverloadFunction(pvApiCtx, x, fname, (unsigned int)strlen(fname))
-/**
- * Get the memory address of a variable from the variable position
- * @param[in] _iVar variable number
- * @param[out] _piAddress return variable address
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress);
-
-/**
- * Get the name of a variable from the variable position
- * @param[in] _iVar variable number
- * @param[out] _pstName variable name
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getVarNameFromPosition(void* _pvCtx, int _iVar, char* _pstName);
-
-/**
- * Get the memory address of a variable from the variable name
- * @param[in] _pstName variable name
- * @param[out] _piAddress return variable address
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getVarAddressFromName(void* _pvCtx, const char* _pstName, int** _piAddress);
-
-/**
- * Get the variable type
- * @param[in] _piAddress variable address
- * @param[out] _piType return variable type ( sci_matrix, sci_strings, ... )
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getVarType(void* _pvCtx, int* _piAddress, int* _piType);
-
-/**
- * Get the variable type from the variable name
- * @param[in] _pstName variable name
- * @param[out] _piType return variable type ( sci_matrix, sci_strings, ... )
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getNamedVarType(void* _pvCtx, const char* _pstName, int* _piType);
-
-/**
- * Check if the variable type is complex double, complex sparse double or complex polynomial
- * @param[in] _piAddress variable address
- * @return if complex 1 otherwise 0
- */
-int isVarComplex(void* _pvCtx, int* _piAddress);
-
-/**
-* Check if the named variable type is complex double, complex sparse double or complex polynomial
-* @param[in] _pstName variable name
-* @return if complex 1 otherwise 0
-*/
-int isNamedVarComplex(void* _pvCtx, const char *_pstName);
-
-/**
- * Get variable dimensions
- * @param[in] _piAddress variable address
- * @param[out] _piRows return number of rows
- * @param[out] _piCols return number of cols
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getVarDimension(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols);
-
-/**
- * Get named variable dimensions
- * @param[in] _pstName variable name
- * @param[out] _piRows return number of rows
- * @param[out] _piCols return number of cols
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getNamedVarDimension(void* _pvCtx, const char *_pstName, int* _piRows, int* _piCols);
-
-/**
- * Check if a variable is a matrix form ( row x col )
- * @param[in] _piAddress variable address
- * @return if matrix form type variable 1 otherwise 0
- */
-int isVarMatrixType(void* _pvCtx, int* _piAddress);
-
-/**
- * Check if a named variable is a matrix form ( row x col )
- * @param[in] _pstName variable name
- * @return if matrix form type variable 1 otherwise 0
- */
-int isNamedVarMatrixType(void* _pvCtx, const char *_pstName);
-
-/**
- * Get process mode from input variable
- * @param[in] _iPos variable position in function call
- * @param[in] _piAddRef variable address
- * @param[out] _piMode return process mode ( 0 -> All, 1 -> Row, 2 -> Col )
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getProcessMode(void* _pvCtx, int _iPos, int* _piAddRef, int *_piMode);
-
-/**
- * Get dimension for variable, extract value from a single value
- * @param[in] _piAddress variable address ( double or int variable )
- * @param[out] _piVal return value
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getDimFromVar(void* _pvCtx, int* _piAddress, int* _piVal);
-
-/**
- * Get dimension for a named variable, extract value from a single value
- * @param[in] _pstName variable name
- * @param[out] _piVal return value
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-SciErr getDimFromNamedVar(void* _pvCtx, const char* _pstName, int* _piVal);
-
-/**
- * Get Rhs value from variable address
- * @param[in] _piAddress varaible address
- * @return rhs value of the variable, if failed returns 0
- */
-int getRhsFromAddress(void* _pvCtx, int* _piAddress);
-
-/**
- * Check if a variable is a row vector
- * @param[in] _piAddress variable address
- * @return 1 for true and 0 for false
- */
-int isRowVector(void* _pvCtx, int* _piAddress);
-
-/**
- * Check if a variable is a column vector
- * @param[in] _piAddress variable address
- * @return 1 for true and 0 for false
- */
-int isColumnVector(void* _pvCtx, int* _piAddress);
-
-/**
- * Check if a variable is a vector ( row or column )
- * @param[in] _piAddress variable address
- * @return 1 for true and 0 for false
- */
-int isVector(void* _pvCtx, int* _piAddress);
-
-/**
- * Check if a variable is a scalar
- * @param[in] _piAddress variable address
- * @return 1 for true and 0 for false
- */
-int isScalar(void* _pvCtx, int* _piAddress);
-
-/**
- * Check if a variable is a square matrix
- * @param[in] _piAddress variable address
- * @return 1 for true and 0 for false
- */
-int isSquareMatrix(void* _pvCtx, int* _piAddress);
-
-/**
- * Check matrix dimension
- * @param[in] _piAddress variable address
- * @param[in] _iRows accepted number of rows ( if -1, don't check )
- * @param[in] _iCols accepted number of columns ( if -1, don't check )
- * @return 1 for true and 0 for false
- */
-int checkVarDimension(void* _pvCtx, int* _piAddress, int _iRows, int _iCols);
-
-/**
- * Check if a matrix is empty
- * @param[in] _piAddress variable address
- * @return 1 for true and 0 for false
- */
-int isEmptyMatrix(void* _pvCtx, int* _piAddress);
-
-/**
- * Create an empty matrix
- * @param[in] _iVar variable number
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int createEmptyMatrix(void* _pvCtx, int _iVar);
-
-/**
- * Create a named empty matrix
- * @param[in] _pstName variable name
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int createNamedEmptyMatrix(void* _pvCtx, const char* _pstName);
-
-/**
- * Check if a named variable exists
- * @param[in] _pstName variable name
- * @return if the operation succeeded ( 0 ) or not ( !0 )
- */
-int isNamedVarExist(void* _pvCtx, const char* _pstName);
-
-/**
- * Check if a named variable is a row vector
- * @param[in] _pstName variable name
- * @return 1 for true and 0 for false
- */
-int isNamedRowVector(void* _pvCtx, const char* _pstName);
-
-/**
- * Check if a named variable is a column vector
- * @param[in] _pstName variable name
- * @return 1 for true and 0 for false
- */
-int isNamedColumnVector(void* _pvCtx, const char* _pstName);
-
-/**
- * Check if a named variable is a vector ( row or column )
- * @param[in] _pstName variable name
- * @return 1 for true and 0 for false
- */
-int isNamedVector(void* _pvCtx, const char* _pstName);
-
-/**
- * Check if a named variable is a scalar
- * @param[in] _pstName variable name
- * @return 1 for true and 0 for false
- */
-int isNamedScalar(void* _pvCtx, const char* _pstName);
-
-/**
- * Check if a named variable is a square matrix
- * @param[in] _pstName variable name
- * @return 1 for true and 0 for false
- */
-int isNamedSquareMatrix(void* _pvCtx, const char* _pstName);
-
-/**
- * Check if a named variable is an empty matrix
- * @param[in] _pstName variable name
- * @return 1 for true and 0 for false
- */
-int isNamedEmptyMatrix(void* _pvCtx, const char* _pstName);
+    /**
+     * Get the memory address of a variable from the variable position
+     * @param[in] _iVar variable number
+     * @param[out] _piAddress return variable address
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getVarAddressFromPosition(void* _pvCtx, int _iVar, int** _piAddress);
+
+    /**
+     * Get the name of a variable from the variable position
+     * @param[in] _iVar variable number
+     * @param[out] _pstName variable name
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getVarNameFromPosition(void* _pvCtx, int _iVar, char* _pstName);
+
+    /**
+     * Get the memory address of a variable from the variable name
+     * @param[in] _pstName variable name
+     * @param[out] _piAddress return variable address
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getVarAddressFromName(void* _pvCtx, const char* _pstName, int** _piAddress);
+
+    /**
+     * Get the variable type
+     * @param[in] _piAddress variable address
+     * @param[out] _piType return variable type ( sci_matrix, sci_strings, ... )
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getVarType(void* _pvCtx, int* _piAddress, int* _piType);
+
+    /**
+     * Get the variable type from the variable name
+     * @param[in] _pstName variable name
+     * @param[out] _piType return variable type ( sci_matrix, sci_strings, ... )
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getNamedVarType(void* _pvCtx, const char* _pstName, int* _piType);
+
+    /**
+     * Check if the variable type is complex double, complex sparse double or complex polynomial
+     * @param[in] _piAddress variable address
+     * @return if complex 1 otherwise 0
+     */
+    int isVarComplex(void* _pvCtx, int* _piAddress);
+
+    /**
+    * Check if the named variable type is complex double, complex sparse double or complex polynomial
+    * @param[in] _pstName variable name
+    * @return if complex 1 otherwise 0
+    */
+    int isNamedVarComplex(void* _pvCtx, const char *_pstName);
+
+    /**
+     * Get variable dimensions
+     * @param[in] _piAddress variable address
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of cols
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getVarDimension(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols);
+
+    /**
+     * Get named variable dimensions
+     * @param[in] _pstName variable name
+     * @param[out] _piRows return number of rows
+     * @param[out] _piCols return number of cols
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getNamedVarDimension(void* _pvCtx, const char *_pstName, int* _piRows, int* _piCols);
+
+    /**
+     * Check if a variable is a matrix form ( row x col )
+     * @param[in] _piAddress variable address
+     * @return if matrix form type variable 1 otherwise 0
+     */
+    int isVarMatrixType(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check if a named variable is a matrix form ( row x col )
+     * @param[in] _pstName variable name
+     * @return if matrix form type variable 1 otherwise 0
+     */
+    int isNamedVarMatrixType(void* _pvCtx, const char *_pstName);
+
+    /**
+     * Get process mode from input variable
+     * @param[in] _iPos variable position in function call
+     * @param[in] _piAddRef variable address
+     * @param[out] _piMode return process mode ( 0 -> All, 1 -> Row, 2 -> Col )
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getProcessMode(void* _pvCtx, int _iPos, int* _piAddRef, int *_piMode);
+
+    /**
+     * Get dimension for variable, extract value from a single value
+     * @param[in] _piAddress variable address ( double or int variable )
+     * @param[out] _piVal return value
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getDimFromVar(void* _pvCtx, int* _piAddress, int* _piVal);
+
+    /**
+     * Get dimension for a named variable, extract value from a single value
+     * @param[in] _pstName variable name
+     * @param[out] _piVal return value
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    SciErr getDimFromNamedVar(void* _pvCtx, const char* _pstName, int* _piVal);
+
+    /**
+     * Get Rhs value from variable address
+     * @param[in] _piAddress varaible address
+     * @return rhs value of the variable, if failed returns 0
+     */
+    int getRhsFromAddress(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check if a variable is a row vector
+     * @param[in] _piAddress variable address
+     * @return 1 for true and 0 for false
+     */
+    int isRowVector(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check if a variable is a column vector
+     * @param[in] _piAddress variable address
+     * @return 1 for true and 0 for false
+     */
+    int isColumnVector(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check if a variable is a vector ( row or column )
+     * @param[in] _piAddress variable address
+     * @return 1 for true and 0 for false
+     */
+    int isVector(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check if a variable is a scalar
+     * @param[in] _piAddress variable address
+     * @return 1 for true and 0 for false
+     */
+    int isScalar(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check if a variable is a square matrix
+     * @param[in] _piAddress variable address
+     * @return 1 for true and 0 for false
+     */
+    int isSquareMatrix(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Check matrix dimension
+     * @param[in] _piAddress variable address
+     * @param[in] _iRows accepted number of rows ( if -1, don't check )
+     * @param[in] _iCols accepted number of columns ( if -1, don't check )
+     * @return 1 for true and 0 for false
+     */
+    int checkVarDimension(void* _pvCtx, int* _piAddress, int _iRows, int _iCols);
+
+    /**
+     * Check if a matrix is empty
+     * @param[in] _piAddress variable address
+     * @return 1 for true and 0 for false
+     */
+    int isEmptyMatrix(void* _pvCtx, int* _piAddress);
+
+    /**
+     * Create an empty matrix
+     * @param[in] _iVar variable number
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int createEmptyMatrix(void* _pvCtx, int _iVar);
+
+    /**
+     * Create a named empty matrix
+     * @param[in] _pstName variable name
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int createNamedEmptyMatrix(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Check if a named variable exists
+     * @param[in] _pstName variable name
+     * @return if the operation succeeded ( 0 ) or not ( !0 )
+     */
+    int isNamedVarExist(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Check if a named variable is a row vector
+     * @param[in] _pstName variable name
+     * @return 1 for true and 0 for false
+     */
+    int isNamedRowVector(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Check if a named variable is a column vector
+     * @param[in] _pstName variable name
+     * @return 1 for true and 0 for false
+     */
+    int isNamedColumnVector(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Check if a named variable is a vector ( row or column )
+     * @param[in] _pstName variable name
+     * @return 1 for true and 0 for false
+     */
+    int isNamedVector(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Check if a named variable is a scalar
+     * @param[in] _pstName variable name
+     * @return 1 for true and 0 for false
+     */
+    int isNamedScalar(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Check if a named variable is a square matrix
+     * @param[in] _pstName variable name
+     * @return 1 for true and 0 for false
+     */
+    int isNamedSquareMatrix(void* _pvCtx, const char* _pstName);
+
+    /**
+     * Check if a named variable is an empty matrix
+     * @param[in] _pstName variable name
+     * @return 1 for true and 0 for false
+     */
+    int isNamedEmptyMatrix(void* _pvCtx, const char* _pstName);
 
 #ifdef __cplusplus
 }
index 0204f77..9981621 100644 (file)
 /*
 * 1 : First version
 * 2 : Shortcut functions added
-* 3 : Add some functions/macros in replacement of stack functions/macros : 
+* 3 : Add some functions/macros in replacement of stack functions/macros :
         - Rhs -> InputArgument
         - Lhs -> OutputArgument
         - LhsVar -> AssignOutputVariable
-        - PutLhsVar -> UpdateStack
+        - PutLhsVar -> ReturnArguments
         - CheckRhs -> CheckInputArgument
         - CheckLhs -> CheckOutputArgument
 */
index f35d7ec..f7b97ee 100644 (file)
@@ -35,9 +35,9 @@ extern "C"
 extern "C"
 {
     extern int C2F(cvnamel) (int *id, char *str, int *jobptr, int *str_len);
-    extern  int C2F(cvname)(int *,char *,int *, unsigned long int);
-/* *jobptr==0: Get Scilab codes from C-string */
-/* *jobptr==1: Get C-string from Scilab codes */
+    extern  int C2F(cvname)(int *, char *, int *, unsigned long int);
+    /* *jobptr==0: Get Scilab codes from C-string */
+    /* *jobptr==1: Get C-string from Scilab codes */
 
     extern int C2F(stackp) (int *, int *);
 };
@@ -46,22 +46,24 @@ extern "C"
 #define idstk(x,y) (C2F(vstk).idstk+(x-1)+(y-1)*nsiz)
 #define CvNameL(id,str,jobptr,str_len) C2F(cvnamel)(id,str,jobptr,str_len);
 /*--------------------------------------------------------------------------*/
-int* getInputArgument(void* _pvCtx)
+/* Replaces Rhs */
+int* getNbInputArgument(void* _pvCtx)
 {
     return &C2F(com).rhs;
 }
 
-int* getOutputArgument(void* _pvCtx)
+/* Replaces Lhs */
+int* getNbOutputArgument(void* _pvCtx)
 {
     return &C2F(com).lhs;
 }
 
 int* assignOutputVariable(void* _pvCtx, int _iVal)
 {
-    return &(C2F(intersci).lhsvar[_iVal-1]);
+    return &(C2F(intersci).lhsvar[_iVal - 1]);
 }
 
-int updateStack(void* _pvCtx)
+int returnArguments(void* _pvCtx)
 {
     return C2F(putlhsvar)();
 }
@@ -79,12 +81,12 @@ int checkInputArgument(void* _pvCtx, int _iMin, int _iMax)
     int cx0 = 0;
     C2F(cvname) (&C2F(recu).ids[(C2F(recu).pt + 1) * nsiz - nsiz],  ((StrCtx *) _pvCtx)->pstName, &cx0, (unsigned long int)strlen(((StrCtx *)_pvCtx)->pstName));
 
-    if(_iMin <= InputArgument && _iMax >= InputArgument)
+    if (_iMin <= nbInputArgument && _iMax >= nbInputArgument)
     {
         return 1;
     }
 
-    if(_iMax == _iMin)
+    if (_iMax == _iMin)
     {
         Scierror(77, _("%s: Wrong number of input argument(s): %d expected.\n"), ((StrCtx *) _pvCtx)->pstName, _iMax);
     }
@@ -103,7 +105,7 @@ int checkInputArgumentAtLeast(void* _pvCtx, int _iMin)
     sciErr.iErr = 0;
     sciErr.iMsgCount = 0;
 
-    if(_iMin <= InputArgument)
+    if (_iMin <= nbInputArgument)
     {
         return 1;
     }
@@ -119,7 +121,7 @@ int checkInputArgumentAtMost(void* _pvCtx, int _iMax)
     sciErr.iErr = 0;
     sciErr.iMsgCount = 0;
 
-    if(_iMax >= InputArgument)
+    if (_iMax >= nbInputArgument)
     {
         return 1;
     }
@@ -136,12 +138,12 @@ int checkOutputArgument(void* _pvCtx, int _iMin, int _iMax)
     sciErr.iMsgCount = 0;
 
 
-    if(_iMin <= OutputArgument && _iMax >= OutputArgument)
+    if (_iMin <= nbOutputArgument && _iMax >= nbOutputArgument)
     {
         return 1;
     }
 
-    if(_iMax == _iMin)
+    if (_iMax == _iMin)
     {
         Scierror(78, _("%s: Wrong number of output argument(s): %d expected.\n"), ((StrCtx *) _pvCtx)->pstName, _iMax);
     }
@@ -160,7 +162,7 @@ int checkOutputArgumentAtLeast(void* _pvCtx, int _iMin)
     sciErr.iErr = 0;
     sciErr.iMsgCount = 0;
 
-    if(_iMin <= OutputArgument)
+    if (_iMin <= nbOutputArgument)
     {
         return 1;
     }
@@ -176,7 +178,7 @@ int checkOutputArgumentAtMost(void* _pvCtx, int _iMax)
     sciErr.iErr = 0;
     sciErr.iMsgCount = 0;
 
-    if(_iMax >= OutputArgument)
+    if (_iMax >= nbOutputArgument)
     {
         return 1;
     }
@@ -340,7 +342,8 @@ SciErr getVarAddressFromName(void *_pvCtx, const char *_pstName, int **_piAddres
     //get variable address
     getNewVarAddressFromPosition(_pvCtx, Fin, &piAddr);
     if (piAddr[0] < 0)
-    {                           //get address from reference
+    {
+        //get address from reference
         int iStackRef = *Lstk(Fin);
         int iStackAddr = iadr(iStackRef);
         int iNewStackRef = iStackAddr + 1;
@@ -409,13 +412,13 @@ int isVarComplex(void *_pvCtx, int *_piAddress)
     getVarType(_pvCtx, _piAddress, &iType);
     switch (iType)
     {
-    case sci_matrix:
-    case sci_poly:
-    case sci_sparse:
-        iComplex = _piAddress[3];
-        break;
-    default:
-        iComplex = 0;
+        case sci_matrix:
+        case sci_poly:
+        case sci_sparse:
+            iComplex = _piAddress[3];
+            break;
+        default:
+            iComplex = 0;
     }
     return iComplex;
 }
@@ -472,18 +475,18 @@ int isVarMatrixType(void *_pvCtx, int *_piAddress)
 
         switch (iType)
         {
-        case sci_matrix:
-        case sci_poly:
-        case sci_boolean:
-        case sci_sparse:
-        case sci_boolean_sparse:
-        case sci_matlab_sparse:
-        case sci_ints:
-        case sci_handles:
-        case sci_strings:
-            return 1;
-        default:
-            return 0;
+            case sci_matrix:
+            case sci_poly:
+            case sci_boolean:
+            case sci_sparse:
+            case sci_boolean_sparse:
+            case sci_matlab_sparse:
+            case sci_ints:
+            case sci_handles:
+            case sci_strings:
+                return 1;
+            default:
+                return 0;
         }
     }
     else
@@ -697,7 +700,7 @@ SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
 
         switch (iPrec)
         {
-        case SCI_INT8:
+            case SCI_INT8:
             {
                 char *pcData = NULL;
 
@@ -710,7 +713,7 @@ SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
                 *_piVal = pcData[0];
             }
             break;
-        case SCI_UINT8:
+            case SCI_UINT8:
             {
                 unsigned char *pucData = NULL;
 
@@ -723,7 +726,7 @@ SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
                 *_piVal = pucData[0];
             }
             break;
-        case SCI_INT16:
+            case SCI_INT16:
             {
                 short *psData = NULL;
 
@@ -736,7 +739,7 @@ SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
                 *_piVal = psData[0];
             }
             break;
-        case SCI_UINT16:
+            case SCI_UINT16:
             {
                 unsigned short *pusData = NULL;
 
@@ -749,7 +752,7 @@ SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
                 *_piVal = pusData[0];
             }
             break;
-        case SCI_INT32:
+            case SCI_INT32:
             {
                 int *piData = NULL;
 
@@ -762,7 +765,7 @@ SciErr getDimFromVar(void *_pvCtx, int *_piAddress, int *_piVal)
                 *_piVal = piData[0];
             }
             break;
-        case SCI_UINT32:
+            case SCI_UINT32:
             {
                 unsigned int *puiData = NULL;
 
@@ -1267,7 +1270,7 @@ int isNamedVarExist(void *_pvCtx, const char *_pstName)
 /*--------------------------------------------------------------------------*/
 int checkNamedVarFormat(void* _pvCtx, const char *_pstName)
 {
-    #define FORBIDDEN_CHARS " */\\.,;:^@><!=+-&|()~\n\t'\""
+#define FORBIDDEN_CHARS " */\\.,;:^@><!=+-&|()~\n\t'\""
     int iRet = 1;
 
     // check pointer
index a69e3fe..36d46ba 100644 (file)
@@ -13,7 +13,7 @@
 #include "api_scilab.h"
 #include "MALLOC.h"
 
-int booleanExample(char *fname,unsigned long fname_len)
+int booleanExample(char *fname, unsigned long fname_len)
 {
     SciErr sciErr;
     int* piAddr = NULL;
@@ -26,24 +26,24 @@ int booleanExample(char *fname,unsigned long fname_len)
     CheckLhs(0, 1);
 
     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
-    if(isBooleanType(pvApiCtx, piAddr))
+    if (isBooleanType(pvApiCtx, piAddr))
     {
-        if(isScalar(pvApiCtx, piAddr))
+        if (isScalar(pvApiCtx, piAddr))
         {
             int iBool = 0;
             iRet = getScalarBoolean(pvApiCtx, piAddr, &iBool);
-            if(iRet)
+            if (iRet)
             {
                 return 0;
             }
             iRet = createScalarBoolean(pvApiCtx, Rhs + 1, iBool);
-            //iRet = createScalarBoolean(pvApiCtx, InputArgument + 1, iBool);
-            if(iRet)
+            //iRet = createScalarBoolean(pvApiCtx, nbInputArgument + 1, iBool);
+            if (iRet)
             {
                 return 0;
             }
@@ -55,22 +55,22 @@ int booleanExample(char *fname,unsigned long fname_len)
             int *piBool        = NULL;
 
             sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &piBool);
-            if(sciErr.iErr)
+            if (sciErr.iErr)
             {
                 printError(&sciErr, 0);
                 return 0;
             }
 
             sciErr = createMatrixOfBoolean(pvApiCtx, Rhs + 1, iRows, iCols, piBool);
-            //sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, iRows, iCols, piBool);
-            if(sciErr.iErr)
+            //sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
+            if (sciErr.iErr)
             {
                 printError(&sciErr, 0);
                 return 0;
             }
         }
         LhsVar(1) = Rhs + 1;
-        //AssignOutputVariable(1) = InputArgument + 1;
+        //AssignOutputVariable(1) = nbInputArgument + 1;
     }
     else
     {
index 7d98840..be7000a 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int booleanSparseExample(char *fname,unsigned long fname_len)
+int booleanSparseExample(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       int* piAddr             = NULL;
-       int iType               = 0;
-       int iRet                = 0;
+    SciErr sciErr;
+    int* piAddr                = NULL;
+    int iType          = 0;
+    int iRet           = 0;
 
     CheckInputArgument(pvApiCtx, 1, 1);
     CheckOutputArgument(pvApiCtx, 0, 1);
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-       if(sciErr.iErr)
-       {
-                       printError(&sciErr, 0);
-                       return 0;
-       }
-
-       if(isBooleanSparseType(pvApiCtx, piAddr))
-       {
-               int iRows                       = 0;
-               int iCols                       = 0;
-               int iNbItem                     = 0;
-               int* piNbItemRow        = NULL;
-               int* piColPos           = NULL;
-
-               iRet = getAllocatedBooleanSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &iNbItem, &piNbItemRow, &piColPos);
-               if(iRet)
-               {
-                       freeAllocatedBooleanSparse(piNbItemRow, piColPos);
-                       return iRet;
-               }
-
-               sciErr = createBooleanSparseMatrix(pvApiCtx, InputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos);
-               if(sciErr.iErr)
-               {
-                       freeAllocatedBooleanSparse(piNbItemRow, piColPos);
-                       printError(&sciErr, 0);
-                       return sciErr.iErr;
-               }
-
-               freeAllocatedBooleanSparse(piNbItemRow, piColPos);
-               AssignOutputVariable(1) = InputArgument + 1;
-       }
-       return 0;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if (isBooleanSparseType(pvApiCtx, piAddr))
+    {
+        int iRows                      = 0;
+        int iCols                      = 0;
+        int iNbItem                    = 0;
+        int* piNbItemRow       = NULL;
+        int* piColPos          = NULL;
+
+        iRet = getAllocatedBooleanSparseMatrix(pvApiCtx, piAddr, &iRows, &iCols, &iNbItem, &piNbItemRow, &piColPos);
+        if (iRet)
+        {
+            freeAllocatedBooleanSparse(piNbItemRow, piColPos);
+            return iRet;
+        }
+
+        sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos);
+        if (sciErr.iErr)
+        {
+            freeAllocatedBooleanSparse(piNbItemRow, piColPos);
+            printError(&sciErr, 0);
+            return sciErr.iErr;
+        }
+
+        freeAllocatedBooleanSparse(piNbItemRow, piColPos);
+        AssignOutputVariable(1) = nbInputArgument + 1;
+    }
+    return 0;
 }
index 37248c5..a26956f 100644 (file)
 
 SciErr printf_info(int _iVar);
 
-int common_function(char *fname,unsigned long fname_len)
+int common_function(char *fname, unsigned long fname_len)
 {
     SciErr sciErr;
     int i;
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < InputArgument ; i++)
+    for (i = 0 ; i < nbInputArgument ; i++)
     {
         sciErr = printf_info(i + 1);
-        if(sciErr.iErr)
+        if (sciErr.iErr)
         {
             printError(&sciErr, 0);
             break;
@@ -39,15 +39,15 @@ int common_function(char *fname,unsigned long fname_len)
     //1 for true, 0 for false
     iBool = sciErr.iErr == 0 ? 1 : 0;
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, 1, 1, &iBool);
-    if(sciErr.iErr)
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, 1, 1, &iBool);
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
@@ -61,7 +61,7 @@ SciErr printf_info(int _iVar)
     int iComplex    = 0;
 
     sciErr = getVarAddressFromPosition(pvApiCtx, _iVar, &piAddr);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         return sciErr;
     }
@@ -69,13 +69,13 @@ SciErr printf_info(int _iVar)
     sciprint("Variable %d information:\n", _iVar);
 
     sciErr = getVarType(pvApiCtx, piAddr, &iType);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         return sciErr;
     }
 
     sciprint("\tType: ");
-    switch(iType)
+    switch (iType)
     {
         case sci_matrix :
             sciprint("double\n");
@@ -100,12 +100,12 @@ SciErr printf_info(int _iVar)
             int iPrec           = 0;
 
             sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr, &iPrec);
-            if(sciErr.iErr)
+            if (sciErr.iErr)
             {
                 return sciErr;
             }
 
-            if(iPrec > 10)
+            if (iPrec > 10)
             {
                 pstSign = pstUnsigned;
             }
@@ -130,16 +130,16 @@ SciErr printf_info(int _iVar)
             return sciErr;
     }
 
-    if(isVarComplex(pvApiCtx, piAddr))
+    if (isVarComplex(pvApiCtx, piAddr))
     {
         sciprint("\tComplex: Yes\n");
     }
 
     sciprint("\tDimensions: ");
-    if(isVarMatrixType(pvApiCtx, piAddr))
+    if (isVarMatrixType(pvApiCtx, piAddr))
     {
         sciErr = getVarDimension(pvApiCtx, piAddr, &iRows, &iCols);
-        if(sciErr.iErr)
+        if (sciErr.iErr)
         {
             return sciErr;
         }
@@ -149,7 +149,7 @@ SciErr printf_info(int _iVar)
     else
     {
         sciErr = getListItemNumber(pvApiCtx, piAddr, &iItem);
-        if(sciErr.iErr)
+        if (sciErr.iErr)
         {
             return sciErr;
         }
index 6b1d567..18a9102 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int doubleExample(char *fname,unsigned long fname_len)
+int doubleExample(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       int* piAddr = NULL;
-       int iType   = 0;
-       int iRet    = 0;
+    SciErr sciErr;
+    int* piAddr = NULL;
+    int iType   = 0;
+    int iRet    = 0;
 
     CheckInputArgument(pvApiCtx, 1, 1);
     CheckOutputArgument(pvApiCtx, 0, 1);
 
     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       if(isEmptyMatrix(pvApiCtx, piAddr))
-       {
-               iRet = createEmptyMatrix(pvApiCtx, InputArgument + 1);
-               if(iRet)
-               {
-                       return iRet;
-               }
+    if (isEmptyMatrix(pvApiCtx, piAddr))
+    {
+        iRet = createEmptyMatrix(pvApiCtx, nbInputArgument + 1);
+        if (iRet)
+        {
+            return iRet;
+        }
 
-               AssignOutputVariable(1) = 0;
-       }
-       else if(isDoubleType(pvApiCtx, piAddr))
-       {
-               if(isScalar(pvApiCtx, piAddr))
-               {
-                       double dblReal  = 0;
-                       double dblImg   = 0;
+        AssignOutputVariable(1) = 0;
+    }
+    else if (isDoubleType(pvApiCtx, piAddr))
+    {
+        if (isScalar(pvApiCtx, piAddr))
+        {
+            double dblReal     = 0;
+            double dblImg   = 0;
 
-                       if(isVarComplex(pvApiCtx, piAddr))
-                       {
-                               iRet = getScalarComplexDouble(pvApiCtx, piAddr, &dblReal, &dblImg);
-                               if(iRet)
-                               {
-                                       return iRet;
-                               }
+            if (isVarComplex(pvApiCtx, piAddr))
+            {
+                iRet = getScalarComplexDouble(pvApiCtx, piAddr, &dblReal, &dblImg);
+                if (iRet)
+                {
+                    return iRet;
+                }
 
-                               iRet = createScalarComplexDouble(pvApiCtx, InputArgument + 1, dblReal, dblImg);
-                               if(iRet)
-                               {
-                                       return iRet;
-                               }
-                       }
-                       else
-                       {
-                               iRet = getScalarDouble(pvApiCtx, piAddr, &dblReal);
-                               if(iRet)
-                               {
-                                       return iRet;
-                               }
+                iRet = createScalarComplexDouble(pvApiCtx, nbInputArgument + 1, dblReal, dblImg);
+                if (iRet)
+                {
+                    return iRet;
+                }
+            }
+            else
+            {
+                iRet = getScalarDouble(pvApiCtx, piAddr, &dblReal);
+                if (iRet)
+                {
+                    return iRet;
+                }
 
-                               iRet = createScalarDouble(pvApiCtx, InputArgument + 1, dblReal);
-                               if(iRet)
-                               {
-                                       return iRet;
-                               }
-                       }
-               }
-               else
-               {
-                       int iRows                       = 0;
-                       int iCols                       = 0;
-                       double* pdblReal        = NULL;
-                       double* pdblImg         = NULL;
+                iRet = createScalarDouble(pvApiCtx, nbInputArgument + 1, dblReal);
+                if (iRet)
+                {
+                    return iRet;
+                }
+            }
+        }
+        else
+        {
+            int iRows                  = 0;
+            int iCols                  = 0;
+            double* pdblReal   = NULL;
+            double* pdblImg            = NULL;
 
-                       if(isVarComplex(pvApiCtx, piAddr))
-                       {
-                               sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
-                               if(sciErr.iErr)
-                               {
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
+            if (isVarComplex(pvApiCtx, piAddr))
+            {
+                sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
 
-                               sciErr = createComplexMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblReal, pdblImg);
-                               if(sciErr.iErr)
-                               {
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
-                       }
-                       else
-                       {
-                               sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
-                               if(sciErr.iErr)
-                               {
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
+                sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal, pdblImg);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
+            }
+            else
+            {
+                sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
 
-                               sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblReal);
-                               if(sciErr.iErr)
-                               {
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
-                       }
-               }
+                sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
+            }
+        }
 
-        AssignOutputVariable(1) = InputArgument + 1;
-       }
+        AssignOutputVariable(1) = nbInputArgument + 1;
+    }
 
-       return 0;
+    return 0;
 }
index 06b09e9..a6c7f06 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int read_double(char *fname,unsigned long fname_len)
+int read_double(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       int i;
-       //first variable info : real matrix of double
-       int iType                       = 0;
-       int iRows                       = 0;
-       int iCols                       = 0;
-       int iComplex            = 0;
-       int *piAddr                     = NULL;
-       double* pdblReal        = NULL;
-       double* pdblImg         = NULL;
+    SciErr sciErr;
+    int i;
+    //first variable info : real matrix of double
+    int iType                  = 0;
+    int iRows                  = 0;
+    int iCols                  = 0;
+    int iComplex               = 0;
+    int *piAddr                        = NULL;
+    double* pdblReal   = NULL;
+    double* pdblImg            = NULL;
 
-       //check input and output arguments
+    //check input and output arguments
     CheckInputArgument(pvApiCtx, 1, 1);
     CheckOutputArgument(pvApiCtx, 1, 1);
 
     /************************
-       *    First variable    *
-       ************************/
+    *    First variable    *
+    ************************/
 
-       //get variable address of the first input argument
-       sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //get variable address of the first input argument
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check type
-       sciErr = getVarType(pvApiCtx, piAddr, &iType);
-       if(sciErr.iErr || iType != sci_matrix)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check type
+    sciErr = getVarType(pvApiCtx, piAddr, &iType);
+    if (sciErr.iErr || iType != sci_matrix)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //get complexity
-       iComplex        = isVarComplex(pvApiCtx, piAddr);
+    //get complexity
+    iComplex   = isVarComplex(pvApiCtx, piAddr);
 
-       //check complexity
-       if(iComplex)
-       {
-               //get size and data from Scilab memory
-               sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
-       }
-       else
-       {
-               //get size and data from Scilab memory
-               sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
-       }
+    //check complexity
+    if (iComplex)
+    {
+        //get size and data from Scilab memory
+        sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
+    }
+    else
+    {
+        //get size and data from Scilab memory
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
+    }
 
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //Do something with data
-       //if variable is complex, switch real part and imaginary part otherwise multiply by -1
-       if(iComplex)
-       {
-               sciErr = createComplexMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblImg, pdblReal);
-       }
-       else
-       {
-               for(i = 0 ; i < iRows * iCols ; i++)
-               {
-                       pdblReal[i] = pdblReal[i] * -1;
-               }
-               sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows, iCols, pdblReal);
-       }
+    //Do something with data
+    //if variable is complex, switch real part and imaginary part otherwise multiply by -1
+    if (iComplex)
+    {
+        sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblImg, pdblReal);
+    }
+    else
+    {
+        for (i = 0 ; i < iRows * iCols ; i++)
+        {
+            pdblReal[i] = pdblReal[i] * -1;
+        }
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal);
+    }
 
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-    AssignOutputVariable(1) = InputArgument + 1;
-       return 0;
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    return 0;
 }
index ced115e..ccfb727 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int write_double(char *fname,unsigned long fname_len)
+int write_double(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       int i,j;
-       //first variable info : real matrix of double 3 x 4
-       int iRows1                      = 3;
-       int iCols1                      = 4;
-       double* pdblReal1       = NULL;
-       //second variable info : complex matrix of double 4 x 6
-       int iRows2                      = 4;
-       int iCols2                      = 6;
-       double* pdblReal2       = NULL;
-       double* pdblImg2        = NULL;
+    SciErr sciErr;
+    int i, j;
+    //first variable info : real matrix of double 3 x 4
+    int iRows1                 = 3;
+    int iCols1                 = 4;
+    double* pdblReal1  = NULL;
+    //second variable info : complex matrix of double 4 x 6
+    int iRows2                 = 4;
+    int iCols2                 = 6;
+    double* pdblReal2  = NULL;
+    double* pdblImg2   = NULL;
 
-       /************************
-       *    First variable    *
-       ************************/
+    /************************
+    *    First variable    *
+    ************************/
 
-       //alloc array of data in OS memory
-       pdblReal1 = (double*)malloc(sizeof(double) * iRows1 * iCols1);
-       //fill array with incremental values
-       //[ 0   1   2   3
-       //  4   5   6   7
-       //  8   9   10  11]
-       for(i = 0 ; i < iRows1 ; i++)
-       {
-               for(j = 0 ; j < iCols1 ; j++)
-               {
-                       pdblReal1[i + iRows1 * j] = i * iCols1 + j;
-               }
-       }
+    //alloc array of data in OS memory
+    pdblReal1 = (double*)malloc(sizeof(double) * iRows1 * iCols1);
+    //fill array with incremental values
+    //[ 0   1   2   3
+    //  4   5   6   7
+    //  8   9   10  11]
+    for (i = 0 ; i < iRows1 ; i++)
+    {
+        for (j = 0 ; j < iCols1 ; j++)
+        {
+            pdblReal1[i + iRows1 * j] = i * iCols1 + j;
+        }
+    }
 
-       //can be written in a single loop
-       //for(i = 0 ; i < iRows1 * iCols1; i++)
-       //{
-       //  pdblReal1[i] = i;
-       //}
-       //create a variable from a existing data array
+    //can be written in a single loop
+    //for(i = 0 ; i < iRows1 * iCols1; i++)
+    //{
+    //  pdblReal1[i] = i;
+    //}
+    //create a variable from a existing data array
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows1, iCols1, pdblReal1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //after creation, we can free memory.
+    free(pdblReal1);
 
-       sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, iRows1, iCols1, pdblReal1);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-       //after creation, we can free memory.
-       free(pdblReal1);
 
-       
     /*************************
-       *    Second variable    *
-       *************************/
+    *    Second variable    *
+    *************************/
 
-       //reserve space in scilab memory and fill it
-       sciErr = allocComplexMatrixOfDouble(pvApiCtx, InputArgument + 2, iRows2, iCols2, &pdblReal2, &pdblImg2);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //reserve space in scilab memory and fill it
+    sciErr = allocComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 2, iRows2, iCols2, &pdblReal2, &pdblImg2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //fill array with incremental values for real part and decremental for imaginary part
-       //[ 23i     1+22i       2+21i       3+20i       4+19i       5+18i
-       //  6+17i   7+16i       8+15i       9+14i       10+13i      11+12i
-       //  12+11i  13+10i      14+9i       15+8i       16+7i       17+6i
-       //  18+5i   19+4i       20+3i       21+2i       22+1i       23  ]
-       for(i = 0 ; i < iRows2 ; i++)
-       {
-               for(j = 0 ; j < iCols2 ; j++)
-               {
-                       pdblReal2[i + iRows2 * j] = i * iCols2 + j;
-                       pdblImg2 [i + iRows2 * j]       = (iRows2 * iCols2 - 1) - (i * iCols2 + j);
-               }
-       }
+    //fill array with incremental values for real part and decremental for imaginary part
+    //[ 23i     1+22i       2+21i       3+20i       4+19i       5+18i
+    //  6+17i   7+16i       8+15i       9+14i       10+13i      11+12i
+    //  12+11i  13+10i      14+9i       15+8i       16+7i       17+6i
+    //  18+5i   19+4i       20+3i       21+2i       22+1i       23  ]
+    for (i = 0 ; i < iRows2 ; i++)
+    {
+        for (j = 0 ; j < iCols2 ; j++)
+        {
+            pdblReal2[i + iRows2 * j] = i * iCols2 + j;
+            pdblImg2 [i + iRows2 * j]  = (iRows2 * iCols2 - 1) - (i * iCols2 + j);
+        }
+    }
 
-       //can be written in a single loop
-       //for(i = 0 ; i < iRows2 * iCols2; i++)
-       //{
-       //  pdblReal2[i] = i;
-       //  pdblImg2 [i] = (iRows2 * iCols2 - 1) - i;
-       //}
-       // /!\ DO NOT FREE MEMORY, in this case, it's the Scilab memory
-       //assign allocated variables to Lhs position
+    //can be written in a single loop
+    //for(i = 0 ; i < iRows2 * iCols2; i++)
+    //{
+    //  pdblReal2[i] = i;
+    //  pdblImg2 [i] = (iRows2 * iCols2 - 1) - i;
+    //}
+    // /!\ DO NOT FREE MEMORY, in this case, it's the Scilab memory
+    //assign allocated variables to Lhs position
 
-    AssignOutputVariable(1) = InputArgument + 1;
-    AssignOutputVariable(2) = InputArgument + 2;
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(2) = nbInputArgument + 2;
 
     return 0;
 }
index d8e659a..a61ba9e 100644 (file)
 
 void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn);
 
-int read_integer(char *fname,unsigned long fname_len)
+int read_integer(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       //output variable info
-       int iRows8                                      = 0;
-       int iCols8                                      = 0;
-       int iRows16                                     = 0;
-       int iCols16                                     = 0;
-       int iRows32                                     = 0;
-       int iCols32                                     = 0;
-       int iRowsu8                                     = 0;
-       int iColsu8                                     = 0;
-       int iRowsu16                            = 0;
-       int iColsu16                            = 0;
-       int iRowsu32                            = 0;
-       int iColsu32                            = 0;
-       int iPrec                                       = 0;
-       int* piAddr8                            = NULL;
-       int* piAddr16                           = NULL;
-       int* piAddr32                           = NULL;
-       int* piAddru8                           = NULL;
-       int* piAddru16                          = NULL;
-       int* piAddru32                          = NULL;
-       char* pcData                            = NULL;
-       short* psData                           = NULL;
-       int* piData                                     = NULL;
-       unsigned char* pucData          = NULL;
-       unsigned short* pusData         = NULL;
-       unsigned int* puiData           = NULL;
-       char* pcDataOut                         = NULL;
-       short* psDataOut                        = NULL;
-       int* piDataOut                          = NULL;
-       unsigned char* pucDataOut       = NULL;
-       unsigned short* pusDataOut      = NULL;
-       unsigned int* puiDataOut        = NULL;
+    SciErr sciErr;
+    //output variable info
+    int iRows8                                 = 0;
+    int iCols8                                 = 0;
+    int iRows16                                        = 0;
+    int iCols16                                        = 0;
+    int iRows32                                        = 0;
+    int iCols32                                        = 0;
+    int iRowsu8                                        = 0;
+    int iColsu8                                        = 0;
+    int iRowsu16                               = 0;
+    int iColsu16                               = 0;
+    int iRowsu32                               = 0;
+    int iColsu32                               = 0;
+    int iPrec                                  = 0;
+    int* piAddr8                               = NULL;
+    int* piAddr16                              = NULL;
+    int* piAddr32                              = NULL;
+    int* piAddru8                              = NULL;
+    int* piAddru16                             = NULL;
+    int* piAddru32                             = NULL;
+    char* pcData                               = NULL;
+    short* psData                              = NULL;
+    int* piData                                        = NULL;
+    unsigned char* pucData             = NULL;
+    unsigned short* pusData            = NULL;
+    unsigned int* puiData              = NULL;
+    char* pcDataOut                            = NULL;
+    short* psDataOut                   = NULL;
+    int* piDataOut                             = NULL;
+    unsigned char* pucDataOut  = NULL;
+    unsigned short* pusDataOut = NULL;
+    unsigned int* puiDataOut   = NULL;
 
-       //check input/ouput arguments count
+    //check input/ouput arguments count
     CheckInputArgument(pvApiCtx, 6, 6);
     CheckOutputArgument(pvApiCtx, 6, 6);
 
-       //get varialbe address
-       sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //get varialbe address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_INT8)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_INT8)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_UINT8)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_UINT8)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_INT16)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_INT16)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_UINT16)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_INT32)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_UINT16)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_INT32)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_UINT32)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_UINT32)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //alloc and fill new variable
-       pcDataOut   = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
-       pucDataOut  = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
-       psDataOut   = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
-       pusDataOut  = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
-       piDataOut   = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
-       puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
+    //alloc and fill new variable
+    pcDataOut   = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
+    pucDataOut  = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
+    psDataOut   = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
+    pusDataOut  = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
+    piDataOut   = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
+    puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
 
-       //create new variable
-       sciErr = createMatrixOfInteger8(pvApiCtx, InputArgument + 1, iRows8, iCols8, pcDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument + 1, iRows8, iCols8, pcDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, InputArgument + 2, iRowsu8, iColsu8, pucDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 2, iRowsu8, iColsu8, pucDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfInteger16(pvApiCtx, InputArgument + 3, iRows16, iCols16, psDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 3, iRows16, iCols16, psDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, InputArgument + 4, iRowsu16, iColsu16, pusDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 4, iRowsu16, iColsu16, pusDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 5, iRows32, iCols32, piDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 5, iRows32, iCols32, piDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, InputArgument + 6, iRowsu32, iColsu32, puiDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 6, iRowsu32, iColsu32, puiDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = InputArgument + 1;
-       AssignOutputVariable(2) = InputArgument + 2;
-       AssignOutputVariable(3) = InputArgument + 3;
-       AssignOutputVariable(4) = InputArgument + 4;
-       AssignOutputVariable(5) = InputArgument + 5;
-       AssignOutputVariable(6) = InputArgument + 6;
-       return 0;
+    //assign allocated variables to Lhs position
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(2) = nbInputArgument + 2;
+    AssignOutputVariable(3) = nbInputArgument + 3;
+    AssignOutputVariable(4) = nbInputArgument + 4;
+    AssignOutputVariable(5) = nbInputArgument + 5;
+    AssignOutputVariable(6) = nbInputArgument + 6;
+    return 0;
 }
 
 void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn)
 {
-       int i = 0;
-       void* pvDataOut = (void*)malloc(_iSize * _iRows * _iCols);
-       for(i = 0 ; i < _iRows * _iCols ; i++)
-       {
-               int iVal = 0;
-               memcpy(&iVal, (char*)_pvDataIn + i * _iSize, _iSize);
-               iVal *= _iCoeff;
-               memcpy((char*)pvDataOut + i * _iSize, &iVal, _iSize);
-       }
-       return pvDataOut;
+    int i = 0;
+    void* pvDataOut = (void*)malloc(_iSize * _iRows * _iCols);
+    for (i = 0 ; i < _iRows * _iCols ; i++)
+    {
+        int iVal = 0;
+        memcpy(&iVal, (char*)_pvDataIn + i * _iSize, _iSize);
+        iVal *= _iCoeff;
+        memcpy((char*)pvDataOut + i * _iSize, &iVal, _iSize);
+    }
+    return pvDataOut;
 }
index a1ecc29..2af0823 100644 (file)
 #include "MALLOC.h"
 
 void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn);
-int read_integer(char *fname,unsigned long fname_len)
+int read_integer(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       //output variable info
-       int iRows8                                      = 0;
-       int iCols8                                      = 0;
-       int iRows16                                     = 0;
-       int iCols16                                     = 0;
-       int iRows32                                     = 0;
-       int iCols32                                     = 0;
-       int iRowsu8                                     = 0;
-       int iColsu8                                     = 0;
-       int iRowsu16                            = 0;
-       int iColsu16                            = 0;
-       int iRowsu32                            = 0;
-       int iColsu32                            = 0;
-       int iPrec                                       = 0;
-       int* piAddr8                            = NULL;
-       int* piAddr16                           = NULL;
-       int* piAddr32                           = NULL;
-       int* piAddru8                           = NULL;
-       int* piAddru16                          = NULL;
-       int* piAddru32                          = NULL;
-       char* pcData                            = NULL;
-       short* psData                           = NULL;
-       int* piData                                     = NULL;
-       unsigned char* pucData          = NULL;
-       unsigned short* pusData         = NULL;
-       unsigned int* puiData           = NULL;
-       char* pcDataOut                         = NULL;
-       short* psDataOut                        = NULL;
-       int* piDataOut                          = NULL;
-       unsigned char* pucDataOut       = NULL;
-       unsigned short* pusDataOut      = NULL;
-       unsigned int* puiDataOut        = NULL;
+    SciErr sciErr;
+    //output variable info
+    int iRows8                                 = 0;
+    int iCols8                                 = 0;
+    int iRows16                                        = 0;
+    int iCols16                                        = 0;
+    int iRows32                                        = 0;
+    int iCols32                                        = 0;
+    int iRowsu8                                        = 0;
+    int iColsu8                                        = 0;
+    int iRowsu16                               = 0;
+    int iColsu16                               = 0;
+    int iRowsu32                               = 0;
+    int iColsu32                               = 0;
+    int iPrec                                  = 0;
+    int* piAddr8                               = NULL;
+    int* piAddr16                              = NULL;
+    int* piAddr32                              = NULL;
+    int* piAddru8                              = NULL;
+    int* piAddru16                             = NULL;
+    int* piAddru32                             = NULL;
+    char* pcData                               = NULL;
+    short* psData                              = NULL;
+    int* piData                                        = NULL;
+    unsigned char* pucData             = NULL;
+    unsigned short* pusData            = NULL;
+    unsigned int* puiData              = NULL;
+    char* pcDataOut                            = NULL;
+    short* psDataOut                   = NULL;
+    int* piDataOut                             = NULL;
+    unsigned char* pucDataOut  = NULL;
+    unsigned short* pusDataOut = NULL;
+    unsigned int* puiDataOut   = NULL;
 
-       //check input/ouput arguments count
-       CheckInputArgument(pvApiCtx, 6,6);
-       CheckOutputArgument(pvApiCtx, 6,6);
+    //check input/ouput arguments count
+    CheckInputArgument(pvApiCtx, 6, 6);
+    CheckOutputArgument(pvApiCtx, 6, 6);
 
-       //get varialbe address
-       sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //get varialbe address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddru8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr16);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddru16);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr32);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddru32);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_INT8)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_INT8)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_UINT8)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_UINT8)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_INT16)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_INT16)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_UINT16)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_UINT16)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_INT32)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_INT32)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //check variable precision
-       sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
-       if(sciErr.iErr || iPrec != SCI_UINT32)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //check variable precision
+    sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
+    if (sciErr.iErr || iPrec != SCI_UINT32)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //retrieve dimensions and data
-       sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //retrieve dimensions and data
+    sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //alloc and fill new variable
-       pcDataOut   = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
-       pucDataOut  = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
-       psDataOut   = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
-       pusDataOut  = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
-       piDataOut   = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
-       puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
+    //alloc and fill new variable
+    pcDataOut   = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
+    pucDataOut  = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
+    psDataOut   = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
+    pusDataOut  = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
+    piDataOut   = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
+    puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);
 
-       //create new variable
-       sciErr = createMatrixOfInteger8(pvApiCtx, InputArgument + 1, iRows8, iCols8, pcDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument + 1, iRows8, iCols8, pcDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, InputArgument + 2, iRowsu8, iColsu8, pucDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 2, iRowsu8, iColsu8, pucDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfInteger16(pvApiCtx, InputArgument + 3, iRows16, iCols16, psDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 3, iRows16, iCols16, psDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, InputArgument + 4, iRowsu16, iColsu16, pusDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 4, iRowsu16, iColsu16, pusDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfInteger32(pvApiCtx, InputArgument + 5, iRows32, iCols32, piDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 5, iRows32, iCols32, piDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //create new variable
-       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, InputArgument + 6, iRowsu32, iColsu32, puiDataOut);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //create new variable
+    sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 6, iRowsu32, iColsu32, puiDataOut);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = InputArgument + 1;
-       AssignOutputVariable(2) = InputArgument + 2;
-       AssignOutputVariable(3) = InputArgument + 3;
-       AssignOutputVariable(4) = InputArgument + 4;
-       AssignOutputVariable(5) = InputArgument + 5;
-       AssignOutputVariable(6) = InputArgument + 6;
-       return 0;
+    //assign allocated variables to Lhs position
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(2) = nbInputArgument + 2;
+    AssignOutputVariable(3) = nbInputArgument + 3;
+    AssignOutputVariable(4) = nbInputArgument + 4;
+    AssignOutputVariable(5) = nbInputArgument + 5;
+    AssignOutputVariable(6) = nbInputArgument + 6;
+    return 0;
 }
 
 void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn)
 {
-       int i = 0;
-       void* pvDataOut = (void*)malloc(_iSize * _iRows * _iCols);
-       for(i = 0 ; i < _iRows * _iCols ; i++)
-       {
-               int iVal = 0;
-               memcpy(&iVal, (char*)_pvDataIn + i * _iSize, _iSize);
-               iVal *= _iCoeff;
-               memcpy((char*)pvDataOut + i * _iSize, &iVal, _iSize);
-       }
-       return pvDataOut;
+    int i = 0;
+    void* pvDataOut = (void*)malloc(_iSize * _iRows * _iCols);
+    for (i = 0 ; i < _iRows * _iCols ; i++)
+    {
+        int iVal = 0;
+        memcpy(&iVal, (char*)_pvDataIn + i * _iSize, _iSize);
+        iVal *= _iCoeff;
+        memcpy((char*)pvDataOut + i * _iSize, &iVal, _iSize);
+    }
+    return pvDataOut;
 }
index ac89062..17f16ef 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int list_createlist(char *fname,unsigned long fname_len)
+int list_createlist(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       int *piAddr             = NULL;
-       int* piChild            = NULL;
-       double pdblData1[]      = {1,3,5,2,4,6};
-       double pdblData2[]      = {6,4,2,5,3,1};
-       char *pstData[]         = {"may","be","the","with","puffin","you"};
-       short psData[]          = {1,4,2,5,3,6};
-       double pdblPoly1[]      = {1};
-       double pdblPoly2[]      = {-2,-1};
-       double pdblPoly3[]      = {1,2,3};
-       double pdblPoly4[]      = {-4,-3,-2,-1};
-       double pdblPoly5[]      = {1,2,3,4,5};
-       double pdblPoly6[]      = {-6,-5,-4,-3,-2,-1};
-       double *pdblPoly[]      = {pdblPoly1, pdblPoly3, pdblPoly5, pdblPoly2, pdblPoly4, pdblPoly6};
-       int piCoef[]            = {1,3,5,2,4,6};
-       int piNbItemRow[]       = {1,2,1};
-       int piColPos[]          = {8,4,7,2};
-       double pdblSReal[]      = {1,2,3,4};
-       double pdblSImg[]       = {4,3,2,1};
-       int piBool[]            = {1,0,1,0,1,0,1,0,1};
-       double* pdblDataPtr     = NULL;
+    SciErr sciErr;
+    int *piAddr             = NULL;
+    int* piChild            = NULL;
+    double pdblData1[]      = {1, 3, 5, 2, 4, 6};
+    double pdblData2[]      = {6, 4, 2, 5, 3, 1};
+    char *pstData[]         = {"may", "be", "the", "with", "puffin", "you"};
+    short psData[]          = {1, 4, 2, 5, 3, 6};
+    double pdblPoly1[]      = {1};
+    double pdblPoly2[]      = { -2, -1};
+    double pdblPoly3[]      = {1, 2, 3};
+    double pdblPoly4[]      = { -4, -3, -2, -1};
+    double pdblPoly5[]      = {1, 2, 3, 4, 5};
+    double pdblPoly6[]      = { -6, -5, -4, -3, -2, -1};
+    double *pdblPoly[]      = {pdblPoly1, pdblPoly3, pdblPoly5, pdblPoly2, pdblPoly4, pdblPoly6};
+    int piCoef[]            = {1, 3, 5, 2, 4, 6};
+    int piNbItemRow[]       = {1, 2, 1};
+    int piColPos[]          = {8, 4, 7, 2};
+    double pdblSReal[]      = {1, 2, 3, 4};
+    double pdblSImg[]       = {4, 3, 2, 1};
+    int piBool[]            = {1, 0, 1, 0, 1, 0, 1, 0, 1};
+    double* pdblDataPtr     = NULL;
 
-       sciErr = createList(pvApiCtx, InputArgument + 1, 8, &piAddr);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createList(pvApiCtx, nbInputArgument + 1, 8, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, InputArgument + 1, piAddr, 2, 2, 3, pstData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, InputArgument + 1, piAddr, 3, 2, 3, psData);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, InputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-       sciErr = createComplexSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, InputArgument + 1, piAddr, 6, 3, 3, piBool);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-       sciErr = createBooleanSparseMatrixInList(pvApiCtx, InputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       //add list in list
-       sciErr = createListInList(pvApiCtx, InputArgument + 1, piAddr, 8, 3, &piChild);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    //add list in list
+    sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, InputArgument + 1, piChild, 1, 3, 2, pdblData1);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, InputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       pdblDataPtr     = (double*)malloc(sizeof(double) * 4);
-       pdblDataPtr[0]  = 1;
-       pdblDataPtr[1]  = 2;
-       pdblDataPtr[2]  = 3;
-       pdblDataPtr[3]  = 4;
+    pdblDataPtr     = (double*)malloc(sizeof(double) * 4);
+    pdblDataPtr[0]  = 1;
+    pdblDataPtr[1]  = 2;
+    pdblDataPtr[2]  = 3;
+    pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, InputArgument + 1, piChild, 3, pdblDataPtr);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
+    sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
 
-       AssignOutputVariable(1) = InputArgument + 1;
-       return 0;
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    return 0;
 }
index ec2d4bb..f324d87 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int read_pointer(char *fname,unsigned long fname_len)
+int read_pointer(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
+    SciErr sciErr;
 
-       CheckInputArgument(pvApiCtx, 0, 1);
+    CheckInputArgument(pvApiCtx, 0, 1);
     CheckOutputArgument(pvApiCtx, 1, 1);
 
-       if(InputArgument == 0)
-       {//create mode
-               double* pdblData    = (double*)malloc(sizeof(double) * 2 * 2);
-               pdblData[0]                     = 1;
-               pdblData[1]                     = 3;
-               pdblData[2]                     = 2;
-               pdblData[3]                     = 4;
-               sciErr = createPointer(pvApiCtx, InputArgument + 1, (void*)pdblData);
-       }
-       else if(InputArgument == 1)
-       {//read mode
-               int iType                       = 0;
-               int* piAddr                     = NULL;
-               void* pvPtr                     = NULL;
-               double* pdblData        = NULL;
-               sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-               if(sciErr.iErr)
-               {
-                       printError(&sciErr, 0);
-                       return 0;
-               }
-               sciErr = getPointer(pvApiCtx, piAddr, &pvPtr);
-               if(sciErr.iErr)
-               {
-                       printError(&sciErr, 0);
-                       return 0;
-               }
-               pdblData = (double*)pvPtr;
-               sciErr = createMatrixOfDouble(pvApiCtx, InputArgument + 1, 2, 2, pdblData);
-       }
-       else
-       {
-               return 0;
-       }
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-       AssignOutputVariable(1) = InputArgument + 1;
-       return 0;
+    if (nbInputArgument == 0)
+    {
+        //create mode
+        double* pdblData    = (double*)malloc(sizeof(double) * 2 * 2);
+        pdblData[0]                    = 1;
+        pdblData[1]                    = 3;
+        pdblData[2]                    = 2;
+        pdblData[3]                    = 4;
+        sciErr = createPointer(pvApiCtx, nbInputArgument + 1, (void*)pdblData);
+    }
+    else if (nbInputArgument == 1)
+    {
+        //read mode
+        int iType                      = 0;
+        int* piAddr                    = NULL;
+        void* pvPtr                    = NULL;
+        double* pdblData       = NULL;
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getPointer(pvApiCtx, piAddr, &pvPtr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        pdblData = (double*)pvPtr;
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, 2, 2, pdblData);
+    }
+    else
+    {
+        return 0;
+    }
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    return 0;
 }
index 8425f29..b21dd77 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int polyExample(char *fname,unsigned long fname_len)
+int polyExample(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       int* piAddr = NULL;
-       int iType   = 0;
-       int iRet    = 0;
+    SciErr sciErr;
+    int* piAddr = NULL;
+    int iType   = 0;
+    int iRet    = 0;
 
     CheckInputArgument(pvApiCtx, 1, 1);
     CheckOutputArgument(pvApiCtx, 0, 1);
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       if(isPolyType(pvApiCtx, piAddr))
-       {
-               char pstVarName[64];
-               int iLen = 0;
-
-               sciErr = getPolyVariableName(pvApiCtx, piAddr, pstVarName, &iLen);
-               if(sciErr.iErr)
-               {
-                       printError(&sciErr, 0);
-                       return sciErr.iErr;
-               }
-
-               if(isScalar(pvApiCtx, piAddr))
-               {
-                       int iNbCoef                             = 0;
-                       double* pdblReal        = NULL;
-                       double* pdblImg         = NULL;
-
-                       if(isVarComplex(pvApiCtx, piAddr))
-                       {
-                               iRet = getAllocatedSingleComplexPoly(pvApiCtx, piAddr, &iNbCoef, &pdblReal, &pdblImg);
-                               if(iRet)
-                               {
-                                       freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
-                                       return iRet;
-                               }
-
-                               sciErr = createComplexMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal, &pdblImg);
-                               if(sciErr.iErr)
-                               {
-                                       freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
-
-                               freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
-                       }
-                       else
-                       {
-                               iRet = getAllocatedSinglePoly(pvApiCtx, piAddr, &iNbCoef, &pdblReal);
-                               if(iRet)
-                               {
-                                       freeAllocatedSinglePoly(pdblReal);
-                                       return iRet;
-                               }
-
-                               sciErr = createMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal);
-                               if(sciErr.iErr)
-                               {
-                                       freeAllocatedSinglePoly(pdblReal);
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
-
-                               freeAllocatedSinglePoly(pdblReal);
-                       }
-               }
-               else
-               {
-                       int iRows           = 0;
-                       int iCols           = 0;
-                       int* piNbCoef       = NULL;
-                       double** pdblReal   = NULL;
-                       double** pdblImg    = NULL;
-
-                       if(isVarComplex(pvApiCtx, piAddr))
-                       {
-                               iRet = getAllocatedMatrixOfComplexPoly(pvApiCtx, piAddr, &iRows, &iCols, &piNbCoef, &pdblReal, &pdblImg);
-                               if(iRet)
-                               {
-                                       freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
-                                       return iRet;
-                               }
-
-                               sciErr = createComplexMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
-                               if(sciErr.iErr)
-                               {
-                                       freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
-
-                               freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
-                       }
-                       else
-                       {
-                               iRet = getAllocatedMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, &piNbCoef, &pdblReal);
-                               if(iRet)
-                               {
-                                       freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
-                                       return iRet;
-                               }
-
-                               sciErr = createMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
-                               if(sciErr.iErr)
-                               {
-                                       freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
-                                       printError(&sciErr, 0);
-                                       return sciErr.iErr;
-                               }
-
-                               freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
-                       }
-               }
-
-        AssignOutputVariable(1) = InputArgument + 1;
-       }
-       else
-       {
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if (isPolyType(pvApiCtx, piAddr))
+    {
+        char pstVarName[64];
+        int iLen = 0;
+
+        sciErr = getPolyVariableName(pvApiCtx, piAddr, pstVarName, &iLen);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return sciErr.iErr;
+        }
+
+        if (isScalar(pvApiCtx, piAddr))
+        {
+            int iNbCoef                                = 0;
+            double* pdblReal   = NULL;
+            double* pdblImg            = NULL;
+
+            if (isVarComplex(pvApiCtx, piAddr))
+            {
+                iRet = getAllocatedSingleComplexPoly(pvApiCtx, piAddr, &iNbCoef, &pdblReal, &pdblImg);
+                if (iRet)
+                {
+                    freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
+                    return iRet;
+                }
+
+                sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal, &pdblImg);
+                if (sciErr.iErr)
+                {
+                    freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
+
+                freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
+            }
+            else
+            {
+                iRet = getAllocatedSinglePoly(pvApiCtx, piAddr, &iNbCoef, &pdblReal);
+                if (iRet)
+                {
+                    freeAllocatedSinglePoly(pdblReal);
+                    return iRet;
+                }
+
+                sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal);
+                if (sciErr.iErr)
+                {
+                    freeAllocatedSinglePoly(pdblReal);
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
+
+                freeAllocatedSinglePoly(pdblReal);
+            }
+        }
+        else
+        {
+            int iRows           = 0;
+            int iCols           = 0;
+            int* piNbCoef       = NULL;
+            double** pdblReal   = NULL;
+            double** pdblImg    = NULL;
+
+            if (isVarComplex(pvApiCtx, piAddr))
+            {
+                iRet = getAllocatedMatrixOfComplexPoly(pvApiCtx, piAddr, &iRows, &iCols, &piNbCoef, &pdblReal, &pdblImg);
+                if (iRet)
+                {
+                    freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
+                    return iRet;
+                }
+
+                sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+                if (sciErr.iErr)
+                {
+                    freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
+
+                freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
+            }
+            else
+            {
+                iRet = getAllocatedMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, &piNbCoef, &pdblReal);
+                if (iRet)
+                {
+                    freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
+                    return iRet;
+                }
+
+                sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
+                if (sciErr.iErr)
+                {
+                    freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
+                    printError(&sciErr, 0);
+                    return sciErr.iErr;
+                }
+
+                freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
+            }
+        }
+
+        AssignOutputVariable(1) = nbInputArgument + 1;
+    }
+    else
+    {
         AssignOutputVariable(1) = 0;
-       }
-       return 0;
+    }
+    return 0;
 }
index f3f2fe9..a4d46bc 100644 (file)
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int read_poly(char *fname,unsigned long fname_len)
+int read_poly(char *fname, unsigned long fname_len)
 {
-       SciErr sciErr;
-       int i,j;
-       //variable info
-       int iRows                       = 0;
-       int iCols                       = 0;
-       int iVarLen                     = 0;
-       int* piAddr                     = NULL;
-       int* piNbCoef           = NULL;
-       double** pdblReal       = NULL;
-       double** pdblImg        = NULL;
-       char* pstVarname        = NULL;
-
-       //check input and output arguments
+    SciErr sciErr;
+    int i, j;
+    //variable info
+    int iRows                  = 0;
+    int iCols                  = 0;
+    int iVarLen                        = 0;
+    int* piAddr                        = NULL;
+    int* piNbCoef              = NULL;
+    double** pdblReal  = NULL;
+    double** pdblImg   = NULL;
+    char* pstVarname   = NULL;
+
+    //check input and output arguments
     CheckInputArgument(pvApiCtx, 1, 1);
     CheckOutputArgument(pvApiCtx, 1, 1);
 
-       sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       if(isVarComplex(pvApiCtx, piAddr) == FALSE)
-       {
-               //Error
-               return 0;
-       }
-
-       //get variable name length
-       sciErr = getPolyVariableName(pvApiCtx, piAddr, NULL, &iVarLen);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       //alloc buff to receive variable name
-       pstVarname = (char*)malloc(sizeof(char) * (iVarLen + 1));//1 for null termination
-
-       //get variable name
-       sciErr = getPolyVariableName(pvApiCtx, piAddr, pstVarname, &iVarLen);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       //First call: retrieve dimmension
-       sciErr = getComplexMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL, NULL);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       //alloc array of coefficient
-       piNbCoef = (int*)malloc(sizeof(int) * iRows * iCols);
-
-       //Second call: retrieve coefficient
-       sciErr = getComplexMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, piNbCoef, NULL, NULL);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       //alloc arrays of data
-       pdblReal    = (double**)malloc(sizeof(double*) * iRows * iCols);
-       pdblImg     = (double**)malloc(sizeof(double*) * iRows * iCols);
-
-       for(i = 0 ; i < iRows * iCols ; i++)
-       {
-               pdblReal[i] = (double*)malloc(sizeof(double) * piNbCoef[i]);
-               pdblImg[i] = (double*)malloc(sizeof(double) * piNbCoef[i]);
-       }
-
-       //Third call: retrieve data
-       sciErr = getComplexMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, piNbCoef, pdblReal, pdblImg);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       //Do something with Data
-       //Invert polynomials in the matrix and invert coefficients
-       for(i = 0 ; i < (iRows * iCols) / 2 ; i++)
-       {
-               int iPos1                       = iRows * iCols - 1 - i;
-               double* pdblSave        = NULL;
-               int iNbCoefSave         = 0;
-               //switch array of coefficient
-               pdblSave                        = pdblReal[i];
-               pdblReal[i]                     = pdblReal[iPos1];
-               pdblReal[iPos1]         = pdblSave;
-               pdblSave                        = pdblImg[i];
-               pdblImg[i]                      = pdblImg[iPos1];
-               pdblImg[iPos1]          = pdblSave;
-               //switch number of coefficient
-               iNbCoefSave                     = piNbCoef[i];
-               piNbCoef[i]                     = piNbCoef[iPos1];
-               piNbCoef[iPos1]         = iNbCoefSave;
-       }
-
-       //switch coefficient
-       for(i = 0 ; i < iRows * iCols ; i++)
-       {
-               for(j = 0 ; j < piNbCoef[i] /2 ; j++)
-               {
-                       int iPos2                       = piNbCoef[i] - 1 - j;
-                       double dblVal           = pdblReal[i][j];
-                       pdblReal[i][j]          = pdblReal[i][iPos2];
-                       pdblReal[i][iPos2]      = dblVal;
-                       dblVal                          = pdblImg[i][j];
-                       pdblImg[i][j]           = pdblImg[i][iPos2];
-                       pdblImg[i][iPos2]       = dblVal;
-               }
-       }
-
-       sciErr = createComplexMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
-       if(sciErr.iErr)
-       {
-               printError(&sciErr, 0);
-               return 0;
-       }
-
-       //free OS memory
-       free(pstVarname);
-       free(piNbCoef);
-       for(i = 0 ; i < iRows * iCols ; i++)
-       {
-               free(pdblReal[i]);
-               free(pdblImg[i]);
-       }
-       free(pdblReal);
-       free(pdblImg);
-       //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = InputArgument + 1;
-       return 0;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if (isVarComplex(pvApiCtx, piAddr) == FALSE)
+    {
+        //Error
+        return 0;
+    }
+
+    //get variable name length
+    sciErr = getPolyVariableName(pvApiCtx, piAddr, NULL, &iVarLen);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //alloc buff to receive variable name
+    pstVarname = (char*)malloc(sizeof(char) * (iVarLen + 1));//1 for null termination
+
+    //get variable name
+    sciErr = getPolyVariableName(pvApiCtx, piAddr, pstVarname, &iVarLen);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //First call: retrieve dimmension
+    sciErr = getComplexMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL, NULL);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //alloc array of coefficient
+    piNbCoef = (int*)malloc(sizeof(int) * iRows * iCols);
+
+    //Second call: retrieve coefficient
+    sciErr = getComplexMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, piNbCoef, NULL, NULL);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //alloc arrays of data
+    pdblReal    = (double**)malloc(sizeof(double*) * iRows * iCols);
+    pdblImg     = (double**)malloc(sizeof(double*) * iRows * iCols);
+
+    for (i = 0 ; i < iRows * iCols ; i++)
+    {
+        pdblReal[i] = (double*)malloc(sizeof(double) * piNbCoef[i]);
+        pdblImg[i] = (double*)malloc(sizeof(double) * piNbCoef[i]);
+    }
+
+    //Third call: retrieve data
+    sciErr = getComplexMatrixOfPoly(pvApiCtx, piAddr, &iRows, &iCols, piNbCoef, pdblReal, pdblImg);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //Do something with Data
+    //Invert polynomials in the matrix and invert coefficients
+    for (i = 0 ; i < (iRows * iCols) / 2 ; i++)
+    {
+        int iPos1                      = iRows * iCols - 1 - i;
+        double* pdblSave       = NULL;
+        int iNbCoefSave                = 0;
+        //switch array of coefficient
+        pdblSave                       = pdblReal[i];
+        pdblReal[i]                    = pdblReal[iPos1];
+        pdblReal[iPos1]                = pdblSave;
+        pdblSave                       = pdblImg[i];
+        pdblImg[i]                     = pdblImg[iPos1];
+        pdblImg[iPos1]         = pdblSave;
+        //switch number of coefficient
+        iNbCoefSave                    = piNbCoef[i];
+        piNbCoef[i]                    = piNbCoef[iPos1];
+        piNbCoef[iPos1]                = iNbCoefSave;
+    }
+
+    //switch coefficient
+    for (i = 0 ; i < iRows * iCols ; i++)
+    {
+        for (j = 0 ; j < piNbCoef[i] / 2 ; j++)
+        {
+            int iPos2                  = piNbCoef[i] - 1 - j;
+            double dblVal              = pdblReal[i][j];
+            pdblReal[i][j]             = pdblReal[i][iPos2];
+            pdblReal[i][iPos2] = dblVal;
+            dblVal                             = pdblImg[i][j];
+            pdblImg[i][j]              = pdblImg[i][iPos2];
+            pdblImg[i][iPos2]  = dblVal;
+        }
+    }
+
+    sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //free OS memory
+    free(pstVarname);
+    free(piNbCoef);
+    for (i = 0 ; i < iRows * iCols ; i++)
+    {
+        free(pdblReal[i]);
+        free(pdblImg[i]);
+    }
+    free(pdblReal);
+    free(pdblImg);
+    //assign allocated variables to Lhs position
+    AssignOutputVariable(1) = nbInputArgument + 1;
+    return 0;
 }
index 3f526fc..2c12150 100644 (file)
@@ -16,7 +16,7 @@
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int write_poly(char *fname,unsigned long fname_len)
+int write_poly(char *fname, unsigned long fname_len)
 {
     SciErr sciErr;
     //output variable info : polinomial matrix 2 x 4
@@ -27,15 +27,15 @@ int write_poly(char *fname,unsigned long fname_len)
     //varname "x"
     char pstVarName[2]      = {"x"};
     //coeficient array
-    int piNbCoef[6]         = {2,4,3,1,4,6};
+    int piNbCoef[6]         = {2, 4, 3, 1, 4, 6};
     //data array
     double *pdblReal[6]     = {0};
-    double pdblPoly0[2]     = {2,1};
-    double pdblPoly1[4]     = {64,0,-12,2};
-    double pdblPoly2[3]     = {5,-4,1};
+    double pdblPoly0[2]     = {2, 1};
+    double pdblPoly1[4]     = {64, 0, -12, 2};
+    double pdblPoly2[3]     = {5, -4, 1};
     double pdblPoly3[1]     = {1};
-    double pdblPoly4[4]     = {18,0,-14,4};
-    double pdblPoly5[6]     = {0,0,0,32,0,8};
+    double pdblPoly4[4]     = {18, 0, -14, 4};
+    double pdblPoly5[6]     = {0, 0, 0, 32, 0, 8};
     pdblReal[0]             = pdblPoly0;
     pdblReal[1]             = pdblPoly1;
     pdblReal[2]             = pdblPoly2;
@@ -43,14 +43,14 @@ int write_poly(char *fname,unsigned long fname_len)
     pdblReal[4]             = pdblPoly4;
     pdblReal[5]             = pdblPoly5;
 
-    sciErr = createMatrixOfPoly(pvApiCtx, InputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
-    if(sciErr.iErr)
+    sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }
index f87dd3a..f594e87 100644 (file)
@@ -16,7 +16,7 @@
 #include "sciprint.h"
 #include "MALLOC.h"
 
-int read_write_boolean(char *fname,unsigned long fname_len)
+int read_write_boolean(char *fname, unsigned long fname_len)
 {
     SciErr sciErr;
     int i;
@@ -27,12 +27,12 @@ int read_write_boolean(char *fname,unsigned long fname_len)
     int* piBool     = NULL;
 
     //check input and output arguments
-    CheckInputArgument(pvApiCtx, 1,1);
-    CheckOutputArgument(pvApiCtx, 1,1);
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1);
 
     //get variable address of the first input argument
     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
@@ -40,25 +40,25 @@ int read_write_boolean(char *fname,unsigned long fname_len)
 
     //get size and data from Scilab memory
     sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &piBool);
-    if(sciErr.iErr)
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
     //Do something with data
-    for(i = 0 ; i < iRows * iCols ; i++)
+    for (i = 0 ; i < iRows * iCols ; i++)
     {
         piBool[i] = piBool[i] == 0 ? 1 : 0;
     }
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, InputArgument + 1, iRows, iCols, piBool);
-    if(sciErr.iErr)
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
+    if (sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = InputArgument + 1;
+    AssignOutputVariable(1) = nbInputArgument + 1;
     return 0;
 }