update api_scilab documention with changes on pvApiCtx 38/8638/2
Antoine ELIAS [Thu, 9 Aug 2012 15:26:59 +0000 (17:26 +0200)]
Change-Id: Ia5f76c6ddb65308ddba767b1a503b4f65121a0af

55 files changed:
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/getting_started.xml
scilab/modules/api_scilab/help/en_US/integer/D_integerExample.xml
scilab/modules/api_scilab/help/en_US/list_management/isListType.xml
scilab/modules/api_scilab/help/en_US/list_management/list_boolean_reading_api.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_reading_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_reading_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_getlistitemaddress_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_getlistitemnumber_api.xml
scilab/modules/api_scilab/help/en_US/list_management/list_integer_reading_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_reading_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_reading_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_reading_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_reading_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/ReturnArguments.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/check_matrix_dimension.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/deleteNamedVariable.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_reading_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

index c125f13..dfc452c 100644 (file)
@@ -27,7 +27,8 @@
     <!--Lib_name: booleanExample-->
     <!--Func_list: booleanExample-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+                <![CDATA[ 
 #include "api_scilab.h"
 
 int booleanExample(char *fname,unsigned long fname_len)
@@ -56,7 +57,7 @@ int booleanExample(char *fname,unsigned long fname_len)
             {
                 return 0;
             }
-            iRet = createScalarBoolean(pvApiCtx, nbInputArgument + 1, iBool);
+            iRet = createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iBool);
             if(iRet)
             {
                 return 0;
@@ -75,18 +76,18 @@ int booleanExample(char *fname,unsigned long fname_len)
                 return 0;
             }
 
-            sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
+            sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, piBool);
             if(sciErr.iErr)
             {
                 printError(&sciErr, 0);
                 return 0;
             }
         }
-        AssignOutputVariable(1) = nbInputArgument + 1;
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     }
     else
     {
-        AssignOutputVariable(1) = 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
     }
     return 0;
 }
index 1b990c2..a580395 100644 (file)
@@ -27,7 +27,8 @@
     <!--Lib_name: booleanSparseExample-->
     <!--Func_list: booleanSparseExample-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+    <![CDATA[ 
 #include "api_scilab.h"
 
 int booleanSparseExample(char *fname,unsigned long fname_len)
@@ -62,7 +63,7 @@ int booleanSparseExample(char *fname,unsigned long fname_len)
                        return iRet;
                }
 
-               sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos);
+               sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos);
                if(sciErr.iErr)
                {
                        freeAllocatedBooleanSparse(piNbItemRow, piColPos);
@@ -71,7 +72,7 @@ int booleanSparseExample(char *fname,unsigned long fname_len)
                }
 
                freeAllocatedBooleanSparse(piNbItemRow, piColPos);
-               AssignOutputVariable(1) = nbInputArgument + 1;
+               AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        }
        return 0;
 }
index 313d323..182876a 100644 (file)
@@ -27,7 +27,8 @@
     <!--Lib_name: doubleExample-->
     <!--Func_list: doubleExample-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+        <![CDATA[ 
 #include "api_scilab.h"
 
 int doubleExample(char *fname,unsigned long fname_len)
@@ -49,13 +50,13 @@ int doubleExample(char *fname,unsigned long fname_len)
 
        if(isEmptyMatrix(pvApiCtx, piAddr))
        {
-               iRet = createEmptyMatrix(pvApiCtx, nbInputArgument + 1);
+               iRet = createEmptyMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1);
                if(iRet)
                {
                        return iRet;
                }
 
-               AssignOutputVariable(1) = 0;
+               AssignOutputVariable(pvApiCtx, 1) = 0;
        }
        else if(isDoubleType(pvApiCtx, piAddr))
        {
@@ -72,7 +73,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarComplexDouble(pvApiCtx, nbInputArgument + 1, dblReal, dblImg);
+                               iRet = createScalarComplexDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dblReal, dblImg);
                                if(iRet)
                                {
                                        return iRet;
@@ -86,7 +87,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarDouble(pvApiCtx, nbInputArgument + 1, dblReal);
+                               iRet = createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dblReal);
                                if(iRet)
                                {
                                        return iRet;
@@ -109,7 +110,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal, pdblImg);
+                               sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pdblReal, pdblImg);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -125,7 +126,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal);
+                               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pdblReal);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -134,7 +135,7 @@ int doubleExample(char *fname,unsigned long fname_len)
                        }
                }
 
-        AssignOutputVariable(1) = nbInputArgument + 1;
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        }
 
        return 0;
index 7c59124..0c46bee 100644 (file)
 *
 -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:id="api_scilab_getting_started" xml:lang="en">
