add localization in toolboxes
[scilab.git] / scilab / contrib / toolbox_skeleton / sci_gateway / c / sci_foo.c
1 /* ==================================================================== */
2 /* Template toolbox_skeleton */
3 /* Example detail in "API_scilab getting started" help page */
4 /* This file is released under the 3-clause BSD license. See COPYING-BSD. */
5 /* ==================================================================== */
6 #include "api_scilab.h"
7 #include "BOOL.h"
8 #include <localization.h>
9
10 /* ==================================================================== */
11 int sci_foo(char *fname, unsigned long fname_len)
12 {
13     // Error management variable
14     SciErr sciErr;
15
16     ////////// Variables declaration //////////
17     int m1 = 0, n1 = 0;
18     int *piAddressVarOne = NULL;
19     double *matrixOfDouble = NULL;
20     double *newMatrixOfDouble = NULL;
21
22     int m2 = 0, n2 = 0;
23     int *piAddressVarTwo = NULL;
24     int *matrixOfBoolean = NULL;
25     int *newMatrixOfBoolean = NULL;
26     int i = 0;
27
28
29     ////////// Check the number of input and output arguments //////////
30     /* --> [c, d] = foo(a, b) */
31     /* check that we have only 2 input arguments */
32     /* check that we have only 2 output argument */
33     CheckInputArgument(pvApiCtx, 2, 2) ;
34     CheckOutputArgument(pvApiCtx, 2, 2) ;
35
36
37     ////////// Manage the first input argument (double) //////////
38     /* get Address of inputs */
39     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
40     if (sciErr.iErr)
41     {
42         printError(&sciErr, 0);
43         return 0;
44     }
45
46     /* Check that the first input argument is a real matrix (and not complex) */
47     if ( !isDoubleType(pvApiCtx, piAddressVarOne) ||  isVarComplex(pvApiCtx, piAddressVarOne) )
48     {
49         Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix expected.\n"), fname, 1);
50         return 0;
51     }
52
53     /* get matrix */
54     sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarOne, &m1, &n1, &matrixOfDouble);
55     if (sciErr.iErr)
56     {
57         printError(&sciErr, 0);
58         return 0;
59     }
60
61     ////////// Manage the second input argument (boolean) //////////
62
63     /* get Address of inputs */
64     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
65     if (sciErr.iErr)
66     {
67         printError(&sciErr, 0);
68         return 0;
69     }
70
71     if ( !isBooleanType(pvApiCtx, piAddressVarTwo) )
72     {
73         Scierror(999, _("%s: Wrong type for input argument #%d: A boolean matrix expected.\n"), fname, 2);
74         return 0;
75     }
76
77     /* get matrix */
78     sciErr = getMatrixOfBoolean(pvApiCtx, piAddressVarTwo, &m2, &n2, &matrixOfBoolean);
79     if (sciErr.iErr)
80     {
81         printError(&sciErr, 0);
82         return 0;
83     }
84
85     ////////// Check the consistency of the two input arguments //////////
86
87     if ((m1 != m2) | - (n1 != n2))
88     {
89         Scierror(999, _("%s: Wrong size for input arguments: Same size expected.\n"), fname, 1);
90         return 0;
91     }
92
93
94     newMatrixOfDouble = (double*)malloc(sizeof(double) * m1 * n1);
95     ////////// Application code //////////
96     // Could be replaced by a call to a library
97
98     for (i = 0; i < m1 * n1; i++)
99     {
100         /* For each element of the matrix, multiply by 2 */
101         newMatrixOfDouble[i] = matrixOfDouble[i] * 2;
102     }
103
104     newMatrixOfBoolean = (int*)malloc(sizeof(double) * m2 * n2);
105     for (i = 0; i < m2 * n2; i++)
106     {
107         /* For each element of the matrix, invert the value */
108         newMatrixOfBoolean[i] = matrixOfBoolean[i] == TRUE ? FALSE : TRUE;
109     }
110
111     ////////// Create the output arguments //////////
112
113     /* Create the matrix as return of the function */
114     sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, newMatrixOfDouble);
115     if (sciErr.iErr)
116     {
117         printError(&sciErr, 0);
118         return 0;
119     }
120
121     /* Create the matrix as return of the function */
122     sciErr = createMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m2, n2, newMatrixOfBoolean);
123     if (sciErr.iErr)
124     {
125         printError(&sciErr, 0);
126         return 0;
127     }
128
129     ////////// Return the output arguments to the Scilab engine //////////
130
131     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
132     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
133
134     ReturnArguments(pvApiCtx);
135
136     return 0;
137 }
138 /* ==================================================================== */
139