Fix rubberbox coordinates
[scilab.git] / scilab / modules / scicos / sci_gateway / c / sci_buildouttb.c
1 /*  Scicos
2 *
3 *  Copyright (C) INRIA - Allan CORNET
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 *
19 * See the file ./license.txt
20 */
21 /*--------------------------------------------------------------------------*/
22 #include "gw_scicos.h"
23 #include "stack-c.h"
24 #include "Scierror.h"
25 #include "localization.h"
26 #include "MALLOC.h"
27 /*--------------------------------------------------------------------------*/
28 /* intbuildouttb build an initialized outtb list
29 *
30 * [outtb]=buildouttb(lnksz,lnktyp)
31 *
32 * rhs 1 : lnksz, give the size of scilab object in outtb
33 *         can be all int type or double matrix
34 *         can have n,2 or 2,n size
35 *
36 * rhs 2 : lnktyp, gives the type of scilab objetc in outtb
37 *         1 : double
38 *         2 : complex
39 *         3 : int32
40 *         4 : int16
41 *         5 : int8
42 *         6 : uint32
43 *         7 : uint16
44 *         8 : uint8
45 *         else : double
46 *         can be all int type or double matrix
47 *         can have n,1 or 1,n size
48 *
49 * lhs 1 : a list of size n
50 *
51 * 02/07/06, Alan : Initial version.
52 * 21/11/06, Alan : Allow void rhs input param.
53 *
54 */
55 /*--------------------------------------------------------------------------*/
56 int sci_buildouttb(char *fname, unsigned long fname_len)
57 {
58     static int l1 = 0, m1 = 0,   n1 = 0;
59     static int l2 = 0, m2 = 0,   n2 = 0;
60     static int l3 = 0, n3 = 1;
61     SciIntMat M1, M2, M3;
62
63     int n_lnksz = 0, n_lnktyp = 0;
64     int *lnksz = NULL, *lnktyp = NULL;
65
66     double *ptr_d = NULL;
67     double *ptr_dc = NULL;
68     int *ptr_i = NULL;
69     short *ptr_s = NULL;
70     char *ptr_c = NULL;
71     int *ptr_ui = NULL;
72     short *ptr_us = NULL;
73     char *ptr_uc = NULL;
74
75     int nm = 0, i = 0, j = 0, ierr = 0;
76
77     static int minlhs = 1, maxlhs = 1;
78     static int minrhs = 2, maxrhs = 2;
79
80     /*check number of lhs/rhs*/
81     CheckLhs(minlhs, maxlhs);
82     CheckRhs(minrhs, maxrhs);
83
84     /*check type of Rhs 1*/
85     if (VarType(1) == 1)
86     {
87         GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
88     }
89     else if (VarType(1) == sci_ints)
90     {
91         GetRhsVar(1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m1, &n1, &M1);
92     }
93     else
94     {
95         Scierror(888, _("%s : lnksz argument must be double or integer.\n"), fname);
96         return 0;
97     }
98
99     /*check type of Rhs 2*/
100     if (VarType(2) == 1)
101     {
102         GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
103     }
104     else if (VarType(2) == sci_ints)
105     {
106         GetRhsVar(2, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m2, &n2, &M2);
107     }
108     else
109     {
110         Scierror(888, _("%s : lnktyp argument must be double or integer.\n"), fname);
111         return 0;
112     }
113
114     /*check size of Rhs 1*/
115     if (m1 == 2)
116     {
117         n_lnksz = n1;
118     }
119     else if (n1 == 2)
120     {
121         n_lnksz = m1;
122     }
123     /*void double input give void list output*/
124     else if ((n1 == 0) || (m1 == 0))
125     {
126         if ((n2 == 0) || (m2 == 0))
127         {
128             /*manually code a void list on rhs(1)*/
129             ptr_i = (int*)GetData(1);
130             ptr_i[0] = sci_list;
131             ptr_i[1] = 0;
132             ptr_i[2] = 1;
133             LhsVar(1) = 1;
134             PutLhsVar();
135             return 0;
136         }
137         else
138         {
139             Scierror(888, _("%s : inconsistent dimension between lnksz and lnktyp.\n"), fname);
140             return 0;
141         }
142     }
143     else
144     {
145         Scierror(888, _("%s : bad dimension for lnksz argument.\n"), fname);
146         return 0;
147     }
148
149     /*check size of Rhs 2*/
150     if (m2 == 1)
151     {
152         n_lnktyp = n2;
153     }
154     else if (n2 == 1)
155     {
156         n_lnktyp = m2;
157     }
158     else if ((n2 == 0) || (m2 == 0))
159     {
160         if ( (n1 != 0) && (m1 != 0) )
161         {
162             Scierror(888, _("%s : inconsistent dimension between lnksz and lnktyp.\n"), fname);
163             return 0;
164         }
165     }
166     else
167     {
168         Scierror(888, _("%s : bad dimension for lnktyp argument.\n"), fname);
169         return 0;
170     }
171
172     /*cross size checking*/
173     if (n_lnksz != n_lnktyp)
174     {
175         Scierror(888, _("%s : lnksz and lnktyp argument must have the same length.\n"), fname);
176         return 0;
177     }
178
179     /*allocate lnksz*/
180     if ((lnksz = MALLOC(2 * n_lnksz * sizeof(int))) == NULL)
181     {
182         Scierror(999, _("%s : No more free memory.\n"), fname);
183         return 0;
184     }
185
186     /* Allocate lnktyp*/
187     if ((lnktyp = MALLOC(n_lnktyp * sizeof(int))) == NULL)
188     {
189         Scierror(999, _("%s : No more free memory.\n"), fname);
190         FREE(lnksz);
191         return 0;
192     }
193
194     /*store rhs 1 in lnksz */
195     if ((m1 == n1) && (m2 == m1))
196     {
197         m1 = -1;    /* this is done for matrix 2,2 */
198     }
199     if (VarType(1) == 8)
200     {
201         switch (M1.it)
202         {
203             case I_CHAR   :
204                 if (m1 == 2)
205                 {
206                     for (j = 0; j < n_lnksz; j++)
207                     {
208                         lnksz[j] = (int) IC_CHAR(M1.D)[j * 2];
209                         lnksz[n_lnksz + j] = (int) IC_CHAR(M1.D)[2 * j + 1];
210                     }
211                 }
212                 else
213                 {
214                     for (j = 0; j < 2 * n_lnksz; j++)
215                     {
216                         lnksz[j] = (int) IC_CHAR(M1.D)[j];
217                     }
218                 }
219                 break;
220
221             case I_INT16  :
222                 if (m1 == 2)
223                 {
224                     for (j = 0; j < n_lnksz; j++)
225                     {
226                         lnksz[j] = (int) IC_INT16(M1.D)[j * 2];
227                         lnksz[n_lnksz + j] = (int) IC_INT16(M1.D)[2 * j + 1];
228                     }
229                 }
230                 else
231                 {
232                     for (j = 0; j < 2 * n_lnksz; j++)
233                     {
234                         lnksz[j] = (int) IC_INT16(M1.D)[j];
235                     }
236                 }
237                 break;
238
239             case I_INT32  :
240                 if (m1 == 2)
241                 {
242                     for (j = 0; j < n_lnksz; j++)
243                     {
244                         lnksz[j] = (int) IC_INT32(M1.D)[j * 2];
245                         lnksz[n_lnksz + j] = (int) IC_INT32(M1.D)[2 * j + 1];
246                     }
247                 }
248                 else
249                 {
250                     for (j = 0; j < 2 * n_lnksz; j++)
251                     {
252                         lnksz[j] = (int) IC_INT32(M1.D)[j];
253                     }
254                 }
255                 break;
256
257             case I_UCHAR  :
258                 if (m1 == 2)
259                 {
260                     for (j = 0; j < n_lnksz; j++)
261                     {
262                         lnksz[j] = (int) IC_UCHAR(M1.D)[j * 2];
263                         lnksz[n_lnksz + j] = (int) IC_UCHAR(M1.D)[2 * j + 1];
264                     }
265                 }
266                 else
267                 {
268                     for (j = 0; j < 2 * n_lnksz; j++)
269                     {
270                         lnksz[j] = (int) IC_UCHAR(M1.D)[j];
271                     }
272                 }
273                 break;
274
275             case I_UINT16 :
276                 if (m1 == 2)
277                 {
278                     for (j = 0; j < n_lnksz; j++)
279                     {
280                         lnksz[j] = (int) IC_UINT16(M1.D)[j * 2];
281                         lnksz[n_lnksz + j] = (int) IC_UINT16(M1.D)[2 * j + 1];
282                     }
283                 }
284                 else
285                 {
286                     for (j = 0; j < 2 * n_lnksz; j++)
287                     {
288                         lnksz[j] = (int) IC_UINT16(M1.D)[j];
289                     }
290                 }
291                 break;
292
293             case I_UINT32 :
294                 if (m1 == 2)
295                 {
296                     for (j = 0; j < n_lnksz; j++)
297                     {
298                         lnksz[j] = (int) IC_UINT32(M1.D)[j * 2];
299                         lnksz[n_lnksz + j] = (int) IC_UINT32(M1.D)[2 * j + 1];
300                     }
301                 }
302                 else
303                 {
304                     for (j = 0; j < 2 * n_lnksz; j++)
305                     {
306                         lnksz[j] = (int) IC_UINT32(M1.D)[j];
307                     }
308                 }
309                 break;
310         }
311     }
312     else
313     {
314         if (m1 == 2)
315         {
316             for (j = 0; j < n_lnksz; j++)
317             {
318                 lnksz[j] = (int) ((double *) stk(l1))[j * 2];
319                 lnksz[n_lnksz + j] = (int) ((double *) stk(l1))[2 * j + 1];
320             }
321         }
322         else
323         {
324             for (j = 0; j < 2 * n_lnksz; j++)
325             {
326                 lnksz[j] = (int) ((double *) stk(l1))[j];
327             }
328         }
329     }
330
331     /*store rhs 2 in lnktyp */
332     if (VarType(2) == sci_ints)
333     {
334         switch (M2.it)
335         {
336             case I_CHAR   :
337                 for (j = 0; j < n_lnktyp; j++)
338                 {
339                     lnktyp[j] = (int) IC_CHAR(M2.D)[j];
340                 }
341                 break;
342
343             case I_INT16  :
344                 for (j = 0; j < n_lnktyp; j++)
345                 {
346                     lnktyp[j] = (int) IC_INT16(M2.D)[j];
347                 }
348                 break;
349
350             case I_INT32  :
351                 for (j = 0; j < n_lnktyp; j++)
352                 {
353                     lnktyp[j] = (int) IC_INT32(M2.D)[j];
354                 }
355                 break;
356
357             case I_UCHAR  :
358                 for (j = 0; j < n_lnktyp; j++)
359                 {
360                     lnktyp[j] = (int) IC_UCHAR(M2.D)[j];
361                 }
362                 break;
363
364             case I_UINT16 :
365                 for (j = 0; j < n_lnktyp; j++)
366                 {
367                     lnktyp[j] = (int) IC_UINT16(M2.D)[j];
368                 }
369                 break;
370
371             case I_UINT32 :
372                 for (j = 0; j < n_lnktyp; j++)
373                 {
374                     lnktyp[j] = (int) IC_UINT32(M2.D)[j];
375                 }
376                 break;
377
378             default :
379                 /* Invalid integer type */
380                 Scierror(999, _("%s: Wrong value for input argument #%d: An integer expected.\n"), fname, 2);
381                 FREE(lnksz);
382                 FREE(lnktyp);
383                 return 0;
384         }
385     }
386     else
387     {
388         for (j = 0; j < n_lnktyp; j++)
389         {
390             lnktyp[j] = (int) ((double *) stk(l2))[j];
391         }
392     }
393
394     /* build output list */
395     CreateVar(3, LIST_DATATYPE, &n_lnktyp, &n3, &l3);
396
397     for (i = 0; i < n_lnktyp; i++)
398     {
399         nm = lnksz[i] * lnksz[i + n_lnktyp];
400         switch (lnktyp[i])
401         {
402             case 1  :
403                 if ((ptr_d = MALLOC(nm * sizeof(double))) == NULL)
404                 {
405                     ierr = -1;
406                     break;
407                 }
408                 for (j = 0; j < nm; j++)
409                 {
410                     ptr_d[j] = 0;
411                 }
412                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_DOUBLE_DATATYPE, &lnksz[i], &lnksz[i + n_lnktyp], &ptr_d);
413                 FREE(ptr_d);
414                 break;
415
416             case 2  :
417                 if ((ptr_d = MALLOC(2 * nm * sizeof(double))) == NULL)
418                 {
419                     ierr = -1;
420                     break;
421                 }
422                 for (j = 0; j < 2 * nm; j++)
423                 {
424                     ptr_d[j] = 0;
425                 }
426                 ptr_dc = &ptr_d[nm];
427                 CreateListCVarFromPtr(3, i + 1, MATRIX_OF_DOUBLE_DATATYPE, (j = 1, &j), &lnksz[i], &lnksz[i + n_lnktyp], &ptr_d, &ptr_dc);
428                 FREE(ptr_d);
429                 break;
430
431             case 3  :
432                 if ((ptr_i = MALLOC(nm * sizeof(int))) == NULL)
433                 {
434                     ierr = -1;
435                     break;
436                 }
437                 for (j = 0; j < nm; j++)
438                 {
439                     ptr_i[j] = 0;
440                 }
441                 M3.m = lnksz[i];
442                 M3.n = lnksz[i + n_lnktyp];
443                 M3.it = 4;
444                 M3.l = -1;
445                 M3.D = ptr_i;
446                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
447                 FREE(ptr_i);
448                 break;
449
450             case 4  :
451                 if ((ptr_s = MALLOC(nm * sizeof(short))) == NULL)
452                 {
453                     ierr = -1;
454                     break;
455                 }
456                 for (j = 0; j < nm; j++)
457                 {
458                     ptr_s[j] = 0;
459                 }
460                 M3.m = lnksz[i];
461                 M3.n = lnksz[i + n_lnktyp];
462                 M3.it = 2;
463                 M3.l = -1;
464                 M3.D = ptr_s;
465                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
466                 FREE(ptr_s);
467                 break;
468
469             case 5  :
470                 if ((ptr_c = MALLOC(nm * sizeof(char))) == NULL)
471                 {
472                     ierr = -1;
473                     break;
474                 }
475                 for (j = 0; j < nm; j++)
476                 {
477                     ptr_c[j] = 0;
478                 }
479                 M3.m = lnksz[i];
480                 M3.n = lnksz[i + n_lnktyp];
481                 M3.it = 1;
482                 M3.l = -1;
483                 M3.D = ptr_c;
484                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
485                 FREE(ptr_c);
486                 break;
487
488             case 6  :
489                 if ((ptr_ui = MALLOC(nm * sizeof(unsigned int))) == NULL)
490                 {
491                     ierr = -1;
492                     break;
493                 }
494                 for (j = 0; j < nm; j++)
495                 {
496                     ptr_ui[j] = 0;
497                 }
498                 M3.m = lnksz[i];
499                 M3.n = lnksz[i + n_lnktyp];
500                 M3.it = 14;
501                 M3.l = -1;
502                 M3.D = ptr_ui;
503                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
504                 FREE(ptr_ui);
505                 break;
506
507             case 7  :
508                 if ((ptr_us = MALLOC(nm * sizeof(unsigned short))) == NULL)
509                 {
510                     ierr = -1;
511                     break;
512                 }
513                 for (j = 0; j < nm; j++)
514                 {
515                     ptr_us[j] = 0;
516                 }
517                 M3.m = lnksz[i];
518                 M3.n = lnksz[i + n_lnktyp];
519                 M3.it = 12;
520                 M3.l = -1;
521                 M3.D = ptr_us;
522                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
523                 FREE(ptr_us);
524                 break;
525
526             case 8  :
527                 if ((ptr_uc = MALLOC(nm * sizeof(unsigned char))) == NULL)
528                 {
529                     ierr = -1;
530                     break;
531                 }
532                 for (j = 0; j < nm; j++)
533                 {
534                     ptr_uc[j] = 0;
535                 }
536                 M3.m = lnksz[i];
537                 M3.n = lnksz[i + n_lnktyp];
538                 M3.it = 11;
539                 M3.l = -1;
540                 M3.D = ptr_uc;
541                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
542                 FREE(ptr_uc);
543                 break;
544
545             default :
546                 if ((ptr_d = MALLOC(nm * sizeof(double))) == NULL)
547                 {
548                     ierr = -1;
549                     break;
550                 }
551                 for (j = 0; j < nm; j++)
552                 {
553                     ptr_d[j] = 0;
554                 }
555                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_DOUBLE_DATATYPE, &lnksz[i], &lnksz[i + n_lnktyp], &ptr_d);
556                 FREE(ptr_d);
557                 break;
558         }
559
560         if (ierr == -1)
561         {
562             Scierror(999, _("%s : No more free memory.\n"), fname);
563             FREE(lnksz);
564             FREE(lnktyp);
565             return 0;
566         }
567     }
568
569     LhsVar(1) = 3;
570     FREE(lnksz);
571     FREE(lnktyp);
572     PutLhsVar();
573     return 0;
574 }
575 /*--------------------------------------------------------------------------*/