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