scicos: protect sciblk4 from out-of-bound writes
[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 = new types::List();
373     for (int k = 0; k < Blocks->noz; k++)
374     {
375         const int rows = Blocks->ozsz[k];               /* retrieve number of rows */
376         const int cols = Blocks->ozsz[Blocks->noz + k]; /* retrieve number of cols */
377         const int type = Blocks->oztyp[k];              /* retrieve type */
378         ozptr->append(vartosci(Blocks->ozptr[k], rows, cols, type));
379     }
380
381     m->append(ozptr);
382
383     /* 12 - nx */
384     m->append(new types::Double(static_cast<double>(Blocks->nx)));
385
386     /* 13 - x */
387     if (flag_imp >= 0)
388     {
389         m->append(vartosci(&x[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
390     }
391     else
392     {
393         m->append(vartosci(Blocks->x, Blocks->nx, 1, SCSREAL_N));
394     }
395
396     /* 14 - xd */
397     if (flag_imp >= 0)
398     {
399         m->append(vartosci(&xd[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
400     }
401     else
402     {
403         m->append(vartosci(Blocks->xd, Blocks->nx, 1, SCSREAL_N));
404     }
405
406     /* 15 - res */
407     m->append(vartosci(Blocks->res, Blocks->nx, 1, SCSREAL_N));
408
409     /* 16 - nin */
410     m->append(new types::Double(static_cast<double>(Blocks->nin)));
411
412     /* 17 - insz */
413     types::Double* insz = new types::Double(3 * Blocks->nin, 1);
414     d = insz->get();
415     for (int i = 0; i < 3 * Blocks->nin; ++i)
416     {
417         d[i] = static_cast<double>(Blocks->insz[i]);
418     }
419
420     m->append(insz);
421
422     /* 18 - inptr */
423     types::List* inptr = new types::List();
424     for (int k = 0; k < Blocks->nin; k++)
425     {
426         const int rows = Blocks->insz[k];                   /* retrieve number of rows */
427         const int cols = Blocks->insz[Blocks->nin + k];     /* retrieve number of cols */
428         const int type = Blocks->insz[2 * Blocks->nin + k]; /* retrieve type */
429         inptr->append(vartosci(Blocks->inptr[k], rows, cols, type));
430     }
431
432     m->append(inptr);
433
434     /* 19 - nout */
435     m->append(new types::Double(static_cast<double>(Blocks->nout)));
436
437     /* 20 - outsz */
438     types::Double* outsz = new types::Double(3 * Blocks->nout, 1);
439     d = outsz->get();
440     for (int i = 0; i < 3 * Blocks->nout; ++i)
441     {
442         d[i] = static_cast<double>(Blocks->outsz[i]);
443     }
444
445     m->append(outsz);
446     /* 21 - outptr */
447     types::List* outptr = new types::List();
448     for (int k = 0; k < Blocks->nout; k++)
449     {
450         const int rows = Blocks->outsz[k];                    /* retrieve number of rows */
451         const int cols = Blocks->outsz[Blocks->nout + k];     /* retrieve number of cols */
452         const int type = Blocks->outsz[2 * Blocks->nout + k]; /* retrieve type */
453         outptr->append(vartosci(Blocks->outptr[k], rows, cols, type));
454     }
455
456     m->append(outptr);
457
458     /* 22 - nevout */
459     m->append(new types::Double(static_cast<double>(Blocks->nevout)));
460
461     /* 23 - evout */
462     m->append(vartosci(Blocks->evout, Blocks->nevout, 1, SCSREAL_N));
463
464     /* 24 - nrpar */
465     m->append(new types::Double(static_cast<double>(Blocks->nrpar)));
466
467     /* 25 - rpar */
468     m->append(vartosci(Blocks->rpar, Blocks->nrpar, 1, SCSREAL_N));
469
470     /* 26 - nipar */
471     m->append(new types::Double(static_cast<double>(Blocks->nipar)));
472
473     /* 27 - ipar */
474     types::Double* ipar = new types::Double(Blocks->nipar, 1);
475     d = ipar->get();
476     for (int i = 0; i < Blocks->nipar; ++i)
477     {
478         d[i] = static_cast<double>(Blocks->ipar[i]);
479     }
480
481     m->append(ipar);
482
483     /* 28 - nopar */
484     m->append(new types::Double(static_cast<double>(Blocks->nopar)));
485
486     /* 29 - oparsz */
487     types::Double* oparsz = new types::Double(Blocks->nopar, 1);
488     d = oparsz->get();
489     for (int i = 0; i < Blocks->nopar; ++i)
490     {
491         d[i] = static_cast<double>(Blocks->oparsz[i]);
492     }
493
494     m->append(oparsz);
495
496     /* 30 - opartyp */
497     types::Double* opartyp = new types::Double(Blocks->nopar, 1);
498     d = opartyp->get();
499     for (int i = 0; i < Blocks->nopar; ++i)
500     {
501         d[i] = static_cast<double>(Blocks->opartyp[i]);
502     }
503
504     m->append(opartyp);
505
506     /* 31 - opar */
507     types::List* opar = new types::List();
508     for (int k = 0; k < Blocks->nopar; k++)
509     {
510         const int rows = Blocks->oparsz[k];                 /* retrieve number of rows */
511         const int cols = Blocks->oparsz[Blocks->nopar + k]; /* retrieve number of cols */
512         const int type = Blocks->opartyp[k];                /* retrieve type */
513         opar->append(vartosci(Blocks->oparptr[k], rows, cols, type));
514     }
515
516     m->append(opar);
517
518     /* 32 - ng */
519     m->append(new types::Double(static_cast<double>(Blocks->ng)));
520
521     /* 33 - g */
522     if (flag_imp >= 0)
523     {
524         m->append(vartosci(&g[zcptr[flag_imp] - 1], Blocks->ng, 1, SCSREAL_N));
525     }
526     else
527     {
528         m->append(vartosci(Blocks->g, Blocks->ng, 1, SCSREAL_N));
529     }
530
531     /* 34 - ztyp */
532     m->append(new types::Double(static_cast<double>(Blocks->ztyp)));
533
534     /* 35 - jroot */
535     types::Double* jroot = new types::Double(Blocks->ng, 1);
536     d = jroot->get();
537     for (int i = 0; i < Blocks->ng; ++i)
538     {
539         d[i] = static_cast<double>(Blocks->jroot[i]);
540     }
541
542     m->append(jroot);
543
544     /* 36 - label */
545     m->append(new types::String(Blocks->label));
546
547     /* 37 - work*/
548     //store address as double
549     m->append(new types::Double((double)((long long)Blocks->work)));
550
551     /* 38 - nmode*/
552     m->append(new types::Double(static_cast<double>(Blocks->nmode)));
553
554     /* 39 - mode */
555     types::Double* mode = new types::Double(Blocks->nmode, 1);
556     d = mode->get();
557     for (int i = 0; i < Blocks->nmode; ++i)
558     {
559         d[i] = static_cast<double>(Blocks->mode[i]);
560     }
561
562     m->append(mode);
563
564     /* 40 - xprop */
565     types::Double* xprop = new types::Double(Blocks->nx, 1);
566     d = xprop->get();
567     for (int i = 0; i < Blocks->nx; ++i)
568     {
569         d[i] = static_cast<double>(Blocks->xprop[i]);
570     }
571
572     m->append(xprop);
573
574     /* 41 - uid */
575     if (Blocks->uid)
576     {
577         m->append(new types::String(Blocks->uid));
578     }
579     else
580     {
581         m->append(new types::String(L""));
582     }
583
584     return m;
585 }
586 /*--------------------------------------------------------------------------*/
587 types::InternalType* refreshblklist(types::InternalType* pIT, const scicos_block* const Blocks, const int flag_imp, const int /*funtyp*/)
588 {
589     if (!pIT->isTList())
590     {
591         return pIT;
592     }
593     types::TList* m = pIT->getAs<types::TList>();
594
595     // ensure that `m` contains the needed elements; if not discard the sync
596     if (m->getSize() != 41)
597     {
598         return m;
599     }
600
601     int* xptr = nullptr; /* to retrieve xptr by import and zcptr of scicos_blocks */
602     double* x = nullptr; /* ptr for x, xd and g for scicos_blocks                 */
603     double* xd = nullptr;
604     int* zcptr = nullptr;
605     double* g = nullptr;
606
607     if (flag_imp >= 0)
608     {
609         int nv, mv; /* length of data                             */
610         int nblk;   /* to store number of blocks                  */
611         //int ng;             /* to store number of zero cross              */
612         void* ptr; /* ptr for data comming from import structure */
613
614         /*retrieve nblk by import structure*/
615         char Nblk[] = "nblk";
616         getscicosvarsfromimport(Nblk, &ptr, &nv, &mv);
617         nblk = ((int*)ptr)[0];
618
619         /* retrieve ng by import structure */
620         char Ng[] = "ng";
621         getscicosvarsfromimport(Ng, &ptr, &nv, &mv);
622         //ng = ((int*)ptr)[0];
623
624         /*retrieve xptr by import structure*/
625         char Xptr[] = "xptr";
626         getscicosvarsfromimport(Xptr, &ptr, &nv, &mv);
627         xptr = (int*)ptr;
628
629         /*retrieve zcptr by import structure*/
630         char Zcptr[] = "zcptr";
631         getscicosvarsfromimport(Zcptr, &ptr, &nv, &mv);
632         zcptr = (int*)ptr;
633
634         /*retrieve x and xd by import structure*/
635         char X[] = "x";
636         getscicosvarsfromimport(X, &ptr, &nv, &mv);
637         x = (double*)ptr;
638         xd = &x[xptr[nblk] - 1];
639
640         /*retrieve g by import structure*/
641         char G[] = "g";
642         getscicosvarsfromimport(G, &ptr, &nv, &mv);
643         g = (double*)ptr;
644     }
645
646     /* 7 - z */
647     m->set(7, vartosci(m->get(7), Blocks->z, Blocks->nz, 1, SCSREAL_N));
648
649     /* 11 - ozptr */
650     if (m->get(11)->isList())
651     {
652         types::List* ozptr = m->get(11)->getAs<types::List>();
653         for (int k = 0; k < Blocks->noz; k++)
654         {
655             const int rows = Blocks->ozsz[k];               /* retrieve number of rows */
656             const int cols = Blocks->ozsz[Blocks->noz + k]; /* retrieve number of cols */
657             const int type = Blocks->oztyp[k];              /* retrieve type */
658             ozptr->set(k, vartosci(ozptr->get(k), Blocks->ozptr[k], rows, cols, type));
659         }
660         m->set(11, ozptr);
661     }
662
663     /* 13 - x */
664     if (flag_imp >= 0)
665     {
666         m->set(13, vartosci(m->get(13), &x[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
667     }
668     else
669     {
670         m->set(13, vartosci(m->get(13), Blocks->x, Blocks->nx, 1, SCSREAL_N));
671     }
672
673     /* 14 - xd */
674     if (flag_imp >= 0)
675     {
676         m->set(14, vartosci(m->get(14), &xd[xptr[flag_imp] - 1], Blocks->nx, 1, SCSREAL_N));
677     }
678     else
679     {
680         m->set(14, vartosci(m->get(14), Blocks->xd, Blocks->nx, 1, SCSREAL_N));
681     }
682
683     /* 15 - res */
684     m->set(15, vartosci(m->get(15), Blocks->res, Blocks->nx, 1, SCSREAL_N));
685
686     /* 18 - inptr */
687     if (m->get(18)->isList())
688     {
689         types::List* inptr = m->get(18)->getAs<types::List>();
690         for (int k = 0; k < Blocks->nin; k++)
691         {
692             const int rows = Blocks->insz[k];                   /* retrieve number of rows */
693             const int cols = Blocks->insz[Blocks->nin + k];     /* retrieve number of cols */
694             const int type = Blocks->insz[2 * Blocks->nin + k]; /* retrieve type */
695             inptr->set(k, vartosci(inptr->get(k), Blocks->inptr[k], rows, cols, type));
696         }
697         m->set(18, inptr);
698     }
699
700     /* 21 - outptr */
701     if (m->get(21)->isList())
702     {
703         types::List* outptr = m->get(21)->getAs<types::List>();
704         for (int k = 0; k < Blocks->nout; k++)
705         {
706             const int rows = Blocks->outsz[k];                    /* retrieve number of rows */
707             const int cols = Blocks->outsz[Blocks->nout + k];     /* retrieve number of cols */
708             const int type = Blocks->outsz[2 * Blocks->nout + k]; /* retrieve type */
709             outptr->set(k, vartosci(outptr->get(k), Blocks->outptr[k], rows, cols, type));
710         }
711         m->set(21, outptr);
712     }
713
714     /* 23 - evout */
715     m->set(23, vartosci(m->get(23), Blocks->evout, Blocks->nevout, 1, SCSREAL_N));
716
717     /* 33 - g */
718     if (flag_imp >= 0)
719     {
720         m->set(33, vartosci(m->get(33), &g[zcptr[flag_imp] - 1], Blocks->ng, 1, SCSREAL_N));
721     }
722     else
723     {
724         m->set(33, vartosci(m->get(33), Blocks->g, Blocks->ng, 1, SCSREAL_N));
725     }
726
727     /* 35 - jroot */
728     m->set(35, vartosci(m->get(35), Blocks->jroot, Blocks->ng, 1, SCSREAL_N));
729
730     /* 39 - mode */
731     m->set(39, vartosci(m->get(39), Blocks->mode, Blocks->nmode, 1, SCSREAL_N));
732
733     /* 40 - xprop */
734     m->set(40, vartosci(m->get(40), Blocks->xprop, Blocks->nx, 1, SCSREAL_N));
735
736     return m;
737 }
738 /*--------------------------------------------------------------------------*/