-  <refnamediv>
-    <refname>Getting started with API_Scilab</refname>
-    <refpurpose>How to load a C, C++ or fortran code in the Scilab engine as a new function</refpurpose>
-  </refnamediv>
-  <refsection>
-    <title>Description</title>
-    <para>
-      As described in the <link linkend="api_scilab">api_scilab presentation</link>, Scilab offers an API to extend the language with C, C++ or Fortran code (sources or libraries).
-    </para>
-    <para>
-      The link between the Scilab engine and the application code is called <literal>gateway</literal>.
-    </para>
-    <para>Most of the time, the process is always the same: 
-      <orderedlist>
-        <listitem>
-          <para>Check the number of arguments (both input and output) provided by the user.</para><para>
-            For example, if the function <literal>foo(x)</literal> is called with <literal>foo()</literal> or <literal>foo(2,3)</literal>, the user must get an answer.
-          </para>
-          <para>
-            More: <link linkend="CheckInputArgument">CheckInputArgument</link> and <link linkend="CheckOutputArgument">CheckOutputArgument</link> 
-          </para>
-        </listitem>
-        <listitem>
-          <para>Manage input arguments</para><para>Several tasks are performed:
-            <orderedlist inheritnum="inherit">
-              <listitem>
-                <para>Get the address to the variable for input argument X</para><para>
-                  Function 
-                  <literal>
-                    SciErr <link linkend="Common_getvaraddr_API">getVarAddressFromPosition</link>(void* context, int positionOfTheVariable, int** address)
-                  </literal>
-                </para>
-              </listitem>
-              <listitem>
-                <para>Check the type of the variable: matrix of double (complex or not), string, etc</para>
-                <para><literal>
-                    SciErr <link linkend="Common_getvartype_API">getVarType</link>(void* context, int* positionOfTheVariable, int* Type)
-                  </literal>
-                </para>
-                <para>Other functions are also provided:
-                  <itemizedlist>
-                    <listitem>
-                      <para>
-                        <literal>int isBooleanType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isBooleanSparseType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isDoubleType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isIntegerType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isPointerType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isPolyType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isSparseType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isStringType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isListType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isTListType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                    <listitem>
-                      <para>
-                        <literal>int isMListType(void* context, int* address)</literal>
-                      </para>
-                    </listitem>
-                  </itemizedlist>
-                </para>
-              </listitem>
-              <listitem>
-                <para>If it is relevant, check if the input argument is complex or not.</para>
-                <para><literal>
-                    int <link linkend="Common_iscomplex_API">isVarComplex</link>(void* context, int* address)
-                  </literal>
-                </para>
-              </listitem>
-              <listitem>
-                <para>Dealing with integer, further checks should be done on the precision of the integer</para>
-                <para><literal>
-                    SciErr <link linkend="int_getmatrixofintegerprecision_API">getMatrixOfIntegerPrecision</link>(void* context, int* address, int* precision)
-                  </literal>
-                </para>
-              </listitem>
-              <listitem>
-                <para>Check the size of the variable: square matrix, scalar, etc</para><para>
-                  The retrieval of the size information will be done with the same functions used to retrieve the actual data. For example, for a matrix of double, the function call 
-                  <literal>
-                    SciErr <link linkend="Double_management_reading_API">getMatrixOfDouble</link>(void* context, int* address, int* nbRows, int* nbCols, double** theActualData)
-                  </literal>
-                  will provide the dimension of the matrix.
-                </para>
-                <para>Almost all Scilab datatypes have an equivalent C function to perform such task.</para>
-              </listitem>
-              <listitem>
-                <para>Other checks can be done like specific values expected, consitency between the first and second input arguments, etc.</para>
-              </listitem>
-              <listitem>
-                <para>Data transformation (optional).</para><para>Depending on the code or library targeted, some transformations can be applied to the data. A classical example is changing the storage of a matrix from column-stored to line-stored.</para><para>Please note that it is usually a performance killer.</para>
-              </listitem>
+    <refnamediv>
+        <refname>Getting started with API_Scilab</refname>
+        <refpurpose>How to load a C, C++ or fortran code in the Scilab engine as a new function</refpurpose>
+    </refnamediv>
+    <refsection>
+        <title>Description</title>
+        <para>
+            As described in the <link linkend="api_scilab">api_scilab presentation</link>, Scilab offers an API to extend the language with C, C++ or Fortran code (sources or libraries).
+        </para>
+        <para>
+            The link between the Scilab engine and the application code is called <literal>gateway</literal>.
+        </para>
+        <para>
+            Most of the time, the process is always the same:
+            <orderedlist>
+                <listitem>
+                    <para>Check the number of arguments (both input and output) provided by the user.</para>
+                    <para>
+                        For example, if the function <literal>foo(x)</literal> is called with <literal>foo()</literal> or <literal>foo(2,3)</literal>, the user must get an answer.
+                    </para>
+                    <para>
+                        More: <link linkend="CheckInputArgument">CheckInputArgument</link> and <link linkend="CheckOutputArgument">CheckOutputArgument</link>
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>Manage input arguments</para>
+                    <para>
+                        Several tasks are performed:
+                        <orderedlist inheritnum="inherit">
+                            <listitem>
+                                <para>Get the address to the variable for input argument X</para>
+                                <para>
+                                    Function
+                                    <literal>
+                                        SciErr <link linkend="Common_getvaraddr_API">getVarAddressFromPosition</link>(void* context, int positionOfTheVariable, int** address)
+                                    </literal>
+                                </para>
+                            </listitem>
+                            <listitem>
+                                <para>Check the type of the variable: matrix of double (complex or not), string, etc</para>
+                                <para>
+                                    <literal>
+                                        SciErr <link linkend="Common_getvartype_API">getVarType</link>(void* context, int* positionOfTheVariable, int* Type)
+                                    </literal>
+                                </para>
+                                <para>
+                                    Other functions are also provided:
+                                    <itemizedlist>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isBooleanType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isBooleanSparseType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isDoubleType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isIntegerType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isPointerType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isPolyType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isSparseType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isStringType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isListType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isTListType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                        <listitem>
+                                            <para>
+                                                <literal>int isMListType(void* context, int* address)</literal>
+                                            </para>
+                                        </listitem>
+                                    </itemizedlist>
+                                </para>
+                            </listitem>
+                            <listitem>
+                                <para>If it is relevant, check if the input argument is complex or not.</para>
+                                <para>
+                                    <literal>
+                                        int <link linkend="Common_iscomplex_API">isVarComplex</link>(void* context, int* address)
+                                    </literal>
+                                </para>
+                            </listitem>
+                            <listitem>
+                                <para>Dealing with integer, further checks should be done on the precision of the integer</para>
+                                <para>
+                                    <literal>
+                                        SciErr <link linkend="int_getmatrixofintegerprecision_API">getMatrixOfIntegerPrecision</link>(void* context, int* address, int* precision)
+                                    </literal>
+                                </para>
+                            </listitem>
+                            <listitem>
+                                <para>Check the size of the variable: square matrix, scalar, etc</para>
+                                <para>
+                                    The retrieval of the size information will be done with the same functions used to retrieve the actual data. For example, for a matrix of double, the function call
+                                    <literal>
+                                        SciErr <link linkend="Double_management_reading_API">getMatrixOfDouble</link>(void* context, int* address, int* nbRows, int* nbCols, double** theActualData)
+                                    </literal>
+                                    will provide the dimension of the matrix.
+                                </para>
+                                <para>Almost all Scilab datatypes have an equivalent C function to perform such task.</para>
+                            </listitem>
+                            <listitem>
+                                <para>Other checks can be done like specific values expected, consitency between the first and second input arguments, etc.</para>
+                            </listitem>
+                            <listitem>
+                                <para>Data transformation (optional).</para>
+                                <para>Depending on the code or library targeted, some transformations can be applied to the data. A classical example is changing the storage of a matrix from column-stored to line-stored.</para>
+                                <para>Please note that it is usually a performance killer.</para>
+                            </listitem>
+                        </orderedlist>
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>Application code</para>
+                    <para>Once all the checks and data retrieval have been performed, the actual core code can be called. The actual intelligence (processes, data transformations, etc) will be performed here.</para>
+                    <para>
+                        This can be done through a thirdparty code stored and built in <literal>src/c</literal>, <literal>src/cpp</literal> or <literal>src/fortran</literal> but also under the form of a library. Virtually, any library could be linked to Scilab.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>Create the output arguments for the Scilab engine</para>
+                    <para>Once the application code has been executed, usually, some data will be returned to the Scilab interpreter.</para>
+                    <para>
+                        For example, to create in the Scilab engine memory a matrix of double, the C function <literal>
+                            SciErr <link linkend="Double_management_writing_API">createMatrixOfDouble</link>(void* context, int position, int nbRows, int nbCols, const double* matrixOfDouble)
+                        </literal>
+                        should be called.
+                    </para>
+                    <para>
+                        The position is usually provided by <literal>nbInputArgument(pvApiCtx) + X</literal>. <literal>X</literal> being the position of the returned output argument. For example, with the function profile <literal>[a, b, c] = foo();</literal> the <literal>nbInputArgument(pvApiCtx) + 3</literal> will be the variable <literal>c</literal>.
+                    </para>
+                    <para>Note that the order of creation must be respected in the gateway.</para>
+                    <para>Almost all Scilab datatypes have an equivalent C function to perform such task.</para>
+                </listitem>
+                <listitem>
+                    <para>Return the output arguments to the Scilab engine</para>
+                    <para>Following, the task 4, the created variable will be returned.</para>
+                    <para>
+                        Taking the previous example <literal>[a, b, c] = foo();</literal>, to return <literal>a</literal>, the following declaration must be done: <literal>AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;</literal>
+                    </para>
+                    <para>
+                        To commit the new variable to the Scilab engine, the function <link linkend="ReturnArguments">ReturnArguments(pvApiCtx)</link> must be called.
+                    </para>
+                </listitem>
             </orderedlist>
