scilab/modules/scicos/sci_gateway/c/sci_buildouttb.c

   1 /*  Scicos
   2 *
   3 *  Copyright (C) INRIA - Allan CORNET
   4 *
   5 * This program is free software; you can redistribute it and/or modify
   6 * it under the terms of the GNU General Public License as published by
   7 * the Free Software Foundation; either version 2 of the License, or
   8 * (at your option) any later version.
   9 *
  10 * This program is distributed in the hope that it will be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public License
  16 * along with this program; if not, write to the Free Software
  17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18 *
  19 * See the file ./license.txt
  20 */
  21 /*--------------------------------------------------------------------------*/
  22 #include "gw_scicos.h"
  23 #include "stack-c.h"
  24 #include "Scierror.h"
  25 #include "localization.h"
  26 #include "MALLOC.h"
  27 /*--------------------------------------------------------------------------*/
  28 /* intbuildouttb build an initialized outtb list
  29 *
  30 * [outtb]=buildouttb(lnksz,lnktyp)
  31 *
  32 * rhs 1 : lnksz, give the size of scilab object in outtb
  33 *         can be all int type or double matrix
  34 *         can have n,2 or 2,n size
  35 *
  36 * rhs 2 : lnktyp, gives the type of scilab object in outtb
  37 *         1 : double
  38 *         2 : complex
  39 *         3 : int32
  40 *         4 : int16
  41 *         5 : int8
  42 *         6 : uint32
  43 *         7 : uint16
  44 *         8 : uint8
  45 *         else : double
  46 *         can be all int type or double matrix
  47 *         can have n,1 or 1,n size
  48 *
  49 * lhs 1 : a list of size n
  50 *
  51 * 02/07/06, Alan : Initial version.
  52 * 21/11/06, Alan : Allow void rhs input param.
  53 *
  54 */
  55 /*--------------------------------------------------------------------------*/
  56 int sci_buildouttb(char *fname, unsigned long fname_len)
  57 {
  58     static int l1 = 0, m1 = 0,   n1 = 0;
  59     static int l2 = 0, m2 = 0,   n2 = 0;
  60     static int l3 = 0, n3 = 1;
  61     SciIntMat M1, M2, M3;
  62
  63     int n_lnksz = 0, n_lnktyp = 0;
  64     int *lnksz = NULL, *lnktyp = NULL;
  65
  66     double *ptr_d = NULL;
  67     double *ptr_dc = NULL;
  68     int *ptr_i = NULL;
  69     short *ptr_s = NULL;
  70     char *ptr_c = NULL;
  71     int *ptr_ui = NULL;
  72     short *ptr_us = NULL;
  73     char *ptr_uc = NULL;
  74
  75     int nm = 0, i = 0, j = 0, ierr = 0;
  76
  77     static int minlhs = 1, maxlhs = 1;
  78     static int minrhs = 2, maxrhs = 2;
  79
  80     /*check number of lhs/rhs*/
  81     CheckLhs(minlhs, maxlhs);
  82     CheckRhs(minrhs, maxrhs);
  83
  84     /*check type of Rhs 1*/
  85     if (VarType(1) == 1)
  86     {
  87         GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
  88     }
  89     else if (VarType(1) == sci_ints)
  90     {
  91         GetRhsVar(1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m1, &n1, &M1);
  92     }
  93     else
  94     {
  95         Scierror(888, _("%s : lnksz argument must be double or integer.\n"), fname);
  96         return 0;
  97     }
  98
  99     /*check type of Rhs 2*/
 100     if (VarType(2) == 1)
 101     {
 102         GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
 103     }
 104     else if (VarType(2) == sci_ints)
 105     {
 106         GetRhsVar(2, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m2, &n2, &M2);
 107     }
 108     else
 109     {
 110         Scierror(888, _("%s : lnktyp argument must be double or integer.\n"), fname);
 111         return 0;
 112     }
 113
 114     /*check size of Rhs 1*/
 115     if (m1 == 2)
 116     {
 117         n_lnksz = n1;
 118     }
 119     else if (n1 == 2)
 120     {
 121         n_lnksz = m1;
 122     }
 123     /*void double input give void list output*/
 124     else if ((n1 == 0) || (m1 == 0))
 125     {
 126         if ((n2 == 0) || (m2 == 0))
 127         {
 128             /*manually code a void list on rhs(1)*/
 129             ptr_i = (int*)GetData(1);
 130             ptr_i[0] = sci_list;
 131             ptr_i[1] = 0;
 132             ptr_i[2] = 1;
 133             LhsVar(1) = 1;
 134             PutLhsVar();
 135             return 0;
 136         }
 137         else
 138         {
 139             Scierror(888, _("%s : inconsistent dimension between lnksz and lnktyp.\n"), fname);
 140             return 0;
 141         }
 142     }
 143     else
 144     {
 145         Scierror(888, _("%s : bad dimension for lnksz argument.\n"), fname);
 146         return 0;
 147     }
 148
 149     /*check size of Rhs 2*/
 150     if (m2 == 1)
 151     {
 152         n_lnktyp = n2;
 153     }
 154     else if (n2 == 1)
 155     {
 156         n_lnktyp = m2;
 157     }
 158     else if ((n2 == 0) || (m2 == 0))
 159     {
 160         if ( (n1 != 0) && (m1 != 0) )
 161         {
 162             Scierror(888, _("%s : inconsistent dimension between lnksz and lnktyp.\n"), fname);
 163             return 0;
 164         }
 165     }
 166     else
 167     {
 168         Scierror(888, _("%s : bad dimension for lnktyp argument.\n"), fname);
 169         return 0;
 170     }
 171
 172     /*cross size checking*/
 173     if (n_lnksz != n_lnktyp)
 174     {
 175         Scierror(888, _("%s : lnksz and lnktyp argument must have the same length.\n"), fname);
 176         return 0;
 177     }
 178
 179     /*allocate lnksz*/
 180     if ((lnksz = MALLOC(2 * n_lnksz * sizeof(int))) == NULL)
 181     {
 182         Scierror(999, _("%s : No more free memory.\n"), fname);
 183         return 0;
 184     }
 185
 186     /* Allocate lnktyp*/
 187     if ((lnktyp = MALLOC(n_lnktyp * sizeof(int))) == NULL)
 188     {
 189         Scierror(999, _("%s : No more free memory.\n"), fname);
 190         FREE(lnksz);
 191         return 0;
 192     }
 193
 194     /*store rhs 1 in lnksz */
 195     if ((m1 == n1) && (m2 == m1))
 196     {
 197         m1 = -1;    /* this is done for matrix 2,2 */
 198     }
 199     if (VarType(1) == 8)
 200     {
 201         switch (M1.it)
 202         {
 203             case I_CHAR   :
 204                 if (m1 == 2)
 205                 {
 206                     for (j = 0; j < n_lnksz; j++)
 207                     {
 208                         lnksz[j] = (int) IC_CHAR(M1.D)[j * 2];
 209                         lnksz[n_lnksz + j] = (int) IC_CHAR(M1.D)[2 * j + 1];
 210                     }
 211                 }
 212                 else
 213                 {
 214                     for (j = 0; j < 2 * n_lnksz; j++)
 215                     {
 216                         lnksz[j] = (int) IC_CHAR(M1.D)[j];
 217                     }
 218                 }
 219                 break;
 220
 221             case I_INT16  :
 222                 if (m1 == 2)
 223                 {
 224                     for (j = 0; j < n_lnksz; j++)
 225                     {
 226                         lnksz[j] = (int) IC_INT16(M1.D)[j * 2];
 227                         lnksz[n_lnksz + j] = (int) IC_INT16(M1.D)[2 * j + 1];
 228                     }
 229                 }
 230                 else
 231                 {
 232                     for (j = 0; j < 2 * n_lnksz; j++)
 233                     {
 234                         lnksz[j] = (int) IC_INT16(M1.D)[j];
 235                     }
 236                 }
 237                 break;
 238
 239             case I_INT32  :
 240                 if (m1 == 2)
 241                 {
 242                     for (j = 0; j < n_lnksz; j++)
 243                     {
 244                         lnksz[j] = (int) IC_INT32(M1.D)[j * 2];
 245                         lnksz[n_lnksz + j] = (int) IC_INT32(M1.D)[2 * j + 1];
 246                     }
 247                 }
 248                 else
 249                 {
 250                     for (j = 0; j < 2 * n_lnksz; j++)
 251                     {
 252                         lnksz[j] = (int) IC_INT32(M1.D)[j];
 253                     }
 254                 }
 255                 break;
 256
 257             case I_UCHAR  :
 258                 if (m1 == 2)
 259                 {
 260                     for (j = 0; j < n_lnksz; j++)
 261                     {
 262                         lnksz[j] = (int) IC_UCHAR(M1.D)[j * 2];
 263                         lnksz[n_lnksz + j] = (int) IC_UCHAR(M1.D)[2 * j + 1];
 264                     }
 265                 }
 266                 else
 267                 {
 268                     for (j = 0; j < 2 * n_lnksz; j++)
 269                     {
 270                         lnksz[j] = (int) IC_UCHAR(M1.D)[j];
 271                     }
 272                 }
 273                 break;
 274
 275             case I_UINT16 :
 276                 if (m1 == 2)
 277                 {
 278                     for (j = 0; j < n_lnksz; j++)
 279                     {
 280                         lnksz[j] = (int) IC_UINT16(M1.D)[j * 2];
 281                         lnksz[n_lnksz + j] = (int) IC_UINT16(M1.D)[2 * j + 1];
 282                     }
 283                 }
 284                 else
 285                 {
 286                     for (j = 0; j < 2 * n_lnksz; j++)
 287                     {
 288                         lnksz[j] = (int) IC_UINT16(M1.D)[j];
 289                     }
 290                 }
 291                 break;
 292
 293             case I_UINT32 :
 294                 if (m1 == 2)
 295                 {
 296                     for (j = 0; j < n_lnksz; j++)
 297                     {
 298                         lnksz[j] = (int) IC_UINT32(M1.D)[j * 2];
 299                         lnksz[n_lnksz + j] = (int) IC_UINT32(M1.D)[2 * j + 1];
 300                     }
 301                 }
 302                 else
 303                 {
 304                     for (j = 0; j < 2 * n_lnksz; j++)
 305                     {
 306                         lnksz[j] = (int) IC_UINT32(M1.D)[j];
 307                     }
 308                 }
 309                 break;
 310         }
 311     }
 312     else
 313     {
 314         if (m1 == 2)
 315         {
 316             for (j = 0; j < n_lnksz; j++)
 317             {
 318                 lnksz[j] = (int) ((double *) stk(l1))[j * 2];
 319                 lnksz[n_lnksz + j] = (int) ((double *) stk(l1))[2 * j + 1];
 320             }
 321         }
 322         else
 323         {
 324             for (j = 0; j < 2 * n_lnksz; j++)
 325             {
 326                 lnksz[j] = (int) ((double *) stk(l1))[j];
 327             }
 328         }
 329     }
 330
 331     /*store rhs 2 in lnktyp */
 332     if (VarType(2) == sci_ints)
 333     {
 334         switch (M2.it)
 335         {
 336             case I_CHAR   :
 337                 for (j = 0; j < n_lnktyp; j++)
 338                 {
 339                     lnktyp[j] = (int) IC_CHAR(M2.D)[j];
 340                 }
 341                 break;
 342
 343             case I_INT16  :
 344                 for (j = 0; j < n_lnktyp; j++)
 345                 {
 346                     lnktyp[j] = (int) IC_INT16(M2.D)[j];
 347                 }
 348                 break;
 349
 350             case I_INT32  :
 351                 for (j = 0; j < n_lnktyp; j++)
 352                 {
 353                     lnktyp[j] = (int) IC_INT32(M2.D)[j];
 354                 }
 355                 break;
 356
 357             case I_UCHAR  :
 358                 for (j = 0; j < n_lnktyp; j++)
 359                 {
 360                     lnktyp[j] = (int) IC_UCHAR(M2.D)[j];
 361                 }
 362                 break;
 363
 364             case I_UINT16 :
 365                 for (j = 0; j < n_lnktyp; j++)
 366                 {
 367                     lnktyp[j] = (int) IC_UINT16(M2.D)[j];
 368                 }
 369                 break;
 370
 371             case I_UINT32 :
 372                 for (j = 0; j < n_lnktyp; j++)
 373                 {
 374                     lnktyp[j] = (int) IC_UINT32(M2.D)[j];
 375                 }
 376                 break;
 377
 378             default :
 379                 /* Invalid integer type */
 380                 Scierror(999, _("%s: Wrong value for input argument #%d: An integer expected.\n"), fname, 2);
 381                 FREE(lnksz);
 382                 FREE(lnktyp);
 383                 return 0;
 384         }
 385     }
 386     else
 387     {
 388         for (j = 0; j < n_lnktyp; j++)
 389         {
 390             lnktyp[j] = (int) ((double *) stk(l2))[j];
 391         }
 392     }
 393
 394     /* build output list */
 395     CreateVar(3, LIST_DATATYPE, &n_lnktyp, &n3, &l3);
 396
 397     for (i = 0; i < n_lnktyp; i++)
 398     {
 399         nm = lnksz[i] * lnksz[i + n_lnktyp];
 400         switch (lnktyp[i])
 401         {
 402             case 1  :
 403                 if ((ptr_d = MALLOC(nm * sizeof(double))) == NULL)
 404                 {
 405                     ierr = -1;
 406                     break;
 407                 }
 408                 for (j = 0; j < nm; j++)
 409                 {
 410                     ptr_d[j] = 0;
 411                 }
 412                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_DOUBLE_DATATYPE, &lnksz[i], &lnksz[i + n_lnktyp], &ptr_d);
 413                 FREE(ptr_d);
 414                 break;
 415
 416             case 2  :
 417                 if ((ptr_d = MALLOC(2 * nm * sizeof(double))) == NULL)
 418                 {
 419                     ierr = -1;
 420                     break;
 421                 }
 422                 for (j = 0; j < 2 * nm; j++)
 423                 {
 424                     ptr_d[j] = 0;
 425                 }
 426                 ptr_dc = &ptr_d[nm];
 427                 CreateListCVarFromPtr(3, i + 1, MATRIX_OF_DOUBLE_DATATYPE, (j = 1, &j), &lnksz[i], &lnksz[i + n_lnktyp], &ptr_d, &ptr_dc);
 428                 FREE(ptr_d);
 429                 break;
 430
 431             case 3  :
 432                 if ((ptr_i = MALLOC(nm * sizeof(int))) == NULL)
 433                 {
 434                     ierr = -1;
 435                     break;
 436                 }
 437                 for (j = 0; j < nm; j++)
 438                 {
 439                     ptr_i[j] = 0;
 440                 }
 441                 M3.m = lnksz[i];
 442                 M3.n = lnksz[i + n_lnktyp];
 443                 M3.it = 4;
 444                 M3.l = -1;
 445                 M3.D = ptr_i;
 446                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
 447                 FREE(ptr_i);
 448                 break;
 449
 450             case 4  :
 451                 if ((ptr_s = MALLOC(nm * sizeof(short))) == NULL)
 452                 {
 453                     ierr = -1;
 454                     break;
 455                 }
 456                 for (j = 0; j < nm; j++)
 457                 {
 458                     ptr_s[j] = 0;
 459                 }
 460                 M3.m = lnksz[i];
 461                 M3.n = lnksz[i + n_lnktyp];
 462                 M3.it = 2;
 463                 M3.l = -1;
 464                 M3.D = ptr_s;
 465                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
 466                 FREE(ptr_s);
 467                 break;
 468
 469             case 5  :
 470                 if ((ptr_c = MALLOC(nm * sizeof(char))) == NULL)
 471                 {
 472                     ierr = -1;
 473                     break;
 474                 }
 475                 for (j = 0; j < nm; j++)
 476                 {
 477                     ptr_c[j] = 0;
 478                 }
 479                 M3.m = lnksz[i];
 480                 M3.n = lnksz[i + n_lnktyp];
 481                 M3.it = 1;
 482                 M3.l = -1;
 483                 M3.D = ptr_c;
 484                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
 485                 FREE(ptr_c);
 486                 break;
 487
 488             case 6  :
 489                 if ((ptr_ui = MALLOC(nm * sizeof(unsigned int))) == NULL)
 490                 {
 491                     ierr = -1;
 492                     break;
 493                 }
 494                 for (j = 0; j < nm; j++)
 495                 {
 496                     ptr_ui[j] = 0;
 497                 }
 498                 M3.m = lnksz[i];
 499                 M3.n = lnksz[i + n_lnktyp];
 500                 M3.it = 14;
 501                 M3.l = -1;
 502                 M3.D = ptr_ui;
 503                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
 504                 FREE(ptr_ui);
 505                 break;
 506
 507             case 7  :
 508                 if ((ptr_us = MALLOC(nm * sizeof(unsigned short))) == NULL)
 509                 {
 510                     ierr = -1;
 511                     break;
 512                 }
 513                 for (j = 0; j < nm; j++)
 514                 {
 515                     ptr_us[j] = 0;
 516                 }
 517                 M3.m = lnksz[i];
 518                 M3.n = lnksz[i + n_lnktyp];
 519                 M3.it = 12;
 520                 M3.l = -1;
 521                 M3.D = ptr_us;
 522                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
 523                 FREE(ptr_us);
 524                 break;
 525
 526             case 8  :
 527                 if ((ptr_uc = MALLOC(nm * sizeof(unsigned char))) == NULL)
 528                 {
 529                     ierr = -1;
 530                     break;
 531                 }
 532                 for (j = 0; j < nm; j++)
 533                 {
 534                     ptr_uc[j] = 0;
 535                 }
 536                 M3.m = lnksz[i];
 537                 M3.n = lnksz[i + n_lnktyp];
 538                 M3.it = 11;
 539                 M3.l = -1;
 540                 M3.D = ptr_uc;
 541                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &M3.m, &M3.n, &M3);
 542                 FREE(ptr_uc);
 543                 break;
 544
 545             default :
 546                 if ((ptr_d = MALLOC(nm * sizeof(double))) == NULL)
 547                 {
 548                     ierr = -1;
 549                     break;
 550                 }
 551                 for (j = 0; j < nm; j++)
 552                 {
 553                     ptr_d[j] = 0;
 554                 }
 555                 CreateListVarFromPtr(3, i + 1, MATRIX_OF_DOUBLE_DATATYPE, &lnksz[i], &lnksz[i + n_lnktyp], &ptr_d);
 556                 FREE(ptr_d);
 557                 break;
 558         }
 559
 560         if (ierr == -1)
 561         {
 562             Scierror(999, _("%s : No more free memory.\n"), fname);
 563             FREE(lnksz);
 564             FREE(lnktyp);
 565             return 0;
 566         }
 567     }
 568
 569     LhsVar(1) = 3;
 570     FREE(lnksz);
 571     FREE(lnktyp);
 572     PutLhsVar();
 573     return 0;
 574 }
 575 /*--------------------------------------------------------------------------*/