scilab/modules/core/src/c/expr.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2007 - INRIA - Allan CORNET
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  10  *
  11  */
  12 #include <string.h>
  13 #include <stdio.h>
  14 #include "expr.h"
  15 #include "ifexpr.h"
  16 #include "msgs.h"
  17 #include "stack-def.h"
  18 #include "stack-c.h"
  19 #include "Scierror.h"
  20 #include "do_error_number.h"
  21 #include "parserConstant.h"
  22 #include "basout.h"
  23 /*--------------------------------------------------------------------------*/
  24 static int inc = 1;
  25 static int checkvalue = 4095;
  26 static int code = 30;
  27 static int val = 0;
  28 /*--------------------------------------------------------------------------*/
  29 extern int C2F(compil)(int *, int *, int *, int *, int *);
  30 extern int C2F(getsym)(void);
  31 extern int C2F(istrue)(int *);
  32 extern int C2F(eptover)(int *, int *);
  33 /*--------------------------------------------------------------------------*/
  34 int C2F(expr)(void)
  35 {
  36     static int eye[6] = { 672014862, 673720360, 673720360, 673720360, 673720360, 673720360 };
  37     int i = 0, j = 0;
  38     int r = 0 , s = 0, ir = 0, op = 0, ls = 0, sign = 0;
  39     int temp = 0;
  40     int kount = 0;
  41
  42     if (C2F(iop).ddt == 4)
  43     {
  44         static char tmp[100];
  45         static int io;
  46         sprintf(tmp, " expr   pt:%d rstk(pt):%d sym:%d", C2F(recu).pt, C2F(recu).rstk[C2F(recu).pt - 1], C2F(com).sym);
  47         C2F(basout)(&io, &C2F(iop).wte, tmp, (long)strlen(tmp));
  48     }
  49
  50     r = C2F(recu).rstk[C2F(recu).pt - 1];
  51     if (r == 204)
  52     {
  53         goto L85;
  54     }
  55
  56     ir = r / 100;
  57
  58     if (ir != 1)
  59     {
  60         goto L1;
  61     }
  62
  63     switch (r - 100)
  64     {
  65         case 1:
  66             goto L5;
  67         case 2:
  68             goto L6;
  69         case 3:
  70             goto L25;
  71         case 4:
  72             goto L26;
  73         case 5:
  74             goto L61;
  75         case 6:
  76             goto L73;
  77         case 7:
  78             goto L74;
  79         case 8:
  80             goto L82;
  81         case 9:
  82             goto L83;
  83         case 10:
  84             goto L86;
  85         case 11:
  86             goto L87;
  87         case 12:
  88             goto L102;
  89         case 13:
  90             goto L104;
  91         case 14:
  92             goto L102;
  93         case 15:
  94             goto L23;
  95     }
  96
  97 L1:
  98     if (C2F(com).sym >= ou && C2F(com).sym <= great)
  99     {
 100         SciError(40);
 101         return 0;
 102     }
 103 L2:
 104     kount = 1;
 105     if (C2F(com).sym == not)
 106     {
 107         goto L70;
 108     }
 109
 110     if (C2F(com).sym == colon)
 111     {
 112         C2F(putid)(C2F(com).syn, eye);
 113     }
 114
 115 L3:
 116     s = 1;
 117 L4:
 118     if (C2F(com).sym == minus)
 119     {
 120         s = -s;
 121     }
 122
 123     if (C2F(com).sym == plus || C2F(com).sym == minus)
 124     {
 125         C2F(getsym)();
 126         goto L4;
 127     }
 128     sign = plus;
 129     if (s < 0)
 130     {
 131         sign = minus;
 132     }
 133
 134     if (C2F(eptover)(&inc, &checkvalue))
 135     {
 136         return 0;
 137     }
 138
 139     C2F(recu).pstk[C2F(recu).pt - 1] = sign + (kount << 8);
 140     C2F(recu).rstk[C2F(recu).pt - 1] = 101;
 141     C2F(recu).icall = 2;
 142     /* *call* term */
 143     return 0;
 144 L5:
 145     sign = C2F(recu).pstk[C2F(recu).pt - 1] % 256;
 146     kount = C2F(recu).pstk[C2F(recu).pt - 1] / 256;
 147     --C2F(recu).pt;
 148     if (sign != minus)
 149     {
 150         goto L10;
 151     }
 152
 153     Rhs = 1;
 154     ++C2F(recu).pt;
 155     C2F(recu).pstk[C2F(recu).pt - 1] = kount;
 156     Fin = minus;
 157     C2F(recu).rstk[C2F(recu).pt - 1] = 102;
 158     C2F(recu).icall = 4;
 159     /* *call* allops(minus) */
 160     return 0;
 161 L6:
 162     kount = C2F(recu).pstk[C2F(recu).pt - 1];
 163     --C2F(recu).pt;
 164 L10:
 165     if (C2F(com).sym == plus || C2F(com).sym == minus)
 166     {
 167         goto L20;
 168     }
 169     if (C2F(recu).rstk[C2F(recu).pt - 1] == 113)
 170     {
 171         goto L104;
 172     }
 173     if (C2F(recu).rstk[C2F(recu).pt - 1] == 112)
 174     {
 175         goto L102;
 176     }
 177     if (C2F(com).sym == eol)
 178     {
 179         goto L50;
 180     }
 181     if (C2F(com).sym >= ou || C2F(com).sym == equal)
 182     {
 183         goto L70;
 184     }
 185     goto L50;
 186 L20:
 187     if (C2F(recu).rstk[C2F(recu).pt - 1] != 301)
 188     {
 189         goto L21;
 190     }
 191     /* blank or tab is delimiter inside angle brackets */
 192     ls = C2F(iop).lpt[2] - 2;
 193     if ( (i = C2F(iop).lin[ls - 1], abs(i)) == blank && (j = C2F(iop).lin[C2F(iop).lpt[2] - 1], abs(j)) != blank)
 194     {
 195         goto L50;
 196     }
 197
 198 L21:
 199     op = C2F(com).sym;
 200     C2F(getsym)();
 201     /* next lines added to handle sequence of + and - operators, S. Steer */
 202     /* 03/2005 (Matlab compatibility). Here i implemented a lazy way */
 203     /* without calling unary + or unary - operator */
 204 L22:
 205     if (C2F(com).sym == plus)
 206     {
 207         /* 1++2 or 1-+2 */
 208         C2F(getsym)();
 209         goto L22;
 210     }
 211     if (C2F(com).sym == minus)
 212     {
 213         /* 1+-2 or 1--2 */
 214         if (op == minus)
 215         {
 216             op = plus;
 217         }
 218         else
 219         {
 220             op = minus;
 221         }
 222
 223         C2F(getsym)();
 224         goto L22;
 225     }
 226     ++C2F(recu).pt;
 227     C2F(recu).pstk[C2F(recu).pt - 1] = op + (kount << 8);
 228     if (C2F(com).sym != not)
 229     {
 230         goto L24;
 231     }
 232
 233     C2F(recu).rstk[C2F(recu).pt - 1] = 115;
 234     /* *call* lfact */
 235     goto L85;
 236
 237 L23:
 238     goto L25;
 239
 240 L24:
 241     C2F(recu).rstk[C2F(recu).pt - 1] = 103;
 242     C2F(recu).icall = 2;
 243     /* *call* term */
 244     return 0;
 245 L25:
 246     op = C2F(recu).pstk[C2F(recu).pt - 1] % 256;
 247     kount = C2F(recu).pstk[C2F(recu).pt - 1] / 256;
 248     Rhs = 2;
 249     C2F(recu).pstk[C2F(recu).pt - 1] = kount;
 250     C2F(recu).rstk[C2F(recu).pt - 1] = 104;
 251     Fin = op;
 252     C2F(recu).icall = 4;
 253     /* *call* allops(op) */
 254     return 0;
 255 L26:
 256     kount = C2F(recu).pstk[C2F(recu).pt - 1];
 257     --C2F(recu).pt;
 258     goto L10;
 259 L50:
 260     if (C2F(com).sym != colon)
 261     {
 262         goto L60;
 263     }
 264
 265     C2F(getsym)();
 266     ++kount;
 267     goto L3;
 268 L60:
 269     if (kount > 3)
 270     {
 271         SciError(33);
 272         if (Err > 0)
 273         {
 274             return 0;
 275         }
 276     }
 277     Rhs = kount;
 278     if (kount <= 1)
 279     {
 280         return 0;
 281     }
 282     ++C2F(recu).pt;
 283     C2F(recu).rstk[C2F(recu).pt - 1] = 105;
 284     Fin = colon;
 285     C2F(recu).icall = 4;
 286     /* *call* allops(colon) */
 287     return 0;
 288 L61:
 289     --C2F(recu).pt;
 290     r = C2F(recu).rstk[C2F(recu).pt - 1];
 291     ir = r / 100;
 292     if (ir != 1)
 293     {
 294         return 0;
 295     }
 296
 297     switch (r - 100)
 298     {
 299         case 1:
 300             goto L5;
 301         case 2:
 302             goto L6;
 303         case 3:
 304             goto L25;
 305         case 4:
 306             goto L26;
 307         case 5:
 308             goto L61;
 309         case 6:
 310             goto L73;
 311         case 7:
 312             goto L74;
 313         case 8:
 314             goto L82;
 315         case 9:
 316             goto L83;
 317         case 10:
 318             goto L86;
 319         case 11:
 320             goto L87;
 321         case 12:
 322             goto L102;
 323         case 13:
 324             goto L104;
 325         case 14:
 326             goto L102;
 327     }
 328
 329     /* in-line lexpr */
 330 L70:
 331     if (C2F(iop).ddt == 4) {}
 332 L72:
 333     if (C2F(eptover)(&inc, &checkvalue))
 334     {
 335         return 0;
 336     }
 337     C2F(recu).ids[C2F(recu).pt * 6 - 6] = 0;
 338     C2F(recu).ids[C2F(recu).pt * 6 - 5] = C2F(errgst).err1;
 339     if (C2F(com).sym == ou)
 340     {
 341         /* call getsym */
 342         C2F(recu).pstk[C2F(recu).pt - 1] = ou;
 343         if (C2F(ifexpr)())
 344         {
 345             /* checking for possible logical 'if expression' */
 346             /* evaluation shortcircuit */
 347             if (C2F(com).comp[0] != 0)
 348             {
 349                 if (C2F(compil)(&code, &inc, &val, &val, &val))
 350                 {
 351                     if (Err > 0)
 352                     {
 353                         return 0;
 354                     }
 355                     C2F(recu).ids[C2F(recu).pt * 6 - 6] = C2F(com).comp[0];
 356                 }
 357             }
 358             else
 359             {
 360                 temp = (i = *istk(iadr(C2F(vstk).lstk[Top - 1])), abs(i));
 361                 if ( (temp != 8) && (C2F(istrue)(&val)) )
 362                 {
 363                     /* first term is true there is no use to evaluate the other */
 364                     C2F(recu).ids[C2F(recu).pt * 6 - 6] = 1;
 365                     /* err1 <>0 sets interpretation without evaluation */
 366                     /* use special value to be able to distinguish from */
 367                     /* recovered errors */
 368                     C2F(errgst).err1 = 9191919;
 369                 }
 370             }
 371         }
 372     }
 373     else
 374     {
 375         C2F(recu).pstk[C2F(recu).pt - 1] = 0;
 376     }
 377     C2F(recu).pstk[C2F(recu).pt - 1] += kount << 8;
 378     C2F(recu).rstk[C2F(recu).pt - 1] = 106;
 379     /* *call* lterm */
 380     goto L80;
 381 L73:
 382     op = C2F(recu).pstk[C2F(recu).pt - 1] % 256;
 383     kount = C2F(recu).pstk[C2F(recu).pt - 1] / 256;
 384     --C2F(recu).pt;
 385     if (op == 0)
 386     {
 387         goto L75;
 388     }
 389
 390     if (C2F(com).comp[0] == 0 && C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 6] == 1)
 391     {
 392         /* term has not been evaluated */
 393         if ((i = -C2F(errgst).errct, abs(i)) / 100000 == 0)
 394         {
 395             C2F(errgst).err1 = C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 5];
 396         }
 397         else if (C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 5] != 0)
 398         {
 399             C2F(errgst).err1 = C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 5];
 400         }
 401         else
 402         {
 403             if (C2F(errgst).err1 == 9191919)
 404             {
 405                 C2F(errgst).err1 = 0;
 406             }
 407         }
 408         if (C2F(errgst).err1 > 0)
 409         {
 410             return 0;
 411         }
 412         goto L75;
 413     }
 414     C2F(recu).icall = 4;
 415     Fin = ou;
 416     Rhs = 2;
 417     ++C2F(recu).pt;
 418     C2F(recu).rstk[C2F(recu).pt - 1] = 107;
 419     C2F(recu).pstk[C2F(recu).pt - 1] = kount;
 420     /* *call* allops(ou) */
 421     return 0;
 422 L74:
 423     kount = C2F(recu).pstk[C2F(recu).pt - 1];
 424     if (C2F(com).comp[0] != 0 && C2F(recu).ids[C2F(recu).pt * 6 - 6] != 0)
 425     {
 426         i = C2F(recu).ids[C2F(recu).pt * 6 - 6] - 1;
 427         if ( (C2F(compil)(&code, &val, &i, &val, &val)) && (Err > 0) )
 428         {
 429             return 0;
 430         }
 431     }
 432     --C2F(recu).pt;
 433 L75:
 434     if (C2F(com).sym == ou)
 435     {
 436         goto L72;
 437     }
 438     goto L50;
 439     /* in-line lterm */
 440 L80:
 441     if (C2F(iop).ddt == 4) { }
 442 L81:
 443     if (C2F(eptover)(&inc, &checkvalue))
 444     {
 445         return 0;
 446     }
 447
 448     C2F(recu).ids[C2F(recu).pt * 6 - 6] = 0;
 449     C2F(recu).ids[C2F(recu).pt * 6 - 5] = C2F(errgst).err1;
 450     if (C2F(com).sym == et)
 451     {
 452         C2F(recu).pstk[C2F(recu).pt - 1] = et;
 453         C2F(recu).ids[C2F(recu).pt * 6 - 6] = 0;
 454         if (C2F(ifexpr)())
 455         {
 456             /* if expression evaluation, checking for possible */
 457             /* logical expression evaluation shortcircuit */
 458             if (C2F(com).comp[0] != 0)
 459             {
 460                 if (C2F(compil)(&code, &val, &val, &val, &val))
 461                 {
 462                     if (Err > 0)
 463                     {
 464                         return 0;
 465                     }
 466                     C2F(recu).ids[C2F(recu).pt * 6 - 6] = C2F(com).comp[0];
 467                 }
 468             }
 469             else
 470             {
 471                 temp = (i = *istk(iadr(C2F(vstk).lstk[Top - 1])), abs(i));
 472                 if ( (temp != 8) && (! C2F(istrue)(&val)) )
 473                 {
 474                     /* first term is false there is no use to evaluate the other */
 475                     C2F(recu).ids[C2F(recu).pt * 6 - 6] = 1;
 476                     /* err1 <>0 sets interpretation without evaluation */
 477                     C2F(errgst).err1 = 9191919;
 478                 }
 479             }
 480         }
 481     }
 482     else
 483     {
 484         C2F(recu).pstk[C2F(recu).pt - 1] = 0;
 485     }
 486     C2F(recu).pstk[C2F(recu).pt - 1] += kount << 8;
 487     C2F(recu).rstk[C2F(recu).pt - 1] = 108;
 488     /* *call* lfact */
 489     goto L85;
 490 L82:
 491     op = C2F(recu).pstk[C2F(recu).pt - 1] % 256;
 492     kount = C2F(recu).pstk[C2F(recu).pt - 1] / 256;
 493     --C2F(recu).pt;
 494     if (op == 0)
 495     {
 496         goto L84;
 497     }
 498
 499     if (C2F(com).comp[0] == 0 && C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 6] == 1)
 500     {
 501         /* term has not been evaluated */
 502         if ((i = -C2F(errgst).errct, abs(i)) / 100000 == 0)
 503         {
 504             C2F(errgst).err1 = C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 5];
 505         }
 506         else if (C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 5] != 0)
 507         {
 508             /* error detected before if expression evaluation (should not occur ?) */
 509             C2F(errgst).err1 = C2F(recu).ids[(C2F(recu).pt + 1) * 6 - 5];
 510         }
 511         else
 512         {
 513             if (C2F(errgst).err1 == 9191919)
 514             {
 515                 C2F(errgst).err1 = 0;
 516             }
 517         }
 518         if (C2F(errgst).err1 > 0)
 519         {
 520             return 0;
 521         }
 522         goto L84;
 523     }
 524     C2F(recu).icall = 4;
 525     Fin = et;
 526     Rhs = 2;
 527     ++C2F(recu).pt;
 528     C2F(recu).pstk[C2F(recu).pt - 1] = kount;
 529     C2F(recu).rstk[C2F(recu).pt - 1] = 109;
 530     /* *call* allops(et) */
 531     return 0;
 532 L83:
 533     kount = C2F(recu).pstk[C2F(recu).pt - 1];
 534     if (C2F(com).comp[0] != 0 && C2F(recu).ids[C2F(recu).pt * 6 - 6] != 0)
 535     {
 536         i = C2F(recu).ids[C2F(recu).pt * 6 - 6] - 1;
 537         if ( (C2F(compil)(&code, &val, &i, &val, &val)) && (Err > 0) )
 538         {
 539             return 0;
 540         }
 541     }
 542     --C2F(recu).pt;
 543 L84:
 544     if (C2F(com).sym != et)
 545     {
 546         goto L73;
 547     }
 548     goto L81;
 549
 550     /* in-line lfact */
 551 L85:
 552     if (C2F(iop).ddt == 4) { }
 553     if (C2F(eptover)(&inc, &checkvalue))
 554     {
 555         return 0;
 556     }
 557
 558     C2F(recu).pstk[C2F(recu).pt - 1] = 0;
 559     if (C2F(com).sym == not && C2F(com).char1 != equal)
 560     {
 561         C2F(recu).pstk[C2F(recu).pt - 1] = not;
 562         C2F(getsym)();
 563     }
 564     C2F(recu).pstk[C2F(recu).pt - 1] += kount << 8;
 565     C2F(recu).rstk[C2F(recu).pt - 1] = 110;
 566     /* *call* lprim */
 567     goto L100;
 568 L86:
 569     op = C2F(recu).pstk[C2F(recu).pt - 1] % 256;
 570     kount = C2F(recu).pstk[C2F(recu).pt - 1] / 256;
 571     --C2F(recu).pt;
 572     if (op == 0)
 573     {
 574         goto L82;
 575     }
 576     Fin = op;
 577     Rhs = 1;
 578     ++C2F(recu).pt;
 579     C2F(recu).pstk[C2F(recu).pt - 1] = kount;
 580     C2F(recu).rstk[C2F(recu).pt - 1] = 111;
 581     C2F(recu).icall = 4;
 582     /* *call* allops(not) */
 583     return 0;
 584 L87:
 585     --C2F(recu).pt;
 586     /* next two lines to handle a+~b and a*~b,... */
 587     if (C2F(recu).rstk[C2F(recu).pt - 1] == 115)
 588     {
 589         goto L23;
 590     }
 591     if (C2F(recu).rstk[C2F(recu).pt - 1] == 204)
 592     {
 593         return 0;
 594     }
 595     goto L82;
 596     /* in-line lprim */
 597 L100:
 598     if (C2F(iop).ddt == 4) { }
 599     if (C2F(recu).pstk[C2F(recu).pt - 1] % 256 != 0)
 600     {
 601         goto L101;
 602     }
 603     if (C2F(com).sym != et && C2F(com).sym != ou)
 604     {
 605         goto L103;
 606     }
 607     C2F(getsym)();
 608     /* modif SS */
 609     if (C2F(eptover)(&val, &checkvalue))
 610     {
 611         return 0;
 612     }
 613 L101:
 614     ++C2F(recu).pt;
 615     C2F(recu).rstk[C2F(recu).pt - 1] = 112;
 616     C2F(recu).icall = 1;
 617     /* *call* expr */
 618     goto L2;
 619 L102:
 620     --C2F(recu).pt;
 621     if ((C2F(com).sym != equal && C2F(com).sym < less) || C2F(com).sym == eol)
 622     {
 623         goto L86;
 624     }
 625 L103:
 626     op = C2F(com).sym;
 627     C2F(getsym)();
 628     if (op == equal && C2F(com).sym != equal)
 629     {
 630         if (C2F(com).sym == great || C2F(com).sym == less)
 631         {
 632             SciError(2);
 633             return 0;
 634         }
 635         int code_message = 7;
 636         C2F(msgs)(&code_message, &val);
 637     }
 638
 639     if (C2F(com).sym == equal || C2F(com).sym == great)
 640     {
 641         if (op != equal)
 642         {
 643             op += C2F(com).sym;
 644         }
 645         C2F(getsym)();
 646         if (op == not + equal)
 647         {
 648             op = less + great;
 649         }
 650     }
 651     ++C2F(recu).pt;
 652     C2F(recu).rstk[C2F(recu).pt - 1] = 113;
 653     C2F(recu).pstk[C2F(recu).pt - 1] = op;
 654     C2F(recu).icall = 1;
 655     /* *call* expr */
 656     goto L2;
 657 L104:
 658     Fin = C2F(recu).pstk[C2F(recu).pt - 1];
 659     Rhs = 2;
 660     C2F(recu).rstk[C2F(recu).pt - 1] = 114;
 661     C2F(recu).icall = 4;
 662     /* *call* allops(fin) */
 663     return 0;
 664 }
 665 /*--------------------------------------------------------------------------*/
 666
 667