-          </para>
-        </listitem>
-        <listitem>
-          <para>Application code</para><para>Once all the checks and data retrieval have been performed, the actual core code can be called. The actual intelligence (processes, data transformations, etc) will be performed here.</para><para>
-            This can be done through a thirdparty code stored and built in <literal>src/c</literal>, <literal>src/cpp</literal> or <literal>src/fortran</literal> but also under the form of a library. Virtually, any library could be linked to Scilab.
-          </para>
-        </listitem>
-        <listitem>
-          <para>Create the output arguments for the Scilab engine</para><para>Once the application code has been executed, usually, some data will be returned to the Scilab interpreter.</para>
-          <para>For example, to create in the Scilab engine memory a matrix of double, the C function <literal>
-              SciErr <link linkend="Double_management_writing_API">createMatrixOfDouble</link>(void* context, int position, int nbRows, int nbCols, const double* matrixOfDouble)
-            </literal>
-            should be called.
-          </para>
-          <para>
-            The position is usually provided by <literal>nbInputArgument + X</literal>. <literal>X</literal> being the position of the returned output argument. For example, with the function profile <literal>[a, b, c] = foo();</literal> the <literal>nbInputArgument + 3</literal> will be the variable <literal>c</literal>.
-          </para>
-          <para>Note that the order of creation must be respected in the gateway.</para><para>Almost all Scilab datatypes have an equivalent C function to perform such task.</para>
-        </listitem>
-        <listitem>
-          <para>Return the output arguments to the Scilab engine</para><para>Following, the task 4, the created variable will be returned.</para><para>
-            Taking the previous example <literal>[a, b, c] = foo();</literal>, to return <literal>a</literal>, the following declaration must be done: <literal>AssignOutputVariable(1) = nbInputArgument + 1;</literal>
-          </para>
-          <para>
-            To commit the new variable to the Scilab engine, the function <link linkend="ReturnArguments">ReturnArguments()</link> must be called.
-          </para>
-        </listitem>
-      </orderedlist>
-      
-    </para>
-    <para>Note that almost all the API_Scilab functions returns a C structure called SciErr which contains many information about the error.</para>
-    <para>
-      By default, Scilab numerical values are stored with the C type <literal>double</literal>.
-    </para>
-    <para>
-      As convention, gateways are stored in <literal>sci_gateway/c/</literal> (or <literal>/cpp/</literal>) and are called <literal>sci_functionName.c</literal>.
-    </para>
-  </refsection>
-  <refsection>
-    <title>Real life example</title>
-    <para>Taking the sample Scilab function:</para>
-    <para>
-      <literal>[c,d] = foo(a,b)</literal>
-    </para>
-    <para>
-      with <literal>a</literal> being a matrix of double and <literal>b</literal> a matrix of boolean with the same size of <literal>a</literal>, foo will multiply each element of <literal>a</literal> by 2 and return it as <literal>c</literal> and transform each element of element of b to its opposite.
-    </para>
-    <para>
-      The example is available in the toolbox skeleton provided with the Scilab binary. The path is <literal>contrib/toolbox_skeleton/sci_gateway/c/sci_foo.c</literal>
-    </para>
-    <para>Detailed explanations are provided under the form of C comment in the following example.</para>
-    <programlisting role="code_gateway"><![CDATA[ 
-    // Full source can be found in the sci_gateway/c/ directory of the
-    // toolbox skeleton
 
-    // Standard header
-    #include "api_scilab.h"
-    #include "BOOL.h"
+        </para>
+        <para>Note that almost all the API_Scilab functions returns a C structure called SciErr which contains many information about the error.</para>
+        <para>
+            By default, Scilab numerical values are stored with the C type <literal>double</literal>.
+        </para>
+        <para>
+            As convention, gateways are stored in <literal>sci_gateway/c/</literal> (or <literal>/cpp/</literal>) and are called <literal>sci_functionName.c</literal>.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Real life example</title>
+        <para>Taking the sample Scilab function:</para>
+        <para>
+            <literal>[c,d] = foo(a,b)</literal>
+        </para>
+        <para>
+            with <literal>a</literal> being a matrix of double and <literal>b</literal> a matrix of boolean with the same size of <literal>a</literal>, foo will multiply each element of <literal>a</literal> by 2 and return it as <literal>c</literal> and transform each element of element of b to its opposite.
+        </para>
+        <para>
+            The example is available in the toolbox skeleton provided with the Scilab binary. The path is <literal>contrib/toolbox_skeleton/sci_gateway/c/sci_foo.c</literal>
+        </para>
+        <para>Detailed explanations are provided under the form of C comment in the following example.</para>
+        <programlisting role="code_gateway">
+            <![CDATA[ 
+// Full source can be found in the sci_gateway/c/ directory of the
+// toolbox skeleton
 
-    // Function declaration
-    int sci_foo(char *fname, unsigned long fname_len)
-    {
+// Standard header
+#include "api_scilab.h"
+#include "BOOL.h"
+
+// Function declaration
+int sci_foo(char *fname, unsigned long fname_len)
+{
     // Error management variable
     SciErr sciErr;
 
     ////////// Create the output arguments //////////
 
     /* Create the matrix as return of the function */
-    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, m1, n1, newMatrixOfDouble);
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, newMatrixOfDouble);
     free(newMatrixOfDouble); // Data have been copied into Scilab memory
     if (sciErr.iErr)
     {
     }
 
     /* Create the matrix as return of the function */
-    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 2, m2, n2, newMatrixOfBoolean);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m2, n2, newMatrixOfBoolean);
     free(newMatrixOfBoolean); // Data have been copied into Scilab memory
     if (sciErr.iErr)
     {
 
     ////////// Return the output arguments to the Scilab engine //////////
 
-    AssignOutputVariable(1) = nbInputArgument + 1;
-    AssignOutputVariable(2) = nbInputArgument + 2;
-
-    ReturnArguments();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
 
+    ReturnArguments(pvApiCtx);
     return 0;
 }
-      ]]></programlisting>
-    <para>
-      To build this code and load it to Scilab, we use the dynamic link capabilities of Scilab. Delegating the build process to Scilab, this code is multiplaform.
-      <programlisting role="scilab"><![CDATA[ 
+      ]]>
+        </programlisting>
+        <para>
+            To build this code and load it to Scilab, we use the dynamic link capabilities of Scilab. Delegating the build process to Scilab, this code is multiplaform.
+            <programlisting role="scilab">
+                <![CDATA[ 
       files=["sci_foo.c"];
       // TODO: WTF ?
       WITHOUT_AUTO_PUTLHSVAR = %t;
       ilib_build('build_lib',['foo','sci_foo'],files,[]);
       exec loader.sce
       [c, d] = foo([2,%pi], [%t, %f])
-      ]]></programlisting>
-    </para>
-    <para>
-      Various checks can be performed:
-      <programlisting role="no-scilab-exec"><![CDATA[ 
+      ]]>
+            </programlisting>
+        </para>
+        <para>
+            Various checks can be performed:
+            <programlisting role="no-scilab-exec">
+                <![CDATA[ 
 -->[c, d] = foo(2, 2) 
                    !--error 999 
 foo: Wrong type for input argument #2: A boolean matrix expected.
-      ]]></programlisting>
-      <programlisting role="no-scilab-exec"><![CDATA[ 
+      ]]>
+            </programlisting>
+            <programlisting role="no-scilab-exec">
+                <![CDATA[ 
 -->[c, d] = foo([2,2], %t)
                         !--error 999 
 foo: Wrong size for input arguments: Same size expected.
-      ]]></programlisting>
-      <programlisting role="no-scilab-exec"><![CDATA[ 
+      ]]>
+            </programlisting>
+            <programlisting role="no-scilab-exec">
+                <![CDATA[ 
 -->[a,b]=foo(2+%i,%t)
                    !--error 999 
 foo: Wrong type for input argument #1: A real matrix expected.
-      ]]></programlisting>
-      <programlisting role="no-scilab-exec"><![CDATA[ 
+      ]]>
+            </programlisting>
+            <programlisting role="no-scilab-exec">
+                <![CDATA[ 
 -->[c, d] = foo([2,%pi], [%t, %f])
  d  =
  
@@ -369,7 +398,8 @@ foo: Wrong type for input argument #1: A real matrix expected.
  c  =
  
     4.    6.2831853 
-      ]]></programlisting>
-    </para>
-  </refsection>
+      ]]>
+            </programlisting>
+        </para>
+    </refsection>
 </refentry>
