Xcos MVC: fix includes
[scilab.git] / scilab / modules / scicos / src / cpp / extractblklist.cpp
1 /*  Scicos
2 *
3 *  Copyright (C) INRIA - Alan LAYEC
4 *  Copyright (C) 2013 - Scilab Enterprises - Clement DAVID
5 *  Copyright (C) 2015 - Scilab Enterprises - Antoine ELIAS
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 *
21 * See the file ./license.txt
22 */
23 /*--------------------------------------------------------------------------*/
24 #include <cstring>
25
26 #include "extractblklist.hxx"
27
28 #include "internal.hxx"
29 #include "list.hxx"
30 #include "tlist.hxx"
31 #include "double.hxx"
32 #include "string.hxx"
33 #include "int.hxx"
34
35 extern "C"
36 {
37 #include "scicos_block4.h"
38 #include "charEncoding.h"
39 }
40 /*--------------------------------------------------------------------------*/
41
42 template <typename T>
43 bool sci2var(T* p, void** dest)
44 {
45     const int size = p->getSize();
46     typename T::type* srcR = p->get();
47
48     if (p->isComplex())
49     {
50         typename T::type* srcI = p->getImg();
51         *dest = (typename T::type*)MALLOC(sizeof(typename T::type) * size * 2);
52         if (*dest == nullptr)
53         {
54             return false;
55         }
56
57         typename T::type* destR = (typename T::type*)*dest;
58         typename T::type* destI = destR + size;
59         for (int i = 0; i < size; ++i)
60         {
61             destR[i] = srcR[i];
62             destI[i] = srcI[i];
63         }
64     }
65     else
66     {
67         *dest = (typename T::type*)MALLOC(sizeof(typename T::type) * size);
68         if (*dest == nullptr)
69         {
70             return false;
71         }
72
73         typename T::type* destR = (typename T::type*)*dest;
74         for (int i = 0; i < size; ++i)
75         {
76             destR[i] = srcR[i];
77         }
78     }
79
80     return true;
81 }
82
83 static bool sci2var(types::InternalType* p, void** dest)
84 {
85     *dest = nullptr;
86     switch (p->getType())
87     {
88         case types::InternalType::ScilabDouble:
89         {
90             return sci2var(p->getAs<types::Double>(), dest);
91         }
92         case types::InternalType::ScilabInt8:
93         {
94             return sci2var(p->getAs<types::Int8>(), dest);
95         }
96         case types::InternalType::ScilabInt16:
97         {
98             return sci2var(p->getAs<types::Int16>(), dest);
99         }
100         case types::InternalType::ScilabInt32:
101         {
102             return sci2var(p->getAs<types::Int32>(), dest);
103         }
104         case types::InternalType::ScilabInt64:
105         {
106             return sci2var(p->getAs<types::Int64>(), dest);
107         }
108         case types::InternalType::ScilabUInt8:
109         {
110             return sci2var(p->getAs<types::UInt8>(), dest);
111         }
112         case types::InternalType::ScilabUInt16:
113         {
114             return sci2var(p->getAs<types::UInt16>(), dest);
115         }
116         case types::InternalType::ScilabUInt32:
117         {
118             return sci2var(p->getAs<types::UInt32>(), dest);
119         }
120         case types::InternalType::ScilabUInt64:
121         {
122             return sci2var(p->getAs<types::UInt64>(), dest);
123         }
124         default:
125             return false;
126     }
127
128     return false;
129 }
130
131 static bool getString(types::InternalType* p, char** dest)
132 {
133     *dest = nullptr;
134
135     if (p == nullptr)
136     {
137         return false;
138     }
139
140     if (p->isString())
141     {
142         types::String* s = p->getAs<types::String>();
143         if (s->isScalar())
144         {
145             *dest = wide_string_to_UTF8(s->get()[0]);
146             return true;
147         }
148     }
149     return false;
150 }
151
152 static bool getDoubleArray(types::InternalType* p, double** dest, const int size)
153 {
154     *dest = nullptr;
155
156     if (p == nullptr)
157     {
158         return false;
159     }
160
161     if (p->isDouble())
162     {
163         types::Double* d = p->getAs<types::Double>();
164         if (d->getSize() == size)
165         {
166             if (size == 0)
167             {
168                 return true;
169             }
170
171             *dest = (double*)MALLOC(sizeof(double) * size);
172             if (*dest == nullptr)
173             {
174                 return false;
175             }
176             memcpy(*dest, d->get(), sizeof(double) * size);
177             return true;
178         }
179     }
180
181     return false;
182 }
183
184 static bool getDoubleArrayAsInt(types::InternalType* p, int** dest, const int size)
185 {
186     *dest = nullptr;
187
188     if (p == nullptr)
189     {
190         return false;
191     }
192
193     if (p->isDouble())
194     {
195         types::Double* d = p->getAs<types::Double>();
196         if (d->getSize() == size)
197         {
198             if (size == 0)
199             {
200                 return true;
201             }
202
203             const double* const dbl = d->get();
204             *dest = (int*)MALLOC(sizeof(int) * size);
205             if (*dest == nullptr)
206             {
207                 return false;
208             }
209
210             for (int i = 0; i < size; ++i)
211             {
212                 (*dest)[i] = static_cast<int>(dbl[i]);
213             }
214             return true;
215         }
216     }
217
218     return false;
219 }
220
221 static bool getDoubleAsInt(types::InternalType* p, int* dest)
222 {
223     if (p == nullptr)
224     {
225         return false;
226     }
227
228     if (p->isDouble())
229     {
230         types::Double* d = p->getAs<types::Double>();
231         if (d->isScalar())
232         {
233             *dest = static_cast<int>(d->get()[0]);
234             return true;
235         }
236     }
237     return false;
238 }
239
240 static bool checkType(const int type, types::InternalType* p)
241 {
242     if (p == nullptr)
243     {
244         return false;
245     }
246
247     switch (type)
248     {
249         case 10:
250             if (p->isDouble())
251             {
252                 return true;
253             }
254         case 11:
255             if (p->isDouble() && p->getAs<types::Double>()->isComplex())
256             {
257                 return true;
258             }
259         case 81:
260             if (p->isInt8())
261             {
262                 return true;
263             }
264         case 82:
265             if (p->isInt16())
266             {
267                 return true;
268             }
269         case 84:
270             if (p->isInt32())
271             {
272                 return true;
273             }
274         case 811:
275             if (p->isUInt8())
276             {
277                 return true;
278             }
279         case 812:
280             if (p->isUInt16())
281             {
282                 return true;
283             }
284         case 814:
285             if (p->isUInt32())
286             {
287                 return true;
288             }
289     }
290
291     return false;
292 }
293
294 bool extractblklist(types::TList* t, scicos_block* const Block)
295 {
296     types::InternalType* pIT = nullptr;
297
298     /* 2 - nevprt */
299     if (getDoubleAsInt(t->getField(L"nevprt"), &Block->nevprt) == false)
300     {
301         return false;
302     }
303
304     /* 3 - funpt */
305     //function ptr hide in double*
306     pIT = t->getField(L"funpt");
307     if (pIT->isDouble())
308     {
309         types::Double* d = pIT->getAs<types::Double>();
310         Block->funpt = (voidg)(long long)d->get()[0];
311     }
312
313     /* 4 - type */
314     if (getDoubleAsInt(t->getField(L"type"), &Block->type) == false)
315     {
316         return false;
317     }
318
319     /* 5 - scsptr */
320     //function ptr hide in double*
321     pIT = t->getField(L"scsptr");
322     if (pIT->isDouble())
323     {
324         types::Double* d = pIT->getAs<types::Double>();
325         Block->scsptr = (void*)(long long)d->get()[0];
326     }
327
328     /* 6 - nz */
329     if (getDoubleAsInt(t->getField(L"nz"), &Block->nz) == false)
330     {
331         return false;
332     }
333
334     /* 7 - z */
335     if (getDoubleArray(t->getField(L"z"), &Block->z, Block->nz) == false)
336     {
337         return false;
338     }
339
340     /* 8 - noz */
341     if (getDoubleAsInt(t->getField(L"noz"), &Block->noz) == false)
342     {
343         return false;
344     }
345
346     /* 9 - ozsz */
347     if (getDoubleArrayAsInt(t->getField(L"ozsz"), &Block->ozsz, Block->noz * 2) == false)
348     {
349         return false;
350     }
351
352     /* 10 - oztyp */
353     if (getDoubleArrayAsInt(t->getField(L"oztyp"), &Block->ozsz, Block->noz) == false)
354     {
355         return false;
356     }
357
358     /* 11 - oz */
359     pIT = t->getField(L"oz");
360     if (pIT->isList())
361     {
362         types::List* ozptr = pIT->getAs<types::List>();
363         if (ozptr->getSize() != Block->noz)
364         {
365             return false;
366         }
367
368         Block->ozptr = (void**)MALLOC(sizeof(void*) * Block->noz);
369         if (Block->ozptr == nullptr)
370         {
371             return false;
372         }
373
374         for (int i = 0; i < Block->noz; ++i)
375         {
376             pIT = ozptr->get(i);
377             if (checkType(Block->oztyp[i], pIT) == false)
378             {
379                 return false;
380             }
381
382             if (sci2var(pIT, &Block->ozptr[i]) == false)
383             {
384                 return false;
385             }
386         }
387     }
388
389     /* 12 - nx */
390     if (getDoubleAsInt(t->getField(L"nx"), &Block->nx) == false)
391     {
392         return false;
393     }
394
395     /* 13 - x */
396     if (getDoubleArray(t->getField(L"x"), &Block->x, Block->nx) == false)
397     {
398         return false;
399     }
400
401     /* 14 - xd */
402     if (getDoubleArray(t->getField(L"xd"), &Block->xd, Block->nx) == false)
403     {
404         return false;
405     }
406
407     /* 15 - res */
408     if (getDoubleArray(t->getField(L"res"), &Block->res, Block->nx) == false)
409     {
410         return false;
411     }
412
413     /* 16 - nin */
414     if (getDoubleAsInt(t->getField(L"nin"), &Block->nin) == false)
415     {
416         return false;
417     }
418
419     /* 17 - insz */
420     if (getDoubleArrayAsInt(t->getField(L"insz"), &Block->insz, Block->nin * 3) == false)
421     {
422         return false;
423     }
424
425     /* 18 - inptr */
426     pIT = t->getField(L"inptr");
427     if (pIT->isList())
428     {
429         types::List* inptr = pIT->getAs<types::List>();
430         if (inptr->getSize() != Block->nin)
431         {
432             return false;
433         }
434
435         Block->inptr = (void**)MALLOC(sizeof(void*) * Block->nin);
436         if (Block->inptr == nullptr)
437         {
438             return false;
439         }
440
441         for (int i = 0; i < Block->nin; ++i)
442         {
443             pIT = inptr->get(i);
444             if (checkType(Block->insz[2 * Block->nin + i], pIT) == false)
445             {
446                 return false;
447             }
448
449             if (sci2var(pIT, &Block->inptr[i]) == false)
450             {
451                 return false;
452             }
453         }
454     }
455
456     /* 19 - nout */
457     if (getDoubleAsInt(t->getField(L"nout"), &Block->nout) == false)
458     {
459         return false;
460     }
461
462     /* 20 - outsz */
463     if (getDoubleArrayAsInt(t->getField(L"outsz"), &Block->outsz, Block->nout * 3) == false)
464     {
465         return false;
466     }
467
468     /* 21 - outptr */
469     pIT = t->getField(L"outptr");
470     if (pIT->isList())
471     {
472         types::List* outptr = pIT->getAs<types::List>();
473         if (outptr->getSize() != Block->nout)
474         {
475             return false;
476         }
477
478         Block->outptr = (void**)MALLOC(sizeof(void*) * Block->nout);
479         if (Block->outptr == nullptr)
480         {
481             return false;
482         }
483
484         for (int i = 0; i < Block->nout; ++i)
485         {
486             pIT = outptr->get(i);
487             if (checkType(Block->outsz[2 * Block->nout + i], pIT) == false)
488             {
489                 return false;
490             }
491
492             if (sci2var(pIT, &Block->outptr[i]) == false)
493             {
494                 return false;
495             }
496         }
497     }
498
499     /* 22 - nevout */
500     if (getDoubleAsInt(t->getField(L"nevout"), &Block->nevout) == false)
501     {
502         return false;
503     }
504
505     /* 23 - evout */
506     if (getDoubleArray(t->getField(L"evout"), &Block->evout, Block->nevout) == false)
507     {
508         return false;
509     }
510
511     /* 24 - nrpar */
512     if (getDoubleAsInt(t->getField(L"nrpar"), &Block->nrpar) == false)
513     {
514         return false;
515     }
516
517     /* 25 - rpar */
518     if (getDoubleArray(t->getField(L"rpar"), &Block->rpar, Block->nrpar) == false)
519     {
520         return false;
521     }
522
523     /* 26 - nipar */
524     if (getDoubleAsInt(t->getField(L"nipar"), &Block->nipar) == false)
525     {
526         return false;
527     }
528
529     /* 27 - ipar */
530     if (getDoubleArrayAsInt(t->getField(L"ipar"), &Block->ipar, Block->nipar) == false)
531     {
532         return false;
533     }
534
535     /* 28 - nopar */
536     if (getDoubleAsInt(t->getField(L"nopar"), &Block->nopar) == false)
537     {
538         return false;
539     }
540
541     /* 29 - oparsz */
542     if (getDoubleArrayAsInt(t->getField(L"oparsz"), &Block->oparsz, 2 * Block->nopar) == false)
543     {
544         return false;
545     }
546
547     /* 30 - opartyp */
548     if (getDoubleArrayAsInt(t->getField(L"opartyp"), &Block->opartyp, Block->nopar) == false)
549     {
550         return false;
551     }
552
553     /* 31 - opar */
554     pIT = t->getField(L"opar");
555     if (pIT->isList())
556     {
557         types::List* opar = pIT->getAs<types::List>();
558         if (opar->getSize() != Block->nopar)
559         {
560             return false;
561         }
562
563         Block->oparptr = (void**)MALLOC(sizeof(void*) * Block->nopar);
564         if (Block->inptr == nullptr)
565         {
566             return false;
567         }
568
569         for (int i = 0; i < Block->nopar; ++i)
570         {
571             pIT = opar->get(i);
572             if (checkType(Block->opartyp[i], pIT) == false)
573             {
574                 return false;
575             }
576
577             if (sci2var(pIT, &Block->oparptr[i]) == false)
578             {
579                 return false;
580             }
581         }
582     }
583
584     /* 32 - ng */
585     if (getDoubleAsInt(t->getField(L"ng"), &Block->ng) == false)
586     {
587         return false;
588     }
589
590     /* 33 - g */
591     if (getDoubleArray(t->getField(L"g"), &Block->g, Block->ng) == false)
592     {
593         return false;
594     }
595
596     /* 34 - ztyp */
597     if (getDoubleAsInt(t->getField(L"ztyp"), &Block->ztyp) == false)
598     {
599         return false;
600     }
601
602     /* 35 - jroot */
603     if (getDoubleArrayAsInt(t->getField(L"jroot"), &Block->jroot, Block->ng) == false)
604     {
605         return false;
606     }
607
608     /* 36 - label */
609     if (getString(t->getField(L"label"), &Block->label) == false)
610     {
611         return false;
612     }
613
614     /* 37 - work*/
615     pIT = t->getField(L"work");
616     if (pIT->isDouble())
617     {
618         types::Double* d = pIT->getAs<types::Double>();
619         Block->work = (void**)(long long)d->get()[0];
620     }
621
622     /* 38 - nmode*/
623     if (getDoubleAsInt(t->getField(L"nmode"), &Block->nmode) == false)
624     {
625         return false;
626     }
627
628     /* 39 - mode */
629     if (getDoubleArrayAsInt(t->getField(L"mode"), &Block->mode, Block->nmode) == false)
630     {
631         return false;
632     }
633
634     /* 40 - xprop */
635     if (getDoubleArrayAsInt(t->getField(L"xprop"), &Block->xprop, Block->nx) == false)
636     {
637         return false;
638     }
639
640     return true;
641 }
642 /*--------------------------------------------------------------------------*/