Xcos MVC: fix includes
[scilab.git] / scilab / modules / scicos / src / cpp / createblklist.cpp
1 /*  Scicos
2 *
3 *  Copyright (C) 2015 - Scilab Enterprises - Antoine ELIAS
4 *  Copyright (C) DIGITEO - 2009 - Allan CORNET
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 *
20 * See the file ./license.txt
21 */
22 /*--------------------------------------------------------------------------*/
23 #include "createblklist.hxx"
24
25 #include "internal.hxx"
26 #include "list.hxx"
27 #include "tlist.hxx"
28 #include "double.hxx"
29 #include "string.hxx"
30 #include "int.hxx"
31
32 extern "C"
33 {
34 #include "import.h"
35 #include "scicos_block4.h"
36 }
37 /*--------------------------------------------------------------------------*/
38 //extern void str2sci(char** x, int n, int m); /* core/src/c/str2sci.h */
39 //extern void C2F(itosci)();
40 //extern void C2F(dtosci)();
41 //extern int C2F(scierr)();
42 //extern void C2F(vvtosci)();
43 //extern int C2F(mktlist)();
44 /*--------------------------------------------------------------------------*/
45 static types::InternalType* vartosci(void* data, const int rows, const int cols, const int type)
46 {
47     const int size = rows * cols;
48     switch (type)
49     {
50         case SCSREAL_N:
51         {
52             types::Double* var = new types::Double(rows, cols);
53             for (int i = 0; i < size; ++i)
54             {
55                 var->get()[i] = ((types::Double::type*)data)[i];
56             }
57             return var;
58         }
59         case SCSCOMPLEX_N:
60         {
61             types::Double* var = new types::Double(rows, cols, true);
62             for (int i = 0; i < size; ++i)
63             {
64                 var->get()[i] = ((types::Double::type*)data)[i];
65                 var->getImg()[i] = ((types::Double::type*)data)[size + i];
66             }
67             return var;
68         }
69         case SCSINT8_N:
70         {
71             types::Int8* var = new types::Int8(rows, cols);
72             for (int i = 0; i < size; ++i)
73             {
74                 var->get()[i] = ((types::Int8::type*)data)[i];
75             }
76             return var;
77         }
78         case SCSINT16_N:
79         {
80             types::Int16* var = new types::Int16(rows, cols);
81             for (int i = 0; i < size; ++i)
82             {
83                 var->get()[i] = ((types::Int16::type*)data)[i];
84             }
85             return var;
86         }
87         case SCSINT32_N:
88         {
89             types::Int32* var = new types::Int32(rows, cols);
90             for (int i = 0; i < size; ++i)
91             {
92                 var->get()[i] = ((types::Int32::type*)data)[i];
93             }
94             return var;
95         }
96         case SCSUINT8_N:
97         {
98             types::UInt8* var = new types::UInt8(rows, cols);
99             for (int i = 0; i < size; ++i)
100             {
101                 var->get()[i] = ((types::UInt8::type*)data)[i];
102             }
103             return var;
104         }
105         case SCSUINT16_N:
106         {
107             types::UInt16* var = new types::UInt16(rows, cols);
108             for (int i = 0; i < size; ++i)
109             {
110                 var->get()[i] = ((types::UInt16::type*)data)[i];
111             }
112             return var;
113         }
114         case SCSUINT32_N:
115         {
116             types::UInt32* var = new types::UInt32(rows, cols);
117             for (int i = 0; i < size; ++i)
118             {
119                 var->get()[i] = ((types::UInt32::type*)data)[i];
120             }
121             return var;
122         }
123         default:
124         {
125             return nullptr;
126         }
127     }
128 }
129
130 types::InternalType* createblklist(const scicos_block* const Blocks, const int flag_imp, const int /*funtyp*/)
131 {
132     /* set string of first element of scilab Blocks tlist -please update me- */
133     const int fieldCount = 41;
134     int size = 0;
135
136     static const char *str_blklst[] = {"scicos_block", "nevprt", "funpt", "type",
137                                        "scsptr", "nz", "z", "noz",
138                                        "ozsz", "oztyp", "oz", "nx",
139                                        "x", "xd", "res", "nin",
140                                        "insz", "inptr", "nout", "outsz",
141                                        "outptr", "nevout", "evout", "nrpar",
142                                        "rpar", "nipar", "ipar", "nopar",
143                                        "oparsz", "opartyp", "opar", "ng",
144                                        "g", "ztyp", "jroot", "label",
145                                        "work", "nmode", "mode", "xprop",
146                                        "uid"
147                                       };
148
149     int *xptr = nullptr;   /* to retrieve xptr by import and zcptr of scicos_blocks */
150     double *x = nullptr;   /* ptr for x, xd and g for scicos_blocks                 */
151     double *xd = nullptr;
152     int *zcptr = nullptr;
153     double *g = nullptr;
154
155     if (flag_imp >= 0)
156     {
157         int nv, mv;         /* length of data                             */
158         int nblk;           /* to store number of blocks                  */
159         //int ng;             /* to store number of zero cross              */
160         void *ptr;          /* ptr for data comming from import structure */
161
162         /*retrieve nblk by import structure*/
163         char Nblk[] = "nblk";
164         getscicosvarsfromimport(Nblk, &ptr, &nv, &mv);
165         nblk = ((int*)ptr)[0];
166
167         /* retrieve ng by import structure */
168         char Ng[] = "ng";
169         getscicosvarsfromimport(Ng, &ptr, &nv, &mv);
170         //ng = ((int*)ptr)[0];
171
172         /*retrieve xptr by import structure*/
173         char Xptr[] = "xptr";
174         getscicosvarsfromimport(Xptr, &ptr, &nv, &mv);
175         xptr = (int *)ptr;
176
177         /*retrieve zcptr by import structure*/
178         char Zcptr[] = "zcptr";
179         getscicosvarsfromimport(Zcptr, &ptr, &nv, &mv);
180         zcptr = (int *)ptr;
181
182         /*retrieve x and xd by import structure*/
183         char X[] = "x";
184         getscicosvarsfromimport(X, &ptr, &nv, &mv);
185         x = (double *)ptr;
186         xd = &x[xptr[nblk] - 1];
187
188         /*retrieve g by import structure*/
189         char G[] = "g";
190         getscicosvarsfromimport(G, &ptr, &nv, &mv);
191         g = (double *)ptr;
192     }
193
194     types::TList* m = new types::TList();
195
196     /* 1 - scicos_block */
197     types::String* s = new types::String(1, fieldCount);
198     for (int i = 0; i < fieldCount; ++i)
199     {
200         s->set(i, str_blklst[i]);
201     }
202
203     m->append(s);
204
205     /* 2 - nevprt */
206     m->append(new types::Double(static_cast<double>(Blocks->nevprt)));
207
208     /* 3 - funpt */
209     //cast function ptr to double*
210     if (sizeof(voidg) >= sizeof(double))
211     {
212         // store N double values as the function pointer value
213         size = sizeof(voidg) / sizeof(double);
214     }
215     else
216     {
217         // push at least one double
218         size = 1;
219     }
220
221     types::Double* funpt = new types::Double(size, 1);
222     double* d = funpt->get();
223     for (int i = 0; i < size; ++i)
224     {
225         d[i] = (double)((long long)Blocks->funpt);
226     }
227
228     m->append(funpt);
229
230     /* 4 - type */
231     m->append(new types::Double(static_cast<double>(Blocks->type)));
232
233     /* 5 - scsptr */
234     //cast function ptr to double*
235     size = 0;
236     if (sizeof(types::InternalType*) >= sizeof(double))
237     {
238         // store N double values as the function pointer value
239         size = sizeof(types::InternalType*) / sizeof(double);
240     }
241     else
242     {
243         // push at least one double
244         size = 1;
245     }
246     types::Double* scsptr = new types::Double(size, 1);
247     d = scsptr->get();
248     for (int i = 0; i < size; ++i)
249     {
250         d[i] = (double)((long long)Blocks->scsptr);
251     }
252
253     m->append(scsptr);
254
255     /* 6 - nz */
256     m->append(new types::Double(static_cast<double>(Blocks->nz)));
257
258     /* 7 - z */
259     m->append(vartosci(Blocks->z, Blocks->nz, 1, SCSREAL_N));
260
261     /* 8 - noz */
262     m->append(new types::Double(static_cast<double>(Blocks->noz)));
263
264     /* 9 - ozsz */
265     types::Double* ozsz = new types::Double(Blocks->noz, 1);
266     d = ozsz->get();
267     for (int i = 0; i < Blocks->noz; ++i)
268     {
269         d[i] = static_cast<double>(Blocks->ozsz[i]);
270     }
271
272     m->append(ozsz);
273
274     /* 10 - oztyp */
275     types::Double* oztyp = new types::Double(Blocks->noz, 1);
276     d = oztyp->get();
277     for (int i = 0; i < Blocks->noz; ++i)
278     {
279         d[i] = static_cast<double>(Blocks->oztyp[i]);
280     }
281
282     m->append(oztyp);
283
284     /* 11 - ozptr */
285     types::List* ozptr = new types::List();
286     for (int k = 0; k < Blocks->noz; k++)
287     {
288         const int rows = Blocks->ozsz[k]; /* retrieve number of rows */
289         const int cols = Blocks->ozsz[Blocks->noz + k]; /* retrieve number of cols */
290         const int type = Blocks->oztyp[k]; /* retrieve type */
291         ozptr->append(vartosci(Blocks->ozptr[k], rows, cols, type));
292     }
293
294     m->append(ozptr);
295
296     /* 12 - nx */
297     m->append(new types::Double(static_cast<double>(Blocks->nx)));
298
299     /* 13 - x */
300     if (flag_imp >= 0)
301     {
302         m->append(vartosci(&x[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
303     }
304     else
305     {
306         m->append(vartosci(Blocks->x, Blocks->nx, 1, SCSREAL_N));
307     }
308
309     /* 14 - xd */
310     if (flag_imp >= 0)
311     {
312         m->append(vartosci(&xd[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
313     }
314     else
315     {
316         m->append(vartosci(Blocks->xd, Blocks->nx, 1, SCSREAL_N));
317     }
318
319     /* 15 - res */
320     m->append(vartosci(Blocks->res, Blocks->nx, 1, SCSREAL_N));
321
322     /* 16 - nin */
323     m->append(new types::Double(static_cast<double>(Blocks->nin)));
324
325     /* 17 - insz */
326     types::Double* insz = new types::Double(Blocks->nin, 1);
327     d = insz->get();
328     for (int i = 0; i < Blocks->nin; ++i)
329     {
330         d[i] = static_cast<double>(Blocks->insz[i]);
331     }
332
333     m->append(insz);
334
335     /* 18 - inptr */
336     types::List* inptr = new types::List();
337     for (int k = 0; k < Blocks->nin; k++)
338     {
339         const int rows = Blocks->insz[k]; /* retrieve number of rows */
340         const int cols = Blocks->insz[Blocks->nin + k]; /* retrieve number of cols */
341         const int type = Blocks->insz[2 * Blocks->nin + k]; /* retrieve type */
342         inptr->append(vartosci(Blocks->inptr[k], rows, cols, type));
343     }
344
345     m->append(inptr);
346
347     /* 19 - nout */
348     m->append(new types::Double(static_cast<double>(Blocks->nout)));
349
350     /* 20 - outsz */
351     types::Double* outsz = new types::Double(3 * Blocks->nout, 1);
352     d = outsz->get();
353     for (int i = 0; i < 3 * Blocks->nout; ++i)
354     {
355         d[i] = static_cast<double>(Blocks->outsz[i]);
356     }
357
358     m->append(outsz);
359     /* 21 - outptr */
360     types::List* outptr = new types::List();
361     for (int k = 0; k < Blocks->nout; k++)
362     {
363         const int rows = Blocks->outsz[k]; /* retrieve number of rows */
364         const int cols = Blocks->outsz[Blocks->nout + k]; /* retrieve number of cols */
365         const int type = Blocks->outsz[2 * Blocks->nout + k]; /* retrieve type */
366         outptr->append(vartosci(Blocks->outptr[k], rows, cols, type));
367     }
368
369     m->append(outptr);
370
371     /* 22 - nevout */
372     m->append(new types::Double(static_cast<double>(Blocks->nevout)));
373
374     /* 23 - evout */
375     m->append(vartosci(Blocks->evout, Blocks->nevout, 1, SCSREAL_N));
376
377     /* 24 - nrpar */
378     m->append(new types::Double(static_cast<double>(Blocks->nrpar)));
379
380     /* 25 - rpar */
381     m->append(vartosci(Blocks->rpar, Blocks->nrpar, 1, SCSREAL_N));
382
383     /* 26 - nipar */
384     m->append(new types::Double(static_cast<double>(Blocks->nipar)));
385
386     /* 27 - ipar */
387     types::Double* ipar = new types::Double(Blocks->nipar, 1);
388     d = ipar->get();
389     for (int i = 0; i < Blocks->nipar; ++i)
390     {
391         d[i] = static_cast<double>(Blocks->ipar[i]);
392     }
393
394     m->append(ipar);
395
396     /* 28 - nopar */
397     m->append(new types::Double(static_cast<double>(Blocks->nopar)));
398
399     /* 29 - oparsz */
400     types::Double* oparsz = new types::Double(Blocks->nopar, 1);
401     d = oparsz->get();
402     for (int i = 0; i < Blocks->nopar; ++i)
403     {
404         d[i] = static_cast<double>(Blocks->oparsz[i]);
405     }
406
407     m->append(oparsz);
408
409     /* 30 - opartyp */
410     types::Double* opartyp = new types::Double(Blocks->nopar, 1);
411     d = opartyp->get();
412     for (int i = 0; i < Blocks->nopar; ++i)
413     {
414         d[i] = static_cast<double>(Blocks->opartyp[i]);
415     }
416
417     m->append(opartyp);
418
419     /* 31 - opar */
420     types::List* opar = new types::List();
421     for (int k = 0; k < Blocks->nopar; k++)
422     {
423         const int rows = Blocks->oparsz[k]; /* retrieve number of rows */
424         const int cols = Blocks->oparsz[Blocks->nopar + k]; /* retrieve number of cols */
425         const int type = Blocks->opartyp[k]; /* retrieve type */
426         opar->append(vartosci(Blocks->oparptr[k], rows, cols, type));
427     }
428
429     m->append(opar);
430
431     /* 32 - ng */
432     m->append(new types::Double(static_cast<double>(Blocks->ng)));
433
434     /* 33 - g */
435     if (flag_imp >= 0)
436     {
437         m->append(vartosci(&g[zcptr[flag_imp] - 1], Blocks->ng, 1, SCSREAL_N));
438     }
439     else
440     {
441         m->append(vartosci(Blocks->g, Blocks->ng, 1, SCSREAL_N));
442     }
443
444     /* 34 - ztyp */
445     m->append(new types::Double(static_cast<double>(Blocks->ztyp)));
446
447     /* 35 - jroot */
448     types::Double* jroot = new types::Double(Blocks->ng, 1);
449     d = jroot->get();
450     for (int i = 0; i < Blocks->ng; ++i)
451     {
452         d[i] = static_cast<double>(Blocks->jroot[i]);
453     }
454
455     m->append(jroot);
456
457     /* 36 - label */
458     m->append(new types::String(Blocks->label));
459
460     /* 37 - work*/
461     //store address as double
462     m->append(new types::Double((double)((long long)Blocks->work)));
463
464     /* 38 - nmode*/
465     m->append(new types::Double(static_cast<double>(Blocks->nmode)));
466
467     /* 39 - mode */
468     types::Double* mode = new types::Double(Blocks->nmode, 1);
469     d = mode->get();
470     for (int i = 0; i < Blocks->nmode; ++i)
471     {
472         d[i] = static_cast<double>(Blocks->mode[i]);
473     }
474
475     m->append(mode);
476
477     /* 40 - xprop */
478     types::Double* xprop = new types::Double(Blocks->nx, 1);
479     d = xprop->get();
480     for (int i = 0; i < Blocks->nx; ++i)
481     {
482         d[i] = static_cast<double>(Blocks->xprop[i]);
483     }
484
485     m->append(xprop);
486
487     /* 41 - uid */
488     if (Blocks->uid)
489     {
490         m->append(new types::String(Blocks->uid));
491     }
492     else
493     {
494         m->append(new types::String(L""));
495     }
496
497     return m;
498 }
499 /*--------------------------------------------------------------------------*/
500