index 7f8686a..0e7efcf 100644 (file)
@@ -70,7 +70,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarInteger8(pvApiCtx, nbInputArgument + 1, cData);
+                               iRet = createScalarInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, cData);
                                if(iRet)
                                {
                                        return iRet;
@@ -89,7 +89,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument + 1, iRows, iCols, pcData);
+                               sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pcData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -107,7 +107,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarInteger16(pvApiCtx, nbInputArgument + 1, sData);
+                               iRet = createScalarInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, sData);
                                if(iRet)
                                {
                                        return iRet;
@@ -126,7 +126,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 1, iRows, iCols, psData);
+                               sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, psData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -144,7 +144,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarInteger32(pvApiCtx, nbInputArgument + 1, iData);
+                               iRet = createScalarInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iData);
                                if(iRet)
                                {
                                        return iRet;
@@ -163,7 +163,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 1, iRows, iCols, piData);
+                               sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, piData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -184,7 +184,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarUnsignedInteger8(pvApiCtx, nbInputArgument + 1, ucData);
+                               iRet = createScalarUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, ucData);
                                if(iRet)
                                {
                                        return iRet;
@@ -203,7 +203,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 1, iRows, iCols, pucData);
+                               sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pucData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -222,7 +222,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarUnsignedInteger16(pvApiCtx, nbInputArgument + 1, usData);
+                               iRet = createScalarUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, usData);
                                if(iRet)
                                {
                                        return iRet;
@@ -241,7 +241,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 1, iRows, iCols, pusData);
+                               sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pusData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -259,7 +259,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               iRet = createScalarUnsignedInteger32(pvApiCtx, nbInputArgument + 1, uiData);
+                               iRet = createScalarUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, uiData);
                                if(iRet)
                                {
                                        return iRet;
@@ -278,7 +278,7 @@ int integerExample(char *fname,unsigned long fname_len)
                                        return sciErr.iErr;
                                }
 
