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