git.m6w6.name Git - m6w6/ext-psi/blob - src/calc/oper.h

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8      * Redistributions of source code must retain the above copyright notice,
   9        this list of conditions and the following disclaimer.
  10      * Redistributions in binary form must reproduce the above copyright
  11        notice, this list of conditions and the following disclaimer in the
  12        documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24 *******************************************************************************/
  25
  26 #include "php_psi_stdinc.h"
  27 #include <assert.h>
  28
  29 #include "token.h"
  30
  31 static inline int psi_calc_oper(token_t op1, token_t op2)
  32 {
  33         if (PSI_T_LPAREN == op2) {
  34                 return -1;
  35         } else if (PSI_T_LPAREN == op1) {
  36                 return 1;
  37         } else if (op1 == op2) {
  38                 return 0;
  39         } else if (!op1) {
  40                 return 1;
  41         } else if (!op2) {
  42                 return -1;
  43         }
  44
  45         switch (op1) {
  46         case PSI_T_NOT:
  47                 switch (op2) {
  48                 case PSI_T_NOT:
  49                         return 0;
  50                 case PSI_T_TILDE:
  51                         return 0;
  52                 case PSI_T_ASTERISK:
  53                         return -1;
  54                 case PSI_T_SLASH:
  55                         return -1;
  56                 case PSI_T_MODULO:
  57                         return -1;
  58                 case PSI_T_PLUS:
  59                         return -1;
  60                 case PSI_T_MINUS:
  61                         return -1;
  62                 case PSI_T_LSHIFT:
  63                         return -1;
  64                 case PSI_T_RSHIFT:
  65                         return -1;
  66                 case PSI_T_LCHEVR:
  67                         return -1;
  68                 case PSI_T_CMP_LE:
  69                         return -1;
  70                 case PSI_T_RCHEVR:
  71                         return -1;
  72                 case PSI_T_CMP_GE:
  73                         return -1;
  74                 case PSI_T_AMPERSAND:
  75                         return -1;
  76                 case PSI_T_CMP_EQ:
  77                         return -1;
  78                 case PSI_T_CMP_NE:
  79                         return -1;
  80                 case PSI_T_CARET:
  81                         return -1;
  82                 case PSI_T_PIPE:
  83                         return -1;
  84                 case PSI_T_AND:
  85                         return -1;
  86                 case PSI_T_OR:
  87                         return -1;
  88                 default:
  89                         assert(0);
  90                         break;
  91                 }
  92                 break;
  93
  94         case PSI_T_TILDE:
  95                 switch (op2) {
  96                 case PSI_T_NOT:
  97                         return 0;
  98                 case PSI_T_TILDE:
  99                         return 0;
 100                 case PSI_T_ASTERISK:
 101                         return -1;
 102                 case PSI_T_SLASH:
 103                         return -1;
 104                 case PSI_T_MODULO:
 105                         return -1;
 106                 case PSI_T_PLUS:
 107                         return -1;
 108                 case PSI_T_MINUS:
 109                         return -1;
 110                 case PSI_T_LSHIFT:
 111                         return -1;
 112                 case PSI_T_RSHIFT:
 113                         return -1;
 114                 case PSI_T_LCHEVR:
 115                         return -1;
 116                 case PSI_T_CMP_LE:
 117                         return -1;
 118                 case PSI_T_RCHEVR:
 119                         return -1;
 120                 case PSI_T_CMP_GE:
 121                         return -1;
 122                 case PSI_T_AMPERSAND:
 123                         return -1;
 124                 case PSI_T_CMP_EQ:
 125                         return -1;
 126                 case PSI_T_CMP_NE:
 127                         return -1;
 128                 case PSI_T_CARET:
 129                         return -1;
 130                 case PSI_T_PIPE:
 131                         return -1;
 132                 case PSI_T_AND:
 133                         return -1;
 134                 case PSI_T_OR:
 135                         return -1;
 136                 default:
 137                         assert(0);
 138                         break;
 139                 }
 140                 break;
 141
 142         case PSI_T_ASTERISK:
 143                 switch (op2) {
 144                 case PSI_T_NOT:
 145                         return 1;
 146                 case PSI_T_TILDE:
 147                         return 1;
 148                 case PSI_T_ASTERISK:
 149                         return 0;
 150                 case PSI_T_SLASH:
 151                         return 0;
 152                 case PSI_T_MODULO:
 153                         return 0;
 154                 case PSI_T_PLUS:
 155                         return -1;
 156                 case PSI_T_MINUS:
 157                         return -1;
 158                 case PSI_T_LSHIFT:
 159                         return -1;
 160                 case PSI_T_RSHIFT:
 161                         return -1;
 162                 case PSI_T_LCHEVR:
 163                         return -1;
 164                 case PSI_T_CMP_LE:
 165                         return -1;
 166                 case PSI_T_RCHEVR:
 167                         return -1;
 168                 case PSI_T_CMP_GE:
 169                         return -1;
 170                 case PSI_T_AMPERSAND:
 171                         return -1;
 172                 case PSI_T_CMP_EQ:
 173                         return -1;
 174                 case PSI_T_CMP_NE:
 175                         return -1;
 176                 case PSI_T_CARET:
 177                         return -1;
 178                 case PSI_T_PIPE:
 179                         return -1;
 180                 case PSI_T_AND:
 181                         return -1;
 182                 case PSI_T_OR:
 183                         return -1;
 184                 default:
 185                         assert(0);
 186                         break;
 187                 }
 188                 break;
 189
 190         case PSI_T_SLASH:
 191                 switch (op2) {
 192                 case PSI_T_NOT:
 193                         return 1;
 194                 case PSI_T_TILDE:
 195                         return 1;
 196                 case PSI_T_ASTERISK:
 197                         return 0;
 198                 case PSI_T_SLASH:
 199                         return 0;
 200                 case PSI_T_MODULO:
 201                         return 0;
 202                 case PSI_T_PLUS:
 203                         return -1;
 204                 case PSI_T_MINUS:
 205                         return -1;
 206                 case PSI_T_LSHIFT:
 207                         return -1;
 208                 case PSI_T_RSHIFT:
 209                         return -1;
 210                 case PSI_T_LCHEVR:
 211                         return -1;
 212                 case PSI_T_CMP_LE:
 213                         return -1;
 214                 case PSI_T_RCHEVR:
 215                         return -1;
 216                 case PSI_T_CMP_GE:
 217                         return -1;
 218                 case PSI_T_AMPERSAND:
 219                         return -1;
 220                 case PSI_T_CMP_EQ:
 221                         return -1;
 222                 case PSI_T_CMP_NE:
 223                         return -1;
 224                 case PSI_T_CARET:
 225                         return -1;
 226                 case PSI_T_PIPE:
 227                         return -1;
 228                 case PSI_T_AND:
 229                         return -1;
 230                 case PSI_T_OR:
 231                         return -1;
 232                 default:
 233                         assert(0);
 234                         break;
 235                 }
 236                 break;
 237
 238         case PSI_T_MODULO:
 239                 switch (op2) {
 240                 case PSI_T_NOT:
 241                         return 1;
 242                 case PSI_T_TILDE:
 243                         return 1;
 244                 case PSI_T_ASTERISK:
 245                         return 0;
 246                 case PSI_T_SLASH:
 247                         return 0;
 248                 case PSI_T_MODULO:
 249                         return 0;
 250                 case PSI_T_PLUS:
 251                         return -1;
 252                 case PSI_T_MINUS:
 253                         return -1;
 254                 case PSI_T_LSHIFT:
 255                         return -1;
 256                 case PSI_T_RSHIFT:
 257                         return -1;
 258                 case PSI_T_LCHEVR:
 259                         return -1;
 260                 case PSI_T_CMP_LE:
 261                         return -1;
 262                 case PSI_T_RCHEVR:
 263                         return -1;
 264                 case PSI_T_CMP_GE:
 265                         return -1;
 266                 case PSI_T_AMPERSAND:
 267                         return -1;
 268                 case PSI_T_CMP_EQ:
 269                         return -1;
 270                 case PSI_T_CMP_NE:
 271                         return -1;
 272                 case PSI_T_CARET:
 273                         return -1;
 274                 case PSI_T_PIPE:
 275                         return -1;
 276                 case PSI_T_AND:
 277                         return -1;
 278                 case PSI_T_OR:
 279                         return -1;
 280                 default:
 281                         assert(0);
 282                         break;
 283                 }
 284                 break;
 285
 286         case PSI_T_PLUS:
 287                 switch (op2) {
 288                 case PSI_T_NOT:
 289                         return 1;
 290                 case PSI_T_TILDE:
 291                         return 1;
 292                 case PSI_T_ASTERISK:
 293                         return 1;
 294                 case PSI_T_SLASH:
 295                         return 1;
 296                 case PSI_T_MODULO:
 297                         return 1;
 298                 case PSI_T_PLUS:
 299                         return 0;
 300                 case PSI_T_MINUS:
 301                         return 0;
 302                 case PSI_T_LSHIFT:
 303                         return -1;
 304                 case PSI_T_RSHIFT:
 305                         return -1;
 306                 case PSI_T_LCHEVR:
 307                         return -1;
 308                 case PSI_T_CMP_LE:
 309                         return -1;
 310                 case PSI_T_RCHEVR:
 311                         return -1;
 312                 case PSI_T_CMP_GE:
 313                         return -1;
 314                 case PSI_T_AMPERSAND:
 315                         return -1;
 316                 case PSI_T_CMP_EQ:
 317                         return -1;
 318                 case PSI_T_CMP_NE:
 319                         return -1;
 320                 case PSI_T_CARET:
 321                         return -1;
 322                 case PSI_T_PIPE:
 323                         return -1;
 324                 case PSI_T_AND:
 325                         return -1;
 326                 case PSI_T_OR:
 327                         return -1;
 328                 default:
 329                         assert(0);
 330                         break;
 331                 }
 332                 break;
 333
 334         case PSI_T_MINUS:
 335                 switch (op2) {
 336                 case PSI_T_NOT:
 337                         return 1;
 338                 case PSI_T_TILDE:
 339                         return 1;
 340                 case PSI_T_ASTERISK:
 341                         return 1;
 342                 case PSI_T_SLASH:
 343                         return 1;
 344                 case PSI_T_MODULO:
 345                         return 1;
 346                 case PSI_T_PLUS:
 347                         return 0;
 348                 case PSI_T_MINUS:
 349                         return 0;
 350                 case PSI_T_LSHIFT:
 351                         return -1;
 352                 case PSI_T_RSHIFT:
 353                         return -1;
 354                 case PSI_T_LCHEVR:
 355                         return -1;
 356                 case PSI_T_CMP_LE:
 357                         return -1;
 358                 case PSI_T_RCHEVR:
 359                         return -1;
 360                 case PSI_T_CMP_GE:
 361                         return -1;
 362                 case PSI_T_AMPERSAND:
 363                         return -1;
 364                 case PSI_T_CMP_EQ:
 365                         return -1;
 366                 case PSI_T_CMP_NE:
 367                         return -1;
 368                 case PSI_T_CARET:
 369                         return -1;
 370                 case PSI_T_PIPE:
 371                         return -1;
 372                 case PSI_T_AND:
 373                         return -1;
 374                 case PSI_T_OR:
 375                         return -1;
 376                 default:
 377                         assert(0);
 378                         break;
 379                 }
 380                 break;
 381
 382         case PSI_T_LSHIFT:
 383                 switch (op2) {
 384                 case PSI_T_NOT:
 385                         return 1;
 386                 case PSI_T_TILDE:
 387                         return 1;
 388                 case PSI_T_ASTERISK:
 389                         return 1;
 390                 case PSI_T_SLASH:
 391                         return 1;
 392                 case PSI_T_MODULO:
 393                         return 1;
 394                 case PSI_T_PLUS:
 395                         return 1;
 396                 case PSI_T_MINUS:
 397                         return 1;
 398                 case PSI_T_LSHIFT:
 399                         return 0;
 400                 case PSI_T_RSHIFT:
 401                         return 0;
 402                 case PSI_T_LCHEVR:
 403                         return -1;
 404                 case PSI_T_CMP_LE:
 405                         return -1;
 406                 case PSI_T_RCHEVR:
 407                         return -1;
 408                 case PSI_T_CMP_GE:
 409                         return -1;
 410                 case PSI_T_AMPERSAND:
 411                         return -1;
 412                 case PSI_T_CMP_EQ:
 413                         return -1;
 414                 case PSI_T_CMP_NE:
 415                         return -1;
 416                 case PSI_T_CARET:
 417                         return -1;
 418                 case PSI_T_PIPE:
 419                         return -1;
 420                 case PSI_T_AND:
 421                         return -1;
 422                 case PSI_T_OR:
 423                         return -1;
 424                 default:
 425                         assert(0);
 426                         break;
 427                 }
 428                 break;
 429
 430         case PSI_T_RSHIFT:
 431                 switch (op2) {
 432                 case PSI_T_NOT:
 433                         return 1;
 434                 case PSI_T_TILDE:
 435                         return 1;
 436                 case PSI_T_ASTERISK:
 437                         return 1;
 438                 case PSI_T_SLASH:
 439                         return 1;
 440                 case PSI_T_MODULO:
 441                         return 1;
 442                 case PSI_T_PLUS:
 443                         return 1;
 444                 case PSI_T_MINUS:
 445                         return 1;
 446                 case PSI_T_LSHIFT:
 447                         return 0;
 448                 case PSI_T_RSHIFT:
 449                         return 0;
 450                 case PSI_T_LCHEVR:
 451                         return -1;
 452                 case PSI_T_CMP_LE:
 453                         return -1;
 454                 case PSI_T_RCHEVR:
 455                         return -1;
 456                 case PSI_T_CMP_GE:
 457                         return -1;
 458                 case PSI_T_AMPERSAND:
 459                         return -1;
 460                 case PSI_T_CMP_EQ:
 461                         return -1;
 462                 case PSI_T_CMP_NE:
 463                         return -1;
 464                 case PSI_T_CARET:
 465                         return -1;
 466                 case PSI_T_PIPE:
 467                         return -1;
 468                 case PSI_T_AND:
 469                         return -1;
 470                 case PSI_T_OR:
 471                         return -1;
 472                 default:
 473                         assert(0);
 474                         break;
 475                 }
 476                 break;
 477
 478         case PSI_T_LCHEVR:
 479                 switch (op2) {
 480                 case PSI_T_NOT:
 481                         return 1;
 482                 case PSI_T_TILDE:
 483                         return 1;
 484                 case PSI_T_ASTERISK:
 485                         return 1;
 486                 case PSI_T_SLASH:
 487                         return 1;
 488                 case PSI_T_MODULO:
 489                         return 1;
 490                 case PSI_T_PLUS:
 491                         return 1;
 492                 case PSI_T_MINUS:
 493                         return 1;
 494                 case PSI_T_LSHIFT:
 495                         return 1;
 496                 case PSI_T_RSHIFT:
 497                         return 1;
 498                 case PSI_T_LCHEVR:
 499                         return 0;
 500                 case PSI_T_CMP_LE:
 501                         return 0;
 502                 case PSI_T_RCHEVR:
 503                         return 0;
 504                 case PSI_T_CMP_GE:
 505                         return 0;
 506                 case PSI_T_AMPERSAND:
 507                         return -1;
 508                 case PSI_T_CMP_EQ:
 509                         return -1;
 510                 case PSI_T_CMP_NE:
 511                         return -1;
 512                 case PSI_T_CARET:
 513                         return -1;
 514                 case PSI_T_PIPE:
 515                         return -1;
 516                 case PSI_T_AND:
 517                         return -1;
 518                 case PSI_T_OR:
 519                         return -1;
 520                 default:
 521                         assert(0);
 522                         break;
 523                 }
 524                 break;
 525
 526         case PSI_T_CMP_LE:
 527                 switch (op2) {
 528                 case PSI_T_NOT:
 529                         return 1;
 530                 case PSI_T_TILDE:
 531                         return 1;
 532                 case PSI_T_ASTERISK:
 533                         return 1;
 534                 case PSI_T_SLASH:
 535                         return 1;
 536                 case PSI_T_MODULO:
 537                         return 1;
 538                 case PSI_T_PLUS:
 539                         return 1;
 540                 case PSI_T_MINUS:
 541                         return 1;
 542                 case PSI_T_LSHIFT:
 543                         return 1;
 544                 case PSI_T_RSHIFT:
 545                         return 1;
 546                 case PSI_T_LCHEVR:
 547                         return 0;
 548                 case PSI_T_CMP_LE:
 549                         return 0;
 550                 case PSI_T_RCHEVR:
 551                         return 0;
 552                 case PSI_T_CMP_GE:
 553                         return 0;
 554                 case PSI_T_AMPERSAND:
 555                         return -1;
 556                 case PSI_T_CMP_EQ:
 557                         return -1;
 558                 case PSI_T_CMP_NE:
 559                         return -1;
 560                 case PSI_T_CARET:
 561                         return -1;
 562                 case PSI_T_PIPE:
 563                         return -1;
 564                 case PSI_T_AND:
 565                         return -1;
 566                 case PSI_T_OR:
 567                         return -1;
 568                 default:
 569                         assert(0);
 570                         break;
 571                 }
 572                 break;
 573
 574         case PSI_T_RCHEVR:
 575                 switch (op2) {
 576                 case PSI_T_NOT:
 577                         return 1;
 578                 case PSI_T_TILDE:
 579                         return 1;
 580                 case PSI_T_ASTERISK:
 581                         return 1;
 582                 case PSI_T_SLASH:
 583                         return 1;
 584                 case PSI_T_MODULO:
 585                         return 1;
 586                 case PSI_T_PLUS:
 587                         return 1;
 588                 case PSI_T_MINUS:
 589                         return 1;
 590                 case PSI_T_LSHIFT:
 591                         return 1;
 592                 case PSI_T_RSHIFT:
 593                         return 1;
 594                 case PSI_T_LCHEVR:
 595                         return 0;
 596                 case PSI_T_CMP_LE:
 597                         return 0;
 598                 case PSI_T_RCHEVR:
 599                         return 0;
 600                 case PSI_T_CMP_GE:
 601                         return 0;
 602                 case PSI_T_AMPERSAND:
 603                         return -1;
 604                 case PSI_T_CMP_EQ:
 605                         return -1;
 606                 case PSI_T_CMP_NE:
 607                         return -1;
 608                 case PSI_T_CARET:
 609                         return -1;
 610                 case PSI_T_PIPE:
 611                         return -1;
 612                 case PSI_T_AND:
 613                         return -1;
 614                 case PSI_T_OR:
 615                         return -1;
 616                 default:
 617                         assert(0);
 618                         break;
 619                 }
 620                 break;
 621
 622         case PSI_T_CMP_GE:
 623                 switch (op2) {
 624                 case PSI_T_NOT:
 625                         return 1;
 626                 case PSI_T_TILDE:
 627                         return 1;
 628                 case PSI_T_ASTERISK:
 629                         return 1;
 630                 case PSI_T_SLASH:
 631                         return 1;
 632                 case PSI_T_MODULO:
 633                         return 1;
 634                 case PSI_T_PLUS:
 635                         return 1;
 636                 case PSI_T_MINUS:
 637                         return 1;
 638                 case PSI_T_LSHIFT:
 639                         return 1;
 640                 case PSI_T_RSHIFT:
 641                         return 1;
 642                 case PSI_T_LCHEVR:
 643                         return 0;
 644                 case PSI_T_CMP_LE:
 645                         return 0;
 646                 case PSI_T_RCHEVR:
 647                         return 0;
 648                 case PSI_T_CMP_GE:
 649                         return 0;
 650                 case PSI_T_AMPERSAND:
 651                         return -1;
 652                 case PSI_T_CMP_EQ:
 653                         return -1;
 654                 case PSI_T_CMP_NE:
 655                         return -1;
 656                 case PSI_T_CARET:
 657                         return -1;
 658                 case PSI_T_PIPE:
 659                         return -1;
 660                 case PSI_T_AND:
 661                         return -1;
 662                 case PSI_T_OR:
 663                         return -1;
 664                 default:
 665                         assert(0);
 666                         break;
 667                 }
 668                 break;
 669
 670         case PSI_T_AMPERSAND:
 671                 switch (op2) {
 672                 case PSI_T_NOT:
 673                         return 1;
 674                 case PSI_T_TILDE:
 675                         return 1;
 676                 case PSI_T_ASTERISK:
 677                         return 1;
 678                 case PSI_T_SLASH:
 679                         return 1;
 680                 case PSI_T_MODULO:
 681                         return 1;
 682                 case PSI_T_PLUS:
 683                         return 1;
 684                 case PSI_T_MINUS:
 685                         return 1;
 686                 case PSI_T_LSHIFT:
 687                         return 1;
 688                 case PSI_T_RSHIFT:
 689                         return 1;
 690                 case PSI_T_LCHEVR:
 691                         return 1;
 692                 case PSI_T_CMP_LE:
 693                         return 1;
 694                 case PSI_T_RCHEVR:
 695                         return 1;
 696                 case PSI_T_CMP_GE:
 697                         return 1;
 698                 case PSI_T_AMPERSAND:
 699                         return 0;
 700                 case PSI_T_CMP_EQ:
 701                         return -1;
 702                 case PSI_T_CMP_NE:
 703                         return -1;
 704                 case PSI_T_CARET:
 705                         return -1;
 706                 case PSI_T_PIPE:
 707                         return -1;
 708                 case PSI_T_AND:
 709                         return -1;
 710                 case PSI_T_OR:
 711                         return -1;
 712                 default:
 713                         assert(0);
 714                         break;
 715                 }
 716                 break;
 717
 718         case PSI_T_CMP_EQ:
 719                 switch (op2) {
 720                 case PSI_T_NOT:
 721                         return 1;
 722                 case PSI_T_TILDE:
 723                         return 1;
 724                 case PSI_T_ASTERISK:
 725                         return 1;
 726                 case PSI_T_SLASH:
 727                         return 1;
 728                 case PSI_T_MODULO:
 729                         return 1;
 730                 case PSI_T_PLUS:
 731                         return 1;
 732                 case PSI_T_MINUS:
 733                         return 1;
 734                 case PSI_T_LSHIFT:
 735                         return 1;
 736                 case PSI_T_RSHIFT:
 737                         return 1;
 738                 case PSI_T_LCHEVR:
 739                         return 1;
 740                 case PSI_T_CMP_LE:
 741                         return 1;
 742                 case PSI_T_RCHEVR:
 743                         return 1;
 744                 case PSI_T_CMP_GE:
 745                         return 1;
 746                 case PSI_T_AMPERSAND:
 747                         return 1;
 748                 case PSI_T_CMP_EQ:
 749                         return 0;
 750                 case PSI_T_CMP_NE:
 751                         return 0;
 752                 case PSI_T_CARET:
 753                         return -1;
 754                 case PSI_T_PIPE:
 755                         return -1;
 756                 case PSI_T_AND:
 757                         return -1;
 758                 case PSI_T_OR:
 759                         return -1;
 760                 default:
 761                         assert(0);
 762                         break;
 763                 }
 764                 break;
 765
 766         case PSI_T_CMP_NE:
 767                 switch (op2) {
 768                 case PSI_T_NOT:
 769                         return 1;
 770                 case PSI_T_TILDE:
 771                         return 1;
 772                 case PSI_T_ASTERISK:
 773                         return 1;
 774                 case PSI_T_SLASH:
 775                         return 1;
 776                 case PSI_T_MODULO:
 777                         return 1;
 778                 case PSI_T_PLUS:
 779                         return 1;
 780                 case PSI_T_MINUS:
 781                         return 1;
 782                 case PSI_T_LSHIFT:
 783                         return 1;
 784                 case PSI_T_RSHIFT:
 785                         return 1;
 786                 case PSI_T_LCHEVR:
 787                         return 1;
 788                 case PSI_T_CMP_LE:
 789                         return 1;
 790                 case PSI_T_RCHEVR:
 791                         return 1;
 792                 case PSI_T_CMP_GE:
 793                         return 1;
 794                 case PSI_T_AMPERSAND:
 795                         return 1;
 796                 case PSI_T_CMP_EQ:
 797                         return 0;
 798                 case PSI_T_CMP_NE:
 799                         return 0;
 800                 case PSI_T_CARET:
 801                         return -1;
 802                 case PSI_T_PIPE:
 803                         return -1;
 804                 case PSI_T_AND:
 805                         return -1;
 806                 case PSI_T_OR:
 807                         return -1;
 808                 default:
 809                         assert(0);
 810                         break;
 811                 }
 812                 break;
 813
 814         case PSI_T_CARET:
 815                 switch (op2) {
 816                 case PSI_T_NOT:
 817                         return 1;
 818                 case PSI_T_TILDE:
 819                         return 1;
 820                 case PSI_T_ASTERISK:
 821                         return 1;
 822                 case PSI_T_SLASH:
 823                         return 1;
 824                 case PSI_T_MODULO:
 825                         return 1;
 826                 case PSI_T_PLUS:
 827                         return 1;
 828                 case PSI_T_MINUS:
 829                         return 1;
 830                 case PSI_T_LSHIFT:
 831                         return 1;
 832                 case PSI_T_RSHIFT:
 833                         return 1;
 834                 case PSI_T_LCHEVR:
 835                         return 1;
 836                 case PSI_T_CMP_LE:
 837                         return 1;
 838                 case PSI_T_RCHEVR:
 839                         return 1;
 840                 case PSI_T_CMP_GE:
 841                         return 1;
 842                 case PSI_T_AMPERSAND:
 843                         return 1;
 844                 case PSI_T_CMP_EQ:
 845                         return 1;
 846                 case PSI_T_CMP_NE:
 847                         return 1;
 848                 case PSI_T_CARET:
 849                         return 0;
 850                 case PSI_T_PIPE:
 851                         return -1;
 852                 case PSI_T_AND:
 853                         return -1;
 854                 case PSI_T_OR:
 855                         return -1;
 856                 default:
 857                         assert(0);
 858                         break;
 859                 }
 860                 break;
 861
 862         case PSI_T_PIPE:
 863                 switch (op2) {
 864                 case PSI_T_NOT:
 865                         return 1;
 866                 case PSI_T_TILDE:
 867                         return 1;
 868                 case PSI_T_ASTERISK:
 869                         return 1;
 870                 case PSI_T_SLASH:
 871                         return 1;
 872                 case PSI_T_MODULO:
 873                         return 1;
 874                 case PSI_T_PLUS:
 875                         return 1;
 876                 case PSI_T_MINUS:
 877                         return 1;
 878                 case PSI_T_LSHIFT:
 879                         return 1;
 880                 case PSI_T_RSHIFT:
 881                         return 1;
 882                 case PSI_T_LCHEVR:
 883                         return 1;
 884                 case PSI_T_CMP_LE:
 885                         return 1;
 886                 case PSI_T_RCHEVR:
 887                         return 1;
 888                 case PSI_T_CMP_GE:
 889                         return 1;
 890                 case PSI_T_AMPERSAND:
 891                         return 1;
 892                 case PSI_T_CMP_EQ:
 893                         return 1;
 894                 case PSI_T_CMP_NE:
 895                         return 1;
 896                 case PSI_T_CARET:
 897                         return 1;
 898                 case PSI_T_PIPE:
 899                         return 0;
 900                 case PSI_T_AND:
 901                         return -1;
 902                 case PSI_T_OR:
 903                         return -1;
 904                 default:
 905                         assert(0);
 906                         break;
 907                 }
 908                 break;
 909
 910         case PSI_T_AND:
 911                 switch (op2) {
 912                 case PSI_T_NOT:
 913                         return 1;
 914                 case PSI_T_TILDE:
 915                         return 1;
 916                 case PSI_T_ASTERISK:
 917                         return 1;
 918                 case PSI_T_SLASH:
 919                         return 1;
 920                 case PSI_T_MODULO:
 921                         return 1;
 922                 case PSI_T_PLUS:
 923                         return 1;
 924                 case PSI_T_MINUS:
 925                         return 1;
 926                 case PSI_T_LSHIFT:
 927                         return 1;
 928                 case PSI_T_RSHIFT:
 929                         return 1;
 930                 case PSI_T_LCHEVR:
 931                         return 1;
 932                 case PSI_T_CMP_LE:
 933                         return 1;
 934                 case PSI_T_RCHEVR:
 935                         return 1;
 936                 case PSI_T_CMP_GE:
 937                         return 1;
 938                 case PSI_T_AMPERSAND:
 939                         return 1;
 940                 case PSI_T_CMP_EQ:
 941                         return 1;
 942                 case PSI_T_CMP_NE:
 943                         return 1;
 944                 case PSI_T_CARET:
 945                         return 1;
 946                 case PSI_T_PIPE:
 947                         return 1;
 948                 case PSI_T_AND:
 949                         return 0;
 950                 case PSI_T_OR:
 951                         return -1;
 952                 default:
 953                         assert(0);
 954                         break;
 955                 }
 956                 break;
 957
 958         case PSI_T_OR:
 959                 switch (op2) {
 960                 case PSI_T_NOT:
 961                         return 1;
 962                 case PSI_T_TILDE:
 963                         return 1;
 964                 case PSI_T_ASTERISK:
 965                         return 1;
 966                 case PSI_T_SLASH:
 967                         return 1;
 968                 case PSI_T_MODULO:
 969                         return 1;
 970                 case PSI_T_PLUS:
 971                         return 1;
 972                 case PSI_T_MINUS:
 973                         return 1;
 974                 case PSI_T_LSHIFT:
 975                         return 1;
 976                 case PSI_T_RSHIFT:
 977                         return 1;
 978                 case PSI_T_LCHEVR:
 979                         return 1;
 980                 case PSI_T_CMP_LE:
 981                         return 1;
 982                 case PSI_T_RCHEVR:
 983                         return 1;
 984                 case PSI_T_CMP_GE:
 985                         return 1;
 986                 case PSI_T_AMPERSAND:
 987                         return 1;
 988                 case PSI_T_CMP_EQ:
 989                         return 1;
 990                 case PSI_T_CMP_NE:
 991                         return 1;
 992                 case PSI_T_CARET:
 993                         return 1;
 994                 case PSI_T_PIPE:
 995                         return 1;
 996                 case PSI_T_AND:
 997                         return 1;
 998                 case PSI_T_OR:
 999                         return 0;
1000                 default:
1001                         assert(0);
1002                         break;
1003                 }
1004                 break;
1005
1006         default:
1007                 assert(0);
1008                 break;
1009         }
1010         return 0;
1011 }