-                               sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 1, iRows, iCols, puiData);
+                               sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, puiData);
                                if(sciErr.iErr)
                                {
                                        printError(&sciErr, 0);
@@ -295,7 +295,7 @@ int integerExample(char *fname,unsigned long fname_len)
                }
        }
     
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 85e58fb..14f83b6 100644 (file)
@@ -116,8 +116,8 @@ fileData = [
 '            sprintf(pstRet, ""%s"", ""unmanaged type"");'
 '        }'
 '    }'
-'    createSingleString(pvApiCtx, nbInputArgument + 1, pstRet);'
-'    AssignOutputVariable(1) = nbInputArgument + 1;'
+'    createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstRet);'
+'    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;'
 '    return 0;'
 '}'
 ]
index 8ba8be0..a6337fa 100644 (file)
@@ -144,7 +144,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index 8782928..f5c575d 100644 (file)
@@ -218,54 +218,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -273,21 +273,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -300,14 +300,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 66cebd8..063d79e 100644 (file)
@@ -160,7 +160,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index de3e558..2ee647d 100644 (file)
@@ -154,54 +154,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -209,21 +209,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -236,14 +236,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 76a88fa..89d4043 100644 (file)
@@ -118,54 +118,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -173,21 +173,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -200,14 +200,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index f9cb82d..e8342c3 100644 (file)
@@ -154,7 +154,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index 674ae2e..4fa57fe 100644 (file)
@@ -238,54 +238,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -293,21 +293,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -320,14 +320,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 273f694..18cf1f8 100644 (file)
@@ -99,7 +99,7 @@ int common_list(char *fname,unsigned long fname_len)
     }
 
     get_list_info(piAddr);
-    AssignOutputVariable(1) = 0;
+    AssignOutputVariable(pvApiCtx, 1) = 0;
     return 0;
 }
 int get_list_info(int* _piAddress)
index ab03c22..9f98507 100644 (file)
@@ -91,7 +91,7 @@ int common_list(char *fname,unsigned long fname_len)
     }
 
     get_list_info(piAddr);
-    AssignOutputVariable(1) = 0;
+    AssignOutputVariable(pvApiCtx, 1) = 0;
     return 0;
 }
 int get_list_info(int* _piAddress)
index d522fe7..d622096 100644 (file)
@@ -158,7 +158,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index 0cc7d31..4a72310 100644 (file)
@@ -240,54 +240,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -295,21 +295,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -322,14 +322,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index a5d3a79..44a43a2 100644 (file)
@@ -136,7 +136,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index 67b8937..547dd12 100644 (file)
@@ -121,54 +121,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -176,21 +176,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -203,14 +203,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 328dd72..f02d3ce 100644 (file)
@@ -161,7 +161,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index 4c28716..2e305d1 100644 (file)
@@ -163,54 +163,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -218,21 +218,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -245,14 +245,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index d9c2b55..217b283 100644 (file)
@@ -177,7 +177,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index 8a3b5da..5bb1fd6 100644 (file)
@@ -174,54 +174,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -229,21 +229,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -256,14 +256,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 44c6b93..b3a8eff 100644 (file)
@@ -151,7 +151,7 @@ int common_read(char *fname,unsigned long fname_len)
        }
 
        get_info(1, NULL, piAddr, 0);
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
 
index b30b25b..5fc1f50 100644 (file)
@@ -137,54 +137,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, nbInputArgument + 1, 8, &piAddr);
+       sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 8, &piAddr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
+       sciErr = createComplexMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 2, pdblData1, pdblData2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument + 1, piAddr, 2, 2, 3, pstData);
+       sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 2, 3, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument + 1, piAddr, 3, 2, 3, psData);
+       sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 2, 3, psData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument + 1, piAddr, 4, "x", 3, 2, piCoef, pdblPoly);
+       sciErr = createMatrixOfPolyInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createComplexSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 3, 10, 4, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument + 1, piAddr, 6, 3, 3, piBool);
+       sciErr = createMatrixOfBooleanInList(pvApiCtx, nbInputArgument(pvApiCtx) + 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);
+       sciErr = createBooleanSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 7, 3, 10, 4, piNbItemRow, piColPos);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -192,21 +192,21 @@ int list_createlist(char *fname,unsigned long fname_len)
        }
 
        //add list in list
-       sciErr = createListInList(pvApiCtx, nbInputArgument + 1, piAddr, 8, 3, &piChild);
+       sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 8, 3, &piChild);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument + 1, piChild, 1, 3, 2, pdblData1);
+       sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 1, 3, 2, pdblData1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
+       sciErr = createSparseMatrixInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 2, 3, 10, 4, piNbItemRow, piColPos, pdblSReal);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -219,14 +219,14 @@ int list_createlist(char *fname,unsigned long fname_len)
        pdblDataPtr[2]  = 3;
        pdblDataPtr[3]  = 4;
 
-       sciErr = createPointerInList(pvApiCtx, nbInputArgument + 1, piChild, 3, pdblDataPtr);
+       sciErr = createPointerInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, 3, pdblDataPtr);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 8e03cd3..3875d28 100644 (file)
@@ -10,7 +10,7 @@
   </refnamediv>
   <refsynopsisdiv>
     <title>Calling Sequence</title>
-    <synopsis>AssignOutputVariable(RankPos) = RankVar;</synopsis>
+    <synopsis>AssignOutputVariable(pvApiCtx, RankPos) = RankVar;</synopsis>
   </refsynopsisdiv>
   <refsection>
     <title>Arguments</title>
@@ -55,7 +55,8 @@
       integer but will neither be used nor returned as an output
       argument.
     </para>
-    <programlisting role="example"><![CDATA[
+    <programlisting role="example">
+        <![CDATA[
 #include "api_scilab.h"
 int sci_mysizedouble(char * fname, unsigned long fname_len)
 {
@@ -80,13 +81,13 @@ int sci_mysizedouble(char * fname, unsigned long fname_len)
                return 0;
        }
 
-    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
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 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(pvApiCtx) + 2, 1, 1, &m_in_row); // store a same value, but will neither be used nor returned to Scilab
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 3, 1, 1, &n_in_col); // the n_in_col parameter handles the number of columns of the matrix sent as argument
 
-    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();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; // We set the parameter "nbInputArgument(pvApiCtx) + 1" as an output argument
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 3; // We set the parameter "nbInputArgument(pvApiCtx) + 3" as an output argument
+    ReturnArguments(pvApiCtx);
     return 0;
 }
  ]]></programlisting>
