Bug #16106 fixed: Xcos sciblk4 opar failed to simulate
[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 "double.hxx"
24 #include "int.hxx"
25 #include "internal.hxx"
26 #include "list.hxx"
27 #include "string.hxx"
28 #include "tlist.hxx"
29
30 extern "C"
31 {
32 #include "import.h"
33 }
34
35 #include "createblklist.hxx"
36 /*--------------------------------------------------------------------------*/
37 static types::InternalType* allocsci(void* data, const int rows, const int cols, const int type)
38 {
39     switch (type)
40     {
41         case SCSREAL_N:
42         {
43             types::Double* var = new types::Double(rows, cols);
44             return var;
45         }
46         case SCSCOMPLEX_N:
47         {
48             types::Double* var = new types::Double(rows, cols, true);
49             return var;
50         }
51         case SCSINT8_N:
52         {
53             types::Int8* var = new types::Int8(rows, cols);
54             return var;
55         }
56         case SCSINT16_N:
57         {
58             types::Int16* var = new types::Int16(rows, cols);
59             return var;
60         }
61         case SCSINT32_N:
62         {
63             types::Int32* var = new types::Int32(rows, cols);
64             return var;
65         }
66         case SCSUINT8_N:
67         {
68             types::UInt8* var = new types::UInt8(rows, cols);
69             return var;
70         }
71         case SCSUINT16_N:
72         {
73             types::UInt16* var = new types::UInt16(rows, cols);
74             return var;
75         }
76         case SCSUINT32_N:
77         {
78             types::UInt32* var = new types::UInt32(rows, cols);
79             return var;
80         }
81         default: // case SCSUNKNOW_N: pass the data by pointers
82         {
83             return (types::InternalType*)data;
84         }
85     }
86 }
87 /*--------------------------------------------------------------------------*/
88 static types::InternalType* vartosci(types::InternalType* pIT, void* data, const int rows, const int cols, const int type)
89 {
90     int size = rows * cols;
91     switch (type)
92     {
93         case SCSREAL_N:
94         {
95             if (!pIT->isDouble())
96             {
97                 return pIT;
98             }
99             types::Double* var = pIT->getAs<types::Double>();
100             size = std::min(var->getSize(), size);
101             for (int i = 0; i < size; ++i)
102             {
103                 var->get()[i] = ((types::Double::type*)data)[i];
104             }
105             return var;
106         }
107         case SCSCOMPLEX_N:
108         {
109             if (!pIT->isDouble())
110             {
111                 return pIT;
112             }
113             types::Double* var = pIT->getAs<types::Double>();
114             size = std::min(var->getSize(), size);
115             for (int i = 0; i < size; ++i)
116             {
117                 var->get()[i] = ((types::Double::type*)data)[i];
118                 var->getImg()[i] = ((types::Double::type*)data)[size + i];
119             }
120             return var;
121         }
122         case SCSINT8_N:
123         {
124             if (!pIT->isInt8())
125             {
126                 return pIT;
127             }
128             types::Int8* var = pIT->getAs<types::Int8>();
129             size = std::min(var->getSize(), size);
130             for (int i = 0; i < size; ++i)
131             {
132                 var->get()[i] = ((types::Int8::type*)data)[i];
133             }
134             return var;
135         }
136         case SCSINT16_N:
137         {
138             if (!pIT->isInt16())
139             {
140                 return pIT;
141             }
142             types::Int16* var = pIT->getAs<types::Int16>();
143             size = std::min(var->getSize(), size);
144             for (int i = 0; i < size; ++i)
145             {
146                 var->get()[i] = ((types::Int16::type*)data)[i];
147             }
148             return var;
149         }
150         case SCSINT32_N:
151         {
152             if (!pIT->isInt32())
153             {
154                 return pIT;
155             }
156             types::Int32* var = pIT->getAs<types::Int32>();
157             size = std::min(var->getSize(), size);
158             for (int i = 0; i < size; ++i)
159             {
160                 var->get()[i] = ((types::Int32::type*)data)[i];
161             }
162             return var;
163         }
164         case SCSUINT8_N:
165         {
166             if (!pIT->isUInt8())
167             {
168                 return pIT;
169             }
170             types::UInt8* var = pIT->getAs<types::UInt8>();
171             size = std::min(var->getSize(), size);
172             for (int i = 0; i < size; ++i)
173             {
174                 var->get()[i] = ((types::UInt8::type*)data)[i];
175             }
176             return var;
177         }
178         case SCSUINT16_N:
179         {
180             if (!pIT->isUInt16())
181             {
182                 return pIT;
183             }
184             types::UInt16* var = pIT->getAs<types::UInt16>();
185             size = std::min(var->getSize(), size);
186             for (int i = 0; i < size; ++i)
187             {
188                 var->get()[i] = ((types::UInt16::type*)data)[i];
189             }
190             return var;
191         }
192         case SCSUINT32_N:
193         {
194             if (!pIT->isUInt32())
195             {
196                 return pIT;
197             }
198             types::UInt32* var = pIT->getAs<types::UInt32>();
199             size = std::min(var->getSize(), size);
200             for (int i = 0; i < size; ++i)
201             {
202                 var->get()[i] = ((types::UInt32::type*)data)[i];
203             }
204             return var;
205         }
206         default: // case SCSUNKNOW_N: pass the data by pointers
207         {
208             return (types::InternalType*)data;
209         }
210     }
211 }
212 /*--------------------------------------------------------------------------*/
213 static types::InternalType* vartosci(void* data, const int rows, const int cols, const int type)
214 {
215     return vartosci(allocsci(data, rows, cols, type), data, rows, cols, type);
216 }
217 /*--------------------------------------------------------------------------*/
218 types::InternalType* createblklist(const scicos_block* const Blocks, const int flag_imp, const int /*funtyp*/)
219 {
220     const int fieldCount = 41;
221     int size = 0;
222
223     /* set string of first element of scilab Blocks tlist */
224     static const char* str_blklst[] = {"scicos_block", "nevprt", "funpt", "type",
225                                        "scsptr", "nz", "z", "noz",
226                                        "ozsz", "oztyp", "oz", "nx",
227                                        "x", "xd", "res", "nin",
228                                        "insz", "inptr", "nout", "outsz",
229                                        "outptr", "nevout", "evout", "nrpar",
230                                        "rpar", "nipar", "ipar", "nopar",
231                                        "oparsz", "opartyp", "opar", "ng",
232                                        "g", "ztyp", "jroot", "label",
233                                        "work", "nmode", "mode", "xprop",
234                                        "uid"
235                                       };
236
237     int* xptr = nullptr; /* to retrieve xptr by import and zcptr of scicos_blocks */
238     double* x = nullptr; /* ptr for x, xd and g for scicos_blocks                 */
239     double* xd = nullptr;
240     int* zcptr = nullptr;
241     double* g = nullptr;
242
243     if (flag_imp >= 0)
244     {
245         int nv, mv; /* length of data                             */
246         int nblk;   /* to store number of blocks                  */
247         //int ng;             /* to store number of zero cross              */
248         void* ptr; /* ptr for data comming from import structure */
249
250         /*retrieve nblk by import structure*/
251         char Nblk[] = "nblk";
252         getscicosvarsfromimport(Nblk, &ptr, &nv, &mv);
253         nblk = ((int*)ptr)[0];
254
255         /* retrieve ng by import structure */
256         char Ng[] = "ng";
257         getscicosvarsfromimport(Ng, &ptr, &nv, &mv);
258         //ng = ((int*)ptr)[0];
259
260         /*retrieve xptr by import structure*/
261         char Xptr[] = "xptr";
262         getscicosvarsfromimport(Xptr, &ptr, &nv, &mv);
263         xptr = (int*)ptr;
264
265         /*retrieve zcptr by import structure*/
266         char Zcptr[] = "zcptr";
267         getscicosvarsfromimport(Zcptr, &ptr, &nv, &mv);
268         zcptr = (int*)ptr;
269
270         /*retrieve x and xd by import structure*/
271         char X[] = "x";
272         getscicosvarsfromimport(X, &ptr, &nv, &mv);
273         x = (double*)ptr;
274         xd = &x[xptr[nblk] - 1];
275
276         /*retrieve g by import structure*/
277         char G[] = "g";
278         getscicosvarsfromimport(G, &ptr, &nv, &mv);
279         g = (double*)ptr;
280     }
281
282     types::TList* m = new types::TList();
283
284     /* 1 - scicos_block */
285     types::String* s = new types::String(1, fieldCount);
286     for (int i = 0; i < fieldCount; ++i)
287     {
288         s->set(i, str_blklst[i]);
289     }
290
291     m->append(s);
292
293     /* 2 - nevprt */
294     m->append(new types::Double(static_cast<double>(Blocks->nevprt)));
295
296     /* 3 - funpt */
297     //cast function ptr to double*
298     if (sizeof(voidg) >= sizeof(double))
299     {
300         // store N double values as the function pointer value
301         size = sizeof(voidg) / sizeof(double);
302     }
303     else
304     {
305         // push at least one double
306         size = 1;
307     }
308
309     types::Double* funpt = new types::Double(size, 1);
310     double* d = funpt->get();
311     for (int i = 0; i < size; ++i)
312     {
313         d[i] = (double)((long long)Blocks->funpt);
314     }
315
316     m->append(funpt);
317
318     /* 4 - type */
319     m->append(new types::Double(static_cast<double>(Blocks->type)));
320
321     /* 5 - scsptr */
322     //cast function ptr to double*
323     if (sizeof(types::InternalType*) >= sizeof(double))
324     {
325         // store N double values as the function pointer value
326         size = sizeof(types::InternalType*) / sizeof(double);
327     }
328     else
329     {
330         // push at least one double
331         size = 1;
332     }
333     types::Double* scsptr = new types::Double(size, 1);
334     d = scsptr->get();
335     for (int i = 0; i < size; ++i)
336     {
337         d[i] = (double)((long long)Blocks->scsptr);
338     }
339
340     m->append(scsptr);
341
342     /* 6 - nz */
343     m->append(new types::Double(static_cast<double>(Blocks->nz)));
344
345     /* 7 - z */
346     m->append(vartosci(Blocks->z, Blocks->nz, 1, SCSREAL_N));
347
348     /* 8 - noz */
349     m->append(new types::Double(static_cast<double>(Blocks->noz)));
350
351     /* 9 - ozsz */
352     types::Double* ozsz = new types::Double(Blocks->noz, 1);
353     d = ozsz->get();
354     for (int i = 0; i < Blocks->noz; ++i)
355     {
356         d[i] = static_cast<double>(Blocks->ozsz[i]);
357     }
358
359     m->append(ozsz);
360
361     /* 10 - oztyp */
362     types::Double* oztyp = new types::Double(Blocks->noz, 1);
363     d = oztyp->get();
364     for (int i = 0; i < Blocks->noz; ++i)
365     {
366         d[i] = static_cast<double>(Blocks->oztyp[i]);
367     }
368
369     m->append(oztyp);
370
371     /* 11 - ozptr */
372     types::List* ozptr;
373
374     // special case, some values are embeded into a Scilab list ; unwrap them
375     if (Blocks->noz == 1 && Blocks->oztyp[0] == SCSUNKNOW_N)
376     {
377         ozptr = (types::List*) vartosci(Blocks->ozptr[0], Blocks->ozsz[0], Blocks->ozsz[1], Blocks->oztyp[0]);
378     }
379     else
380     {
381         ozptr = new types::List();
382         for (int k = 0; k < Blocks->noz; k++)
383         {
384             const int rows = Blocks->ozsz[k];               /* retrieve number of rows */
385             const int cols = Blocks->ozsz[Blocks->noz + k]; /* retrieve number of cols */
386             const int type = Blocks->oztyp[k];              /* retrieve type */
387
388             ozptr->append(vartosci(Blocks->ozptr[k], rows, cols, type));
389         }
390     }
391
392     m->append(ozptr);
393
394     /* 12 - nx */
395     m->append(new types::Double(static_cast<double>(Blocks->nx)));
396
397     /* 13 - x */
398     if (flag_imp >= 0)
399     {
400         m->append(vartosci(&x[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
401     }
402     else
403     {
404         m->append(vartosci(Blocks->x, Blocks->nx, 1, SCSREAL_N));
405     }
406
407     /* 14 - xd */
408     if (flag_imp >= 0)
409     {
410         m->append(vartosci(&xd[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
411     }
412     else
413     {
414         m->append(vartosci(Blocks->xd, Blocks->nx, 1, SCSREAL_N));
415     }
416
417     /* 15 - res */
418     m->append(vartosci(Blocks->res, Blocks->nx, 1, SCSREAL_N));
419
420     /* 16 - nin */
421     m->append(new types::Double(static_cast<double>(Blocks->nin)));
422
423     /* 17 - insz */
424     types::Double* insz = new types::Double(3 * Blocks->nin, 1);
425     d = insz->get();
426     for (int i = 0; i < 3 * Blocks->nin; ++i)
427     {
428         d[i] = static_cast<double>(Blocks->insz[i]);
429     }
430
431     m->append(insz);
432
433     /* 18 - inptr */
434     types::List* inptr = new types::List();
435     for (int k = 0; k < Blocks->nin; k++)
436     {
437         const int rows = Blocks->insz[k];                   /* retrieve number of rows */
438         const int cols = Blocks->insz[Blocks->nin + k];     /* retrieve number of cols */
439         const int type = Blocks->insz[2 * Blocks->nin + k]; /* retrieve type */
440         inptr->append(vartosci(Blocks->inptr[k], rows, cols, type));
441     }
442
443     m->append(inptr);
444
445     /* 19 - nout */
446     m->append(new types::Double(static_cast<double>(Blocks->nout)));
447
448     /* 20 - outsz */
449     types::Double* outsz = new types::Double(3 * Blocks->nout, 1);
450     d = outsz->get();
451     for (int i = 0; i < 3 * Blocks->nout; ++i)
452     {
453         d[i] = static_cast<double>(Blocks->outsz[i]);
454     }
455
456     m->append(outsz);
457     /* 21 - outptr */
458     types::List* outptr = new types::List();
459     for (int k = 0; k < Blocks->nout; k++)
460     {
461         const int rows = Blocks->outsz[k];                    /* retrieve number of rows */
462         const int cols = Blocks->outsz[Blocks->nout + k];     /* retrieve number of cols */
463         const int type = Blocks->outsz[2 * Blocks->nout + k]; /* retrieve type */
464         outptr->append(vartosci(Blocks->outptr[k], rows, cols, type));
465     }
466
467     m->append(outptr);
468
469     /* 22 - nevout */
470     m->append(new types::Double(static_cast<double>(Blocks->nevout)));
471
472     /* 23 - evout */
473     m->append(vartosci(Blocks->evout, Blocks->nevout, 1, SCSREAL_N));
474
475     /* 24 - nrpar */
476     m->append(new types::Double(static_cast<double>(Blocks->nrpar)));
477
478     /* 25 - rpar */
479     m->append(vartosci(Blocks->rpar, Blocks->nrpar, 1, SCSREAL_N));
480
481     /* 26 - nipar */
482     m->append(new types::Double(static_cast<double>(Blocks->nipar)));
483
484     /* 27 - ipar */
485     types::Double* ipar = new types::Double(Blocks->nipar, 1);
486     d = ipar->get();
487     for (int i = 0; i < Blocks->nipar; ++i)
488     {
489         d[i] = static_cast<double>(Blocks->ipar[i]);
490     }
491
492     m->append(ipar);
493
494     /* 28 - nopar */
495     m->append(new types::Double(static_cast<double>(Blocks->nopar)));
496
497     /* 29 - oparsz */
498     types::Double* oparsz = new types::Double(Blocks->nopar, 1);
499     d = oparsz->get();
500     for (int i = 0; i < Blocks->nopar; ++i)
501     {
502         d[i] = static_cast<double>(Blocks->oparsz[i]);
503     }
504
505     m->append(oparsz);
506
507     /* 30 - opartyp */
508     types::Double* opartyp = new types::Double(Blocks->nopar, 1);
509     d = opartyp->get();
510     for (int i = 0; i < Blocks->nopar; ++i)
511     {
512         d[i] = static_cast<double>(Blocks->opartyp[i]);
513     }
514
515     m->append(opartyp);
516
517     /* 31 - opar */
518     types::List* opar;
519
520     // special case, some values are embeded into a Scilab list ; unwrap them
521     if (Blocks->nopar == 1 && Blocks->opartyp[0] == SCSUNKNOW_N)
522     {
523         opar = (types::List*) vartosci(Blocks->oparptr[0], Blocks->oparsz[0], Blocks->oparsz[1], Blocks->opartyp[0]);
524     }
525     else
526     {
527         opar = new types::List();
528         for (int k = 0; k < Blocks->noz; k++)
529         {
530             const int rows = Blocks->oparsz[k];               /* retrieve number of rows */
531             const int cols = Blocks->oparsz[Blocks->noz + k]; /* retrieve number of cols */
532             const int type = Blocks->opartyp[k];              /* retrieve type */
533
534             opar->append(vartosci(Blocks->oparptr[k], rows, cols, type));
535         }
536     }
537
538     m->append(opar);
539
540     /* 32 - ng */
541     m->append(new types::Double(static_cast<double>(Blocks->ng)));
542
543     /* 33 - g */
544     if (flag_imp >= 0)
545     {
546         m->append(vartosci(&g[zcptr[flag_imp] - 1], Blocks->ng, 1, SCSREAL_N));
547     }
548     else
549     {
550         m->append(vartosci(Blocks->g, Blocks->ng, 1, SCSREAL_N));
551     }
552
553     /* 34 - ztyp */
554     m->append(new types::Double(static_cast<double>(Blocks->ztyp)));
555
556     /* 35 - jroot */
557     types::Double* jroot = new types::Double(Blocks->ng, 1);
558     d = jroot->get();
559     for (int i = 0; i < Blocks->ng; ++i)
560     {
561         d[i] = static_cast<double>(Blocks->jroot[i]);
562     }
563
564     m->append(jroot);
565
566     /* 36 - label */
567     m->append(new types::String(Blocks->label));
568
569     /* 37 - work*/
570     //store address as double
571     m->append(new types::Double((double)((long long)Blocks->work)));
572
573     /* 38 - nmode*/
574     m->append(new types::Double(static_cast<double>(Blocks->nmode)));
575
576     /* 39 - mode */
577     types::Double* mode = new types::Double(Blocks->nmode, 1);
578     d = mode->get();
579     for (int i = 0; i < Blocks->nmode; ++i)
580     {
581         d[i] = static_cast<double>(Blocks->mode[i]);
582     }
583
584     m->append(mode);
585
586     /* 40 - xprop */
587     types::Double* xprop = new types::Double(Blocks->nx, 1);
588     d = xprop->get();
589     for (int i = 0; i < Blocks->nx; ++i)
590     {
591         d[i] = static_cast<double>(Blocks->xprop[i]);
592     }
593
594     m->append(xprop);
595
596     /* 41 - uid */
597     if (Blocks->uid)
598     {
599         m->append(new types::String(Blocks->uid));
600     }
601     else
602     {
603         m->append(new types::String(L""));
604     }
605
606     return m;
607 }
608 /*--------------------------------------------------------------------------*/
609 types::InternalType* refreshblklist(types::InternalType* pIT, const scicos_block* const Blocks, const int flag_imp, const int /*funtyp*/)
610 {
611     if (!pIT->isTList())
612     {
613         return pIT;
614     }
615     types::TList* m = pIT->getAs<types::TList>();
616
617     // ensure that `m` contains the needed elements; if not discard the sync
618     if (m->getSize() != 41)
619     {
620         return m;
621     }
622
623     int* xptr = nullptr; /* to retrieve xptr by import and zcptr of scicos_blocks */
624     double* x = nullptr; /* ptr for x, xd and g for scicos_blocks                 */
625     double* xd = nullptr;
626     int* zcptr = nullptr;
627     double* g = nullptr;
628
629     if (flag_imp >= 0)
630     {
631         int nv, mv; /* length of data                             */
632         int nblk;   /* to store number of blocks                  */
633         //int ng;             /* to store number of zero cross              */
634         void* ptr; /* ptr for data comming from import structure */
635
636         /*retrieve nblk by import structure*/
637         char Nblk[] = "nblk";
638         getscicosvarsfromimport(Nblk, &ptr, &nv, &mv);
639         nblk = ((int*)ptr)[0];
640
641         /* retrieve ng by import structure */
642         char Ng[] = "ng";
643         getscicosvarsfromimport(Ng, &ptr, &nv, &mv);
644         //ng = ((int*)ptr)[0];
645
646         /*retrieve xptr by import structure*/
647         char Xptr[] = "xptr";
648         getscicosvarsfromimport(Xptr, &ptr, &nv, &mv);
649         xptr = (int*)ptr;
650
651         /*retrieve zcptr by import structure*/
652         char Zcptr[] = "zcptr";
653         getscicosvarsfromimport(Zcptr, &ptr, &nv, &mv);
654         zcptr = (int*)ptr;
655
656         /*retrieve x and xd by import structure*/
657         char X[] = "x";
658         getscicosvarsfromimport(X, &ptr, &nv, &mv);
659         x = (double*)ptr;
660         xd = &x[xptr[nblk] - 1];
661
662         /*retrieve g by import structure*/
663         char G[] = "g";
664         getscicosvarsfromimport(G, &ptr, &nv, &mv);
665         g = (double*)ptr;
666     }
667
668     /* 7 - z */
669     m->set(6, vartosci(m->get(6), Blocks->z, Blocks->nz, 1, SCSREAL_N));
670
671     /* 11 - ozptr */
672     if (m->get(10)->isList())
673     {
674         types::List* ozptr = m->get(10)->getAs<types::List>();
675
676         // special case, some values are embeded into a Scilab list ; wrap them
677         if (Blocks->noz == 1 && Blocks->oztyp[0] == SCSUNKNOW_N)
678         {
679             m->set(10, ozptr);
680         }
681         else
682         {
683             for (int k = 0; k < Blocks->noz; k++)
684             {
685                 const int rows = Blocks->ozsz[k];               /* retrieve number of rows */
686                 const int cols = Blocks->ozsz[Blocks->noz + k]; /* retrieve number of cols */
687                 const int type = Blocks->oztyp[k];              /* retrieve type */
688                 ozptr->set(k, vartosci(ozptr->get(k), Blocks->ozptr[k], rows, cols, type));
689             }
690             m->set(10, ozptr);
691         }
692     }
693
694     /* 13 - x */
695     if (flag_imp >= 0)
696     {
697         m->set(12, vartosci(m->get(12), &x[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
698     }
699     else
700     {
701         m->set(12, vartosci(m->get(12), Blocks->x, Blocks->nx, 1, SCSREAL_N));
702     }
703
704     /* 14 - xd */
705     if (flag_imp >= 0)
706     {
707         m->set(13, vartosci(m->get(13), &xd[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
708     }
709     else
710     {
711         m->set(13, vartosci(m->get(13), Blocks->xd, Blocks->nx, 1, SCSREAL_N));
712     }
713
714     /* 15 - res */
715     m->set(14, vartosci(m->get(14), Blocks->res, Blocks->nx, 1, SCSREAL_N));
716
717     /* 18 - inptr */
718     if (m->get(17)->isList())
719     {
720         types::List* inptr = m->get(17)->getAs<types::List>();
721         for (int k = 0; k < Blocks->nin; k++)
722         {
723             const int rows = Blocks->insz[k];                   /* retrieve number of rows */
724             const int cols = Blocks->insz[Blocks->nin + k];     /* retrieve number of cols */
725             const int type = Blocks->insz[2 * Blocks->nin + k]; /* retrieve type */
726             inptr->set(k, vartosci(inptr->get(k), Blocks->inptr[k], rows, cols, type));
727         }
728         m->set(17, inptr);
729     }
730
731     /* 21 - outptr */
732     if (m->get(20)->isList())
733     {
734         types::List* outptr = m->get(20)->getAs<types::List>();
735         for (int k = 0; k < Blocks->nout; k++)
736         {
737             const int rows = Blocks->outsz[k];                    /* retrieve number of rows */
738             const int cols = Blocks->outsz[Blocks->nout + k];     /* retrieve number of cols */
739             const int type = Blocks->outsz[2 * Blocks->nout + k]; /* retrieve type */
740             outptr->set(k, vartosci(outptr->get(k), Blocks->outptr[k], rows, cols, type));
741         }
742         m->set(20, outptr);
743     }
744
745     /* 23 - evout */
746     m->set(22, vartosci(m->get(22), Blocks->evout, Blocks->nevout, 1, SCSREAL_N));
747
748     /* 33 - g */
749     if (flag_imp >= 0)
750     {
751         m->set(32, vartosci(m->get(32), &g[zcptr[flag_imp] - 1], Blocks->ng, 1, SCSREAL_N));
752     }
753     else
754     {
755         m->set(32, vartosci(m->get(32), Blocks->g, Blocks->ng, 1, SCSREAL_N));
756     }
757
758     /* 35 - jroot */
759     m->set(34, vartosci(m->get(34), Blocks->jroot, Blocks->ng, 1, SCSREAL_N));
760
761     /* 39 - mode */
762     m->set(38, vartosci(m->get(38), Blocks->mode, Blocks->nmode, 1, SCSREAL_N));
763
764     /* 40 - xprop */
765     m->set(39, vartosci(m->get(39), Blocks->xprop, Blocks->nx, 1, SCSREAL_N));
766
767     return m;
768 }
769 /*--------------------------------------------------------------------------*/