site/js/JSmolJavaExt.js

   1 // JSmolJavaExt.js
   2
   3
   4 // This library will be wrapped by an additional anonymous function using ANT in
   5 // build_03_tojs.xml. This task will also modify variable names. References
   6 // to Clazz._ will not be changed, but other Clazz.xxx will be changed to
   7 // (local scope) Clazz_xxx, allowing them to be further compressed using
   8 // Google Closure Compiler in that same ANT task.
   9
  10 // BH 5/31/2015 5:53:04 PM Number.compareTo added
  11 // BH 5/21/2015 5:46:30 PM Number("0xFFFFFFFF") is not -1
  12 // BH 4/23/2015 9:08:59 AM xx.getComponentType() is nonfunctional. Array.newInstance now defines a wrapper for .getClass().getComponentType() that works
  13 // BH 4/12/2015 1:37:44 PM adding Math.rint = Math.round
  14 // BH 1/16/2015 10:09:38 AM Chrome failure jqGrig due to new String("x").toString() not being a simple string
  15 // BH 8/14/2014 6:49:22 PM Character class efficiencies
  16 // BH 7/24/2014 9:02:18 AM most browsers do not support String.codePointAt()
  17 // BH 7/11/2014 4:17:22 PM fix for Boolean.valueOf("false") not being false
  18 // BH 5/27/2014 6:29:59 AM ensure floats and doubles have decimal point in toString
  19 // BH 4/1/2014 12:23:41 PM Encoding moved to Clazz._Encoding;
  20 // BH 4/1/2014 7:51:46 AM removing java.lang.B00lean
  21 // BH 3/7/2014 9:17:10 AM removing Array.toString; moving that code here from j2sJmol.js
  22 // BH 1/30/2014 9:04:25 AM adding Throwable.getStackTrace() as a STRING
  23 // BH 12/4/2013 9:20:44 PM fix for reassigning Date.prototype.toString()
  24 // BH 12/3/2013 11:43:10 AM bizarre Safari bug in reassigning Boolean (OK, I admit, we shouldn't have done that...)
  25 // BH 12/1/2013 6:50:16 AM evit Number.prototype.toString assignment removed!
  26 // BH 11/30/2013 1:46:31 PM fixing Byte, Short, Long, Integer, Float, Double to reflect proper bounds and error conditions
  27 // BH 11/29/2013 8:58:49 PM removing Boolean.toString(boolean)
  28 // BH 11/4/2013 7:34:26 AM changing "var nativeClazz" to "var nativeClass" to avoid ANT replacement of "nativeClazz." to "nativeClazz_"
  29 // BH 10/19/2013 1:29:27 PM fixed String.$replace()
  30 // BH 10/18/2013 6:09:23 PM fixed (Double|Float).valueOf(NaN).valueOf(), which should return NaN, not throw an error
  31 // BH 10/12/2013 11:18:44 AM fixed bug in Double(String) and Float(String) that was returning typeof "string"
  32 // BH 10/10/2013 2:40:20 PM  added Math.log10
  33 // BH 7/23/2013 7:24:01 AM fixing Number.shortValue() and Number.byteValue() for negative values
  34 // BH 6/16/2013 1:31:30 PM adding /| in String.replace -- thank you David Koes
  35 // BH 3/13/2013 12:49:23 PM setting Boolean.valueOf() "@"
  36 // BH 3/2/2013 10:46:45 PM removed Double.valueOf(String)
  37 // BH 11/6/2012 8:26:33 PM added instanceof Int32Array in String.instantialize
  38 // BH 10/13/2012 11:38:07 PM corrected Integer.parseInt to allow only +-0123456789; created Integer.parseIntRadix
  39 // BH 11/1/2012 added Short
  40 // BH 9/10/2012 6:27:21 AM added java.net.URL... classes
  41 // BH 1/7/2013 7:40:06 AM added Clazz.dateToString
  42
  43 ;(function(Clazz) {
  44
  45 // moved here from package.js
  46 // these classes will be created as objects prior to any others
  47 // and are then available immediately
  48
  49         Clazz._Loader.registerPackages("java", [ "io", "lang", "lang.reflect", "util" ]);
  50
  51   var sJU = "java.util";
  52
  53   //var sJU = "JU";
  54         //Clazz._Loader.registerPackages (sJU, ["regex", "zip"]);
  55         //var javautil = JU;
  56
  57   var javautil = java.util;
  58
  59         Clazz._Loader.ignore([
  60                 "net.sf.j2s.ajax.HttpRequest",
  61                 sJU + ".MapEntry.Type",
  62                 //"java.net.UnknownServiceException",
  63                 "java.lang.Runtime",
  64                 "java.security.AccessController",
  65                 "java.security.PrivilegedExceptionAction",
  66                 "java.io.File",
  67                 "java.io.FileInputStream",
  68                 "java.io.FileWriter",
  69                 "java.io.OutputStreamWriter",
  70 //              sJU + ".Calendar", // bypassed in ModelCollection
  71 //              "java.text.SimpleDateFormat", // not used
  72 //              "java.text.DateFormat", // not used
  73                 sJU + ".concurrent.Executors"
  74         ])
  75
  76 Math.rint = Math.round;
  77
  78 Math.log10||(Math.log10=function(a){return Math.log(a)/2.302585092994046});
  79
  80 if(Clazz._supportsNativeObject){
  81         // Number and Array are special -- do not override prototype.toString -- "length - 2" here
  82         for(var i=0;i<Clazz._extendedObjectMethods.length - 2;i++){
  83                 var p=Clazz._extendedObjectMethods[i];
  84                 Array.prototype[p] = Clazz._O.prototype[p];
  85                 Number.prototype[p] = Clazz._O.prototype[p];
  86         }
  87 }
  88
  89 java.lang.Number=Number;
  90 Number.__CLASS_NAME__="Number";
  91 Clazz.implementOf(Number,java.io.Serializable);
  92 Number.equals=Clazz._innerFunctions.equals;
  93 Number.getName=Clazz._innerFunctions.getName;
  94 Number.prototype.compareTo = function(x) { var a = this.value, b = x.value; return (a < b ? -1 : a == b ? 0 : 1) };
  95
  96 Clazz.defineMethod(Number,"shortValue",
  97 function(){
  98 var x = Math.round(this)&0xffff;
  99 return (this < 0 && x > 0 ? x - 0x10000 : x);
 100 });
 101
 102 Clazz.defineMethod(Number,"byteValue",
 103 function(){
 104 var x = Math.round(this)&0xff;
 105 return (this < 0 && x > 0 ? x - 0x100 : x);
 106 });
 107
 108 Clazz.defineMethod(Number,"intValue",
 109 function(){
 110 return Math.round(this)&0xffffffff;
 111 });
 112
 113 Clazz.defineMethod(Number,"longValue",
 114 function(){
 115 return Math.round(this);
 116 });
 117
 118 Clazz.defineMethod(Number,"floatValue",
 119 function(){
 120 return this.valueOf();
 121 });
 122 Clazz.defineMethod(Number,"doubleValue",
 123 function(){
 124 return parseFloat(this.valueOf());
 125 });
 126
 127 Clazz.overrideMethod(Number,"hashCode",
 128 function(){
 129 return this.valueOf();
 130 });
 131
 132 java.lang.Integer=Integer=function(){
 133 Clazz.instantialize(this,arguments);
 134 };
 135 Clazz.decorateAsType(Integer,"Integer",Number,Comparable,null,true);
 136 Integer.prototype.valueOf=function(){return 0;};
 137 Integer.toString=Integer.prototype.toString=function(){
 138 if(arguments.length!=0){
 139 return""+arguments[0];
 140 } else if(this===Integer){
 141 return"class java.lang.Integer";
 142 }
 143 return""+this.valueOf();
 144 };
 145
 146 /*
 147
 148 Clazz.makeConstructor(Integer,
 149 function(){
 150 this.valueOf=function(){
 151 return 0;
 152 };
 153 });
 154 */
 155
 156
 157 Clazz.overrideConstructor(Integer, function(v){
 158  v == null && (v = 0);
 159  if (typeof v != "number")
 160         v = Integer.parseIntRadix(v, 10);
 161  this.valueOf=function(){return v;};
 162 }); //BH
 163 /*
 164 Clazz.makeConstructor(Integer,
 165 function(s){
 166 var value=Integer.parseInt(s,10);
 167 this.valueOf=function(){
 168 return value;
 169 };
 170 },"String");
 171 */
 172 Integer.MIN_VALUE=Integer.prototype.MIN_VALUE=-0x80000000;
 173 Integer.MAX_VALUE=Integer.prototype.MAX_VALUE=0x7fffffff;
 174 Integer.TYPE=Integer.prototype.TYPE=Integer;
 175
 176
 177 Clazz.defineMethod(Integer,"bitCount",
 178 function(i) {
 179         i = i - ((i >>> 1) & 0x55555555);
 180         i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
 181         i = (i + (i >>> 4)) & 0x0f0f0f0f;
 182         i = i + (i >>> 8);
 183         i = i + (i >>> 16);
 184         return i & 0x3f;
 185 },"Number");
 186 Integer.bitCount=Integer.prototype.bitCount;
 187
 188 Clazz.defineMethod(Integer,"numberOfLeadingZeros",
 189 function(i) {
 190  if (i == 0) return 32;
 191  var n = 1;
 192  if (i >>> 16 == 0) { n += 16; i <<= 16; }
 193  if (i >>> 24 == 0) { n +=  8; i <<=  8; }
 194  if (i >>> 28 == 0) { n +=  4; i <<=  4; }
 195  if (i >>> 30 == 0) { n +=  2; i <<=  2; }
 196  n -= i >>> 31;
 197  return n;
 198 },"Number");
 199 Integer.numberOfLeadingZeros=Integer.prototype.numberOfLeadingZeros;
 200
 201 Clazz.defineMethod(Integer,"numberOfTrailingZeros",
 202 function(i) {
 203         if (i == 0) return 32;
 204         var n = 31;
 205         var y = i <<16; if (y != 0) { n = n -16; i = y; }
 206         y = i << 8; if (y != 0) { n = n - 8; i = y; }
 207         y = i << 4; if (y != 0) { n = n - 4; i = y; }
 208         y = i << 2; if (y != 0) { n = n - 2; i = y; }
 209         return n - ((i << 1) >>> 31);
 210 },"Number");
 211 Integer.numberOfTrailingZeros=Integer.prototype.numberOfTrailingZeros;
 212
 213 Clazz.defineMethod(Integer,"parseIntRadix",
 214 function(s,radix){
 215 if(s==null){
 216 throw new NumberFormatException("null");
 217 }if(radix<2){
 218 throw new NumberFormatException("radix "+radix+" less than Character.MIN_RADIX");
 219 }if(radix>36){
 220 throw new NumberFormatException("radix "+radix+" greater than Character.MAX_RADIX");
 221 }
 222 if (radix == 10) {
 223         for (var i = s.length; --i >= 0;) {
 224                 var c = s.charCodeAt(i);
 225                 if (c >= 48 && c <= 57) continue;
 226                 if (i > 0 || c != 43 && c != 45)
 227                         throw new NumberFormatException("Not a Number : "+s);
 228
 229         }
 230 }
 231 var i=parseInt(s,radix);
 232 if(isNaN(i)){
 233 throw new NumberFormatException("Not a Number : "+s);
 234 }
 235 return i;
 236 },"String, Number");
 237 Integer.parseIntRadix=Integer.prototype.parseIntRadix;
 238
 239 Clazz.defineMethod(Integer,"parseInt",
 240 function(s){
 241 return Integer.parseIntRadix(s,10);
 242 },"String");
 243 Integer.parseInt=Integer.prototype.parseInt;
 244
 245 /*
 246 Clazz.defineMethod(Integer,"$valueOf",
 247 function(s){
 248 return new Integer(Integer.parseIntRadix(s,10));
 249 },"String");
 250 */
 251
 252 Clazz.overrideMethod(Integer,"$valueOf",
 253 function(s){
 254 return new Integer(s);
 255 });
 256
 257 /*
 258 Clazz.defineMethod(Integer,"$valueOf",
 259 function(s,r){
 260 return new Integer(Integer.parseIntRadix(s,r));
 261 },"String, Number");
 262 */
 263
 264 Integer.$valueOf=Integer.prototype.$valueOf;
 265
 266
 267 Clazz.overrideMethod(Integer,"equals",
 268 function(s){
 269 if(s==null||!Clazz.instanceOf(s,Integer)){
 270 return false;
 271 }
 272 return s.valueOf()==this.valueOf();
 273 },"Object");
 274 Integer.toHexString=Integer.prototype.toHexString=function(d){
 275 if(d.valueOf)d=d.valueOf();
 276 if (d < 0) {
 277 var b = d & 0xFFFFFF;
 278 var c = ((d>>24)&0xFF);
 279 return c._numberToString(16) + (b = "000000" + b._numberToString(16)).substring(b.length - 6);
 280 }
 281 return d._numberToString(16);};
 282 Integer.toOctalString=Integer.prototype.toOctalString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(8);};
 283 Integer.toBinaryString=Integer.prototype.toBinaryString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(2);};
 284
 285 Integer.decodeRaw=Clazz.defineMethod(Integer,"decodeRaw", function(n){
 286 if (n.indexOf(".") >= 0)n = "";
 287 var i = (n.startsWith("-") ? 1 : 0);
 288 n = n.replace(/\#/, "0x").toLowerCase();
 289 var radix=(n.startsWith("0x", i) ? 16 : n.startsWith("0", i) ? 8 : 10);
 290 // The general problem with parseInt is that is not strict -- ParseInt("10whatever") == 10.
 291 // Number is strict, but Number("055") does not work, though ParseInt("055", 8) does.
 292 // need to make sure negative numbers are negative
 293 n = Number(n) & 0xFFFFFFFF;
 294 return (radix == 8 ? parseInt(n, 8) : n);
 295 },"~S");
 296
 297 Integer.decode=Clazz.defineMethod(Integer,"decode", function(n){
 298         n = Integer.decodeRaw(n);
 299         if (isNaN(n) || n < Integer.MIN_VALUE|| n > Integer.MAX_VALUE)
 300         throw new NumberFormatException("Invalid Integer");
 301         return new Integer(n);
 302 },"~S");
 303
 304 Clazz.overrideMethod(Integer,"hashCode",
 305 function(){
 306 return this.valueOf();
 307 });
 308
 309 // Note that Long is problematic in JavaScript
 310
 311 java.lang.Long=Long=function(){
 312 Clazz.instantialize(this,arguments);
 313 };
 314 Clazz.decorateAsType(Long,"Long",Number,Comparable,null,true);
 315 Long.prototype.valueOf=function(){return 0;};
 316 Long.toString=Long.prototype.toString=function(){
 317 if(arguments.length!=0){
 318 return""+arguments[0];
 319 }else if(this===Long){
 320 return"class java.lang.Long";
 321 }
 322 return""+this.valueOf();
 323 };
 324
 325 Clazz.overrideConstructor(Long, function(v){
 326  v == null && (v = 0);
 327  v = (typeof v == "number" ? Math.round(v) : Integer.parseIntRadix(v, 10));
 328 this.valueOf=function(){return v;};
 329 });
 330
 331 //Long.MIN_VALUE=Long.prototype.MIN_VALUE=-0x8000000000000000;
 332 //Long.MAX_VALUE=Long.prototype.MAX_VALUE=0x7fffffffffffffff;
 333 Long.TYPE=Long.prototype.TYPE=Long;
 334
 335 Clazz.defineMethod(Long,"parseLong",
 336 function(s,radix){
 337  return Integer.parseInt(s, radix || 10);
 338 });
 339
 340 Long.parseLong=Long.prototype.parseLong;
 341
 342 Clazz.overrideMethod(Long,"$valueOf",
 343 function(s){
 344 return new Long(s);
 345 });
 346 /*
 347 Clazz.defineMethod(Long,"$valueOf",
 348 function(s){
 349 return new Long(s);
 350 },"Number");
 351
 352 Clazz.defineMethod(Long,"$valueOf",
 353 function(s,r){
 354 return new Long(Long.parseLong(s,r));
 355 },"String, Number");
 356 */
 357 Long.$valueOf=Long.prototype.$valueOf;
 358 Clazz.overrideMethod(Long,"equals",
 359 function(s){
 360 if(s==null||!Clazz.instanceOf(s,Long)){
 361 return false;
 362 }
 363 return s.valueOf()==this.valueOf();
 364 },"Object");
 365 Long.toHexString=Long.prototype.toHexString=function(i){
 366 return i.toString(16);
 367 };
 368 Long.toOctalString=Long.prototype.toOctalString=function(i){
 369 return i.toString(8);
 370 };
 371 Long.toBinaryString=Long.prototype.toBinaryString=function(i){
 372 return i.toString(2);
 373 };
 374
 375
 376 Long.decode=Clazz.defineMethod(Long,"decode",
 377 function(n){
 378         n = Integer.decodeRaw(n);
 379         if (isNaN(n))
 380                 throw new NumberFormatException("Invalid Long");
 381         return new Long(n);
 382 },"~S");
 383
 384 java.lang.Short = Short = function () {
 385 Clazz.instantialize (this, arguments);
 386 };
 387 Clazz.decorateAsType (Short, "Short", Number, Comparable, null, true);
 388 Short.prototype.valueOf = function () { return 0; };
 389 Short.toString = Short.prototype.toString = function () {
 390         if (arguments.length != 0) {
 391                 return "" + arguments[0];
 392         } else if (this === Short) {
 393                 return "class java.lang.Short"; // Short.class.toString
 394         }
 395         return "" + this.valueOf ();
 396 };
 397
 398 Clazz.overrideConstructor(Short,
 399 function (v) {
 400  v == null && (v = 0);
 401  if (typeof v != "number")
 402         v = Integer.parseIntRadix(v, 10);
 403  v = v.shortValue();
 404  this.valueOf = function () {return v;};
 405 });
 406
 407
 408 Short.MIN_VALUE = Short.prototype.MIN_VALUE = -32768;
 409 Short.MAX_VALUE = Short.prototype.MAX_VALUE = 32767;
 410 Short.TYPE = Short.prototype.TYPE = Short;
 411
 412 Clazz.defineMethod(Short, "parseShortRadix",
 413 function (s, radix) {
 414 return Integer.parseIntRadix(s, radix).shortValue();
 415 }, "String, Number");
 416 Short.parseShortRadix = Short.prototype.parseShortRadix;
 417
 418 Clazz.defineMethod(Short, "parseShort",
 419 function (s) {
 420 return Short.parseShortRadix (s, 10);
 421 }, "String");
 422
 423 Short.parseShort = Short.prototype.parseShort;
 424
 425 /*
 426 Clazz.defineMethod(Short, "$valueOf",
 427 function (s) {
 428 return new Short(Short.parseShort (s, 10));
 429 }, "String");
 430         */
 431
 432 Clazz.overrideMethod(Short, "$valueOf",
 433 function (s) {
 434 return new Short(s);
 435 });
 436
 437 /*
 438 Clazz.defineMethod(Short, "$valueOf",
 439 function (s, r) {
 440 return new Short(Short.parseShort (s, r));
 441 }, "String, Number");
 442         */
 443
 444 Short.$valueOf = Short.prototype.$valueOf;
 445 Clazz.overrideMethod(Short, "equals",
 446 function (s) {
 447 if(s == null || !Clazz.instanceOf(s, Short) ){
 448         return false;
 449 }
 450 return s.valueOf()  == this.valueOf();
 451 }, "Object");
 452 Short.toHexString = Short.prototype.toHexString = function (i) {
 453         return i.toString (16);
 454 };
 455 Short.toOctalString = Short.prototype.toOctalString = function (i) {
 456         return i.toString (8);
 457 };
 458 Short.toBinaryString = Short.prototype.toBinaryString = function (i) {
 459         return i.toString (2);
 460 };
 461 Short.decode = Clazz.defineMethod(Short, "decode",
 462 function(n){
 463         n = Integer.decodeRaw(n);
 464         if (isNaN(n) || n < -32768|| n > 32767)
 465                 throw new NumberFormatException("Invalid Short");
 466         return new Short(n);
 467 }, "~S");
 468
 469 java.lang.Byte=Byte=function(){
 470 Clazz.instantialize(this,arguments);
 471 };
 472 Clazz.decorateAsType(Byte,"Byte",Number,Comparable,null,true);
 473 Byte.prototype.valueOf=function(){return 0;};
 474 Byte.toString=Byte.prototype.toString=function(){
 475 if(arguments.length!=0){
 476 return""+arguments[0];
 477 }else if(this===Byte){
 478 return"class java.lang.Byte";
 479 }
 480 return""+this.valueOf();
 481 };
 482 Clazz.makeConstructor(Byte,
 483 function(v){
 484  if (typeof v != "number")
 485          v = Integer.parseIntRadix(v, 10);
 486  v = v.byteValue();
 487 this.valueOf=function(){
 488 return v;
 489 };
 490 });
 491
 492 Byte.serialVersionUID=Byte.prototype.serialVersionUID=-7183698231559129828;
 493 Byte.MIN_VALUE=Byte.prototype.MIN_VALUE=-128;
 494 Byte.MAX_VALUE=Byte.prototype.MAX_VALUE=127;
 495 Byte.SIZE=Byte.prototype.SIZE=8;
 496 Byte.TYPE=Byte.prototype.TYPE=Byte;
 497
 498 Clazz.defineMethod(Byte,"parseByteRadix",
 499 function(s,radix){
 500  return Integer.parseIntRadix(s, radix).byteValue();
 501 },"String, Number");
 502 Byte.parseByteRadix=Byte.prototype.parseByteRadix;
 503
 504 Clazz.defineMethod(Byte,"parseByte",
 505 function(s){
 506 return Byte.parseByte(s,10);
 507 },"String");
 508
 509 Byte.parseByte=Byte.prototype.parseByte;
 510
 511 Clazz.overrideMethod(Byte, "$valueOf",
 512 function (s) {
 513 return new Byte(s);
 514 });
 515
 516 Byte.$valueOf=Byte.prototype.$valueOf;
 517 Clazz.overrideMethod(Byte,"equals",
 518 function(s){
 519 if(s==null||!Clazz.instanceOf(s,Byte)){
 520 return false;
 521 }
 522 return s.valueOf()==this.valueOf();
 523 },"Object");
 524 Byte.toHexString=Byte.prototype.toHexString=function(i){
 525 return i.toString(16);
 526 };
 527 Byte.toOctalString=Byte.prototype.toOctalString=function(i){
 528 return i.toString(8);
 529 };
 530 Byte.toBinaryString=Byte.prototype.toBinaryString=function(i){
 531 return i.toString(2);
 532 };
 533 Byte.decode=Clazz.defineMethod(Byte,"decode",
 534 function(n){
 535         n = Integer.decodeRaw(n);
 536         if (isNaN(n) || n < -128|| n > 127)
 537                 throw new NumberFormatException("Invalid Byte");
 538 return new Byte(n);
 539 },"~S");
 540
 541 Clazz._floatToString = function(f) {
 542  var s = ""+f
 543  if (s.indexOf(".") < 0 && s.indexOf("e") < 0)
 544          s += ".0";
 545  return s;
 546 }
 547
 548 java.lang.Float=Float=function(){
 549 Clazz.instantialize(this,arguments);
 550 };
 551 Clazz.decorateAsType(Float,"Float",Number,Comparable,null,true);
 552 Float.prototype.valueOf=function(){return 0;};
 553 Float.toString=Float.prototype.toString=function(){
 554 if(arguments.length!=0){
 555 return Clazz._floatToString(arguments[0]);
 556 }else if(this===Float){
 557 return"class java.lang.Float";
 558 }
 559 return Clazz._floatToString(this.valueOf());
 560 };
 561
 562 Clazz.overrideConstructor(Float, function(v){
 563  v == null && (v = 0);
 564  if (typeof v != "number")
 565         v = Number(v);
 566  this.valueOf=function(){return v;}
 567 });
 568
 569 Float.serialVersionUID=Float.prototype.serialVersionUID=-2671257302660747028;
 570 Float.MIN_VALUE=Float.prototype.MIN_VALUE=3.4028235e+38;
 571 Float.MAX_VALUE=Float.prototype.MAX_VALUE=1.4e-45;
 572 Float.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
 573 Float.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
 574 Float.NaN=Number.NaN;
 575 Float.TYPE=Float.prototype.TYPE=Float;
 576
 577 Clazz.defineMethod(Float,"parseFloat",
 578 function(s){
 579 if(s==null){
 580 throw new NumberFormatException("null");
 581 }
 582 if (typeof s == "number")return s;  // important -- typeof NaN is "number" and is OK here
 583 var floatVal=Number(s);
 584 if(isNaN(floatVal)){
 585 throw new NumberFormatException("Not a Number : "+s);
 586 }
 587 return floatVal;
 588 },"String");
 589 Float.parseFloat=Float.prototype.parseFloat;
 590
 591 Clazz.overrideMethod(Float,"$valueOf",
 592 function(s){
 593 return new Float(s);
 594 });
 595
 596 Float.$valueOf=Float.prototype.$valueOf;
 597
 598 Clazz.defineMethod(Float,"isNaN",
 599 function(num){
 600 return isNaN(num);
 601 },"Number");
 602 Float.isNaN=Float.prototype.isNaN;
 603 Clazz.defineMethod(Float,"isInfinite",
 604 function(num){
 605 return!isFinite(num);
 606 },"Number");
 607 Float.isInfinite=Float.prototype.isInfinite;
 608
 609 Clazz.overrideMethod(Float,"equals",
 610 function(s){
 611 if(s==null||!Clazz.instanceOf(s,Float)){
 612 return false;
 613 }
 614 return s.valueOf()==this.valueOf();
 615 },"Object");
 616
 617 java.lang.Double=Double=function(){
 618 Clazz.instantialize(this,arguments);
 619 };
 620 Clazz.decorateAsType(Double,"Double",Number,Comparable,null,true);
 621 Double.prototype.valueOf=function(){return 0;};
 622 Double.toString=Double.prototype.toString=function(){
 623 if(arguments.length!=0){
 624 return Clazz._floatToString(arguments[0]);
 625 }else if(this===Double){
 626 return"class java.lang.Double";
 627 }
 628 return Clazz._floatToString(this.valueOf());
 629 };
 630
 631 Clazz.overrideConstructor(Double, function(v){
 632  v == null && (v = 0);
 633  if (typeof v != "number")
 634         v = Double.parseDouble(v);
 635  this.valueOf=function(){return v;};
 636 }); // BH
 637
 638 Double.serialVersionUID=Double.prototype.serialVersionUID=-9172774392245257468;
 639 Double.MIN_VALUE=Double.prototype.MIN_VALUE=4.9e-324;
 640 Double.MAX_VALUE=Double.prototype.MAX_VALUE=1.7976931348623157e+308;
 641 Double.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
 642 Double.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
 643 Double.NaN=Number.NaN;
 644 Double.TYPE=Double.prototype.TYPE=Double;
 645
 646 Clazz.defineMethod(Double,"isNaN",
 647 function(num){
 648 return isNaN(num);
 649 },"Number");
 650 Double.isNaN=Double.prototype.isNaN;
 651 Clazz.defineMethod(Double,"isInfinite",
 652 function(num){
 653 return!isFinite(num);
 654 },"Number");
 655 Double.isInfinite=Double.prototype.isInfinite;
 656
 657 Clazz.defineMethod(Double,"parseDouble",
 658 function(s){
 659 if(s==null){
 660 throw new NumberFormatException("null");
 661 }
 662 if (typeof s == "number")return s;  // important -- typeof NaN is "number" and is OK here
 663 var doubleVal=Number(s);
 664 if(isNaN(doubleVal)){
 665 throw new NumberFormatException("Not a Number : "+s);
 666 }
 667 return doubleVal;
 668 },"String");
 669 Double.parseDouble=Double.prototype.parseDouble;
 670
 671 /*
 672 Clazz.defineMethod(Double,"$valueOf",
 673 function(s){
 674 return new Double(this.parseDouble(s));
 675 },"String");
 676 */
 677
 678 Clazz.defineMethod(Double,"$valueOf",
 679 function(v){
 680 return new Double(v);
 681 },"Number");
 682
 683 Double.$valueOf=Double.prototype.$valueOf;
 684
 685 Clazz.overrideMethod(Double,"equals",
 686 function(s){
 687 if(s==null||!Clazz.instanceOf(s,Double)){
 688 return false;
 689 }
 690 return s.valueOf()==this.valueOf();
 691 },"Object");
 692
 693
 694 //java.lang.B00lean = Boolean; ?? BH why this?
 695 Boolean = java.lang.Boolean = Boolean || function () {Clazz.instantialize (this, arguments);};
 696 if (Clazz._supportsNativeObject) {
 697         for (var i = 0; i < Clazz._extendedObjectMethods.length; i++) {
 698                 var p = Clazz._extendedObjectMethods[i];
 699                 Boolean.prototype[p] = Clazz._O.prototype[p];
 700         }
 701 }
 702 Boolean.__CLASS_NAME__="Boolean";
 703 Clazz.implementOf(Boolean,[java.io.Serializable,java.lang.Comparable]);
 704 Boolean.equals=Clazz._innerFunctions.equals;
 705 Boolean.getName=Clazz._innerFunctions.getName;
 706 Boolean.serialVersionUID=Boolean.prototype.serialVersionUID=-3665804199014368530;
 707
 708 //Clazz.makeConstructor(Boolean,
 709 //function(value){
 710 //this.valueOf=function(){
 711 //return value;
 712 //};
 713 //},"~B");
 714
 715 Clazz.overrideConstructor(Boolean,
 716 function(s){
 717         var b = ((typeof s == "string" ? Boolean.toBoolean(s) : s) ? true : false);
 718         this.valueOf=function(){return b;};
 719 },"~O");
 720
 721 Boolean.parseBoolean=Clazz.defineMethod(Boolean,"parseBoolean",
 722 function(s){
 723 return Boolean.toBoolean(s);
 724 },"~S");
 725 Clazz.defineMethod(Boolean,"booleanValue",
 726 function(){
 727 return this.valueOf();
 728 });
 729 Boolean.$valueOf=Clazz.overrideMethod(Boolean,"$valueOf",
 730 function(b){
 731 return((typeof b == "string"? "true".equalsIgnoreCase(b) : b)?Boolean.TRUE:Boolean.FALSE);
 732 });
 733
 734 /*
 735 Boolean.toString=Clazz.defineMethod(Boolean,"toString",
 736 function(b){
 737 return b?"true":"false";
 738 },"~B");
 739 */
 740
 741 Clazz.overrideMethod(Boolean,"toString",
 742 function(){
 743 return this.valueOf()?"true":"false";
 744 });
 745 Clazz.overrideMethod(Boolean,"hashCode",
 746 function(){
 747 return this.valueOf()?1231:1237;
 748 });
 749 Clazz.overrideMethod(Boolean,"equals",
 750 function(obj){
 751 if(Clazz.instanceOf(obj,Boolean)){
 752 return this.booleanValue()==obj.booleanValue();
 753 }return false;
 754 },"~O");
 755 Boolean.getBoolean=Clazz.defineMethod(Boolean,"getBoolean",
 756 function(name){
 757 var result=false;
 758 try{
 759 result=Boolean.toBoolean(System.getProperty(name));
 760 }catch(e){
 761 if(Clazz.instanceOf(e,IllegalArgumentException)){
 762 }else if(Clazz.instanceOf(e,NullPointerException)){
 763 }else{
 764 throw e;
 765 }
 766 }
 767 return result;
 768 },"~S");
 769 Clazz.overrideMethod(Boolean,"compareTo",
 770 function(b){
 771 return(b.value==this.value?0:(this.value?1:-1));
 772 },"Boolean");
 773 Boolean.toBoolean=Clazz.defineMethod(Boolean,"toBoolean",
 774 ($fz=function(name){
 775 return((name!=null)&&name.equalsIgnoreCase("true"));
 776 },$fz.isPrivate=true,$fz),"~S");
 777 Boolean.TRUE=Boolean.prototype.TRUE=new Boolean(true);
 778 Boolean.FALSE=Boolean.prototype.FALSE=new Boolean(false);
 779 Boolean.TYPE=Boolean.prototype.TYPE=Boolean;
 780
 781
 782 Clazz._Encoding=new Object();
 783
 784 (function(Encoding) {
 785
 786 Encoding.UTF8="utf-8";
 787 Encoding.UTF16="utf-16";
 788 Encoding.ASCII="ascii";
 789
 790
 791 Encoding.guessEncoding=function(str){
 792 if(str.charCodeAt(0)==0xEF&&str.charCodeAt(1)==0xBB&&str.charCodeAt(2)==0xBF){
 793 return Encoding.UTF8;
 794 }else if(str.charCodeAt(0)==0xFF&&str.charCodeAt(1)==0xFE){
 795 return Encoding.UTF16;
 796 }else{
 797 return Encoding.ASCII;
 798 }
 799 };
 800
 801 Encoding.readUTF8=function(str){
 802 var encoding=this.guessEncoding(str);
 803 var startIdx=0;
 804 if(encoding==Encoding.UTF8){
 805 startIdx=3;
 806 }else if(encoding==Encoding.UTF16){
 807 startIdx=2;
 808 }
 809 var arrs=new Array();
 810 for(var i=startIdx;i<str.length;i++){
 811 var charCode=str.charCodeAt(i);
 812 if(charCode<0x80){
 813 arrs[arrs.length]=str.charAt(i);
 814 }else if(charCode>0xc0&&charCode<0xe0){
 815 var c1=charCode&0x1f;
 816 i++;
 817 var c2=str.charCodeAt(i)&0x3f;
 818 var c=(c1<<6)+c2;
 819 arrs[arrs.length]=String.fromCharCode(c);
 820 }else if(charCode>=0xe0){
 821 var c1=charCode&0x0f;
 822 i++;
 823 var c2=str.charCodeAt(i)&0x3f;
 824 i++;
 825 var c3=str.charCodeAt(i)&0x3f;
 826 var c=(c1<<12)+(c2<<6)+c3;
 827 arrs[arrs.length]=String.fromCharCode(c);
 828 }
 829 }
 830 return arrs.join('');
 831 };
 832
 833 Encoding.convert2UTF8=function(str){
 834 var encoding=this.guessEncoding(str);
 835 var startIdx=0;
 836 if(encoding==Encoding.UTF8){
 837 return str;
 838 }else if(encoding==Encoding.UTF16){
 839 startIdx=2;
 840 }
 841
 842 var offset=0;
 843 var arrs=new Array(offset+str.length-startIdx);
 844
 845 for(var i=startIdx;i<str.length;i++){
 846 var charCode=str.charCodeAt(i);
 847 if(charCode<0x80){
 848 arrs[offset+i-startIdx]=str.charAt(i);
 849 }else if(charCode<=0x07ff){
 850 var c1=0xc0+((charCode&0x07c0)>>6);
 851 var c2=0x80+(charCode&0x003f);
 852 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2);
 853 }else{
 854 var c1=0xe0+((charCode&0xf000)>>12);
 855 var c2=0x80+((charCode&0x0fc0)>>6);
 856 var c3=0x80+(charCode&0x003f);
 857 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2)+String.fromCharCode(c3);
 858 }
 859 }
 860 return arrs.join('');
 861 };
 862 Encoding.base64Chars=new Array(
 863 'A','B','C','D','E','F','G','H',
 864 'I','J','K','L','M','N','O','P',
 865 'Q','R','S','T','U','V','W','X',
 866 'Y','Z','a','b','c','d','e','f',
 867 'g','h','i','j','k','l','m','n',
 868 'o','p','q','r','s','t','u','v',
 869 'w','x','y','z','0','1','2','3',
 870 '4','5','6','7','8','9','+','/'
 871 );
 872 Encoding.encodeBase64=function(str){
 873 if(str==null||str.length==0)return str;
 874 var b64=Encoding.base64Chars;
 875 var length=str.length;
 876 var index=0;
 877 var buf=[];
 878 var c0,c1,c2;
 879 while(index<length){
 880 c0=str.charCodeAt(index++);
 881 buf[buf.length]=b64[c0>>2];
 882 if(index<length){
 883 c1=str.charCodeAt(index++);
 884 buf[buf.length]=b64[((c0<<4)&0x30)|(c1>>4)];
 885 if(index<length){
 886 c2=str.charCodeAt(index++);
 887 buf[buf.length]=b64[((c1<<2)&0x3c)|(c2>>6)];
 888 buf[buf.length]=b64[c2&0x3F];
 889 }else{
 890 buf[buf.length]=b64[((c1<<2)&0x3c)];
 891 buf[buf.length]='=';
 892 }
 893 }else{
 894 buf[buf.length]=b64[(c0<<4)&0x30];
 895 buf[buf.length]='=';
 896 buf[buf.length]='=';
 897 }
 898 }
 899 return buf.join('');
 900 };
 901 Encoding.decodeBase64=function(str){
 902 if(str==null||str.length==0)return str;
 903 var b64=Encoding.base64Chars;
 904 var xb64=Encoding.xBase64Chars;
 905 if(Encoding.xBase64Chars==null){
 906 xb64=new Object();
 907 for(var i=0;i<b64.length;i++){
 908 xb64[b64[i]]=i;
 909 }
 910 Encoding.xBase64Chars=xb64;
 911 }
 912 var length=str.length;
 913 var index=0;
 914 var buf=[];
 915 var c0,c1,c2,c3;
 916 var c=0;
 917 while(index<length&&c++<60000){
 918 c0=xb64[str.charAt(index++)];
 919 c1=xb64[str.charAt(index++)];
 920 c2=xb64[str.charAt(index++)];
 921 c3=xb64[str.charAt(index++)];
 922 buf[buf.length]=String.fromCharCode(((c0<<2)&0xff)|c1>>4);
 923 if(c2!=null){
 924 buf[buf.length]=String.fromCharCode(((c1<<4)&0xff)|c2>>2);
 925 if(c3!=null){
 926 buf[buf.length]=String.fromCharCode(((c2<<6)&0xff)|c3);
 927 }
 928 }
 929 }
 930 return buf.join('');
 931 };
 932
 933 if(String.prototype.$replace==null){
 934 java.lang.String=String;
 935 if(Clazz._supportsNativeObject){
 936 for(var i=0;i<Clazz._extendedObjectMethods.length;i++){
 937 var p=Clazz._extendedObjectMethods[i];
 938 if("to$tring"==p||"toString"==p||"equals"==p||"hashCode"==p){
 939 continue;
 940 }
 941 String.prototype[p]=Clazz._O.prototype[p];
 942 }
 943 }
 944
 945 Clazz.implementOf(String,[java.io.Serializable,CharSequence,Comparable]);
 946
 947 String.getName=Clazz._innerFunctions.getName;
 948
 949 String.serialVersionUID=String.prototype.serialVersionUID=-6849794470754667710;
 950
 951
 952 ;(function(sp) {
 953
 954 sp.$replace=function(c1,c2){
 955         if (c1 == c2 || this.indexOf (c1) < 0) return "" + this;
 956         if (c1.length == 1) {
 957                 if ("\\$.*+|?^{}()[]".indexOf(c1) >= 0)         c1 = "\\" + c1;
 958         } else {
 959                 c1=c1.replace(/([\\\$\.\*\+\|\?\^\{\}\(\)\[\]])/g,function($0,$1){return"\\"+$1;});
 960         }
 961         return this.replace(new RegExp(c1,"gm"),c2);
 962 };
 963 sp.$generateExpFunction=function(str){
 964 var arr=[];
 965 var orders=[];
 966 var idx=0;
 967 arr[0]="";
 968 var i=0;
 969 for(;i<str.length;i++){
 970 var ch=str.charAt(i);
 971 if(i!=str.length-1&&ch=='\\'){
 972 i++;
 973 var c=str.charAt(i);
 974 if(c=='\\'){
 975 arr[idx]+='\\';
 976 }
 977 arr[idx]+=c;
 978 }else if(i!=str.length-1&&ch=='$'){
 979 i++;
 980 orders[idx]=parseInt(str.charAt(i));
 981 idx++;
 982 arr[idx]="";
 983 }else if(ch=='\r'){
 984 arr[idx]+="\\r";
 985 }else if(ch=='\n'){
 986 arr[idx]+="\\n";
 987 }else if(ch=='\t'){
 988 arr[idx]+="\\t";
 989 }else if(ch=='\"'){
 990 arr[idx]+="\\\"";
 991 }else{
 992 arr[idx]+=ch;
 993 }
 994 }
 995 var funStr="f = function (";
 996 var max=Math.max.apply({},orders);
 997 for(i=0;i<=max;i++){
 998 funStr+="$"+i;
 999 if(i!=max){
1000 funStr+=", ";
1001 }
1002 }
1003 funStr+=") { return ";
1004 for(i=0;i<arr.length-1;i++){
1005 funStr+="\""+arr[i]+"\" + $"+orders[i]+" + ";
1006 }
1007 funStr+="\""+arr[i]+"\"; }";
1008 var f=null;
1009 eval(funStr)
1010 return f;
1011 };
1012
1013 sp.replaceAll=function(exp,str){
1014 var regExp=new RegExp(exp,"gm");
1015 return this.replace(regExp,this.$generateExpFunction(str));
1016 };
1017 sp.replaceFirst=function(exp,str){
1018 var regExp=new RegExp(exp,"m");
1019 return this.replace(regExp,this.$generateExpFunction(str));
1020 };
1021 sp.matches=function(exp){
1022 if(exp!=null){
1023 exp="^("+exp+")$";
1024 }
1025 var regExp=new RegExp(exp,"gm");
1026 var m=this.match(regExp);
1027 return m!=null&&m.length!=0;
1028 };
1029 sp.regionMatches=function(ignoreCase,toffset,
1030 other,ooffset,len){
1031
1032 if(typeof ignoreCase=="number"
1033 ||(ignoreCase!=true&&ignoreCase!=false)){
1034 len=ooffset;
1035 ooffset=other;
1036 other=toffset;
1037 toffset=ignoreCase;
1038 ignoreCase=false;
1039 }
1040 var to=toffset;
1041 var po=ooffset;
1042
1043 if((ooffset<0)||(toffset<0)||(toffset>this.length-len)||
1044 (ooffset>other.length-len)){
1045 return false;
1046 }
1047 var s1=this.substring(toffset,toffset+len);
1048 var s2=other.substring(ooffset,ooffset+len);
1049 if(ignoreCase){
1050 s1=s1.toLowerCase();
1051 s2=s2.toLowerCase();
1052 }
1053 return s1==s2;
1054 };
1055
1056
1057
1058 sp.$plit=function(regex,limit){
1059 if (!limit && regex == " ")
1060         return this.split(regex);
1061
1062 if(limit!=null&&limit>0){
1063 if(limit==1){
1064 return this;
1065 }
1066 var regExp=new RegExp("("+regex+")","gm");
1067 var count=1;
1068 var s=this.replace(regExp,function($0,$1){
1069 count++;
1070 if(count==limit){
1071 return"@@_@@";
1072 }else if(count>limit){
1073 return $0;
1074 }else{
1075 return $0;
1076 }
1077 });
1078 regExp=new RegExp(regex,"gm");
1079 var arr=this.split(regExp);
1080 if(arr.length>limit){
1081 arr[limit-1]=s.substring(s.indexOf("@@_@@")+5);
1082 arr.length=limit;
1083 }
1084 return arr;
1085 }else{
1086 var regExp=new RegExp(regex,"gm");
1087 return this.split(regExp);
1088 }
1089 };
1090 /*
1091 sp.trim=function(){
1092 var len=this.length;
1093 var st=0;
1094
1095 while((st<len)&&(this.charAt(st)<=' ')){
1096 st++;
1097 }
1098 while((st<len)&&(this.charAt(len-1)<=' ')){
1099 len--;
1100 }
1101 return((st>0)||(len<len))?this.substring(st,len):this;
1102 };
1103
1104
1105 */
1106
1107 if (!sp.trim)
1108 sp.trim=function(){
1109 return this.replace(/^\s+/g,'').replace(/\s+$/g,'');
1110 };
1111
1112 if (!sp.startsWith || !sp.endsWith) {
1113 var sn=function(s, prefix,toffset){
1114 var to=toffset;
1115 var po=0;
1116 var pc=prefix.length;
1117
1118 if((toffset<0)||(toffset>s.length-pc)){
1119 return false;
1120 }
1121 while(--pc>=0){
1122 if(s.charAt(to++)!=prefix.charAt(po++)){
1123 return false;
1124 }
1125 }
1126 return true;
1127 };
1128
1129 sp.startsWith=function(prefix){
1130 if(arguments.length==1){
1131 return sn(this,arguments[0],0);
1132 }else if(arguments.length==2){
1133 return sn(this,arguments[0],arguments[1]);
1134 }else{
1135 return false;
1136 }
1137 };
1138
1139 sp.endsWith=function(suffix){
1140 return sn(this, suffix,this.length-suffix.length);
1141 };
1142
1143 }
1144
1145 sp.equals=function(anObject){
1146 return this.valueOf()==anObject;
1147 };
1148
1149 sp.equalsIgnoreCase=function(anotherString){
1150 return(anotherString==null)?false:(this==anotherString
1151 ||this.toLowerCase()==anotherString.toLowerCase());
1152 };
1153
1154
1155 sp.hash=0;
1156
1157 sp.hashCode=function(){
1158 var h=this.hash;
1159 if(h==0){
1160 var off=0;
1161 var len=this.length;
1162 for(var i=0;i<len;i++){
1163 h=31*h+this.charCodeAt(off++);
1164 h&=0xffffffff;
1165 }
1166 this.hash=h;
1167 }
1168 return h;
1169 };
1170
1171 sp.getBytes=function(){
1172 if(arguments.length==4){
1173 return this.getChars(arguments[0],arguments[1],arguments[2],arguments[3]);
1174 }
1175 var s=this;
1176 if(arguments.length==1){
1177 var cs=arguments[0].toString().toLowerCase();
1178 var charset=[
1179 "utf-8","UTF8","us-ascii","iso-8859-1","8859_1","gb2312","gb18030","gbk"
1180 ];
1181 var existed=false;
1182 for(var i=0;i<charset.length;i++){
1183 if(charset[i]==cs){
1184 existed=true;
1185 break;
1186 }
1187 }
1188 if(!existed){
1189 throw new java.io.UnsupportedEncodingException();
1190 }
1191 if(cs=="utf-8"||cs=="utf8"){
1192 s=Encoding.convert2UTF8(this);
1193 }
1194 }
1195 var arrs=new Array(s.length);
1196 var c=0,ii=0;
1197 for(var i=0;i<s.length;i++){
1198 c=s.charCodeAt(i);
1199 if(c>255){
1200 arrs[ii]=0x1a;
1201 arrs[ii+1]=c&0xff;
1202 arrs[ii+2]=(c&0xff00)>>8;
1203 ii+=2;
1204 }else{
1205 arrs[ii]=c;
1206 }
1207 ii++;
1208 }
1209 return arrs;
1210 };
1211
1212 /*
1213 sp.compareTo=function(anotherString){
1214 if(anotherString==null){
1215 throw new java.lang.NullPointerException();
1216 }
1217 var len1=this.length;
1218 var len2=anotherString.length;
1219 var n=Math.min(len1,len2);
1220 var k=0;
1221 while(k<n){
1222 var c1=this.charCodeAt(k);
1223 var c2=anotherString.charCodeAt(k);
1224 if(c1!=c2){
1225 return c1-c2;
1226 }
1227 k++;
1228 }
1229 return len1-len2;
1230 };
1231
1232 */
1233
1234 sp.contains = function(a) {return this.indexOf(a) >= 0}  // bh added
1235 sp.compareTo = function(a){return this > a ? 1 : this < a ? -1 : 0} // bh added
1236
1237
1238
1239 sp.toCharArray=function(){
1240 var result=new Array(this.length);
1241 for(var i=0;i<this.length;i++){
1242 result[i]=this.charAt(i);
1243 }
1244 return result;
1245 };
1246 String.value0f=String.valueOf;
1247 String.valueOf=function(o){
1248 if(o=="undefined"){
1249 return String.value0f();
1250 }
1251 if(o instanceof Array){
1252 if(arguments.length==1){
1253 return o.join('');
1254 }else{
1255 var off=arguments[1];
1256 var len=arguments[2];
1257 var oo=new Array(len);
1258 for(var i=0;i<len;i++){
1259 oo[i]=o[off+i];
1260 }
1261 return oo.join('');
1262 }
1263 }
1264 return""+o;
1265 };
1266
1267 sp.subSequence=function(beginIndex,endIndex){
1268 return this.substring(beginIndex,endIndex);
1269 };
1270
1271 sp.compareToIgnoreCase=function(str){
1272 if(str==null){
1273 throw new NullPointerException();
1274 }
1275 var s1=this.toUpperCase();
1276 var s2=str.toUpperCase();
1277 if(s1==s2){
1278 return 0;
1279 }else{
1280 var s1=this.toLowerCase();
1281 var s2=str.toLowerCase();
1282 if(s1==s2){
1283 return 0;
1284 }else if(s1>s2){
1285 return 1;
1286 }else{
1287 return-1;
1288 }
1289 }
1290 };
1291
1292 sp.contentEquals=function(sb){
1293 if(this.length!=sb.length()){
1294 return false;
1295 }
1296 var v=sb.getValue();
1297 var i=0;
1298 var j=0;
1299 var n=this.length;
1300 while(n--!=0){
1301 if(this.charCodeAt(i++)!=v[j++]){
1302 return false;
1303 }
1304 }
1305 return true;
1306 };
1307
1308 sp.getChars=function(srcBegin,srcEnd,dst,dstBegin){
1309 if(srcBegin<0){
1310 throw new StringIndexOutOfBoundsException(srcBegin);
1311 }
1312 if(srcEnd>this.length){
1313 throw new StringIndexOutOfBoundsException(srcEnd);
1314 }
1315 if(srcBegin>srcEnd){
1316 throw new StringIndexOutOfBoundsException(srcEnd-srcBegin);
1317 }
1318 if(dst==null){
1319 throw new NullPointerException();
1320 }
1321 for(var i=0;i<srcEnd-srcBegin;i++){
1322 dst[dstBegin+i]=this.charAt(srcBegin+i);
1323 }
1324 };
1325 sp.$concat=sp.concat;
1326 sp.concat=function(s){
1327 if(s==null){
1328 throw new NullPointerException();
1329 }
1330 return this.$concat(s);
1331 };
1332
1333 sp.$lastIndexOf=sp.lastIndexOf;
1334 sp.lastIndexOf=function(s,last){
1335 if(last!=null&&last+this.length<=0){
1336 return-1;
1337 }
1338 if(last!=null){
1339 return this.$lastIndexOf(s,last);
1340 }else{
1341 return this.$lastIndexOf(s);
1342 }
1343 };
1344
1345 sp.intern=function(){
1346 return this.valueOf();
1347 };
1348 String.copyValueOf=sp.copyValueOf=function(){
1349 if(arguments.length==1){
1350 return String.instantialize(arguments[0]);
1351 }else{
1352 return String.instantialize(arguments[0],arguments[1],arguments[2]);
1353 }
1354 };
1355
1356 sp.codePointAt || (sp.codePointAt = sp.charCodeAt); // Firefox only
1357
1358
1359 })(String.prototype);
1360
1361 /*
1362
1363 String.indexOf=function(source,sourceOffset,sourceCount,
1364 target,targetOffset,targetCount,fromIndex){
1365 if(fromIndex>=sourceCount){
1366 return(targetCount==0?sourceCount:-1);
1367 }
1368 if(fromIndex<0){
1369 fromIndex=0;
1370 }
1371 if(targetCount==0){
1372 return fromIndex;
1373 }
1374
1375 var first=target[targetOffset];
1376 var i=sourceOffset+fromIndex;
1377 var max=sourceOffset+(sourceCount-targetCount);
1378
1379 startSearchForFirstChar:
1380 while(true){
1381
1382 while(i<=max&&source[i]!=first){
1383 i++;
1384 }
1385 if(i>max){
1386 return-1;
1387 }
1388
1389
1390 var j=i+1;
1391 var end=j+targetCount-1;
1392 var k=targetOffset+1;
1393 while(j<end){
1394 if(source[j++]!=target[k++]){
1395 i++;
1396
1397 continue startSearchForFirstChar;
1398 }
1399 }
1400 return i-sourceOffset;
1401 }
1402 };
1403
1404
1405
1406 String.instantialize=function(){
1407 if(arguments.length==0){
1408 return new String();
1409 }else if(arguments.length==1){
1410 var x=arguments[0];
1411 if(typeof x=="string"||x instanceof String){
1412 return new String(x);
1413 }else if(x instanceof Array){
1414 if(x.length>0&&typeof x[0]=="number"){
1415 var arr=new Array(x.length);
1416 for(var i=0;i<x.length;i++){
1417 arr[i]=String.fromCharCode(x[i]&0xff);
1418 }
1419 return Encoding.readUTF8(arr.join(''));
1420 }
1421 return x.join('');
1422 }else if(x.__CLASS_NAME__=="StringBuffer"
1423 ||x.__CLASS_NAME__=="java.lang.StringBuffer"){
1424 var value=x.shareValue();
1425 var length=x.length();
1426 var valueCopy=new Array(length);
1427 for(var i=0;i<length;i++){
1428 valueCopy[i]=value[i];
1429 }
1430 return valueCopy.join('')
1431
1432 }else{
1433 return""+x;
1434 }
1435 }else if(arguments.length==2){
1436 var x=arguments[0];
1437 var hibyte=arguments[1];
1438 if(typeof hibyte=="string"){
1439 return String.instantialize(x,0,x.length,hibyte);
1440 }else{
1441 return String.instantialize(x,hibyte,0,x.length);
1442 }
1443 }else if(arguments.length==3){
1444 var bytes=arguments[0];
1445 var offset=arguments[1];
1446 var length=arguments[2];
1447 if(arguments[2]instanceof Array){
1448 bytes=arguments[2];
1449 offset=arguments[0];
1450 length=arguments[1];
1451 }
1452 var arr=new Array(length);
1453 if(offset<0||length+offset>bytes.length){
1454 throw new IndexOutOfBoundsException();
1455 }
1456 if(length>0){
1457 var isChar=(bytes[offset].length!=null);
1458 if(isChar){
1459 for(var i=0;i<length;i++){
1460 arr[i]=bytes[offset+i];
1461 }
1462 }else{
1463 for(var i=0;i<length;i++){
1464 arr[i]=String.fromCharCode(bytes[offset+i]);
1465 }
1466 }
1467 }
1468 return arr.join('');
1469 }else if(arguments.length==4){
1470 var bytes=arguments[0];
1471 var y=arguments[3];
1472 if(typeof y=="string"||y instanceof String){
1473 var offset=arguments[1];
1474 var length=arguments[2];
1475 var arr=new Array(length);
1476 for(var i=0;i<length;i++){
1477 arr[i]=bytes[offset+i];
1478 if(typeof arr[i]=="number"){
1479 arr[i]=String.fromCharCode(arr[i]&0xff);
1480 }
1481 }
1482 var cs=y.toLowerCase();
1483 if(cs=="utf-8"||cs=="utf8"){
1484 return Encoding.readUTF8(arr.join(''));
1485 }else{
1486 return arr.join('');
1487 }
1488 }else{
1489 var count=arguments[3];
1490 var offset=arguments[2];
1491 var hibyte=arguments[1];
1492 var value=new Array(count);
1493 if(hibyte==0){
1494 for(var i=count;i-->0;){
1495 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
1496 }
1497 }else{
1498 hibyte<<=8;
1499 for(var i=count;i-->0;){
1500 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
1501 }
1502 }
1503 return value.join('');
1504 }
1505 }else{
1506 var s="";
1507 for(var i=0;i<arguments.length;i++){
1508 s+=arguments[i];
1509 }
1510 return s;
1511 }
1512 };
1513
1514
1515 */
1516
1517
1518 String.instantialize=function(){
1519 switch (arguments.length) {
1520 case 0:
1521         return new String();
1522 case 1:
1523         var x=arguments[0];
1524         if(typeof x=="string"||x instanceof String){
1525                 return new String(x);
1526         }
1527         if(x instanceof Array || x instanceof Int32Array){
1528                 if(x.length == 0)
1529                         return "";
1530                 if(typeof x[0]!="number")
1531                         return x.join('');
1532                 var arr=new Array(x.length);
1533                 for(var i=0;i<x.length;i++)
1534                         arr[i]=String.fromCharCode(x[i]&0xff);
1535                 return Encoding.readUTF8(arr.join(''));
1536         }
1537         if(x.__CLASS_NAME__=="StringBuffer"||x.__CLASS_NAME__=="java.lang.StringBuffer"){
1538                 var value=x.shareValue();
1539                 var length=x.length();
1540                 var valueCopy=new Array(length);
1541                 for(var i=0;i<length;i++){
1542                         valueCopy[i]=value[i];
1543                 }
1544                 return valueCopy.join('')
1545         }
1546         return""+x;
1547 case 2:
1548         var x=arguments[0];
1549         var hibyte=arguments[1];
1550         if(typeof hibyte=="string"){
1551                 return String.instantialize(x,0,x.length,hibyte);
1552         }
1553         return String.instantialize(x,hibyte,0,x.length);
1554 case 3:
1555         var bytes=arguments[0];
1556         var offset=arguments[1];
1557         var length=arguments[2];
1558         if(arguments[2]instanceof Array){
1559                 bytes=arguments[2];
1560                 offset=arguments[0];
1561                 length=arguments[1];
1562         }
1563         var arr=new Array(length);
1564         if(offset<0||length+offset>bytes.length){
1565                 throw new IndexOutOfBoundsException();
1566         }
1567         if(length>0){
1568                 var isChar=(bytes[offset].length!=null);
1569                 if(isChar){
1570                         for(var i=0;i<length;i++){
1571                                 arr[i]=bytes[offset+i];
1572                         }
1573                 }else{
1574                         for(var i=0;i<length;i++){
1575                                 arr[i]=String.fromCharCode(bytes[offset+i]);
1576                         }
1577                 }
1578         }
1579         return arr.join('');
1580 case 4:
1581         var bytes=arguments[0];
1582         var y=arguments[3];
1583         if(typeof y=="string"||y instanceof String){
1584                 var offset=arguments[1];
1585                 var length=arguments[2];
1586                 var arr=new Array(length);
1587                 for(var i=0;i<length;i++){
1588                         arr[i]=bytes[offset+i];
1589                         if(typeof arr[i]=="number"){
1590                                 arr[i]=String.fromCharCode(arr[i]&0xff);
1591                         }
1592                 }
1593                 var cs=y.toLowerCase();
1594                 if(cs=="utf-8"||cs=="utf8"){
1595                         return Encoding.readUTF8(arr.join(''));
1596                 }
1597                 return arr.join('');
1598         }
1599         var count=arguments[3];
1600         var offset=arguments[2];
1601         var hibyte=arguments[1];
1602         var value=new Array(count);
1603         if(hibyte==0){
1604                 for(var i=count;i-->0;){
1605                         value[i]=String.fromCharCode(bytes[i+offset]&0xff);
1606                 }
1607         }else{
1608                 hibyte<<=8;
1609                 for(var i=count;i-->0;){
1610                         value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
1611                 }
1612         }
1613         return value.join('');
1614 default:
1615         var s="";
1616         for(var i=0;i<arguments.length;i++){
1617                 s+=arguments[i];
1618         }
1619         return s;
1620 }
1621 };
1622
1623 if(navigator.userAgent.toLowerCase().indexOf("chrome")!=-1){
1624         String.prototype.toString=function(){return this.valueOf();};
1625 }
1626
1627 }
1628
1629 })(Clazz._Encoding);
1630
1631
1632
1633 c$=Clazz.decorateAsClass(function(){
1634 this.value=0;
1635 Clazz.instantialize(this,arguments);
1636 },java.lang,"Character",null,[java.io.Serializable,Comparable]);
1637 Clazz.makeConstructor(c$,
1638 function(value){
1639 this.value=value;
1640 },"~N");
1641 Clazz.defineMethod(c$,"charValue",
1642 function(){
1643 return this.value;
1644 });
1645 Clazz.overrideMethod(c$,"hashCode",
1646 function(){
1647 return(this.value).charCodeAt(0);
1648 });
1649 Clazz.overrideMethod(c$,"equals",
1650 function(obj){
1651 if(Clazz.instanceOf(obj,Character)){
1652 return(this.value).charCodeAt(0)==((obj).charValue()).charCodeAt(0);
1653 }return false;
1654 },"~O");
1655 Clazz.overrideMethod(c$,"compareTo",
1656 function(c){
1657 return(this.value).charCodeAt(0)-(c.value).charCodeAt(0);
1658 },"Character");
1659 c$.toLowerCase=Clazz.defineMethod(c$,"toLowerCase",
1660 function(c){
1661 return(""+c).toLowerCase().charAt(0);
1662 },"~N");
1663 c$.toUpperCase=Clazz.defineMethod(c$,"toUpperCase",
1664 function(c){
1665 return(""+c).toUpperCase().charAt(0);
1666 },"~N");
1667 c$.isDigit=Clazz.defineMethod(c$,"isDigit",
1668 function(c){
1669 c = c.charCodeAt(0);
1670 return (48 <= c && c <= 57);
1671 },"~N");
1672 c$.isUpperCase=Clazz.defineMethod(c$,"isUpperCase",
1673 function(c){
1674 c = c.charCodeAt(0);
1675 return (65 <= c && c <= 90);
1676 },"~N");
1677 c$.isLowerCase=Clazz.defineMethod(c$,"isLowerCase",
1678 function(c){
1679 c = c.charCodeAt(0);
1680 return (97 <= c && c <= 122);
1681 },"~N");
1682 c$.isWhitespace=Clazz.defineMethod(c$,"isWhitespace",
1683 function(c){
1684 c = (c).charCodeAt(0);
1685 return (c >= 0x1c && c <= 0x20 || c >= 0x9 && c <= 0xd || c == 0x1680
1686         || c >= 0x2000 && c != 0x2007 && (c <= 0x200b || c == 0x2028 || c == 0x2029 || c == 0x3000));
1687 },"~N");
1688 c$.isLetter=Clazz.defineMethod(c$,"isLetter",
1689 function(c){
1690 c = c.charCodeAt(0);
1691 return (65 <= c && c <= 90 || 97 <= c && c <= 122);
1692 },"~N");
1693 c$.isLetterOrDigit=Clazz.defineMethod(c$,"isLetterOrDigit",
1694 function(c){
1695 c = c.charCodeAt(0);
1696 return (65 <= c && c <= 90 || 97 <= c && c <= 122 || 48 <= c && c <= 57);
1697 },"~N");
1698 c$.isSpaceChar=Clazz.defineMethod(c$,"isSpaceChar",
1699 function(c){
1700  var i = c.charCodeAt(0);
1701 if(i==0x20||i==0xa0||i==0x1680)return true;
1702 if(i<0x2000)return false;
1703 return i<=0x200b||i==0x2028||i==0x2029||i==0x202f||i==0x3000;
1704 },"~N");
1705 c$.digit=Clazz.defineMethod(c$,"digit",
1706 function(c,radix){
1707 var i = c.charCodeAt(0);
1708 if(radix >= 2 && radix <= 36){
1709         if(i < 128){
1710                 var result = -1;
1711                 if(48 <= i && i <= 57){
1712                 result = i - 48;
1713                 }else if(97 <= i && i <= 122){
1714                 result = i - 87;
1715                 }else if(65 <= i && i <= 90){
1716                 result=i-(55);
1717                 }
1718                 return (result < radix ? result : -1);
1719         }
1720 }
1721 return -1;
1722 },"~N,~N");
1723 Clazz.overrideMethod(c$,"toString",
1724 function(){
1725 var buf=[this.value];
1726 return String.valueOf(buf);
1727 });
1728 c$.toString=Clazz.overrideMethod(c$,"toString",
1729 function(c){
1730 {
1731 if(this===Character){
1732 return"class java.lang.Character";
1733 }
1734 }return String.valueOf(c);
1735 },"~N");
1736 Clazz.defineStatics(c$,
1737 "MIN_VALUE",'\u0000',
1738 "MAX_VALUE",'\uffff',
1739 "MIN_RADIX",2,
1740 "MAX_RADIX",36,
1741 "TYPE",null);
1742
1743 java.lang.Character.TYPE=java.lang.Character.prototype.TYPE=java.lang.Character;
1744
1745
1746
1747 Clazz._ArrayWrapper = function(a, type) {
1748  return {
1749    a: a,
1750    __CLASS_NAME__:"Array",
1751    superClazz: Array,
1752    getComponentType: function() {return type},
1753    instanceOf: function(o) { return  Clazz.instanceOf(type, o) },
1754    getName: function() { return this.__CLASS_NAME__ }
1755  };
1756 }
1757 c$=Clazz_declareType(java.lang.reflect,"Array");
1758 c$.newInstance=Clazz_defineMethod(c$,"newInstance",
1759 function(componentType,size){
1760 var a = Clazz_newArray(size);
1761  a.getClass = function() { return new Clazz._ArrayWrapper(this, componentType);};
1762 return a;
1763 },"Class,~N");
1764
1765 javautil.Date=Date;
1766 Date.TYPE="javautil.Date";
1767 Date.__CLASS_NAME__="Date";
1768 Clazz.implementOf(Date,[java.io.Serializable,java.lang.Comparable]);
1769
1770 Clazz.defineMethod(javautil.Date,"clone",
1771 function(){
1772 return new Date(this.getTime());
1773 });
1774
1775 Clazz.defineMethod(javautil.Date,"before",
1776 function(when){
1777 return this.getTime()<when.getTime();
1778 },"javautil.Date");
1779 Clazz.defineMethod(javautil.Date,"after",
1780 function(when){
1781 return this.getTime()>when.getTime();
1782 },"javautil.Date");
1783 Clazz.defineMethod(javautil.Date,"equals",
1784 function(obj){
1785 return Clazz.instanceOf(obj,javautil.Date)&&this.getTime()==(obj).getTime();
1786 },"Object");
1787 Clazz.defineMethod(javautil.Date,"compareTo",
1788 function(anotherDate){
1789 var thisTime=this.getTime();
1790 var anotherTime=anotherDate.getTime();
1791 return(thisTime<anotherTime?-1:(thisTime==anotherTime?0:1));
1792 },"javautil.Date");
1793 Clazz.defineMethod(javautil.Date,"compareTo",
1794 function(o){
1795 return this.compareTo(o);
1796 },"Object");
1797 Clazz.overrideMethod(javautil.Date,"hashCode",
1798 function(){
1799 var ht=this.getTime();
1800 return parseInt(ht)^parseInt((ht>>32));
1801 });
1802
1803 c$=Clazz.decorateAsClass(function(){
1804 this.source=null;
1805 Clazz.instantialize(this,arguments);
1806 },javautil,"EventObject",null,java.io.Serializable);
1807 Clazz.makeConstructor(c$,
1808 function(source){
1809 if(source!=null)this.source=source;
1810 else throw new IllegalArgumentException();
1811 },"~O");
1812 Clazz.defineMethod(c$,"getSource",
1813 function(){
1814 return this.source;
1815 });
1816 Clazz.overrideMethod(c$,"toString",
1817 function(){
1818 return this.getClass().getName()+"[source="+String.valueOf(this.source)+']';
1819 });
1820 Clazz.declareInterface(javautil,"EventListener");
1821
1822 c$=Clazz.decorateAsClass(function(){
1823 this.listener=null;
1824 Clazz.instantialize(this,arguments);
1825 },javautil,"EventListenerProxy",null,javautil.EventListener);
1826 Clazz.makeConstructor(c$,
1827 function(listener){
1828 this.listener=listener;
1829 },"javautil.EventListener");
1830 Clazz.defineMethod(c$,"getListener",
1831 function(){
1832 return this.listener;
1833 });
1834 Clazz.declareInterface(javautil,"Iterator");
1835
1836 Clazz.declareInterface(javautil,"ListIterator",javautil.Iterator);
1837 Clazz.declareInterface(javautil,"Enumeration");
1838 Clazz.declareInterface(javautil,"Collection",Iterable);
1839
1840 Clazz.declareInterface(javautil,"Set",javautil.Collection);
1841 Clazz.declareInterface(javautil,"Map");
1842 Clazz.declareInterface(javautil.Map,"Entry");
1843
1844 Clazz.declareInterface(javautil,"List",javautil.Collection);
1845
1846 Clazz.declareInterface(javautil,"Queue",javautil.Collection);
1847 Clazz.declareInterface(javautil,"RandomAccess");
1848 c$=Clazz.decorateAsClass(function(){
1849 this.detailMessage=null;
1850 this.cause=null;
1851 this.stackTrace=null;
1852 Clazz.instantialize(this,arguments);
1853 },java.lang,"Throwable",null,java.io.Serializable);
1854 Clazz.prepareFields(c$,function(){
1855 this.cause=this;
1856 //alert("e0 "+ arguments.callee.caller.caller.caller.caller.caller)
1857 });
1858 Clazz.makeConstructor(c$,
1859 function(){
1860 this.fillInStackTrace();
1861 });
1862 Clazz.makeConstructor(c$,
1863 function(message){
1864 this.fillInStackTrace();
1865 this.detailMessage=message;
1866 },"~S");
1867 Clazz.makeConstructor(c$,
1868 function(message,cause){
1869 this.fillInStackTrace();
1870 this.detailMessage=message;
1871 this.cause=cause;
1872 },"~S,Throwable");
1873 Clazz.makeConstructor(c$,
1874 function(cause){
1875 this.fillInStackTrace();
1876 this.detailMessage=(cause==null?null:cause.toString());
1877 this.cause=cause;
1878 },"Throwable");
1879 Clazz.defineMethod(c$,"getMessage",
1880 function(){
1881 return (this.message || this.detailMessage || this.toString());
1882 });
1883 Clazz.defineMethod(c$,"getLocalizedMessage",
1884 function(){
1885 return this.getMessage();
1886 });
1887 Clazz.defineMethod(c$,"getCause",
1888 function(){
1889 return(this.cause===this?null:this.cause);
1890 });
1891 Clazz.defineMethod(c$,"initCause",
1892 function(cause){
1893 if(this.cause!==this)throw new IllegalStateException("Can't overwrite cause");
1894 if(cause===this)throw new IllegalArgumentException("Self-causation not permitted");
1895 this.cause=cause;
1896 return this;
1897 },"Throwable");
1898 Clazz.overrideMethod(c$,"toString",
1899 function(){
1900 var s=this.getClass().getName();
1901 var message=this.message || this.detailMessage;
1902 return(message ? s+": "+message : s);
1903 });
1904 Clazz.defineMethod(c$,"printStackTrace",
1905 function(){
1906 System.err.println(this.getStackTrace ? this.getStackTrace() : this.message + " " + Clazz.getStackTrace());
1907 });
1908
1909 Clazz.defineMethod(c$,"getStackTrace",
1910 function(){
1911 var s = "" + this + "\n";
1912 for(var i=0;i<this.stackTrace.length;i++){
1913  var t=this.stackTrace[i];
1914         var x=t.methodName.indexOf("(");
1915         var n=t.methodName.substring(0,x).replace(/\s+/g,"");
1916         if(n!="construct"||t.nativeClazz==null
1917                  ||Clazz.getInheritedLevel(t.nativeClazz,Throwable)<0){
1918                                 s += t + "\n";
1919         }
1920 }
1921 return s;
1922 });
1923
1924
1925 Clazz.defineMethod(c$,"printStackTrace",
1926 function(s){
1927 this.printStackTrace();
1928 },"java.io.PrintStream");
1929 Clazz.defineMethod(c$,"printStackTrace",
1930 function(s){
1931 this.printStackTrace();
1932 },"java.io.PrintWriter");
1933 Clazz.defineMethod(c$,"fillInStackTrace",
1934 function(){
1935 this.stackTrace=new Array();
1936 var caller=arguments.callee.caller;
1937 var superCaller=null;
1938 var callerList=new Array();
1939 var index=Clazz._callingStackTraces.length-1;
1940 var noLooping=true;
1941 while(index>-1||caller!=null){
1942 var clazzName=null;
1943 var nativeClass=null;
1944 if(!noLooping||caller==Clazz.tryToSearchAndExecute||caller==Clazz.superCall||caller==null){
1945 if(index<0){
1946 break;
1947 }
1948 noLooping=true;
1949 superCaller=Clazz._callingStackTraces[index].caller;
1950 nativeClass=Clazz._callingStackTraces[index].owner;
1951 index--;
1952 }else{
1953 superCaller=caller;
1954 if(superCaller.claxxOwner!=null){
1955 nativeClass=superCaller.claxxOwner;
1956 }else if(superCaller.exClazz!=null){
1957 nativeClass=superCaller.exClazz;
1958 }
1959 }
1960 var st=new StackTraceElement(
1961 ((nativeClass!=null&&nativeClass.__CLASS_NAME__.length!=0)?
1962 nativeClass.__CLASS_NAME__:"anonymous"),
1963 ((superCaller.exName==null)?"anonymous":superCaller.exName)
1964 +" ("+Clazz.getParamsType(superCaller.arguments)+")",
1965 null,-1);
1966 st.nativeClazz=nativeClass;
1967 this.stackTrace[this.stackTrace.length]=st;
1968 for(var i=0;i<callerList.length;i++){
1969 if(callerList[i]==superCaller){
1970
1971 var st=new StackTraceElement("lost","missing",null,-3);
1972 st.nativeClazz=null;
1973 this.stackTrace[this.stackTrace.length]=st;
1974 noLooping=false;
1975
1976 }
1977 }
1978 if(superCaller!=null){
1979 callerList[callerList.length]=superCaller;
1980 }
1981 caller=superCaller.arguments.callee.caller;
1982 }
1983 Clazz._initializingException=false;
1984 return this;
1985 });
1986 Clazz.defineMethod(c$,"setStackTrace",
1987 function(stackTrace){
1988 var defensiveCopy=stackTrace.clone();
1989 for(var i=0;i<defensiveCopy.length;i++)if(defensiveCopy[i]==null)throw new NullPointerException("stackTrace["+i+"]");
1990
1991 this.stackTrace=defensiveCopy;
1992 },"~A");
1993
1994 c$=Clazz.decorateAsClass(function(){
1995 this.declaringClass=null;
1996 this.methodName=null;
1997 this.fileName=null;
1998 this.lineNumber=0;
1999 Clazz.instantialize(this,arguments);
2000 },java.lang,"StackTraceElement",null,java.io.Serializable);
2001 Clazz.makeConstructor(c$,
2002 function(cls,method,file,line){
2003 if(cls==null||method==null){
2004 throw new NullPointerException();
2005 }this.declaringClass=cls;
2006 this.methodName=method;
2007 this.fileName=file;
2008 this.lineNumber=line;
2009 },"~S,~S,~S,~N");
2010 Clazz.overrideMethod(c$,"equals",
2011 function(obj){
2012 if(!(Clazz.instanceOf(obj,StackTraceElement))){
2013 return false;
2014 }var castObj=obj;
2015 if((this.methodName==null)||(castObj.methodName==null)){
2016 return false;
2017 }if(!this.getMethodName().equals(castObj.getMethodName())){
2018 return false;
2019 }if(!this.getClassName().equals(castObj.getClassName())){
2020 return false;
2021 }var localFileName=this.getFileName();
2022 if(localFileName==null){
2023 if(castObj.getFileName()!=null){
2024 return false;
2025 }}else{
2026 if(!localFileName.equals(castObj.getFileName())){
2027 return false;
2028 }}if(this.getLineNumber()!=castObj.getLineNumber()){
2029 return false;
2030 }return true;
2031 },"~O");
2032 Clazz.defineMethod(c$,"getClassName",
2033 function(){
2034 return(this.declaringClass==null)?"<unknown class>":this.declaringClass;
2035 });
2036 Clazz.defineMethod(c$,"getFileName",
2037 function(){
2038 return this.fileName;
2039 });
2040 Clazz.defineMethod(c$,"getLineNumber",
2041 function(){
2042 return this.lineNumber;
2043 });
2044 Clazz.defineMethod(c$,"getMethodName",
2045 function(){
2046 return(this.methodName==null)?"<unknown method>":this.methodName;
2047 });
2048 Clazz.overrideMethod(c$,"hashCode",
2049 function(){
2050 if(this.methodName==null){
2051 return 0;
2052 }return this.methodName.hashCode()^this.declaringClass.hashCode();
2053 });
2054 Clazz.defineMethod(c$,"isNativeMethod",
2055 function(){
2056 return this.lineNumber==-2;
2057 });
2058 Clazz.overrideMethod(c$,"toString",
2059 function(){
2060 var buf=new StringBuilder(80);
2061 buf.append(this.getClassName());
2062 buf.append('.');
2063 buf.append(this.getMethodName());
2064 if(this.isNativeMethod()){
2065 buf.append("(Native Method)");
2066 }else{
2067 var fName=this.getFileName();
2068 if(fName==null){
2069 buf.append("(Unknown Source)");
2070 }else{
2071 var lineNum=this.getLineNumber();
2072 buf.append('(');
2073 buf.append(fName);
2074 if(lineNum>=0){
2075 buf.append(':');
2076 buf.append(lineNum);
2077 }buf.append(')');
2078 }}return buf.toString();
2079 });
2080 TypeError.prototype.getMessage || (TypeError.prototype.getMessage = function(){ return (this.message || this.toString()) + (this.getStackTrace ? this.getStackTrace() : Clazz.getStackTrace())});
2081 c$=Clazz.declareType(java.lang,"Error",Throwable);
2082
2083 c$=Clazz.declareType(java.lang,"LinkageError",Error);
2084
2085 c$=Clazz.declareType(java.lang,"IncompatibleClassChangeError",LinkageError);
2086
2087 c$=Clazz.declareType(java.lang,"AbstractMethodError",IncompatibleClassChangeError);
2088
2089 c$=Clazz.declareType(java.lang,"AssertionError",Error);
2090 Clazz.makeConstructor(c$,
2091 function(detailMessage){
2092 Clazz.superConstructor(this,AssertionError,[String.valueOf(detailMessage),(Clazz.instanceOf(detailMessage,Throwable)?detailMessage:null)]);
2093 },"~O");
2094 Clazz.makeConstructor(c$,
2095 function(detailMessage){
2096 this.construct("" + detailMessage);
2097 },"~B");
2098 Clazz.makeConstructor(c$,
2099 function(detailMessage){
2100 this.construct("" + detailMessage);
2101 },"~N");
2102
2103 c$=Clazz.declareType(java.lang,"ClassCircularityError",LinkageError);
2104
2105 c$=Clazz.declareType(java.lang,"ClassFormatError",LinkageError);
2106
2107 c$=Clazz.decorateAsClass(function(){
2108 this.exception=null;
2109 Clazz.instantialize(this,arguments);
2110 },java.lang,"ExceptionInInitializerError",LinkageError);
2111 Clazz.makeConstructor(c$,
2112 function(){
2113 Clazz.superConstructor(this,ExceptionInInitializerError);
2114 this.initCause(null);
2115 });
2116 Clazz.makeConstructor(c$,
2117 function(detailMessage){
2118 Clazz.superConstructor(this,ExceptionInInitializerError,[detailMessage]);
2119 this.initCause(null);
2120 },"~S");
2121 Clazz.makeConstructor(c$,
2122 function(exception){
2123 Clazz.superConstructor(this,ExceptionInInitializerError);
2124 this.exception=exception;
2125 this.initCause(exception);
2126 },"Throwable");
2127 Clazz.defineMethod(c$,"getException",
2128 function(){
2129 return this.exception;
2130 });
2131 Clazz.overrideMethod(c$,"getCause",
2132 function(){
2133 return this.exception;
2134 });
2135
2136 c$=Clazz.declareType(java.lang,"IllegalAccessError",IncompatibleClassChangeError);
2137
2138 c$=Clazz.declareType(java.lang,"InstantiationError",IncompatibleClassChangeError);
2139
2140 c$=Clazz.declareType(java.lang,"VirtualMachineError",Error);
2141
2142 c$=Clazz.declareType(java.lang,"InternalError",VirtualMachineError);
2143
2144 c$=Clazz.declareType(java.lang,"NoClassDefFoundError",LinkageError);
2145
2146 c$=Clazz.declareType(java.lang,"NoSuchFieldError",IncompatibleClassChangeError);
2147
2148 c$=Clazz.declareType(java.lang,"NoSuchMethodError",IncompatibleClassChangeError);
2149
2150 c$=Clazz.declareType(java.lang,"OutOfMemoryError",VirtualMachineError);
2151
2152 c$=Clazz.declareType(java.lang,"StackOverflowError",VirtualMachineError);
2153
2154 c$=Clazz.declareType(java.lang,"UnknownError",VirtualMachineError);
2155
2156 c$=Clazz.declareType(java.lang,"UnsatisfiedLinkError",LinkageError);
2157
2158 c$=Clazz.declareType(java.lang,"UnsupportedClassVersionError",ClassFormatError);
2159
2160 c$=Clazz.declareType(java.lang,"VerifyError",LinkageError);
2161
2162 c$=Clazz.declareType(java.lang,"ThreadDeath",Error);
2163 Clazz.makeConstructor(c$,
2164 function(){
2165 Clazz.superConstructor(this,ThreadDeath,[]);
2166 });
2167
2168 c$=Clazz.declareType(java.lang,"Exception",Throwable);
2169
2170 c$=Clazz.declareType(java.lang,"RuntimeException",Exception);
2171
2172 c$=Clazz.declareType(java.lang,"ArithmeticException",RuntimeException);
2173
2174 c$=Clazz.declareType(java.lang,"IndexOutOfBoundsException",RuntimeException);
2175
2176 c$=Clazz.declareType(java.lang,"ArrayIndexOutOfBoundsException",IndexOutOfBoundsException);
2177 Clazz.makeConstructor(c$,
2178 function(index){
2179 Clazz.superConstructor(this,ArrayIndexOutOfBoundsException,["Array index out of range: "+index]);
2180 },"~N");
2181
2182 c$=Clazz.declareType(java.lang,"ArrayStoreException",RuntimeException);
2183
2184 c$=Clazz.declareType(java.lang,"ClassCastException",RuntimeException);
2185
2186 c$=Clazz.decorateAsClass(function(){
2187 this.ex=null;
2188 Clazz.instantialize(this,arguments);
2189 },java.lang,"ClassNotFoundException",Exception);
2190 Clazz.makeConstructor(c$,
2191 function(){
2192 Clazz.superConstructor(this,ClassNotFoundException,[Clazz.castNullAs("Throwable")]);
2193 });
2194 Clazz.makeConstructor(c$,
2195 function(detailMessage){
2196 Clazz.superConstructor(this,ClassNotFoundException,[detailMessage,null]);
2197 },"~S");
2198 Clazz.makeConstructor(c$,
2199 function(detailMessage,exception){
2200 Clazz.superConstructor(this,ClassNotFoundException,[detailMessage]);
2201 this.ex=exception;
2202 },"~S,Throwable");
2203 Clazz.defineMethod(c$,"getException",
2204 function(){
2205 return this.ex;
2206 });
2207 Clazz.overrideMethod(c$,"getCause",
2208 function(){
2209 return this.ex;
2210 });
2211
2212 c$=Clazz.declareType(java.lang,"CloneNotSupportedException",Exception);
2213
2214 c$=Clazz.declareType(java.lang,"IllegalAccessException",Exception);
2215
2216 c$=Clazz.declareType(java.lang,"IllegalArgumentException",RuntimeException);
2217 Clazz.makeConstructor(c$,
2218 function(cause){
2219 Clazz.superConstructor(this,IllegalArgumentException,[(cause==null?null:cause.toString()),cause]);
2220 },"Throwable");
2221
2222 c$=Clazz.declareType(java.lang,"IllegalMonitorStateException",RuntimeException);
2223
2224 c$=Clazz.declareType(java.lang,"IllegalStateException",RuntimeException);
2225 Clazz.makeConstructor(c$,
2226 function(cause){
2227 Clazz.superConstructor(this,IllegalStateException,[(cause==null?null:cause.toString()),cause]);
2228 },"Throwable");
2229
2230 c$=Clazz.declareType(java.lang,"IllegalThreadStateException",IllegalArgumentException);
2231
2232 c$=Clazz.declareType(java.lang,"InstantiationException",Exception);
2233
2234 c$=Clazz.declareType(java.lang,"InterruptedException",Exception);
2235
2236 c$=Clazz.declareType(java.lang,"NegativeArraySizeException",RuntimeException);
2237
2238 c$=Clazz.declareType(java.lang,"NoSuchFieldException",Exception);
2239
2240 c$=Clazz.declareType(java.lang,"NoSuchMethodException",Exception);
2241
2242 c$=Clazz.declareType(java.lang,"NullPointerException",RuntimeException);
2243
2244 c$=Clazz.declareType(java.lang,"NumberFormatException",IllegalArgumentException);
2245
2246 c$=Clazz.declareType(java.lang,"SecurityException",RuntimeException);
2247 Clazz.makeConstructor(c$,
2248 function(cause){
2249 Clazz.superConstructor(this,SecurityException,[(cause==null?null:cause.toString()),cause]);
2250 },"Throwable");
2251
2252 c$=Clazz.declareType(java.lang,"StringIndexOutOfBoundsException",IndexOutOfBoundsException);
2253 Clazz.makeConstructor(c$,
2254 function(index){
2255 Clazz.superConstructor(this,StringIndexOutOfBoundsException,["String index out of range: "+index]);
2256 },"~N");
2257
2258 c$=Clazz.declareType(java.lang,"UnsupportedOperationException",RuntimeException);
2259 Clazz.makeConstructor(c$,
2260 function(){
2261 Clazz.superConstructor(this,UnsupportedOperationException,[]);
2262 });
2263 Clazz.makeConstructor(c$,
2264 function(cause){
2265 Clazz.superConstructor(this,UnsupportedOperationException,[(cause==null?null:cause.toString()),cause]);
2266 },"Throwable");
2267
2268 c$=Clazz.decorateAsClass(function(){
2269 this.target=null;
2270 Clazz.instantialize(this,arguments);
2271 },java.lang.reflect,"InvocationTargetException",Exception);
2272 Clazz.makeConstructor(c$,
2273 function(){
2274 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[Clazz.castNullAs("Throwable")]);
2275 });
2276 Clazz.makeConstructor(c$,
2277 function(exception){
2278 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[null,exception]);
2279 this.target=exception;
2280 },"Throwable");
2281 Clazz.makeConstructor(c$,
2282 function(exception,detailMessage){
2283 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[detailMessage,exception]);
2284 this.target=exception;
2285 },"Throwable,~S");
2286 Clazz.defineMethod(c$,"getTargetException",
2287 function(){
2288 return this.target;
2289 });
2290 Clazz.overrideMethod(c$,"getCause",
2291 function(){
2292 return this.target;
2293 });
2294
2295 c$=Clazz.decorateAsClass(function(){
2296 this.undeclaredThrowable=null;
2297 Clazz.instantialize(this,arguments);
2298 },java.lang.reflect,"UndeclaredThrowableException",RuntimeException);
2299 Clazz.makeConstructor(c$,
2300 function(exception){
2301 Clazz.superConstructor(this,java.lang.reflect.UndeclaredThrowableException);
2302 this.undeclaredThrowable=exception;
2303 this.initCause(exception);
2304 },"Throwable");
2305 Clazz.makeConstructor(c$,
2306 function(exception,detailMessage){
2307 Clazz.superConstructor(this,java.lang.reflect.UndeclaredThrowableException,[detailMessage]);
2308 this.undeclaredThrowable=exception;
2309 this.initCause(exception);
2310 },"Throwable,~S");
2311 Clazz.defineMethod(c$,"getUndeclaredThrowable",
2312 function(){
2313 return this.undeclaredThrowable;
2314 });
2315 Clazz.overrideMethod(c$,"getCause",
2316 function(){
2317 return this.undeclaredThrowable;
2318 });
2319
2320 c$=Clazz.declareType(java.io,"IOException",Exception);
2321
2322
2323 c$=Clazz.declareType(java.io,"CharConversionException",java.io.IOException);
2324
2325 c$=Clazz.declareType(java.io,"EOFException",java.io.IOException);
2326
2327 c$=Clazz.declareType(java.io,"FileNotFoundException",java.io.IOException);
2328
2329 c$=Clazz.decorateAsClass(function(){
2330 this.bytesTransferred=0;
2331 Clazz.instantialize(this,arguments);
2332 },java.io,"InterruptedIOException",java.io.IOException);
2333
2334 c$=Clazz.declareType(java.io,"ObjectStreamException",java.io.IOException);
2335
2336 c$=Clazz.decorateAsClass(function(){
2337 this.classname=null;
2338 Clazz.instantialize(this,arguments);
2339 },java.io,"InvalidClassException",java.io.ObjectStreamException);
2340 Clazz.makeConstructor(c$,
2341 function(className,detailMessage){
2342 Clazz.superConstructor(this,java.io.InvalidClassException,[detailMessage]);
2343 this.classname=className;
2344 },"~S,~S");
2345 Clazz.defineMethod(c$,"getMessage",
2346 function(){
2347 var msg=Clazz.superCall(this,java.io.InvalidClassException,"getMessage",[]);
2348 if(this.classname!=null){
2349 msg=this.classname+';' + ' '+msg;
2350 }return msg;
2351 });
2352
2353 c$=Clazz.declareType(java.io,"InvalidObjectException",java.io.ObjectStreamException);
2354
2355 c$=Clazz.declareType(java.io,"NotActiveException",java.io.ObjectStreamException);
2356
2357 c$=Clazz.declareType(java.io,"NotSerializableException",java.io.ObjectStreamException);
2358
2359 c$=Clazz.decorateAsClass(function(){
2360 this.eof=false;
2361 this.length=0;
2362 Clazz.instantialize(this,arguments);
2363 },java.io,"OptionalDataException",java.io.ObjectStreamException);
2364
2365 c$=Clazz.declareType(java.io,"StreamCorruptedException",java.io.ObjectStreamException);
2366
2367 c$=Clazz.declareType(java.io,"SyncFailedException",java.io.IOException);
2368
2369 c$=Clazz.declareType(java.io,"UnsupportedEncodingException",java.io.IOException);
2370
2371 c$=Clazz.declareType(java.io,"UTFDataFormatException",java.io.IOException);
2372
2373 c$=Clazz.decorateAsClass(function(){
2374 this.detail=null;
2375 Clazz.instantialize(this,arguments);
2376 },java.io,"WriteAbortedException",java.io.ObjectStreamException);
2377 Clazz.makeConstructor(c$,
2378 function(detailMessage,rootCause){
2379 Clazz.superConstructor(this,java.io.WriteAbortedException,[detailMessage]);
2380 this.detail=rootCause;
2381 this.initCause(rootCause);
2382 },"~S,Exception");
2383 Clazz.defineMethod(c$,"getMessage",
2384 function(){
2385 var msg=Clazz.superCall(this,java.io.WriteAbortedException,"getMessage",[]);
2386 return (this.detail ? msg + "; "+this.detail.toString() : msg);
2387 });
2388 Clazz.overrideMethod(c$,"getCause",
2389 function(){
2390 return this.detail;
2391 });
2392
2393 c$=Clazz.declareType(javautil,"ConcurrentModificationException",RuntimeException);
2394 Clazz.makeConstructor(c$,
2395 function(){
2396 Clazz.superConstructor(this,javautil.ConcurrentModificationException,[]);
2397 });
2398
2399 c$=Clazz.declareType(javautil,"EmptyStackException",RuntimeException);
2400
2401 c$=Clazz.decorateAsClass(function(){
2402 this.className=null;
2403 this.key=null;
2404 Clazz.instantialize(this,arguments);
2405 },javautil,"MissingResourceException",RuntimeException);
2406 Clazz.makeConstructor(c$,
2407 function(detailMessage,className,resourceName){
2408 Clazz.superConstructor(this,javautil.MissingResourceException,[detailMessage]);
2409 this.className=className;
2410 this.key=resourceName;
2411 },"~S,~S,~S");
2412 Clazz.defineMethod(c$,"getClassName",
2413 function(){
2414 return this.className;
2415 });
2416 Clazz.defineMethod(c$,"getKey",
2417 function(){
2418 return this.key;
2419 });
2420
2421 c$=Clazz.declareType(javautil,"NoSuchElementException",RuntimeException);
2422
2423 c$=Clazz.declareType(javautil,"TooManyListenersException",Exception);
2424
2425 c$=Clazz.declareType(java.lang,"Void");
2426 Clazz.defineStatics(c$,
2427 "TYPE",null);
2428 {
2429 java.lang.Void.TYPE=java.lang.Void;
2430 }Clazz.declareInterface(java.lang.reflect,"GenericDeclaration");
2431 Clazz.declareInterface(java.lang.reflect,"AnnotatedElement");
2432
2433 c$=Clazz.declareType(java.lang.reflect,"AccessibleObject",null,java.lang.reflect.AnnotatedElement);
2434 Clazz.makeConstructor(c$,
2435 function(){
2436 });
2437 Clazz.defineMethod(c$,"isAccessible",
2438 function(){
2439 return false;
2440 });
2441 c$.setAccessible=Clazz.defineMethod(c$,"setAccessible",
2442 function(objects,flag){
2443 return;
2444 },"~A,~B");
2445 Clazz.defineMethod(c$,"setAccessible",
2446 function(flag){
2447 return;
2448 },"~B");
2449 Clazz.overrideMethod(c$,"isAnnotationPresent",
2450 function(annotationType){
2451 return false;
2452 },"Class");
2453 Clazz.overrideMethod(c$,"getDeclaredAnnotations",
2454 function(){
2455 return new Array(0);
2456 });
2457 Clazz.overrideMethod(c$,"getAnnotations",
2458 function(){
2459 return new Array(0);
2460 });
2461 Clazz.overrideMethod(c$,"getAnnotation",
2462 function(annotationType){
2463 return null;
2464 },"Class");
2465 c$.marshallArguments=Clazz.defineMethod(c$,"marshallArguments",
2466 function(parameterTypes,args){
2467 return null;
2468 },"~A,~A");
2469 Clazz.defineMethod(c$,"invokeV",
2470 function(receiver,args){
2471 return;
2472 },"~O,~A");
2473 Clazz.defineMethod(c$,"invokeL",
2474 function(receiver,args){
2475 return null;
2476 },"~O,~A");
2477 Clazz.defineMethod(c$,"invokeI",
2478 function(receiver,args){
2479 return 0;
2480 },"~O,~A");
2481 Clazz.defineMethod(c$,"invokeJ",
2482 function(receiver,args){
2483 return 0;
2484 },"~O,~A");
2485 Clazz.defineMethod(c$,"invokeF",
2486 function(receiver,args){
2487 return 0.0;
2488 },"~O,~A");
2489 Clazz.defineMethod(c$,"invokeD",
2490 function(receiver,args){
2491 return 0.0;
2492 },"~O,~A");
2493 c$.emptyArgs=c$.prototype.emptyArgs=new Array(0);
2494 Clazz.declareInterface(java.lang.reflect,"InvocationHandler");
2495 c$=Clazz.declareInterface(java.lang.reflect,"Member");
2496 Clazz.defineStatics(c$,
2497 "PUBLIC",0,
2498 "DECLARED",1);
2499
2500 c$=Clazz.declareType(java.lang.reflect,"Modifier");
2501 Clazz.makeConstructor(c$,
2502 function(){
2503 });
2504 c$.isAbstract=Clazz.defineMethod(c$,"isAbstract",
2505 function(modifiers){
2506 return((modifiers&1024)!=0);
2507 },"~N");
2508 c$.isFinal=Clazz.defineMethod(c$,"isFinal",
2509 function(modifiers){
2510 return((modifiers&16)!=0);
2511 },"~N");
2512 c$.isInterface=Clazz.defineMethod(c$,"isInterface",
2513 function(modifiers){
2514 return((modifiers&512)!=0);
2515 },"~N");
2516 c$.isNative=Clazz.defineMethod(c$,"isNative",
2517 function(modifiers){
2518 return((modifiers&256)!=0);
2519 },"~N");
2520 c$.isPrivate=Clazz.defineMethod(c$,"isPrivate",
2521 function(modifiers){
2522 return((modifiers&2)!=0);
2523 },"~N");
2524 c$.isProtected=Clazz.defineMethod(c$,"isProtected",
2525 function(modifiers){
2526 return((modifiers&4)!=0);
2527 },"~N");
2528 c$.isPublic=Clazz.defineMethod(c$,"isPublic",
2529 function(modifiers){
2530 return((modifiers&1)!=0);
2531 },"~N");
2532 c$.isStatic=Clazz.defineMethod(c$,"isStatic",
2533 function(modifiers){
2534 return((modifiers&8)!=0);
2535 },"~N");
2536 c$.isStrict=Clazz.defineMethod(c$,"isStrict",
2537 function(modifiers){
2538 return((modifiers&2048)!=0);
2539 },"~N");
2540 c$.isSynchronized=Clazz.defineMethod(c$,"isSynchronized",
2541 function(modifiers){
2542 return((modifiers&32)!=0);
2543 },"~N");
2544 c$.isTransient=Clazz.defineMethod(c$,"isTransient",
2545 function(modifiers){
2546 return((modifiers&128)!=0);
2547 },"~N");
2548 c$.isVolatile=Clazz.defineMethod(c$,"isVolatile",
2549 function(modifiers){
2550 return((modifiers&64)!=0);
2551 },"~N");
2552 c$.toString=Clazz.defineMethod(c$,"toString",
2553 function(modifiers){
2554 var sb=new Array(0);
2555 if(java.lang.reflect.Modifier.isPublic(modifiers))sb[sb.length]="public";
2556 if(java.lang.reflect.Modifier.isProtected(modifiers))sb[sb.length]="protected";
2557 if(java.lang.reflect.Modifier.isPrivate(modifiers))sb[sb.length]="private";
2558 if(java.lang.reflect.Modifier.isAbstract(modifiers))sb[sb.length]="abstract";
2559 if(java.lang.reflect.Modifier.isStatic(modifiers))sb[sb.length]="static";
2560 if(java.lang.reflect.Modifier.isFinal(modifiers))sb[sb.length]="final";
2561 if(java.lang.reflect.Modifier.isTransient(modifiers))sb[sb.length]="transient";
2562 if(java.lang.reflect.Modifier.isVolatile(modifiers))sb[sb.length]="volatile";
2563 if(java.lang.reflect.Modifier.isSynchronized(modifiers))sb[sb.length]="synchronized";
2564 if(java.lang.reflect.Modifier.isNative(modifiers))sb[sb.length]="native";
2565 if(java.lang.reflect.Modifier.isStrict(modifiers))sb[sb.length]="strictfp";
2566 if(java.lang.reflect.Modifier.isInterface(modifiers))sb[sb.length]="interface";
2567 if(sb.length>0){
2568 return sb.join(" ");
2569 }return"";
2570 },"~N");
2571 Clazz.defineStatics(c$,
2572 "PUBLIC",0x1,
2573 "PRIVATE",0x2,
2574 "PROTECTED",0x4,
2575 "STATIC",0x8,
2576 "FINAL",0x10,
2577 "SYNCHRONIZED",0x20,
2578 "VOLATILE",0x40,
2579 "TRANSIENT",0x80,
2580 "NATIVE",0x100,
2581 "INTERFACE",0x200,
2582 "ABSTRACT",0x400,
2583 "STRICT",0x800,
2584 "BRIDGE",0x40,
2585 "VARARGS",0x80,
2586 "SYNTHETIC",0x1000,
2587 "ANNOTATION",0x2000,
2588 "ENUM",0x4000);
2589
2590 c$=Clazz.decorateAsClass(function(){
2591 this.clazz=null;
2592 this.parameterTypes=null;
2593 this.exceptionTypes=null;
2594 this.modifiers=0;
2595 Clazz.instantialize(this,arguments);
2596 },java.lang.reflect,"Constructor",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
2597 Clazz.makeConstructor(c$,
2598 function(declaringClass,parameterTypes,checkedExceptions,modifiers){
2599 Clazz.superConstructor(this,java.lang.reflect.Constructor,[]);
2600 this.clazz=declaringClass;
2601 this.parameterTypes=parameterTypes;
2602 this.exceptionTypes=checkedExceptions;
2603 this.modifiers=modifiers;
2604 },"Class,~A,~A,~N");
2605 Clazz.overrideMethod(c$,"getTypeParameters",
2606 function(){
2607 return null;
2608 });
2609 Clazz.defineMethod(c$,"toGenericString",
2610 function(){
2611 return null;
2612 });
2613 Clazz.defineMethod(c$,"getGenericParameterTypes",
2614 function(){
2615 return null;
2616 });
2617 Clazz.defineMethod(c$,"getGenericExceptionTypes",
2618 function(){
2619 return null;
2620 });
2621 Clazz.defineMethod(c$,"getParameterAnnotations",
2622 function(){
2623 return null;
2624 });
2625 Clazz.defineMethod(c$,"isVarArgs",
2626 function(){
2627 return false;
2628 });
2629 Clazz.overrideMethod(c$,"isSynthetic",
2630 function(){
2631 return false;
2632 });
2633 Clazz.overrideMethod(c$,"equals",
2634 function(object){
2635 if(object!=null&&Clazz.instanceOf(object,java.lang.reflect.Constructor)){
2636 var other=object;
2637 if(this.getDeclaringClass()===other.getDeclaringClass()){
2638 var params1=this.parameterTypes;
2639 var params2=other.parameterTypes;
2640 if(params1.length==params2.length){
2641 for(var i=0;i<params1.length;i++){
2642 if(params1[i]!==params2[i])return false;
2643 }
2644 return true;
2645 }}}return false;
2646 },"~O");
2647 Clazz.overrideMethod(c$,"getDeclaringClass",
2648 function(){
2649 return this.clazz;
2650 });
2651 Clazz.defineMethod(c$,"getExceptionTypes",
2652 function(){
2653 return this.exceptionTypes;
2654 });
2655 Clazz.overrideMethod(c$,"getModifiers",
2656 function(){
2657 return this.modifiers;
2658 });
2659 Clazz.overrideMethod(c$,"getName",
2660 function(){
2661 return this.getDeclaringClass().getName();
2662 });
2663 Clazz.defineMethod(c$,"getParameterTypes",
2664 function(){
2665 return this.parameterTypes;
2666 });
2667 Clazz.overrideMethod(c$,"hashCode",
2668 function(){
2669 return this.getDeclaringClass().getName().hashCode();
2670 });
2671 Clazz.defineMethod(c$,"newInstance",
2672 function(args){
2673 var instance=new this.clazz(Clazz.inheritArgs);
2674 Clazz.instantialize(instance,args);
2675 return instance;
2676 },"~A");
2677 Clazz.overrideMethod(c$,"toString",
2678 function(){
2679 return null;
2680 });
2681
2682 c$=Clazz.declareType(java.lang.reflect,"Field",java.lang.reflect.AccessibleObject,java.lang.reflect.Member);
2683 Clazz.overrideMethod(c$,"isSynthetic",
2684 function(){
2685 return false;
2686 });
2687 Clazz.defineMethod(c$,"toGenericString",
2688 function(){
2689 return null;
2690 });
2691 Clazz.defineMethod(c$,"isEnumConstant",
2692 function(){
2693 return false;
2694 });
2695 Clazz.defineMethod(c$,"getGenericType",
2696 function(){
2697 return null;
2698 });
2699 Clazz.overrideMethod(c$,"equals",
2700 function(object){
2701 return false;
2702 },"~O");
2703 Clazz.overrideMethod(c$,"getDeclaringClass",
2704 function(){
2705 return null;
2706 });
2707 Clazz.overrideMethod(c$,"getName",
2708 function(){
2709 return null;
2710 });
2711 Clazz.defineMethod(c$,"getType",
2712 function(){
2713 return null;
2714 });
2715 Clazz.overrideMethod(c$,"hashCode",
2716 function(){
2717 return 0;
2718 });
2719 Clazz.overrideMethod(c$,"toString",
2720 function(){
2721 return null;
2722 });
2723
2724 c$=Clazz.decorateAsClass(function(){
2725 this.clazz=null;
2726 this.name=null;
2727 this.returnType=null;
2728 this.parameterTypes=null;
2729 this.exceptionTypes=null;
2730 this.modifiers=0;
2731 Clazz.instantialize(this,arguments);
2732 },java.lang.reflect,"Method",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
2733 Clazz.makeConstructor(c$,
2734 function(declaringClass,name,parameterTypes,returnType,checkedExceptions,modifiers){
2735 Clazz.superConstructor(this,java.lang.reflect.Method,[]);
2736 this.clazz=declaringClass;
2737 this.name=name;
2738 this.parameterTypes=parameterTypes;
2739 this.returnType=returnType;
2740 this.exceptionTypes=checkedExceptions;
2741 this.modifiers=modifiers;
2742 },"Class,~S,~A,Class,~A,~N");
2743 Clazz.overrideMethod(c$,"getTypeParameters",
2744 function(){
2745 return null;
2746 });
2747 Clazz.defineMethod(c$,"toGenericString",
2748 function(){
2749 return null;
2750 });
2751 Clazz.defineMethod(c$,"getGenericParameterTypes",
2752 function(){
2753 return null;
2754 });
2755 Clazz.defineMethod(c$,"getGenericExceptionTypes",
2756 function(){
2757 return null;
2758 });
2759 Clazz.defineMethod(c$,"getGenericReturnType",
2760 function(){
2761 return null;
2762 });
2763 Clazz.defineMethod(c$,"getParameterAnnotations",
2764 function(){
2765 return null;
2766 });
2767 Clazz.defineMethod(c$,"isVarArgs",
2768 function(){
2769 return false;
2770 });
2771 Clazz.defineMethod(c$,"isBridge",
2772 function(){
2773 return false;
2774 });
2775 Clazz.overrideMethod(c$,"isSynthetic",
2776 function(){
2777 return false;
2778 });
2779 Clazz.defineMethod(c$,"getDefaultValue",
2780 function(){
2781 return null;
2782 });
2783 Clazz.overrideMethod(c$,"equals",
2784 function(object){
2785 if(object!=null&&Clazz.instanceOf(object,java.lang.reflect.Method)){
2786 var other=object;
2787 if((this.getDeclaringClass()===other.getDeclaringClass())&&(this.getName()===other.getName())){
2788 var params1=this.parameterTypes;
2789 var params2=other.parameterTypes;
2790 if(params1.length==params2.length){
2791 for(var i=0;i<params1.length;i++){
2792 if(params1[i]!==params2[i])return false;
2793 }
2794 return true;
2795 }}}return false;
2796 },"~O");
2797 Clazz.overrideMethod(c$,"getDeclaringClass",
2798 function(){
2799 return this.clazz;
2800 });
2801 Clazz.defineMethod(c$,"getExceptionTypes",
2802 function(){
2803 return this.exceptionTypes;
2804 });
2805 Clazz.overrideMethod(c$,"getModifiers",
2806 function(){
2807 return this.modifiers;
2808 });
2809 Clazz.overrideMethod(c$,"getName",
2810 function(){
2811 return this.name;
2812 });
2813 Clazz.defineMethod(c$,"getParameterTypes",
2814 function(){
2815 return this.parameterTypes;
2816 });
2817 Clazz.defineMethod(c$,"getReturnType",
2818 function(){
2819 return this.returnType;
2820 });
2821 Clazz.overrideMethod(c$,"hashCode",
2822 function(){
2823 return this.getDeclaringClass().getName().hashCode()^this.getName().hashCode();
2824 });
2825 Clazz.defineMethod(c$,"invoke",
2826 function(receiver,args){
2827 var m=this.clazz.prototype[this.getName()];
2828 if(m==null){
2829 m=this.clazz[this.getName()];
2830 }
2831 if(m!=null){
2832 m.apply(receiver,args);
2833 }else{
2834
2835 }
2836 },"~O,~A");
2837 Clazz.overrideMethod(c$,"toString",
2838 function(){
2839 return null;
2840 });
2841
2842 })(Clazz);