index ceb35cd..5e707b0 100644 (file)
@@ -8,13 +8,13 @@
   </refnamediv>
   <refsynopsisdiv>
     <title>Calling Sequence</title>
-    <synopsis>ReturnArguments();</synopsis>
+    <synopsis>ReturnArguments(pvApiCtx);</synopsis>
   </refsynopsisdiv>
   <refsection>
     <title>Description</title>
     <para>
-      ReturnArguments() will return the various variables declared through 
-      AssignOutputVariable(X).
+        ReturnArguments(pvApiCtx) will return the various variables declared through
+        AssignOutputVariable(pvApiCtx, X).
     </para>
   </refsection>
   <refsection>
@@ -28,7 +28,8 @@
         <para>the number of rows (second output argument)</para>
       </listitem>
     </itemizedlist>
-    <programlisting role="example"><![CDATA[
+    <programlisting role="example">
+    <![CDATA[
 #include "api_scilab.h"
 int sci_mysizedouble(char * fname, unsigned long fname_len)
 {
@@ -53,13 +54,13 @@ int sci_mysizedouble(char * fname, unsigned long fname_len)
                return 0;
        }
 
-    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
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 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(pvApiCtx) + 2, 1, 1, &m_in_row); // store a same value, but will neither be used nor returned to Scilab
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 3, 1, 1, &n_in_col); // the n_in_col parameter handles the number of columns of the matrix sent as argument
 
-    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();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; // We set the parameter "nbInputArgument(pvApiCtx) + 1" as an output argument
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 3; // We set the parameter "nbInputArgument(pvApiCtx) + 3" as an output argument
+    ReturnArguments(pvApiCtx);
     return 0;
 }
  ]]></programlisting>
index 45867bb..3b990e9 100644 (file)
@@ -134,14 +134,14 @@ int read_write_boolean(char *fname,unsigned long fname_len)
         piBool[i] = piBool[i] == 0 ? 1 : 0;
     }
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, piBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
  ]]></programlisting>
index a7d56c7..8f9ddc7 100644 (file)
@@ -195,14 +195,14 @@ int read_write_boolean(char *fname,unsigned long fname_len)
         piBool[i] = piBool[i] == 0 ? 1 : 0;
     }
 
-    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument + 1, iRows, iCols, piBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, piBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
  ]]></programlisting>
index 5e3a566..42cb1c6 100644 (file)
@@ -184,14 +184,14 @@ int read_write_bsparse(char *fname,unsigned long fname_len)
         iCol += piNbItemRow[i];
     }
 
-    sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
+    sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
  ]]></programlisting>
index b2ca53b..2d8d208 100644 (file)
@@ -259,14 +259,14 @@ int read_write_bsparse(char *fname,unsigned long fname_len)
         iCol += piNbItemRow[i];
     }
 
-    sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
+    sciErr = createBooleanSparseMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, iNewItem, piNewRow, piNewCol);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
         return 0;
     }
 
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
  ]]></programlisting>
index aaef7c7..a3779bb 100644 (file)
@@ -127,7 +127,7 @@ int check_matrix_dimension(char * fname)
     }
 
     //no return value
-    AssignOutputVariable(0) = 1;
+    AssignOutputVariable(pvApiCtx, 0) = 1;
     return 0;
 }
  ]]>
index b06f8b6..93560d3 100644 (file)
@@ -79,7 +79,8 @@
     <!--Lib_name: common_function-->
     <!--Func_list: common_function-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+    <![CDATA[ 
 #include "api_scilab.h"
 SciErr printf_info(int _iVar);
 
@@ -90,7 +91,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < nbInputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument(pvApiCtx) ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -104,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, nbInputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -112,7 +113,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 6ac27bd..0eb40e8 100644 (file)
@@ -87,7 +87,8 @@
     <!--Lib_name: common_function-->
     <!--Func_list: common_function-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+    <![CDATA[ 
 #include "api_scilab.h"
 SciErr printf_info(int _iVar);
 
@@ -98,7 +99,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < nbInputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument(pvApiCtx) ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -112,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, nbInputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -120,7 +121,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 2be1611..1a0ab2d 100644 (file)
@@ -82,7 +82,8 @@
     <!--Lib_name: common_function-->
     <!--Func_list: common_function-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+    <![CDATA[ 
 #include "api_scilab.h"
 SciErr printf_info(int _iVar);
 
@@ -93,7 +94,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < nbInputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument(pvApiCtx) ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -107,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, nbInputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -115,7 +116,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 46302b8..023f21a 100644 (file)
@@ -82,7 +82,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < nbInputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument(pvApiCtx) ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -96,7 +96,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, nbInputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -104,7 +104,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 638a716..ab1223a 100644 (file)
@@ -75,7 +75,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < nbInputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument(pvApiCtx) ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -89,7 +89,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, nbInputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -97,7 +97,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index 72026b3..9411ff5 100644 (file)
@@ -75,7 +75,7 @@ fileData = ['#include ""api_scilab.h""'
 '    }'
 ''
 '    createScalarBoolean(pvApiCtx, Rhs + 1, iRet);'
-'    AssignOutputVariable(1) = Rhs + 1;'
+'    AssignOutputVariable(pvApiCtx, 1) = Rhs + 1;'
 '    return 0;'
 '}'];
 
index 479d6b9..162b10e 100644 (file)
@@ -169,7 +169,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, nbInputArgument + 1, iRows, iCols, pdblImg, pdblReal);
+               sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pdblImg, pdblReal);
        }
        else
        {
@@ -177,7 +177,7 @@ int read_double(char *fname,unsigned long fname_len)
                {
                        pdblReal[i] = pdblReal[i] * -1;
                }
-               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal);
+               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pdblReal);
        }
 
        if(sciErr.iErr)
@@ -186,7 +186,7 @@ int read_double(char *fname,unsigned long fname_len)
                return 0;
        }
 
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index f1cf86a..d39af7d 100644 (file)
@@ -219,7 +219,7 @@ int write_double(char *fname,unsigned long fname_len)
        //}
        //create a variable from a existing data array
 
-       sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows1, iCols1, pdblReal1);
+       sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows1, iCols1, pdblReal1);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -234,7 +234,7 @@ int write_double(char *fname,unsigned long fname_len)
        *************************/
 
        //reserve space in scilab memory and fill it
