<!--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)
{
return 0;
}
- iRet = createScalarBoolean(pvApiCtx, nbInputArgument + 1, iBool);
+ iRet = createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iBool);
if(iRet)
{
return 0;
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;
}
<!--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)
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);
}
freeAllocatedBooleanSparse(piNbItemRow, piColPos);
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
return 0;
}
<!--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)
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))
{
return iRet;
}
- iRet = createScalarComplexDouble(pvApiCtx, nbInputArgument + 1, dblReal, dblImg);
+ iRet = createScalarComplexDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dblReal, dblImg);
if(iRet)
{
return iRet;
return iRet;
}
- iRet = createScalarDouble(pvApiCtx, nbInputArgument + 1, dblReal);
+ iRet = createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dblReal);
if(iRet)
{
return iRet;
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);
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);
}
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
return 0;
*
-->
<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 =
c =
4. 6.2831853
- ]]></programlisting>
- </para>
- </refsection>
+ ]]>
+ </programlisting>
+ </para>
+ </refsection>
</refentry>
return iRet;
}
- iRet = createScalarInteger8(pvApiCtx, nbInputArgument + 1, cData);
+ iRet = createScalarInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, cData);
if(iRet)
{
return iRet;
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);
return iRet;
}
- iRet = createScalarInteger16(pvApiCtx, nbInputArgument + 1, sData);
+ iRet = createScalarInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, sData);
if(iRet)
{
return iRet;
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);
return iRet;
}
- iRet = createScalarInteger32(pvApiCtx, nbInputArgument + 1, iData);
+ iRet = createScalarInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iData);
if(iRet)
{
return iRet;
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);
return iRet;
}
- iRet = createScalarUnsignedInteger8(pvApiCtx, nbInputArgument + 1, ucData);
+ iRet = createScalarUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, ucData);
if(iRet)
{
return iRet;
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);
return iRet;
}
- iRet = createScalarUnsignedInteger16(pvApiCtx, nbInputArgument + 1, usData);
+ iRet = createScalarUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, usData);
if(iRet)
{
return iRet;
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);
return iRet;
}
- iRet = createScalarUnsignedInteger32(pvApiCtx, nbInputArgument + 1, uiData);
+ iRet = createScalarUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, uiData);
if(iRet)
{
return iRet;
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);
}
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
' 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;'
'}'
]
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
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);
}
//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);
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>
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
}
get_list_info(piAddr);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
int get_list_info(int* _piAddress)
}
get_list_info(piAddr);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
int get_list_info(int* _piAddress)
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
}
get_info(1, NULL, piAddr, 0);
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
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);
}
//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);
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>
</refnamediv>
<refsynopsisdiv>
<title>Calling Sequence</title>
- <synopsis>AssignOutputVariable(RankPos) = RankVar;</synopsis>
+ <synopsis>AssignOutputVariable(pvApiCtx, RankPos) = RankVar;</synopsis>
</refsynopsisdiv>
<refsection>
<title>Arguments</title>
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)
{
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>
</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>
<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)
{
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>
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>
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>
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>
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>
}
//no return value
- AssignOutputVariable(0) = 1;
+ AssignOutputVariable(pvApiCtx, 0) = 1;
return 0;
}
]]>
<!--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);
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)
//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);
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
SciErr printf_info(int _iVar)
<!--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);
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)
//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);
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
SciErr printf_info(int _iVar)
<!--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);
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)
//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);
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
SciErr printf_info(int _iVar)
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)
//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);
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
SciErr printf_info(int _iVar)
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)
//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);
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
SciErr printf_info(int _iVar)
' }'
''
' createScalarBoolean(pvApiCtx, Rhs + 1, iRet);'
-' AssignOutputVariable(1) = Rhs + 1;'
+' AssignOutputVariable(pvApiCtx, 1) = Rhs + 1;'
' return 0;'
'}'];
//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
{
{
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)
return 0;
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
//}
//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);
*************************/
//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);
// /!\ 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;
}
<!--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);
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)
//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);
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
SciErr printf_info(int _iVar)
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);
}
//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);
}
//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);
}
//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);
}
//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);
}
//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);
}
//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;
}
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);
}
//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);
}
//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);
}
//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);
}
//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);
}
//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);
}
//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;
}
<!--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)
{
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;
return 0;
}
pdblData = (double*)pvPtr;
- sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, 2, 2, pdblData);
+ sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 2, 2, pdblData);
}
else
{
printError(&sciErr, 0);
return 0;
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
<!--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)
{
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;
return 0;
}
pdblData = (double*)pvPtr;
- sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, 2, 2, pdblData);
+ sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 2, 2, pdblData);
}
else
{
printError(&sciErr, 0);
return 0;
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
}
}
- 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);
free(pdblReal);
free(pdblImg);
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
}
}
- 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);
free(pdblReal);
free(pdblImg);
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
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);
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
}
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
return 0;
}
]]></programlisting>
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>
}
//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);
free(pstData);
free(pstOut);
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
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);
//free container
free(pstData);
//assign allocated variables to Lhs position
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
return 0;
}
]]></programlisting>
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);
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);
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);
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);
}
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
else
{
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
}
return 0;
}
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);
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);
freeAllocatedSparseMatrix(piNbItemRow, piColPos, pdblReal);
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
else
{
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
}
return 0;
}
return iRet;
}
- iRet = createSingleString(pvApiCtx, nbInputArgument + 1, pstData);
+ iRet = createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstData);
if(iRet)
{
freeAllocatedSingleString(pstData);
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);
freeAllocatedMatrixOfString(iRows, iCols, pstData);
}
- AssignOutputVariable(1) = nbInputArgument + 1;
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
else
{
- AssignOutputVariable(1) = 0;
+ AssignOutputVariable(pvApiCtx, 1) = 0;
}
return 0;
}
projects / scilab.git / commitdiff