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(3 * Blocks->nin, 1);
 326     d = insz->get();
 327     for (int i = 0; i < 3 * 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