-       sciErr = allocComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 2, iRows2, iCols2, &pdblReal2, &pdblImg2);
+       sciErr = allocComplexMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRows2, iCols2, &pdblReal2, &pdblImg2);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -264,8 +264,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) = nbInputArgument + 1;
-    AssignOutputVariable(2) = nbInputArgument + 2;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
 
     return 0;
 }
index 42c6373..31e9f52 100644 (file)
@@ -77,7 +77,8 @@
     <!--Lib_name: common_function-->
     <!--Func_list: common_function-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+    <![CDATA[ 
 #include "api_scilab.h"
 SciErr printf_info(int _iVar);
 
@@ -88,7 +89,7 @@ int common_function(char *fname,unsigned long fname_len)
     int *piAddr1    = NULL;
     int iBool       = 0;
 
-    for(i = 0 ; i < nbInputArgument ; i++)
+    for(i = 0 ; i < nbInputArgument(pvApiCtx) ; i++)
     {
         sciErr = printf_info(i + 1);
         if(sciErr.iErr)
@@ -102,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, nbInputArgument + 1, 1, 1, &iBool);
+    sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &iBool);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -110,7 +111,7 @@ int common_function(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
 SciErr printf_info(int _iVar)
index b0b9f93..eaa0591 100644 (file)
@@ -301,7 +301,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, nbInputArgument + 1, iRows8, iCols8, pcDataOut);
+       sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows8, iCols8, pcDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -309,7 +309,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 2, iRowsu8, iColsu8, pucDataOut);
+       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRowsu8, iColsu8, pucDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -317,7 +317,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 3, iRows16, iCols16, psDataOut);
+       sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows16, iCols16, psDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -325,7 +325,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 4, iRowsu16, iColsu16, pusDataOut);
+       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRowsu16, iColsu16, pusDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -333,7 +333,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 5, iRows32, iCols32, piDataOut);
+       sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows32, iCols32, piDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -341,7 +341,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 6, iRowsu32, iColsu32, puiDataOut);
+       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 6, iRowsu32, iColsu32, puiDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -349,12 +349,12 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //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;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+       AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+       AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+       AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
+       AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+       AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
        return 0;
 }
 
index 13002a4..de8de4a 100644 (file)
@@ -372,7 +372,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, nbInputArgument + 1, iRows8, iCols8, pcDataOut);
+       sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows8, iCols8, pcDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -380,7 +380,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument + 2, iRowsu8, iColsu8, pucDataOut);
+       sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRowsu8, iColsu8, pucDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -388,7 +388,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument + 3, iRows16, iCols16, psDataOut);
+       sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows16, iCols16, psDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -396,7 +396,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument + 4, iRowsu16, iColsu16, pusDataOut);
+       sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRowsu16, iColsu16, pusDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -404,7 +404,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument + 5, iRows32, iCols32, piDataOut);
+       sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows32, iCols32, piDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -412,7 +412,7 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument + 6, iRowsu32, iColsu32, puiDataOut);
+       sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 6, iRowsu32, iColsu32, puiDataOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -420,12 +420,12 @@ int read_integer(char *fname,unsigned long fname_len)
        }
 
        //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;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+       AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+       AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+       AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
+       AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+       AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
        return 0;
 }
 
index 92041d6..0c0919e 100644 (file)
@@ -71,7 +71,8 @@
     <!--Lib_name: pointer_reading-->
     <!--Func_list: read_pointer-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+    <![CDATA[ 
 #include "api_scilab.h"
 int read_pointer(char *fname,unsigned long fname_len)
 {
@@ -80,16 +81,16 @@ int read_pointer(char *fname,unsigned long fname_len)
        CheckInputArgument(pvApiCtx, 0, 1);
     CheckOutputArgument(pvApiCtx, 1, 1);
 
-       if(nbInputArgument == 0)
+       if(nbInputArgument(pvApiCtx) == 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);
+               sciErr = createPointer(pvApiCtx, nbInputArgument(pvApiCtx) + 1, (void*)pdblData);
        }
-       else if(nbInputArgument == 1)
+       else if(nbInputArgument(pvApiCtx) == 1)
        {//read mode
                int iType                       = 0;
                int* piAddr                     = NULL;
@@ -108,7 +109,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                        return 0;
                }
                pdblData = (double*)pvPtr;
-               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, 2, 2, pdblData);
+               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 2, 2, pdblData);
        }
        else
        {
@@ -119,7 +120,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                printError(&sciErr, 0);
                return 0;
        }
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 135c0a5..b99bff0 100644 (file)
     <!--Lib_name: pointer_reading-->
     <!--Func_list: read_pointer-->
     <title>Gateway Source</title>
-    <programlisting role="code_gateway"><![CDATA[ 
+    <programlisting role="code_gateway">
+    <![CDATA[ 
 #include "api_scilab.h"
 int read_pointer(char *fname,unsigned long fname_len)
 {
@@ -136,16 +137,16 @@ int read_pointer(char *fname,unsigned long fname_len)
        CheckInputArgument(pvApiCtx, 0, 1);
     CheckOutputArgument(pvApiCtx, 1, 1);
 
-       if(nbInputArgument == 0)
+       if(nbInputArgument(pvApiCtx) == 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);
+               sciErr = createPointer(pvApiCtx, nbInputArgument(pvApiCtx) + 1, (void*)pdblData);
        }
-       else if(nbInputArgument == 1)
+       else if(nbInputArgument(pvApiCtx) == 1)
        {//read mode
                int iType                       = 0;
                int* piAddr                     = NULL;
@@ -164,7 +165,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                        return 0;
                }
                pdblData = (double*)pvPtr;
-               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, 2, 2, pdblData);
+               sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 2, 2, pdblData);
        }
        else
        {
@@ -175,7 +176,7 @@ int read_pointer(char *fname,unsigned long fname_len)
                printError(&sciErr, 0);
                return 0;
        }
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 6d70718..50209e0 100644 (file)
@@ -201,7 +201,7 @@ int read_poly(char *fname,unsigned long fname_len)
                }
        }
 
-       sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+       sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -219,7 +219,7 @@ int read_poly(char *fname,unsigned long fname_len)
        free(pdblReal);
        free(pdblImg);
        //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index ff05f3b..e27865b 100644 (file)
