tests/regression/jctest.java

   1 /* tests/jctest.java - checks most of the JVM instructions
   2
   3    Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
   4    R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
   5    C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
   6    TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Reinhard Grafl
  28
  29    Changes: Christian Thalinger
  30
  31    $Id: jctest.java 3671 2005-11-15 21:13:09Z twisti $
  32
  33 */
  34
  35 public class jctest implements jcinterface {
  36     static {
  37         p("<clinit> called");
  38     }
  39
  40     static int linenum = 0;
  41
  42     static int i1 = 77;
  43     static long l1 = 123456789, l2 = 987654321, l3 = -99999999999999L;
  44     static int i2, i3 = -100;
  45     static float f1 = 0.1F, f2 = 0.2F, f3 = 0.3F;
  46     static double d1 = 0.001, d2 = 0.002, d3 = 0.003;
  47     static String s1, s2 = "constant string";
  48
  49     int n_i1, n_i2, n_i3, n_i4;
  50     long n_l1, n_l2, n_l3, n_l4;
  51     float n_f1, n_f2, n_f3, n_f4;
  52     double n_d1, n_d2, n_d3, n_d4;
  53
  54
  55     public static void main(String[] s) {
  56         p ("=================== JavaVM - Tester ========================");
  57
  58         p ("------------------- test arguments");
  59         int i;
  60         for (i = 0; i < s.length; i++) p(s[i]);
  61
  62         testgeneral();
  63         testtables();
  64         testcasts();
  65         testspecialnullpointers();
  66         testarrays();
  67
  68         p("------------------- test consts");
  69         testconst( 1,          1);
  70         testconst(-1,         -1);
  71         testconst(-24123,     -4918923241323L);
  72         testconst(-243511,    -4423423234231423L);
  73         testconst(0x7fffffff, 0x7fffffffffffffffL);
  74         testconst(0x80000000, 0x8000000000000000L);
  75
  76         p("------------------- test div and rem consts");
  77         testdivremconst(17);
  78         testdivremconst(12347);
  79         testdivremconst(8893427);
  80         testdivremconst(1005234562);
  81         testdivremconst(-17);
  82         testdivremconst(-12347);
  83         testdivremconst(-8893427);
  84         testdivremconst(-1005234562);
  85
  86         testdivremconst(17L);
  87         testdivremconst(12347L);
  88         testdivremconst(8893427L);
  89         testdivremconst(1005234562L);
  90         testdivremconst(12135005234562L);
  91         testdivremconst(2343552355623464626L);
  92         testdivremconst(-17L);
  93         testdivremconst(-12347L);
  94         testdivremconst(-8893427L);
  95         testdivremconst(-1005234562L);
  96         testdivremconst(-12135005234562L);
  97         testdivremconst(-2343552355623464626L);
  98
  99         p("------------------- test ints");
 100         testint(1,2);
 101         testint(-1,17);
 102         testint(-24351,24123);
 103         testint(4918923,-441423);
 104         testint(0,0);
 105         testint(-1,-1);
 106         testint(1423487,123444444);
 107         testint(0x7fffffff,1);
 108         testint(0,0x7fffffff);
 109         testint(0x3333,143444);
 110         testint(4444441,12342);
 111         testint(0x80000000,-1);
 112
 113         p("------------------- test longs");
 114         testlong(1,2);
 115         testlong(-1,17);
 116         testlong(-24351,24123);
 117         testlong(4918923241323L,-4423423234231423L);
 118         testlong(0,0);
 119         testlong(-1,-1);
 120         testlong(1423487,123444442344L);
 121         testlong(0x7fffffffffffffffL,1);
 122         testlong(0,0x7fffffffffffffffL);
 123         testlong(0x3333,143444);
 124         testlong(4444441,12342);
 125         testlong(0x8000000000000000L,-1);
 126         testlong(0x0000000080000000L,0x0000000080000000L);
 127
 128         p("------------------- test floats");
 129         testfloat((float) 1,(float) 2.042);
 130         testfloat((float) -1.234,(float) 17.44);
 131         testfloat((float) -24351,(float) 24123);
 132         testfloat((float) 0.1,(float) 1243);
 133         testfloat((float) 0.0,(float) -555.4132);
 134         testfloat((float) 77.0,(float) -555);
 135         testfloat((float) 2147483000.0,(float) -555234);
 136
 137         p("------------------- test doubles");
 138         testdouble(1,2.042);
 139         testdouble(-1.234,17.44);
 140         testdouble(-24351,24123);
 141         testdouble(0.1,1243);
 142         testdouble(0.0,-555.4132);
 143         testdouble(77.0,-555);
 144         testdouble(2147483000.0,-555234);
 145
 146         p("=================== end of test =========================");
 147     }
 148
 149
 150     public static void testgeneral() {
 151         int i;
 152         // ******************** basic data types *******************************
 153
 154         p ("------------------- test int-PUSH-STORE-LOAD");
 155         int j = -1;
 156         p(j); p (0); p(2); p(17); p(-100);
 157         p (500); p(-32768); p(-32769); p(32767); p(32768);
 158         p (90000); p(-1000000000);
 159
 160         p ("------------------- test long-PUSH-STORE-LOAD");
 161         long l = 3L;
 162         p ( l ); p ( 0L ); p ( 99L );
 163         p (500L); p(-32768L); p(-32769L); p(32767L); p(32768L);
 164         p ( 6900000000000L ); p ( 349827389478173274L );
 165
 166         p ("------------------- test float-PUSH-STORE-LOAD");
 167         float f = 99.444F;
 168         p ( f ); p (0.0F); p (1.0F); p (342323423478.2223434234232334F);
 169
 170         p ("------------------- test double-PUSH-STORE-LOAD");
 171         double d = 99234.42D;
 172         p ( d ); p (0.0D); p (1.0D); p (342323423478.2223434234232334D);
 173
 174
 175         // ******************** static variables *******************************
 176
 177         p ("------------------- test static variables");
 178         i1 = i1+i2+i3;
 179         l2 = l1+l2+l3;
 180         f1 = f1*f2;
 181         p (i1); p(i2); p(i3);
 182         p (l1); p(l2); p(l3);
 183         p (f1); p(f2); p(f3);
 184         p (d1); p(d2); p(d3);
 185
 186         // ******************** arithmetic test ********************************
 187
 188         p ("------------------- test arithmetic");
 189         i1 = 17;
 190         i2 = 0x7fffffff;
 191         p (i2);
 192         p (i2+1);
 193         p (i1-i2);
 194         l1 = 0x7fffffffffffffffL;
 195         p (l1);
 196         p (l1+1);
 197         p (l1+0x7fffffffffffffffL);
 198
 199
 200         // ******************** test method calls ******************************
 201
 202         p ("statische methode");
 203         jctest ttt = new jctest ();
 204         ttt.p_manyparam (19,18,17,16, 88,77,66,55,
 205                          0.1F,0.2F,0.3F,0.4F, -2.0D,-3.0D,-4.0D,-5.0D );
 206         jcinterface ttt2 = ttt;
 207         ttt2.p_nonstatic ("interface method");
 208     }
 209
 210
 211
 212     // ************************ test tables ************************************
 213
 214     public static void testtables() {
 215         int i;
 216
 217         p ("------------------- test tableswitch");
 218
 219         for (i = -5; i < 15; i++) {
 220             switch (i) {
 221             case  2:  p ("->  2"); break;
 222             case  3:  p ("->  3"); break;
 223             case  5:  p ("->  5"); break;
 224             case  6:  p ("->  6"); break;
 225             case  7:  p ("->  7"); break;
 226             case  8:  p ("->  8"); break;
 227             case 10:  p ("-> 10"); break;
 228             default:  p ("default"); break;
 229             }
 230         }
 231
 232         p ("------------------- test lookupswitch");
 233
 234         for (i = -5; i < 15; i++) {
 235             switch (i) {
 236             case  2:  p ("->  2"); break;
 237             case  8:  p ("->  8"); break;
 238             case 14:  p ("-> 14"); break;
 239             case -4:  p ("-> -4"); break;
 240             default:  p ("default"); break;
 241             }
 242         }
 243     }
 244
 245
 246     // ****************** test type casts and array stores *********************
 247
 248     public static void testcasts() {
 249         Object     on  = null;
 250         Object     o   = new Object();
 251         Object     oi  = new Integer(0);
 252         Object[]   ona = null;
 253         Object[]   oa  = new Object [1];
 254         Object[]   oia = new Integer[1];
 255         Integer    i   = new Integer(0);
 256         Integer[]  ia;
 257         java.io.DataOutput dataout = null;
 258         Object             od  = new java.io.DataOutputStream(
 259                                                               (java.io.DataOutputStream)dataout);
 260
 261         p ("------------------- test casts");
 262
 263         p("null is instanceof Object:  ", on instanceof Object);
 264         p("Integer is instanceof Object:  ", oi instanceof Object);
 265         p("Integer is instanceof Integer: ", oi instanceof Integer);
 266         p("Object is instanceof Integer:  ", o instanceof Integer);
 267
 268         p("null is instanceof Object[]:  ", on instanceof Object[]);
 269         p("Integer[] is instanceof Object[]:  ", oia instanceof Object[]);
 270         p("Integer[] is instanceof Integer[]: ", oia instanceof Integer[]);
 271         p("Object[] is instanceof Integer[]:  ", oa instanceof Integer[]);
 272
 273         p("Integer is instanceof Object[]:  ", oi instanceof Object[]);
 274         p("Integer[] is instanceof Object:  ", oia instanceof Object);
 275         p("Integer is instanceof Integer[]: ", oi instanceof Integer[]);
 276         p("Object is instanceof Integer[]:  ", o instanceof Integer[]);
 277
 278         try {
 279             p ("type cast check: Integer = Object(Integer)");
 280             i = (Integer) oi;
 281             p ("type cast check: Integer = Object");
 282             i = (Integer) o;
 283             p ("error: class cast exception not thrown");
 284         }
 285         catch (ClassCastException c) {
 286             p ("exception: class cast");
 287         }
 288
 289         p("DataOutputStream is instanceof DataOutput: ",
 290           od instanceof java.io.DataOutput);
 291         p("Object is instanceof DataOutput: ", o instanceof java.io.DataOutput);
 292
 293         try {
 294             p ("type cast check: DataOutput = Object(DataOutputStream)");
 295             dataout = (java.io.DataOutput) od;
 296             p ("type cast check: DataOutput = Object");
 297             dataout = (java.io.DataOutput) o;
 298             p ("error: class cast exception not thrown");
 299         }
 300         catch (ClassCastException c) {
 301             p ("exception: class cast");
 302         }
 303
 304         try {
 305             p ("type cast check: Integer[] = Object(Integer)[]");
 306             ia = (Integer[]) oia;
 307             p ("type cast check: Integer[] = Object[]");
 308             ia = (Integer[]) oa;
 309             p ("error: class cast exception not thrown");
 310         }
 311         catch (ClassCastException c) {
 312             p ("exception: class cast");
 313         }
 314
 315         try {
 316             p ("array store check: Object(Integer)[0] = Integer");
 317             oia[0] = i;
 318             p ("array store check: Object(Integer)[0] = Object");
 319             oia[0] = o;
 320             p ("error: array store exception not thrown");
 321         }
 322         catch (ArrayStoreException c) {
 323             p ("exception: array store");
 324         }
 325     }
 326
 327
 328     // ****************** test special null pointers ***************************
 329
 330     public static void testspecialnullpointers() {
 331         int i = 0;
 332         jctest c = null;
 333         jcinterface f = null;
 334
 335         p ("------------------- test special null pointers");
 336
 337         try {
 338             p ("null pointer check: put field");
 339             c.n_i1 = 0;
 340             p ("error: put field null pointer exception not thrown");
 341         }
 342         catch (NullPointerException x) {
 343             p ("exception: null pointer");
 344         }
 345
 346         try {
 347             p ("null pointer check: get field");
 348             i = c.n_i1;
 349             p ("error: get field null pointer exception not thrown");
 350         }
 351         catch (NullPointerException x) {
 352             p ("exception: null pointer");
 353         }
 354
 355         try {
 356             p ("null pointer check: invokevirtual");
 357             c.p_nonstatic("invokevirtual");
 358             p ("error: invokevirtual null pointer exception not thrown");
 359         }
 360         catch (NullPointerException x) {
 361             p ("exception: null pointer");
 362         }
 363
 364         try {
 365             p ("null pointer check: invokeinterface");
 366             f.p_nonstatic("invokeinterface");
 367             p ("error: invokeinterface null pointer exception not thrown");
 368         }
 369         catch (NullPointerException x) {
 370             p ("exception: null pointer");
 371         }
 372
 373         try {
 374             p ("null pointer check: monitorenter");
 375             synchronized (c) {
 376                 p ("error: monitorenter null pointer exception not thrown");
 377             }
 378         }
 379         catch (NullPointerException x) {
 380             p ("exception: null pointer");
 381         }
 382     }
 383
 384
 385     // ************************ test array bounds ******************************
 386
 387     public static void testarraybounds(byte[] ba, int i) {
 388         p ("testarraybounds: " + (i - 10));
 389         ba[i-10] = 0;
 390         p ("testarraybounds: " + (i - 5));
 391         ba[i-5]  = 0;
 392         p ("testarraybounds: " + (i));
 393         ba[i]    = 0;
 394         p ("testarraybounds: " + (i + 5));
 395         ba[i+5]  = 0;
 396         p ("testarraybounds: " + (i + 10));
 397         ba[i+10] = 0;
 398     }
 399
 400
 401     // ************************ test arrays ************************************
 402
 403     public static void testarrays() {
 404         int    i;
 405         long   l;
 406         float  f;
 407         double d;
 408         String s;
 409
 410         p ("------------------- test byte arrays");
 411
 412         byte[] ba = null;
 413
 414         try {
 415             p ("null pointer check: byte array store");
 416             ba[1] = 0;
 417             p ("error: null pointer exception not thrown");
 418         }
 419         catch (NullPointerException c) {
 420             p ("exception: null pointer");
 421         }
 422         try {
 423             p ("null pointer check: byte array load");
 424             i = ba[1];
 425             p ("error: null pointer exception not thrown");
 426         }
 427         catch (NullPointerException c) {
 428             p ("exception: null pointer");
 429         }
 430
 431         try {
 432             p ("negative array size check: byte array");
 433             ba = new byte [-2];
 434             p ("error: negative array size exception not thrown");
 435         }
 436         catch (NegativeArraySizeException c) {
 437             p ("exception: negative array size");
 438         }
 439
 440         ba = new byte [100];
 441
 442
 443         try {
 444             p ("array bound check: byte array store");
 445             ba[-1] = 0;
 446             p ("error: exception not thrown");
 447         }
 448         catch (ArrayIndexOutOfBoundsException c) {
 449             p ("exception_1: out of bounds: "+(-1));
 450         }
 451         try {
 452             p ("array bound check: byte array load");
 453             i = ba[-1];
 454             p ("error: exception not thrown");
 455         }
 456         catch (ArrayIndexOutOfBoundsException c) {
 457             p ("exception_2: out of bounds: "+(-1));
 458         }
 459
 460         try {
 461             testarraybounds(ba, 5);
 462         }
 463         catch (ArrayIndexOutOfBoundsException c) {
 464             p ("exception_3: out of bounds: "+5);
 465         }
 466         try {
 467             testarraybounds(ba, 50);
 468         }
 469         catch (ArrayIndexOutOfBoundsException c) {
 470             p ("exception_4: out of bounds: "+50);
 471         }
 472         try {
 473             testarraybounds(ba, 100);
 474         }
 475         catch (ArrayIndexOutOfBoundsException c) {
 476             p ("exception_5: out of bounds: "+100);
 477         }
 478
 479         try {
 480             ba[-4] = 0;
 481         }
 482         catch (ArrayIndexOutOfBoundsException c) {
 483             p ("exception_6: out of bounds: "+(-4));
 484         }
 485         try {
 486             ba[-3] = 0;
 487         }
 488         catch (ArrayIndexOutOfBoundsException c) {
 489             p ("exception_7: out of bounds: "+(-3));
 490         }
 491
 492         for (i=-2; i<102; i++) {
 493             try {
 494                 ba[i] = (byte) (i-50);
 495             }
 496             catch (ArrayIndexOutOfBoundsException c) {
 497                 p ("exception_8: out of bounds: "+i);
 498             }
 499         }
 500
 501         try {
 502             ba[102] = 0;
 503         }
 504         catch (ArrayIndexOutOfBoundsException c) {
 505             p ("exception_9: out of bounds: "+102);
 506         }
 507         try {
 508             ba[103] = 0;
 509         }
 510         catch (ArrayIndexOutOfBoundsException c) {
 511             p ("exception_10: out of bounds: "+103);
 512         }
 513         for (i=0; i<100; i++) p (ba[i]);
 514
 515
 516
 517
 518         p ("-------- test short arrays");
 519
 520         short[] sa = null;
 521
 522         try {
 523             p ("null pointer check: short array store");
 524             sa[1] = 0;
 525             p ("error: null pointer exception not thrown");
 526         }
 527         catch (NullPointerException c) {
 528             p ("exception: null pointer");
 529         }
 530         try {
 531             p ("null pointer check: short array load");
 532             i = sa[1];
 533             p ("error: null pointer exception not thrown");
 534         }
 535         catch (NullPointerException c) {
 536             p ("exception: null pointer");
 537         }
 538
 539         sa = new short [100];
 540
 541         try {
 542             p ("array bound check: short array store");
 543             sa[-1] = 0;
 544             p ("error: exception not thrown");
 545         }
 546         catch (ArrayIndexOutOfBoundsException c) {
 547             p ("exception_11: out of bounds: "+(-1));
 548         }
 549         try {
 550             p ("array bound check: short array load");
 551             i = sa[-1];
 552             p ("error: exception not thrown");
 553         }
 554         catch (ArrayIndexOutOfBoundsException c) {
 555             p ("exception_12: out of bounds: "+(-1));
 556         }
 557
 558         for (i=0; i<100; i++) sa[i] = (short) (i-50);
 559         for (i=0; i<100; i++) p (sa[i]);
 560
 561
 562
 563         p ("-------- test int arrays");
 564
 565         int[] ia = null;
 566
 567         try {
 568             p ("null pointer check: int array store");
 569             ia[1] = 0;
 570             p ("error: null pointer exception not thrown");
 571         }
 572         catch (NullPointerException c) {
 573             p ("exception: null pointer");
 574         }
 575         try {
 576             p ("null pointer check: int array load");
 577             i = ia[1];
 578             p ("error: null pointer exception not thrown");
 579         }
 580         catch (NullPointerException c) {
 581             p ("exception: null pointer");
 582         }
 583
 584         ia = new int [50];
 585
 586         try {
 587             p ("array bound check: int array store");
 588             ia[-1] = 0;
 589             p ("error: exception not thrown");
 590         }
 591         catch (ArrayIndexOutOfBoundsException c) {
 592             p ("exception: out of bounds: "+(-1));
 593         }
 594         try {
 595             p ("array bound check: int array load");
 596             i = ia[-1];
 597             p ("error: exception not thrown");
 598         }
 599         catch (ArrayIndexOutOfBoundsException c) {
 600             p ("exception: out of bounds: "+(-1));
 601         }
 602
 603         for (i=0; i<10; i++) ia[i] = (123456 + i);
 604         for (i=0; i<10; i++) p (ia[i]);
 605
 606
 607
 608         p ("-------- test long arrays");
 609
 610         long[] la = null;
 611
 612         try {
 613             p ("null pointer check: long array store");
 614             la[1] = 0;
 615             p ("error: null pointer exception not thrown");
 616         }
 617         catch (NullPointerException c) {
 618             p ("exception: null pointer");
 619         }
 620         try {
 621             p ("null pointer check: long array load");
 622             l = la[1];
 623             p ("error: null pointer exception not thrown");
 624         }
 625         catch (NullPointerException c) {
 626             p ("exception: null pointer");
 627         }
 628
 629         la = new long [10];
 630
 631         try {
 632             p ("array bound check: long array store");
 633             la[-1] = 0;
 634             p ("error: exception not thrown");
 635         }
 636         catch (ArrayIndexOutOfBoundsException c) {
 637             p ("exception: out of bounds: "+(-1));
 638         }
 639         try {
 640             p ("array bound check: long array load");
 641             l = la[-1];
 642             p ("error: exception not thrown");
 643         }
 644         catch (ArrayIndexOutOfBoundsException c) {
 645             p ("exception: out of bounds: "+(-1));
 646         }
 647
 648         for (i=0; i<10; i++) la[i] = (1234567890123L + i);
 649         for (i=0; i<10; i++) p (la[i]);
 650
 651
 652         p ("-------- test char arrays");
 653
 654         char[] ca = null;
 655
 656         try {
 657             p ("null pointer check: char array store");
 658             ca[1] = 0;
 659             p ("error: null pointer exception not thrown");
 660         }
 661         catch (NullPointerException c) {
 662             p ("exception: null pointer");
 663         }
 664         try {
 665             p ("null pointer check: char array load");
 666             i = ca[1];
 667             p ("error: null pointer exception not thrown");
 668         }
 669         catch (NullPointerException c) {
 670             p ("exception: null pointer");
 671         }
 672
 673         ca = new char [50];
 674
 675         try {
 676             p ("array bound check: char array store");
 677             ca[-1] = 0;
 678             p ("error: exception not thrown");
 679         }
 680         catch (ArrayIndexOutOfBoundsException c) {
 681             p ("exception: out of bounds: "+(-1));
 682         }
 683         try {
 684             p ("array bound check: char array load");
 685             i = ca[-1];
 686             p ("error: exception not thrown");
 687         }
 688         catch (ArrayIndexOutOfBoundsException c) {
 689             p ("exception: out of bounds: "+(-1));
 690         }
 691
 692         for (i=0; i<50; i++) ca[i] = (char) ('A' + i);
 693         for (i=0; i<50; i++) p (ca[i]);
 694
 695         p ("-------- test address arrays");
 696
 697         String[] sta = null;
 698
 699         try {
 700             p ("null pointer check: address array store");
 701             sta[1] = null;
 702             p ("error: null pointer exception not thrown");
 703         }
 704         catch (NullPointerException c) {
 705             p ("exception: null pointer");
 706         }
 707         try {
 708             p ("null pointer check: address array load");
 709             s = sta[1];
 710             p ("error: null pointer exception not thrown");
 711         }
 712         catch (NullPointerException c) {
 713             p ("exception: null pointer");
 714         }
 715
 716         try {
 717             p ("negative array size check: address array");
 718             sta = new String[-3];
 719             p ("error: negative array size exception not thrown");
 720         }
 721         catch (NegativeArraySizeException c) {
 722             p ("exception: negative array size");
 723         }
 724
 725         sta = new String[5];
 726
 727         try {
 728             p ("array bound check: address array store");
 729             sta[-1] = null;
 730             p ("error: exception not thrown");
 731         }
 732         catch (ArrayIndexOutOfBoundsException c) {
 733             p ("exception: out of bounds: "+(-1));
 734         }
 735         try {
 736             p ("array bound check: address array load");
 737             s = sta[-1];
 738             p ("error: exception not thrown");
 739         }
 740         catch (ArrayIndexOutOfBoundsException c) {
 741             p ("exception: out of bounds: "+(-1));
 742         }
 743
 744         for (i=0; i<5; i++) sta[i] = Integer.toString(i) + ". Zeile";
 745         for (i=0; i<5; i++) p (sta[i]);
 746
 747         p ("-------- test multi dimensional arrays");
 748
 749         int [][][] iaaa = null;
 750
 751         try {
 752             p ("negative array size check: multi dimensional array");
 753             iaaa = new int[2][3][-4];
 754             p ("error: negative array size exception not thrown");
 755         }
 756         catch (NegativeArraySizeException c) {
 757             p ("exception: negative array size");
 758         }
 759
 760         try {
 761             p("savedvar size copy check: multi dimensional array");
 762             Integer io = new Integer(10);
 763             iaaa = new int[10][io.intValue()][10];
 764             for (i = 0; i < 10; i++) {
 765                 for (int j = 0; j < 10; j++) {
 766                     for (int k = 0; k < 10; k++) {
 767                         iaaa[i][j][k] = 1;
 768                     }
 769                 }
 770             }
 771             p("successfully created");
 772         } catch (Exception e) {
 773             p("error: exception thrown: " + e);
 774         }
 775
 776         iaaa = new int[2][3][4];
 777         long [][][] laaa = new long[2][3][6];
 778         float [][][] faaa = new float[2][3][4];
 779         double [][][] daaa = new double[3][4][7];
 780         for (i=0; i<2; i++) {
 781             int i2; for (i2=0; i2<3; i2++) {
 782                 int i3; for (i3=0; i3<4; i3++) {
 783                     iaaa[i][i2][i3] = i*i*i + i2*i2 + i3;
 784                     laaa[i][i2][i3] = i*i*i + i2*i2 + i3 + 7;
 785                     faaa[i][i2][i3] = i*i*i + i2*i2 + i3 + 0.4F;
 786                     daaa[i][i2][i3] = i*i*i + i2*i2 + i3 - 47.0001;
 787                     p (iaaa[i][i2][i3]);
 788                     p (laaa[i][i2][i3]);
 789                     p (faaa[i][i2][i3]);
 790                     p (daaa[i][i2][i3]);
 791                 }
 792             }
 793         }
 794     }
 795
 796
 797     static public void testconst(int i, long l) {
 798         p ("TESTCONST CALLED WITH ", i);
 799         p ("                  AND ", l);
 800
 801         if (!(i == (0))) p("not IFEQ:   ", (0));
 802         if (!(i != (0))) p("not IFNE:   ", (0));
 803         if (!(i <  (0))) p("not IFLT:   ", (0));
 804         if (!(i <= (0))) p("not IFLE:   ", (0));
 805         if (!(i >  (0))) p("not IFGT:   ", (0));
 806         if (!(i >= (0))) p("not IFGE:   ", (0));
 807
 808         if (!(l == (0))) p("not IF_LEQ: ", (0));
 809         if (!(l != (0))) p("not IF_LNE: ", (0));
 810         if (!(l <  (0))) p("not IF_LLT: ", (0));
 811         if (!(l <= (0))) p("not IF_LLE: ", (0));
 812         if (!(l >  (0))) p("not IF_LGT: ", (0));
 813         if (!(l >= (0))) p("not IF_LGE: ", (0));
 814
 815         p("IADDCONST:  ", i  +  (-1));
 816         p("ISUBCONST:  ", i  -  (-1));
 817         p("IMULCONST:  ", i  *  (-1));
 818         p("ISHLCONST:  ", i <<  (-1));
 819         p("ISHRCONST:  ", i >>  (-1));
 820         p("IUSHRCONST: ", i >>> (-1));
 821         p("IANDCONST:  ", i  &  (-1));
 822         p("IORCONST:   ", i  |  (-1));
 823         p("IXORCONST:  ", i  ^  (-1));
 824
 825         if (!(i == (-1))) p("not IFEQ:   ", (-1));
 826         if (!(i != (-1))) p("not IFNE:   ", (-1));
 827         if (!(i <  (-1))) p("not IFLT:   ", (-1));
 828         if (!(i <= (-1))) p("not IFLE:   ", (-1));
 829         if (!(i >  (-1))) p("not IFGT:   ", (-1));
 830         if (!(i >= (-1))) p("not IFGE:   ", (-1));
 831
 832         p("LADDCONST:  ", l  +  (-1));
 833         p("LSUBCONST:  ", l  -  (-1));
 834         p("LMULCONST:  ", l  *  (-1));
 835         p("LSHLCONST:  ", l <<  (-1));
 836         p("LSHRCONST:  ", l >>  (-1));
 837         p("LUSHRCONST: ", l >>> (-1));
 838         p("LANDCONST:  ", l  &  (-1));
 839         p("LORCONST:   ", l  |  (-1));
 840         p("LXORCONST:  ", l  ^  (-1));
 841
 842         if (!(l == (-1))) p("not IF_LEQ: ", (-1));
 843         if (!(l != (-1))) p("not IF_LNE: ", (-1));
 844         if (!(l <  (-1))) p("not IF_LLT: ", (-1));
 845         if (!(l <= (-1))) p("not IF_LLE: ", (-1));
 846         if (!(l >  (-1))) p("not IF_LGT: ", (-1));
 847         if (!(l >= (-1))) p("not IF_LGE: ", (-1));
 848
 849         p("IADDCONST:  ", i  +  (1));
 850         p("ISUBCONST:  ", i  -  (1));
 851         p("IMULCONST:  ", i  *  (1));
 852         p("ISHLCONST:  ", i <<  (1));
 853         p("ISHRCONST:  ", i >>  (1));
 854         p("IUSHRCONST: ", i >>> (1));
 855         p("IANDCONST:  ", i  &  (1));
 856         p("IORCONST:   ", i  |  (1));
 857         p("IXORCONST:  ", i  ^  (1));
 858
 859         if (!(i == (1))) p("not IFEQ:   ", (1));
 860         if (!(i != (1))) p("not IFNE:   ", (1));
 861         if (!(i <  (1))) p("not IFLT:   ", (1));
 862         if (!(i <= (1))) p("not IFLE:   ", (1));
 863         if (!(i >  (1))) p("not IFGT:   ", (1));
 864         if (!(i >= (1))) p("not IFGE:   ", (1));
 865
 866         p("LADDCONST:  ", l  +  (1));
 867         p("LSUBCONST:  ", l  -  (1));
 868         p("LMULCONST:  ", l  *  (1));
 869         p("LSHLCONST:  ", l <<  (1));
 870         p("LSHRCONST:  ", l >>  (1));
 871         p("LUSHRCONST: ", l >>> (1));
 872         p("LANDCONST:  ", l  &  (1));
 873         p("LORCONST:   ", l  |  (1));
 874         p("LXORCONST:  ", l  ^  (1));
 875
 876         if (!(l == (1))) p("not IF_LEQ: ", (1));
 877         if (!(l != (1))) p("not IF_LNE: ", (1));
 878         if (!(l <  (1))) p("not IF_LLT: ", (1));
 879         if (!(l <= (1))) p("not IF_LLE: ", (1));
 880         if (!(l >  (1))) p("not IF_LGT: ", (1));
 881         if (!(l >= (1))) p("not IF_LGE: ", (1));
 882
 883         p("IADDCONST:  ", i  +  (255));
 884         p("ISUBCONST:  ", i  -  (255));
 885         p("IMULCONST:  ", i  *  (255));
 886         p("ISHLCONST:  ", i <<  (255));
 887         p("ISHRCONST:  ", i >>  (255));
 888         p("IUSHRCONST: ", i >>> (255));
 889         p("IANDCONST:  ", i  &  (255));
 890         p("IORCONST:   ", i  |  (255));
 891         p("IXORCONST:  ", i  ^  (255));
 892
 893         if (!(i == (255))) p("not IFEQ:   ", (255));
 894         if (!(i != (255))) p("not IFNE:   ", (255));
 895         if (!(i <  (255))) p("not IFLT:   ", (255));
 896         if (!(i <= (255))) p("not IFLE:   ", (255));
 897         if (!(i >  (255))) p("not IFGT:   ", (255));
 898         if (!(i >= (255))) p("not IFGE:   ", (255));
 899
 900         p("LADDCONST:  ", l  +  (255));
 901         p("LSUBCONST:  ", l  -  (255));
 902         p("LMULCONST:  ", l  *  (255));
 903         p("LSHLCONST:  ", l <<  (255));
 904         p("LSHRCONST:  ", l >>  (255));
 905         p("LUSHRCONST: ", l >>> (255));
 906         p("LANDCONST:  ", l  &  (255));
 907         p("LORCONST:   ", l  |  (255));
 908         p("LXORCONST:  ", l  ^  (255));
 909
 910         if (!(l == (255))) p("not IF_LEQ: ", (255));
 911         if (!(l != (255))) p("not IF_LNE: ", (255));
 912         if (!(l <  (255))) p("not IF_LLT: ", (255));
 913         if (!(l <= (255))) p("not IF_LLE: ", (255));
 914         if (!(l >  (255))) p("not IF_LGT: ", (255));
 915         if (!(l >= (255))) p("not IF_LGE: ", (255));
 916
 917         p("IADDCONST:  ", i  +  (256));
 918         p("ISUBCONST:  ", i  -  (256));
 919         p("IMULCONST:  ", i  *  (256));
 920         p("ISHLCONST:  ", i <<  (256));
 921         p("ISHRCONST:  ", i >>  (256));
 922         p("IUSHRCONST: ", i >>> (256));
 923         p("IANDCONST:  ", i  &  (256));
 924         p("IORCONST:   ", i  |  (256));
 925         p("IXORCONST:  ", i  ^  (256));
 926
 927         if (!(i == (256))) p("not IFEQ:   ", (256));
 928         if (!(i != (256))) p("not IFNE:   ", (256));
 929         if (!(i <  (256))) p("not IFLT:   ", (256));
 930         if (!(i <= (256))) p("not IFLE:   ", (256));
 931         if (!(i >  (256))) p("not IFGT:   ", (256));
 932         if (!(i >= (256))) p("not IFGE:   ", (256));
 933
 934         p("LADDCONST:  ", l  +  (256));
 935         p("LSUBCONST:  ", l  -  (256));
 936         p("LMULCONST:  ", l  *  (256));
 937         p("LSHLCONST:  ", l <<  (256));
 938         p("LSHRCONST:  ", l >>  (256));
 939         p("LUSHRCONST: ", l >>> (256));
 940         p("LANDCONST:  ", l  &  (256));
 941         p("LORCONST:   ", l  |  (256));
 942         p("LXORCONST:  ", l  ^  (256));
 943
 944         if (!(l == (256))) p("not IF_LEQ: ", (256));
 945         if (!(l != (256))) p("not IF_LNE: ", (256));
 946         if (!(l <  (256))) p("not IF_LLT: ", (256));
 947         if (!(l <= (256))) p("not IF_LLE: ", (256));
 948         if (!(l >  (256))) p("not IF_LGT: ", (256));
 949         if (!(l >= (256))) p("not IF_LGE: ", (256));
 950
 951         p("IADDCONST:  ", i  +  (32767));
 952         p("ISUBCONST:  ", i  -  (32767));
 953         p("IMULCONST:  ", i  *  (32767));
 954         p("ISHLCONST:  ", i <<  (32767));
 955         p("ISHRCONST:  ", i >>  (32767));
 956         p("IUSHRCONST: ", i >>> (32767));
 957         p("IANDCONST:  ", i  &  (32767));
 958         p("IORCONST:   ", i  |  (32767));
 959         p("IXORCONST:  ", i  ^  (32767));
 960
 961         if (!(i == (32767))) p("not IFEQ:   ", (32767));
 962         if (!(i != (32767))) p("not IFNE:   ", (32767));
 963         if (!(i <  (32767))) p("not IFLT:   ", (32767));
 964         if (!(i <= (32767))) p("not IFLE:   ", (32767));
 965         if (!(i >  (32767))) p("not IFGT:   ", (32767));
 966         if (!(i >= (32767))) p("not IFGE:   ", (32767));
 967
 968         p("LADDCONST:  ", l  +  (32767));
 969         p("LSUBCONST:  ", l  -  (32767));
 970         p("LMULCONST:  ", l  *  (32767));
 971         p("LSHLCONST:  ", l <<  (32767));
 972         p("LSHRCONST:  ", l >>  (32767));
 973         p("LUSHRCONST: ", l >>> (32767));
 974         p("LANDCONST:  ", l  &  (32767));
 975         p("LORCONST:   ", l  |  (32767));
 976         p("LXORCONST:  ", l  ^  (32767));
 977
 978         if (!(l == (32767))) p("not IF_LEQ: ", (32767));
 979         if (!(l != (32767))) p("not IF_LNE: ", (32767));
 980         if (!(l <  (32767))) p("not IF_LLT: ", (32767));
 981         if (!(l <= (32767))) p("not IF_LLE: ", (32767));
 982         if (!(l >  (32767))) p("not IF_LGT: ", (32767));
 983         if (!(l >= (32767))) p("not IF_LGE: ", (32767));
 984
 985         p("IADDCONST:  ", i  +  (32768));
 986         p("ISUBCONST:  ", i  -  (32768));
 987         p("IMULCONST:  ", i  *  (32768));
 988         p("ISHLCONST:  ", i <<  (32768));
 989         p("ISHRCONST:  ", i >>  (32768));
 990         p("IUSHRCONST: ", i >>> (32768));
 991         p("IANDCONST:  ", i  &  (32768));
 992         p("IORCONST:   ", i  |  (32768));
 993         p("IXORCONST:  ", i  ^  (32768));
 994
 995         if (!(i == (32768))) p("not IFEQ:   ", (32768));
 996         if (!(i != (32768))) p("not IFNE:   ", (32768));
 997         if (!(i <  (32768))) p("not IFLT:   ", (32768));
 998         if (!(i <= (32768))) p("not IFLE:   ", (32768));
 999         if (!(i >  (32768))) p("not IFGT:   ", (32768));
1000         if (!(i >= (32768))) p("not IFGE:   ", (32768));
1001
1002         p("LADDCONST:  ", l  +  (32768));
1003         p("LSUBCONST:  ", l  -  (32768));
1004         p("LMULCONST:  ", l  *  (32768));
1005         p("LSHLCONST:  ", l <<  (32768));
1006         p("LSHRCONST:  ", l >>  (32768));
1007         p("LUSHRCONST: ", l >>> (32768));
1008         p("LANDCONST:  ", l  &  (32768));
1009         p("LORCONST:   ", l  |  (32768));
1010         p("LXORCONST:  ", l  ^  (32768));
1011
1012         if (!(l == (32768))) p("not IF_LEQ: ", (32768));
1013         if (!(l != (32768))) p("not IF_LNE: ", (32768));
1014         if (!(l <  (32768))) p("not IF_LLT: ", (32768));
1015         if (!(l <= (32768))) p("not IF_LLE: ", (32768));
1016         if (!(l >  (32768))) p("not IF_LGT: ", (32768));
1017         if (!(l >= (32768))) p("not IF_LGE: ", (32768));
1018
1019         p("IADDCONST:  ", i  +  (-32768));
1020         p("ISUBCONST:  ", i  -  (-32768));
1021         p("IMULCONST:  ", i  *  (-32768));
1022         p("ISHLCONST:  ", i <<  (-32768));
1023         p("ISHRCONST:  ", i >>  (-32768));
1024         p("IUSHRCONST: ", i >>> (-32768));
1025         p("IANDCONST:  ", i  &  (-32768));
1026         p("IORCONST:   ", i  |  (-32768));
1027         p("IXORCONST:  ", i  ^  (-32768));
1028
1029         if (!(i == (-32768))) p("not IFEQ:   ", (-32768));
1030         if (!(i != (-32768))) p("not IFNE:   ", (-32768));
1031         if (!(i <  (-32768))) p("not IFLT:   ", (-32768));
1032         if (!(i <= (-32768))) p("not IFLE:   ", (-32768));
1033         if (!(i >  (-32768))) p("not IFGT:   ", (-32768));
1034         if (!(i >= (-32768))) p("not IFGE:   ", (-32768));
1035
1036         p("LADDCONST:  ", l  +  (-32768));
1037         p("LSUBCONST:  ", l  -  (-32768));
1038         p("LMULCONST:  ", l  *  (-32768));
1039         p("LSHLCONST:  ", l <<  (-32768));
1040         p("LSHRCONST:  ", l >>  (-32768));
1041         p("LUSHRCONST: ", l >>> (-32768));
1042         p("LANDCONST:  ", l  &  (-32768));
1043         p("LORCONST:   ", l  |  (-32768));
1044         p("LXORCONST:  ", l  ^  (-32768));
1045
1046         if (!(l == (-32768))) p("not IF_LEQ: ", (-32768));
1047         if (!(l != (-32768))) p("not IF_LNE: ", (-32768));
1048         if (!(l <  (-32768))) p("not IF_LLT: ", (-32768));
1049         if (!(l <= (-32768))) p("not IF_LLE: ", (-32768));
1050         if (!(l >  (-32768))) p("not IF_LGT: ", (-32768));
1051         if (!(l >= (-32768))) p("not IF_LGE: ", (-32768));
1052
1053         p("IADDCONST:  ", i  +  (-32769));
1054         p("ISUBCONST:  ", i  -  (-32769));
1055         p("IMULCONST:  ", i  *  (-32769));
1056         p("ISHLCONST:  ", i <<  (-32769));
1057         p("ISHRCONST:  ", i >>  (-32769));
1058         p("IUSHRCONST: ", i >>> (-32769));
1059         p("IANDCONST:  ", i  &  (-32769));
1060         p("IORCONST:   ", i  |  (-32769));
1061         p("IXORCONST:  ", i  ^  (-32769));
1062
1063         if (!(i == (-32769))) p("not IFEQ:   ", (-32769));
1064         if (!(i != (-32769))) p("not IFNE:   ", (-32769));
1065         if (!(i <  (-32769))) p("not IFLT:   ", (-32769));
1066         if (!(i <= (-32769))) p("not IFLE:   ", (-32769));
1067         if (!(i >  (-32769))) p("not IFGT:   ", (-32769));
1068         if (!(i >= (-32769))) p("not IFGE:   ", (-32769));
1069
1070         p("LADDCONST:  ", l  +  (-32769));
1071         p("LSUBCONST:  ", l  -  (-32769));
1072         p("LMULCONST:  ", l  *  (-32769));
1073         p("LSHLCONST:  ", l <<  (-32769));
1074         p("LSHRCONST:  ", l >>  (-32769));
1075         p("LUSHRCONST: ", l >>> (-32769));
1076         p("LANDCONST:  ", l  &  (-32769));
1077         p("LORCONST:   ", l  |  (-32769));
1078         p("LXORCONST:  ", l  ^  (-32769));
1079
1080         if (!(l == (-32769))) p("not IF_LEQ: ", (-32769));
1081         if (!(l != (-32769))) p("not IF_LNE: ", (-32769));
1082         if (!(l <  (-32769))) p("not IF_LLT: ", (-32769));
1083         if (!(l <= (-32769))) p("not IF_LLE: ", (-32769));
1084         if (!(l >  (-32769))) p("not IF_LGT: ", (-32769));
1085         if (!(l >= (-32769))) p("not IF_LGE: ", (-32769));
1086
1087         p("IADDCONST:  ", i  +  (2147483647));
1088         p("ISUBCONST:  ", i  -  (2147483647));
1089         p("IMULCONST:  ", i  *  (2147483647));
1090         p("ISHLCONST:  ", i <<  (2147483647));
1091         p("ISHRCONST:  ", i >>  (2147483647));
1092         p("IUSHRCONST: ", i >>> (2147483647));
1093         p("IANDCONST:  ", i  &  (2147483647));
1094         p("IORCONST:   ", i  |  (2147483647));
1095         p("IXORCONST:  ", i  ^  (2147483647));
1096
1097         if (!(i == (2147483647))) p("not IFEQ:   ", (2147483647));
1098         if (!(i != (2147483647))) p("not IFNE:   ", (2147483647));
1099         if (!(i <  (2147483647))) p("not IFLT:   ", (2147483647));
1100         if (!(i <= (2147483647))) p("not IFLE:   ", (2147483647));
1101         if (!(i >  (2147483647))) p("not IFGT:   ", (2147483647));
1102         if (!(i >= (2147483647))) p("not IFGE:   ", (2147483647));
1103
1104         p("LADDCONST:  ", l  +  (2147483647));
1105         p("LSUBCONST:  ", l  -  (2147483647));
1106         p("LMULCONST:  ", l  *  (2147483647));
1107         p("LSHLCONST:  ", l <<  (2147483647));
1108         p("LSHRCONST:  ", l >>  (2147483647));
1109         p("LUSHRCONST: ", l >>> (2147483647));
1110         p("LANDCONST:  ", l  &  (2147483647));
1111         p("LORCONST:   ", l  |  (2147483647));
1112         p("LXORCONST:  ", l  ^  (2147483647));
1113
1114         if (!(l == (2147483647))) p("not IF_LEQ: ", (2147483647));
1115         if (!(l != (2147483647))) p("not IF_LNE: ", (2147483647));
1116         if (!(l <  (2147483647))) p("not IF_LLT: ", (2147483647));
1117         if (!(l <= (2147483647))) p("not IF_LLE: ", (2147483647));
1118         if (!(l >  (2147483647))) p("not IF_LGT: ", (2147483647));
1119         if (!(l >= (2147483647))) p("not IF_LGE: ", (2147483647));
1120
1121         p("LADDCONST:  ", l  +  (2147483648L));
1122         p("LSUBCONST:  ", l  -  (2147483648L));
1123         p("LMULCONST:  ", l  *  (2147483648L));
1124         p("LSHLCONST:  ", l <<  (2147483648L));
1125         p("LSHRCONST:  ", l >>  (2147483648L));
1126         p("LUSHRCONST: ", l >>> (2147483648L));
1127         p("LANDCONST:  ", l  &  (2147483648L));
1128         p("LORCONST:   ", l  |  (2147483648L));
1129         p("LXORCONST:  ", l  ^  (2147483648L));
1130
1131         if (!(l == (2147483648L))) p("not IF_LEQ: ", (2147483648L));
1132         if (!(l != (2147483648L))) p("not IF_LNE: ", (2147483648L));
1133         if (!(l <  (2147483648L))) p("not IF_LLT: ", (2147483648L));
1134         if (!(l <= (2147483648L))) p("not IF_LLE: ", (2147483648L));
1135         if (!(l >  (2147483648L))) p("not IF_LGT: ", (2147483648L));
1136         if (!(l >= (2147483648L))) p("not IF_LGE: ", (2147483648L));
1137
1138         p("IADDCONST:  ", i  +  (-2147483648));
1139         p("ISUBCONST:  ", i  -  (-2147483648));
1140         p("IMULCONST:  ", i  *  (-2147483648));
1141         p("ISHLCONST:  ", i <<  (-2147483648));
1142         p("ISHRCONST:  ", i >>  (-2147483648));
1143         p("IUSHRCONST: ", i >>> (-2147483648));
1144         p("IANDCONST:  ", i  &  (-2147483648));
1145         p("IORCONST:   ", i  |  (-2147483648));
1146         p("IXORCONST:  ", i  ^  (-2147483648));
1147
1148         if (!(i == (-2147483648))) p("not IFEQ:   ", (-2147483648));
1149         if (!(i != (-2147483648))) p("not IFNE:   ", (-2147483648));
1150         if (!(i <  (-2147483648))) p("not IFLT:   ", (-2147483648));
1151         if (!(i <= (-2147483648))) p("not IFLE:   ", (-2147483648));
1152         if (!(i >  (-2147483648))) p("not IFGT:   ", (-2147483648));
1153         if (!(i >= (-2147483648))) p("not IFGE:   ", (-2147483648));
1154
1155         p("LADDCONST:  ", l  +  (-2147483648));
1156         p("LSUBCONST:  ", l  -  (-2147483648));
1157         p("LMULCONST:  ", l  *  (-2147483648));
1158         p("LSHLCONST:  ", l <<  (-2147483648));
1159         p("LSHRCONST:  ", l >>  (-2147483648));
1160         p("LUSHRCONST: ", l >>> (-2147483648));
1161         p("LANDCONST:  ", l  &  (-2147483648));
1162         p("LORCONST:   ", l  |  (-2147483648));
1163         p("LXORCONST:  ", l  ^  (-2147483648));
1164
1165         if (!(l == (-2147483648))) p("not IF_LEQ: ", (-2147483648));
1166         if (!(l != (-2147483648))) p("not IF_LNE: ", (-2147483648));
1167         if (!(l <  (-2147483648))) p("not IF_LLT: ", (-2147483648));
1168         if (!(l <= (-2147483648))) p("not IF_LLE: ", (-2147483648));
1169         if (!(l >  (-2147483648))) p("not IF_LGT: ", (-2147483648));
1170         if (!(l >= (-2147483648))) p("not IF_LGE: ", (-2147483648));
1171
1172         p("LADDCONST:  ", l  +  (-2147483649L));
1173         p("LSUBCONST:  ", l  -  (-2147483649L));
1174         p("LMULCONST:  ", l  *  (-2147483649L));
1175         p("LSHLCONST:  ", l <<  (-2147483649L));
1176         p("LSHRCONST:  ", l >>  (-2147483649L));
1177         p("LUSHRCONST: ", l >>> (-2147483649L));
1178         p("LANDCONST:  ", l  &  (-2147483649L));
1179         p("LORCONST:   ", l  |  (-2147483649L));
1180         p("LXORCONST:  ", l  ^  (-2147483649L));
1181
1182         if (!(l == (-2147483649L))) p("not IF_LEQ: ", (-2147483649L));
1183         if (!(l != (-2147483649L))) p("not IF_LNE: ", (-2147483649L));
1184         if (!(l <  (-2147483649L))) p("not IF_LLT: ", (-2147483649L));
1185         if (!(l <= (-2147483649L))) p("not IF_LLE: ", (-2147483649L));
1186         if (!(l >  (-2147483649L))) p("not IF_LGT: ", (-2147483649L));
1187         if (!(l >= (-2147483649L))) p("not IF_LGE: ", (-2147483649L));
1188     }
1189
1190     static public void testdivremconst(int a) {
1191         p("IDIVPOW2 (" + a + " / 0x00000002):  ", a / 0x00000002);
1192         p("IDIVPOW2 (" + a + " / 0x00000004):  ", a / 0x00000004);
1193         p("IDIVPOW2 (" + a + " / 0x00000008):  ", a / 0x00000008);
1194         p("IDIVPOW2 (" + a + " / 0x00000010):  ", a / 0x00000010);
1195         p("IDIVPOW2 (" + a + " / 0x00000020):  ", a / 0x00000020);
1196         p("IDIVPOW2 (" + a + " / 0x00000040):  ", a / 0x00000040);
1197         p("IDIVPOW2 (" + a + " / 0x00000080):  ", a / 0x00000080);
1198         p("IDIVPOW2 (" + a + " / 0x00000100):  ", a / 0x00000100);
1199         p("IDIVPOW2 (" + a + " / 0x00000200):  ", a / 0x00000200);
1200         p("IDIVPOW2 (" + a + " / 0x00000400):  ", a / 0x00000400);
1201         p("IDIVPOW2 (" + a + " / 0x00000800):  ", a / 0x00000800);
1202         p("IDIVPOW2 (" + a + " / 0x00001000):  ", a / 0x00001000);
1203         p("IDIVPOW2 (" + a + " / 0x00002000):  ", a / 0x00002000);
1204         p("IDIVPOW2 (" + a + " / 0x00004000):  ", a / 0x00004000);
1205         p("IDIVPOW2 (" + a + " / 0x00008000):  ", a / 0x00008000);
1206         p("IDIVPOW2 (" + a + " / 0x00010000):  ", a / 0x00010000);
1207         p("IDIVPOW2 (" + a + " / 0x00020000):  ", a / 0x00020000);
1208         p("IDIVPOW2 (" + a + " / 0x00040000):  ", a / 0x00040000);
1209         p("IDIVPOW2 (" + a + " / 0x00080000):  ", a / 0x00080000);
1210         p("IDIVPOW2 (" + a + " / 0x00100000):  ", a / 0x00100000);
1211         p("IDIVPOW2 (" + a + " / 0x00200000):  ", a / 0x00200000);
1212         p("IDIVPOW2 (" + a + " / 0x00400000):  ", a / 0x00400000);
1213         p("IDIVPOW2 (" + a + " / 0x00800000):  ", a / 0x00800000);
1214         p("IDIVPOW2 (" + a + " / 0x01000000):  ", a / 0x01000000);
1215         p("IDIVPOW2 (" + a + " / 0x02000000):  ", a / 0x02000000);
1216         p("IDIVPOW2 (" + a + " / 0x04000000):  ", a / 0x04000000);
1217         p("IDIVPOW2 (" + a + " / 0x08000000):  ", a / 0x08000000);
1218         p("IDIVPOW2 (" + a + " / 0x10000000):  ", a / 0x10000000);
1219         p("IDIVPOW2 (" + a + " / 0x20000000):  ", a / 0x20000000);
1220         p("IDIVPOW2 (" + a + " / 0x40000000):  ", a / 0x40000000);
1221         p("IDIVPOW2 (" + a + " / 0x80000000):  ", a / 0x80000000);
1222
1223         p("IREMPOW2 (" + a + " % 0x00000002):  ", a % 0x00000002);
1224         p("IREMPOW2 (" + a + " % 0x00000004):  ", a % 0x00000004);
1225         p("IREMPOW2 (" + a + " % 0x00000008):  ", a % 0x00000008);
1226         p("IREMPOW2 (" + a + " % 0x00000010):  ", a % 0x00000010);
1227         p("IREMPOW2 (" + a + " % 0x00000020):  ", a % 0x00000020);
1228         p("IREMPOW2 (" + a + " % 0x00000040):  ", a % 0x00000040);
1229         p("IREMPOW2 (" + a + " % 0x00000080):  ", a % 0x00000080);
1230         p("IREMPOW2 (" + a + " % 0x00000100):  ", a % 0x00000100);
1231         p("IREMPOW2 (" + a + " % 0x00000200):  ", a % 0x00000200);
1232         p("IREMPOW2 (" + a + " % 0x00000400):  ", a % 0x00000400);
1233         p("IREMPOW2 (" + a + " % 0x00000800):  ", a % 0x00000800);
1234         p("IREMPOW2 (" + a + " % 0x00001000):  ", a % 0x00001000);
1235         p("IREMPOW2 (" + a + " % 0x00002000):  ", a % 0x00002000);
1236         p("IREMPOW2 (" + a + " % 0x00004000):  ", a % 0x00004000);
1237         p("IREMPOW2 (" + a + " % 0x00008000):  ", a % 0x00008000);
1238         p("IREMPOW2 (" + a + " % 0x00010000):  ", a % 0x00010000);
1239         p("IREMPOW2 (" + a + " % 0x00020000):  ", a % 0x00020000);
1240         p("IREMPOW2 (" + a + " % 0x00040000):  ", a % 0x00040000);
1241         p("IREMPOW2 (" + a + " % 0x00080000):  ", a % 0x00080000);
1242         p("IREMPOW2 (" + a + " % 0x00100000):  ", a % 0x00100000);
1243         p("IREMPOW2 (" + a + " % 0x00200000):  ", a % 0x00200000);
1244         p("IREMPOW2 (" + a + " % 0x00400000):  ", a % 0x00400000);
1245         p("IREMPOW2 (" + a + " % 0x00800000):  ", a % 0x00800000);
1246         p("IREMPOW2 (" + a + " % 0x01000000):  ", a % 0x01000000);
1247         p("IREMPOW2 (" + a + " % 0x02000000):  ", a % 0x02000000);
1248         p("IREMPOW2 (" + a + " % 0x04000000):  ", a % 0x04000000);
1249         p("IREMPOW2 (" + a + " % 0x08000000):  ", a % 0x08000000);
1250         p("IREMPOW2 (" + a + " % 0x10000000):  ", a % 0x10000000);
1251         p("IREMPOW2 (" + a + " % 0x20000000):  ", a % 0x20000000);
1252         p("IREMPOW2 (" + a + " % 0x40000000):  ", a % 0x40000000);
1253         p("IREMPOW2 (" + a + " % 0x80000000):  ", a % 0x80000000);
1254     }
1255
1256     static public void testdivremconst(long a) {
1257         p("LDIVPOW2 (" + a + " / 0x00000002):  ", a / 0x00000002);
1258         p("LDIVPOW2 (" + a + " / 0x00000004):  ", a / 0x00000004);
1259         p("LDIVPOW2 (" + a + " / 0x00000008):  ", a / 0x00000008);
1260         p("LDIVPOW2 (" + a + " / 0x00000010):  ", a / 0x00000010);
1261         p("LDIVPOW2 (" + a + " / 0x00000020):  ", a / 0x00000020);
1262         p("LDIVPOW2 (" + a + " / 0x00000040):  ", a / 0x00000040);
1263         p("LDIVPOW2 (" + a + " / 0x00000080):  ", a / 0x00000080);
1264         p("LDIVPOW2 (" + a + " / 0x00000100):  ", a / 0x00000100);
1265         p("LDIVPOW2 (" + a + " / 0x00000200):  ", a / 0x00000200);
1266         p("LDIVPOW2 (" + a + " / 0x00000400):  ", a / 0x00000400);
1267         p("LDIVPOW2 (" + a + " / 0x00000800):  ", a / 0x00000800);
1268         p("LDIVPOW2 (" + a + " / 0x00001000):  ", a / 0x00001000);
1269         p("LDIVPOW2 (" + a + " / 0x00002000):  ", a / 0x00002000);
1270         p("LDIVPOW2 (" + a + " / 0x00004000):  ", a / 0x00004000);
1271         p("LDIVPOW2 (" + a + " / 0x00008000):  ", a / 0x00008000);
1272         p("LDIVPOW2 (" + a + " / 0x00010000):  ", a / 0x00010000);
1273         p("LDIVPOW2 (" + a + " / 0x00020000):  ", a / 0x00020000);
1274         p("LDIVPOW2 (" + a + " / 0x00040000):  ", a / 0x00040000);
1275         p("LDIVPOW2 (" + a + " / 0x00080000):  ", a / 0x00080000);
1276         p("LDIVPOW2 (" + a + " / 0x00100000):  ", a / 0x00100000);
1277         p("LDIVPOW2 (" + a + " / 0x00200000):  ", a / 0x00200000);
1278         p("LDIVPOW2 (" + a + " / 0x00400000):  ", a / 0x00400000);
1279         p("LDIVPOW2 (" + a + " / 0x00800000):  ", a / 0x00800000);
1280         p("LDIVPOW2 (" + a + " / 0x01000000):  ", a / 0x01000000);
1281         p("LDIVPOW2 (" + a + " / 0x02000000):  ", a / 0x02000000);
1282         p("LDIVPOW2 (" + a + " / 0x04000000):  ", a / 0x04000000);
1283         p("LDIVPOW2 (" + a + " / 0x08000000):  ", a / 0x08000000);
1284         p("LDIVPOW2 (" + a + " / 0x10000000):  ", a / 0x10000000);
1285         p("LDIVPOW2 (" + a + " / 0x20000000):  ", a / 0x20000000);
1286         p("LDIVPOW2 (" + a + " / 0x40000000):  ", a / 0x40000000);
1287         p("LDIVPOW2 (" + a + " / 0x80000000):  ", a / 0x80000000);
1288
1289         p("LREMPOW2 (" + a + " % 0x00000002):  ", a % 0x00000002L);
1290         p("LREMPOW2 (" + a + " % 0x00000004):  ", a % 0x00000004L);
1291         p("LREMPOW2 (" + a + " % 0x00000008):  ", a % 0x00000008L);
1292         p("LREMPOW2 (" + a + " % 0x00000010):  ", a % 0x00000010L);
1293         p("LREMPOW2 (" + a + " % 0x00000020):  ", a % 0x00000020L);
1294         p("LREMPOW2 (" + a + " % 0x00000040):  ", a % 0x00000040L);
1295         p("LREMPOW2 (" + a + " % 0x00000080):  ", a % 0x00000080L);
1296         p("LREMPOW2 (" + a + " % 0x00000100):  ", a % 0x00000100L);
1297         p("LREMPOW2 (" + a + " % 0x00000200):  ", a % 0x00000200L);
1298         p("LREMPOW2 (" + a + " % 0x00000400):  ", a % 0x00000400L);
1299         p("LREMPOW2 (" + a + " % 0x00000800):  ", a % 0x00000800L);
1300         p("LREMPOW2 (" + a + " % 0x00001000):  ", a % 0x00001000L);
1301         p("LREMPOW2 (" + a + " % 0x00002000):  ", a % 0x00002000L);
1302         p("LREMPOW2 (" + a + " % 0x00004000):  ", a % 0x00004000L);
1303         p("LREMPOW2 (" + a + " % 0x00008000):  ", a % 0x00008000L);
1304         p("LREMPOW2 (" + a + " % 0x00010000):  ", a % 0x00010000L);
1305         p("LREMPOW2 (" + a + " % 0x00020000):  ", a % 0x00020000L);
1306         p("LREMPOW2 (" + a + " % 0x00040000):  ", a % 0x00040000L);
1307         p("LREMPOW2 (" + a + " % 0x00080000):  ", a % 0x00080000L);
1308         p("LREMPOW2 (" + a + " % 0x00100000):  ", a % 0x00100000L);
1309         p("LREMPOW2 (" + a + " % 0x00200000):  ", a % 0x00200000L);
1310         p("LREMPOW2 (" + a + " % 0x00400000):  ", a % 0x00400000L);
1311         p("LREMPOW2 (" + a + " % 0x00800000):  ", a % 0x00800000L);
1312         p("LREMPOW2 (" + a + " % 0x01000000):  ", a % 0x01000000L);
1313         p("LREMPOW2 (" + a + " % 0x02000000):  ", a % 0x02000000L);
1314         p("LREMPOW2 (" + a + " % 0x04000000):  ", a % 0x04000000L);
1315         p("LREMPOW2 (" + a + " % 0x08000000):  ", a % 0x08000000L);
1316         p("LREMPOW2 (" + a + " % 0x10000000):  ", a % 0x10000000L);
1317         p("LREMPOW2 (" + a + " % 0x20000000):  ", a % 0x20000000L);
1318         p("LREMPOW2 (" + a + " % 0x40000000):  ", a % 0x40000000L);
1319         p("LREMPOW2 (" + a + " % 0x80000000):  ", a % 0x80000000L);
1320     }
1321
1322
1323     static public void testint(int a, int b) {
1324         p("TESTINT called with ", a);
1325         p("                AND ", b);
1326
1327         p("IADD:  ", a+b);
1328         p("ISUB:  ", a-b);
1329         p("IMUL:  ", a*b);
1330         try { p("IDIV:  ", a/b); }
1331         catch (ArithmeticException e) { p("divison by zero"); }
1332         try { p("IREM:  ", a%b); }
1333         catch (ArithmeticException e) { p("divison by zero"); }
1334         p("INEG:  ", -a);
1335         p("ISHL:  ", a<<b);
1336         p("ISHR:  ", a>>b);
1337         p("IUSHR: ", a>>>b);
1338         p("IAND:  ", a & b);
1339         p("IOR:   ", a | b);
1340         p("IXOR:  ", a ^ b);
1341
1342         p("I2L:   ", (long) a);
1343         p("I2F:   ", (float) a);
1344         p("I2D:   ", (double) a);
1345         p("INT2BYTE: ", (byte) a);
1346         p("INT2CHAR: ", (char) a);
1347         p("INT2SHORT: ", (short) a);
1348
1349         if (!(a == 0)) p("not IFEQ");
1350         if (!(a != 0)) p("not IFNE");
1351         if (!(a < 0))  p("not IFLT");
1352         if (!(a <= 0)) p("not IFLE");
1353         if (!(a > 0))  p("not IFGT");
1354         if (!(a >= 0)) p("not IFGE");
1355
1356         if (!(a == b)) p("not IF_ICMPEQ");
1357         if (!(a != b)) p("not IF_ICMPNE");
1358         if (!(a < b))  p("not IF_ICMPLT");
1359         if (!(a <= b)) p("not IF_ICMPLE");
1360         if (!(a > b))  p("not IF_ICMPGT");
1361         if (!(a >= b)) p("not IF_ICMPGE");
1362
1363         p("COND_ICMPEQ " + a + " == 0: " + ((a == 0) ? 0 : 1));
1364         p("COND_ICMPNE " + a + " != 0: " + ((a != 0) ? 0 : 1));
1365         p("COND_ICMPLT " + a + " <  0: " + ((a <  0) ? 0 : 1));
1366         p("COND_ICMPLE " + a + " <= 0: " + ((a <= 0) ? 0 : 1));
1367         p("COND_ICMPGT " + a + " >  0: " + ((a >  0) ? 0 : 1));
1368         p("COND_ICMPGE " + a + " >= 0: " + ((a >= 0) ? 0 : 1));
1369
1370         p("COND_ICMPEQ " + a + " == 0: " + ((a == 0) ? 1 : 0));
1371         p("COND_ICMPNE " + a + " != 0: " + ((a != 0) ? 1 : 0));
1372         p("COND_ICMPLT " + a + " <  0: " + ((a <  0) ? 1 : 0));
1373         p("COND_ICMPLE " + a + " <= 0: " + ((a <= 0) ? 1 : 0));
1374         p("COND_ICMPGT " + a + " >  0: " + ((a >  0) ? 1 : 0));
1375         p("COND_ICMPGE " + a + " >= 0: " + ((a >= 0) ? 1 : 0));
1376
1377         p("COND_ICMPEQ " + a + " == 0: " + ((a == 0) ? 2 : 3));
1378         p("COND_ICMPNE " + a + " != 0: " + ((a != 0) ? 2 : 3));
1379         p("COND_ICMPLT " + a + " <  0: " + ((a <  0) ? 2 : 3));
1380         p("COND_ICMPLE " + a + " <= 0: " + ((a <= 0) ? 2 : 3));
1381         p("COND_ICMPGT " + a + " >  0: " + ((a >  0) ? 2 : 3));
1382         p("COND_ICMPGE " + a + " >= 0: " + ((a >= 0) ? 2 : 3));
1383
1384         p("COND_ICMPEQ " + a + " == " + b + ": " + (a == b));
1385         p("COND_ICMPNE " + a + " != " + b + ": " + (a != b));
1386         p("COND_ICMPLT " + a + " <  " + b + ": " + (a <  b));
1387         p("COND_ICMPLE " + a + " <= " + b + ": " + (a <= b));
1388         p("COND_ICMPGT " + a + " >  " + b + ": " + (a >  b));
1389         p("COND_ICMPGE " + a + " >= " + b + ": " + (a >= b));
1390
1391     }
1392
1393     static public void testlong(long a, long b) {
1394         p("TESTLONG called with ", a);
1395         p("                 AND ", b);
1396
1397         p("LADD:  ", a + b);
1398         p("LSUB:  ", a - b);
1399         p("LMUL:  ", a * b);
1400         try { p("LDIV:  ", a / b); }
1401         catch (ArithmeticException e) { p("divison by zero"); }
1402         try { p("LREM:  ", a % b); }
1403         catch (ArithmeticException e) { p("divison by zero"); }
1404         p("LNEG:  ", -a);
1405         p("LSHL:  ", a << b);
1406         p("LSHR:  ", a >> b);
1407         p("LUSHR: ", a >>>b);
1408         p("LAND:  ", a &  b);
1409         p("LOR:   ", a |  b);
1410         p("LXOR:  ", a ^  b);
1411
1412         p("L2I:   ", (int) a);
1413         p("L2F:   ", (float) a);
1414         p("L2D:   ", (double) a);
1415
1416         p("LCMP a == b : ", a == b);
1417         p("LCMP a != b : ", a != b);
1418         p("LCMP a <  b : ", a <  b);
1419         p("LCMP a <= b : ", a <= b);
1420         p("LCMP a >  b : ", a >  b);
1421         p("LCMP a >= b : ", a >= b);
1422
1423         if (!(a == 0)) p("not IF_LEQ");
1424         if (!(a != 0)) p("not IF_LNE");
1425         if (!(a < 0))  p("not IF_LLT");
1426         if (!(a <= 0)) p("not IF_LLE");
1427         if (!(a > 0))  p("not IF_LGT");
1428         if (!(a >= 0)) p("not IF_LGE");
1429
1430         if (!(a == b)) p("not IF_LCMPEQ");
1431         if (!(a != b)) p("not IF_LCMPNE");
1432         if (!(a < b))  p("not IF_LCMPLT");
1433         if (!(a <= b)) p("not IF_LCMPLE");
1434         if (!(a > b))  p("not IF_LCMPGT");
1435         if (!(a >= b)) p("not IF_LCMPGE");
1436     }
1437
1438     static public void testfloat(float a, float b) {
1439         p("TESTFLOAT called with ", a);
1440         p("                  AND ", b);
1441
1442         p("FADD:  ", a + b);
1443         p("FSUB:  ", a - b);
1444         p("FMUL:  ", a * b);
1445         p("FDIV:  ", a / b);
1446         p("FREM:  ", a % b);
1447
1448         p("F2I:   ", (int) a);
1449         p("F2L:   ", (long) a);
1450         p("F2D:   ", (double) a);
1451
1452         if ((a == b)) p("FCMP a == b");
1453         if ((a != b)) p("FCMP a != b");
1454         if ((a < b))  p("FCMP a < b");
1455         if ((a <= b)) p("FCMP a <= b");
1456         if ((a > b))  p("FCMP a > b");
1457         if ((a >= b)) p("FCMP a >= b");
1458     }
1459
1460     static public void testdouble(double a, double b) {
1461         p("TESTDOUBLE called with ", a);
1462         p("                   AND ", b);
1463
1464         p("DADD:  ", a + b);
1465         p("DSUB:  ", a - b);
1466         p("DMUL:  ", a * b);
1467         p("DDIV:  ", a / b);
1468         p("DREM:  ", a % b);
1469
1470         p("D2I:   ", (int) a);
1471         p("D2L:   ", (long) a);
1472         p("D2F:   ", (float) a);
1473
1474         if ((a == b)) p("DCMP a == b");
1475         if ((a != b)) p("DCMP a != b");
1476         if ((a < b))  p("DCMP a < b");
1477         if ((a <= b)) p("DCMP a <= b");
1478         if ((a > b))  p("DCMP a > b");
1479         if ((a >= b)) p("DCMP a >= b");
1480     }
1481
1482
1483     // ********************* output methods ****************************
1484
1485     public static void pnl() {
1486         System.out.println ();
1487         System.out.print (linenum);
1488         System.out.print (".    ");
1489         linenum++;
1490     }
1491
1492     public static void p(String a) { System.out.print(a); pnl(); }
1493     public static void p(boolean a) {System.out.print(a);
1494     pnl();  }
1495     public static void p(int a) { System.out.print ("int: ");
1496     System.out.print(a);
1497     pnl();  }
1498     public static void p(long a) { System.out.print ("long: ");
1499     System.out.print(a);
1500     pnl(); }
1501     public static void p(short a) { System.out.print ("short: ");
1502     System.out.print(a);
1503     pnl(); }
1504     public static void p(byte a) { System.out.print ("byte: ");
1505     System.out.print(a);
1506     pnl(); }
1507     public static void p(char a) { System.out.print ("char: ");
1508     System.out.print((int) a);
1509     pnl(); }
1510     public static void p(float a) { System.out.print ("float: ");
1511     System.out.print ( java.lang.Float.floatToIntBits(a) );
1512     pnl(); }
1513     public static void p(double a) { System.out.print ("double: ");
1514     System.out.print( java.lang.Double.doubleToLongBits(a) );
1515     pnl(); }
1516
1517     public static void p(String s,boolean i) {
1518         System.out.print(s); p(i);
1519     }
1520     public static void p(String s,int i) {
1521         System.out.print(s); p(i);
1522     }
1523     public static void p(String s,byte i) {
1524         System.out.print(s); p(i);
1525     }
1526     public static void p(String s,char i) {
1527         System.out.print(s); p(i);
1528     }
1529     public static void p(String s,short i) {
1530         System.out.print(s); p(i);
1531     }
1532     public static void p(String s,long l) {
1533         System.out.print(s); p(l);
1534     }
1535     public static void p(String s,float f) {
1536         System.out.print(s); p(f);
1537     }
1538     public static void p(String s,double d) {
1539         System.out.print(s); p(d);
1540     }
1541
1542     // methods for testing interface and method calls
1543
1544     public void jctest() {
1545         p("<init> called");
1546     }
1547
1548     public void p_manyparam(int p_i1,int p_i2,
1549                             int p_i3, int p_i4,
1550                             long p_l1,long p_l2,
1551                             long p_l3,long p_l4,
1552                             float p_f1, float p_f2,
1553                             float p_f3, float p_f4,
1554                             double p_d1, double p_d2,
1555                             double p_d3, double p_d4) {
1556         n_i1 = p_i1;
1557         n_i2 = p_i2;
1558         n_i3 = p_i3;
1559         n_i4 = p_i4;
1560         n_l1 = p_l1;
1561         n_l2 = p_l2;
1562         n_l3 = p_l3;
1563         n_l4 = p_l4;
1564         n_f1 = p_f1;
1565         n_f2 = p_f2;
1566         n_f3 = p_f3;
1567         n_f4 = p_f4;
1568         n_d1 = p_d1;
1569         n_d2 = p_d2;
1570         n_d3 = p_d3;
1571         n_d4 = p_d4;
1572     }
1573
1574     public void p_nonstatic (String a) {
1575         p(a);
1576         p(n_i1);
1577         p(n_i2);
1578         p(n_i3);
1579         p(n_i4);
1580         p(n_l1);
1581         p(n_l2);
1582         p(n_l3);
1583         p(n_l4);
1584         p(n_f1);
1585         p(n_f2);
1586         p(n_f3);
1587         p(n_f4);
1588         p(n_d1);
1589         p(n_d2);
1590         p(n_d3);
1591         p(n_d4);
1592
1593     }
1594 }
1595
1596 interface jcinterface {
1597     public void p_nonstatic (String a);
1598 }