@@ -237,7 +237,7 @@ int read_poly(char *fname,unsigned long fname_len)
                }
        }
 
-       sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+       sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstVarname, iRows, iCols, piNbCoef, pdblReal, pdblImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -255,7 +255,7 @@ int read_poly(char *fname,unsigned long fname_len)
        free(pdblReal);
        free(pdblImg);
        //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 1b05150..f0d0cb9 100644 (file)
@@ -150,7 +150,7 @@ int write_poly(char *fname,unsigned long fname_len)
     pdblReal[4]             = pdblPoly4;
     pdblReal[5]             = pdblPoly5;
 
-    sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
+    sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
     if(sciErr.iErr)
     {
         printError(&sciErr, 0);
@@ -158,7 +158,7 @@ int write_poly(char *fname,unsigned long fname_len)
     }
 
     //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     return 0;
 }
  ]]></programlisting>
index 847f7c3..421ed85 100644 (file)
@@ -189,7 +189,7 @@ int read_sparse(char *fname,unsigned long fname_len)
        }
 
        //assign allocated variables to Lhs position
-       AssignOutputVariable(1) = 0;
+       AssignOutputVariable(pvApiCtx, 1) = 0;
        return 0;
 }
  ]]></programlisting>
index 1c1bdf5..65a7d72 100644 (file)
@@ -244,14 +244,14 @@ int write_sparse(char *fname,unsigned long fname_len)
        double pdblSImg[]       = {4,3,2,1};
        int iNbItem                     = 4;
 
-       sciErr = createComplexSparseMatrix(pvApiCtx, nbInputArgument + 1, 3, 10, iNbItem, piNbItemRow, piColPos, pdblSReal, pdblSImg);
+       sciErr = createComplexSparseMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3, 10, iNbItem, piNbItemRow, piColPos, pdblSReal, pdblSImg);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
                return 0;
        }
 
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index fd8ffc7..5634bdd 100644 (file)
@@ -201,7 +201,7 @@ int read_string(char *fname,unsigned long fname_len)
        }
 
        //create new variable
-       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument + 1, iRowsOut, iColsOut, &pstOut);
+       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRowsOut, iColsOut, &pstOut);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -218,7 +218,7 @@ int read_string(char *fname,unsigned long fname_len)
 
        free(pstData);
        free(pstOut);
-       AssignOutputVariable(1) = nbInputArgument + 1;
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index c53cd5c..6479d55 100644 (file)
@@ -124,7 +124,7 @@ int write_string(char *fname,unsigned long fname_len)
        pstData[5]              = string23;
 
        //create the variable
-       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument + 1, iRows, iCols, pstData);
+       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pstData);
        if(sciErr.iErr)
        {
                printError(&sciErr, 0);
@@ -134,7 +134,7 @@ int write_string(char *fname,unsigned long fname_len)
        //free container
        free(pstData);
        //assign allocated variables to Lhs position
-    AssignOutputVariable(1) = nbInputArgument + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        return 0;
 }
  ]]></programlisting>
index 20164f1..a3277f6 100644 (file)
@@ -72,7 +72,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal, &pdblImg);
+                               sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal, &pdblImg);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedSingleComplexPoly(pdblReal, pdblImg);
@@ -91,7 +91,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal);
+                               sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstVarName, 1, 1, &iNbCoef, &pdblReal);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedSinglePoly(pdblReal);
@@ -119,7 +119,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
+                               sciErr = createComplexMatrixOfPoly(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal, pdblImg);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedMatrixOfComplexPoly(iRows, iCols, piNbCoef, pdblReal, pdblImg);
@@ -138,7 +138,7 @@ int polyExample(char *fname,unsigned long fname_len)
                                        return iRet;
                                }
 
-                               sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
+                               sciErr = createMatrixOfPoly(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstVarName, iRows, iCols, piNbCoef, pdblReal);
                                if(sciErr.iErr)
                                {
                                        freeAllocatedMatrixOfPoly(iRows, iCols, piNbCoef, pdblReal);
@@ -150,11 +150,11 @@ int polyExample(char *fname,unsigned long fname_len)
                        }
                }
 
-        AssignOutputVariable(1) = nbInputArgument + 1;
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        }
        else
        {
-        AssignOutputVariable(1) = 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
        }
        return 0;
 }
index 65af722..97ace10 100644 (file)
@@ -65,7 +65,7 @@ int sparseExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       sciErr = createComplexSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
+                       sciErr = createComplexSparseMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
                        if(sciErr.iErr)
                        {
                                freeAllocatedComplexSparseMatrix(piNbItemRow, piColPos, pdblReal, pdblImg);
@@ -84,7 +84,7 @@ int sparseExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       sciErr = createSparseMatrix(pvApiCtx, nbInputArgument + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
+                       sciErr = createSparseMatrix(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
                        if(sciErr.iErr)
                        {
                                freeAllocatedSparseMatrix(piNbItemRow, piColPos, pdblReal);
@@ -94,11 +94,11 @@ int sparseExample(char *fname,unsigned long fname_len)
 
                        freeAllocatedSparseMatrix(piNbItemRow, piColPos, pdblReal);
                }
-               AssignOutputVariable(1) = nbInputArgument + 1;
+               AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        }
        else
        {
-               AssignOutputVariable(1) = 0;
+               AssignOutputVariable(pvApiCtx, 1) = 0;
        }
        return 0;
 }
index c85b789..bd4555b 100644 (file)
@@ -59,7 +59,7 @@ int stringExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       iRet = createSingleString(pvApiCtx, nbInputArgument + 1, pstData);
+                       iRet = createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstData);
                        if(iRet)
                        {
                                freeAllocatedSingleString(pstData);
@@ -81,7 +81,7 @@ int stringExample(char *fname,unsigned long fname_len)
                                return iRet;
                        }
 
-                       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument + 1, iRows, iCols, pstData);
+                       sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pstData);
                        if(sciErr.iErr)
                        {
                                freeAllocatedMatrixOfString(iRows, iCols, pstData);
@@ -92,11 +92,11 @@ int stringExample(char *fname,unsigned long fname_len)
                        freeAllocatedMatrixOfString(iRows, iCols, pstData);
                }
                
-        AssignOutputVariable(1) = nbInputArgument + 1;
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
        }
        else
        {
-        AssignOutputVariable(1) = 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
        }
        return 0;
 }