4 // This library will be wrapped by an additional anonymous function using ANT in
\r
5 // build_03_tojs.xml. This task will also modify variable names. References
\r
6 // to Clazz._ will not be changed, but other Clazz.xxx will be changed to
\r
7 // (local scope) Clazz_xxx, allowing them to be further compressed using
\r
8 // Google Closure Compiler in that same ANT task.
\r
10 // BH 7/24/2015 7:21:51 AM renamed from JSmolJavaExt.js
\r
11 // BH 5/31/2015 5:53:04 PM Number.compareTo added
\r
12 // BH 5/21/2015 5:46:30 PM Number("0xFFFFFFFF") is not -1
\r
13 // BH 4/23/2015 9:08:59 AM xx.getComponentType() is nonfunctional. Array.newInstance now defines a wrapper for .getClass().getComponentType() that works
\r
14 // BH 4/12/2015 1:37:44 PM adding Math.rint = Math.round
\r
15 // BH 1/16/2015 10:09:38 AM Chrome failure jqGrig due to new String("x").toString() not being a simple string
\r
16 // BH 8/14/2014 6:49:22 PM Character class efficiencies
\r
17 // BH 7/24/2014 9:02:18 AM most browsers do not support String.codePointAt()
\r
18 // BH 7/11/2014 4:17:22 PM fix for Boolean.valueOf("false") not being false
\r
19 // BH 5/27/2014 6:29:59 AM ensure floats and doubles have decimal point in toString
\r
20 // BH 4/1/2014 12:23:41 PM Encoding moved to Clazz._Encoding;
\r
21 // BH 4/1/2014 7:51:46 AM removing java.lang.B00lean
\r
22 // BH 3/7/2014 9:17:10 AM removing Array.toString; moving that code here from j2sJmol.js
\r
23 // BH 1/30/2014 9:04:25 AM adding Throwable.getStackTrace() as a STRING
\r
24 // BH 12/4/2013 9:20:44 PM fix for reassigning Date.prototype.toString()
\r
25 // BH 12/3/2013 11:43:10 AM bizarre Safari bug in reassigning Boolean (OK, I admit, we shouldn't have done that...)
\r
26 // BH 12/1/2013 6:50:16 AM evit Number.prototype.toString assignment removed!
\r
27 // BH 11/30/2013 1:46:31 PM fixing Byte, Short, Long, Integer, Float, Double to reflect proper bounds and error conditions
\r
28 // BH 11/29/2013 8:58:49 PM removing Boolean.toString(boolean)
\r
29 // BH 11/4/2013 7:34:26 AM changing "var nativeClazz" to "var nativeClass" to avoid ANT replacement of "nativeClazz." to "nativeClazz_"
\r
30 // BH 10/19/2013 1:29:27 PM fixed String.$replace()
\r
31 // BH 10/18/2013 6:09:23 PM fixed (Double|Float).valueOf(NaN).valueOf(), which should return NaN, not throw an error
\r
32 // BH 10/12/2013 11:18:44 AM fixed bug in Double(String) and Float(String) that was returning typeof "string"
\r
33 // BH 10/10/2013 2:40:20 PM added Math.log10
\r
34 // BH 7/23/2013 7:24:01 AM fixing Number.shortValue() and Number.byteValue() for negative values
\r
35 // BH 6/16/2013 1:31:30 PM adding /| in String.replace -- thank you David Koes
\r
36 // BH 3/13/2013 12:49:23 PM setting Boolean.valueOf() "@"
\r
37 // BH 3/2/2013 10:46:45 PM removed Double.valueOf(String)
\r
38 // BH 11/6/2012 8:26:33 PM added instanceof Int32Array in String.instantialize
\r
39 // BH 10/13/2012 11:38:07 PM corrected Integer.parseInt to allow only +-0123456789; created Integer.parseIntRadix
\r
40 // BH 11/1/2012 added Short
\r
41 // BH 9/10/2012 6:27:21 AM added java.net.URL... classes
\r
42 // BH 1/7/2013 7:40:06 AM added Clazz.dateToString
\r
46 // moved here from package.js
\r
47 // these classes will be created as objects prior to any others
\r
48 // and are then available immediately
\r
50 Clazz._Loader.registerPackages("java", [ "io", "lang", "lang.reflect", "util" ]);
\r
52 var sJU = "java.util";
\r
55 //Clazz._Loader.registerPackages (sJU, ["regex", "zip"]);
\r
56 //var javautil = JU;
\r
58 var javautil = java.util;
\r
60 Clazz._Loader.ignore([
\r
61 "net.sf.j2s.ajax.HttpRequest",
\r
62 sJU + ".MapEntry.Type",
\r
63 //"java.net.UnknownServiceException",
\r
64 "java.lang.Runtime",
\r
65 "java.security.AccessController",
\r
66 "java.security.PrivilegedExceptionAction",
\r
68 "java.io.FileInputStream",
\r
69 "java.io.FileWriter",
\r
70 "java.io.OutputStreamWriter",
\r
71 // sJU + ".Calendar", // bypassed in ModelCollection
\r
72 // "java.text.SimpleDateFormat", // not used
\r
73 // "java.text.DateFormat", // not used
\r
74 sJU + ".concurrent.Executors"
\r
77 Math.rint = Math.round;
\r
79 Math.log10||(Math.log10=function(a){return Math.log(a)/2.302585092994046});
\r
81 if(Clazz._supportsNativeObject){
\r
82 // Number and Array are special -- do not override prototype.toString -- "length - 2" here
\r
83 for(var i=0;i<Clazz._extendedObjectMethods.length - 2;i++){
\r
84 var p=Clazz._extendedObjectMethods[i];
\r
85 Array.prototype[p] = Clazz._O.prototype[p];
\r
86 Number.prototype[p] = Clazz._O.prototype[p];
\r
90 java.lang.Number=Number;
\r
91 Number.__CLASS_NAME__="Number";
\r
92 Clazz.implementOf(Number,java.io.Serializable);
\r
93 Number.equals=Clazz._innerFunctions.equals;
\r
94 Number.getName=Clazz._innerFunctions.getName;
\r
95 Number.prototype.compareTo = function(x) { var a = this.value, b = x.value; return (a < b ? -1 : a == b ? 0 : 1) };
\r
97 Clazz.defineMethod(Number,"shortValue",
\r
99 var x = Math.round(this)&0xffff;
\r
100 return (this < 0 && x > 0 ? x - 0x10000 : x);
\r
103 Clazz.defineMethod(Number,"byteValue",
\r
105 var x = Math.round(this)&0xff;
\r
106 return (this < 0 && x > 0 ? x - 0x100 : x);
\r
109 Clazz.defineMethod(Number,"intValue",
\r
111 return Math.round(this)&0xffffffff;
\r
114 Clazz.defineMethod(Number,"longValue",
\r
116 return Math.round(this);
\r
119 Clazz.defineMethod(Number,"floatValue",
\r
121 return this.valueOf();
\r
123 Clazz.defineMethod(Number,"doubleValue",
\r
125 return parseFloat(this.valueOf());
\r
128 Clazz.overrideMethod(Number,"hashCode",
\r
130 return this.valueOf();
\r
133 java.lang.Integer=Integer=function(){
\r
134 Clazz.instantialize(this,arguments);
\r
136 Clazz.decorateAsType(Integer,"Integer",Number,Comparable,null,true);
\r
137 Integer.prototype.valueOf=function(){return 0;};
\r
138 Integer.toString=Integer.prototype.toString=function(){
\r
139 if(arguments.length!=0){
\r
140 return""+arguments[0];
\r
141 } else if(this===Integer){
\r
142 return"class java.lang.Integer";
\r
144 return""+this.valueOf();
\r
149 Clazz.makeConstructor(Integer,
\r
151 this.valueOf=function(){
\r
158 Clazz.overrideConstructor(Integer, function(v){
\r
159 v == null && (v = 0);
\r
160 if (typeof v != "number")
\r
161 v = Integer.parseIntRadix(v, 10);
\r
162 this.valueOf=function(){return v;};
\r
165 Clazz.makeConstructor(Integer,
\r
167 var value=Integer.parseInt(s,10);
\r
168 this.valueOf=function(){
\r
173 Integer.MIN_VALUE=Integer.prototype.MIN_VALUE=-0x80000000;
\r
174 Integer.MAX_VALUE=Integer.prototype.MAX_VALUE=0x7fffffff;
\r
175 Integer.TYPE=Integer.prototype.TYPE=Integer;
\r
178 Clazz.defineMethod(Integer,"bitCount",
\r
180 i = i - ((i >>> 1) & 0x55555555);
\r
181 i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
\r
182 i = (i + (i >>> 4)) & 0x0f0f0f0f;
\r
184 i = i + (i >>> 16);
\r
187 Integer.bitCount=Integer.prototype.bitCount;
\r
189 Clazz.defineMethod(Integer,"numberOfLeadingZeros",
\r
191 if (i == 0) return 32;
\r
193 if (i >>> 16 == 0) { n += 16; i <<= 16; }
\r
194 if (i >>> 24 == 0) { n += 8; i <<= 8; }
\r
195 if (i >>> 28 == 0) { n += 4; i <<= 4; }
\r
196 if (i >>> 30 == 0) { n += 2; i <<= 2; }
\r
200 Integer.numberOfLeadingZeros=Integer.prototype.numberOfLeadingZeros;
\r
202 Clazz.defineMethod(Integer,"numberOfTrailingZeros",
\r
204 if (i == 0) return 32;
\r
206 var y = i <<16; if (y != 0) { n = n -16; i = y; }
\r
207 y = i << 8; if (y != 0) { n = n - 8; i = y; }
\r
208 y = i << 4; if (y != 0) { n = n - 4; i = y; }
\r
209 y = i << 2; if (y != 0) { n = n - 2; i = y; }
\r
210 return n - ((i << 1) >>> 31);
\r
212 Integer.numberOfTrailingZeros=Integer.prototype.numberOfTrailingZeros;
\r
214 Clazz.defineMethod(Integer,"parseIntRadix",
\r
217 throw new NumberFormatException("null");
\r
219 throw new NumberFormatException("radix "+radix+" less than Character.MIN_RADIX");
\r
221 throw new NumberFormatException("radix "+radix+" greater than Character.MAX_RADIX");
\r
224 for (var i = s.length; --i >= 0;) {
\r
225 var c = s.charCodeAt(i);
\r
226 if (c >= 48 && c <= 57) continue;
\r
227 if (i > 0 || c != 43 && c != 45)
\r
228 throw new NumberFormatException("Not a Number : "+s);
\r
232 var i=parseInt(s,radix);
\r
234 throw new NumberFormatException("Not a Number : "+s);
\r
237 },"String, Number");
\r
238 Integer.parseIntRadix=Integer.prototype.parseIntRadix;
\r
240 Clazz.defineMethod(Integer,"parseInt",
\r
242 return Integer.parseIntRadix(s,10);
\r
244 Integer.parseInt=Integer.prototype.parseInt;
\r
247 Clazz.defineMethod(Integer,"$valueOf",
\r
249 return new Integer(Integer.parseIntRadix(s,10));
\r
253 Clazz.overrideMethod(Integer,"$valueOf",
\r
255 return new Integer(s);
\r
259 Clazz.defineMethod(Integer,"$valueOf",
\r
261 return new Integer(Integer.parseIntRadix(s,r));
\r
262 },"String, Number");
\r
265 Integer.$valueOf=Integer.prototype.$valueOf;
\r
268 Clazz.overrideMethod(Integer,"equals",
\r
270 if(s==null||!Clazz.instanceOf(s,Integer)){
\r
273 return s.valueOf()==this.valueOf();
\r
275 Integer.toHexString=Integer.prototype.toHexString=function(d){
\r
276 if(d.valueOf)d=d.valueOf();
\r
278 var b = d & 0xFFFFFF;
\r
279 var c = ((d>>24)&0xFF);
\r
280 return c._numberToString(16) + (b = "000000" + b._numberToString(16)).substring(b.length - 6);
\r
282 return d._numberToString(16);};
\r
283 Integer.toOctalString=Integer.prototype.toOctalString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(8);};
\r
284 Integer.toBinaryString=Integer.prototype.toBinaryString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(2);};
\r
286 Integer.decodeRaw=Clazz.defineMethod(Integer,"decodeRaw", function(n){
\r
287 if (n.indexOf(".") >= 0)n = "";
\r
288 var i = (n.startsWith("-") ? 1 : 0);
\r
289 n = n.replace(/\#/, "0x").toLowerCase();
\r
290 var radix=(n.startsWith("0x", i) ? 16 : n.startsWith("0", i) ? 8 : 10);
\r
291 // The general problem with parseInt is that is not strict -- ParseInt("10whatever") == 10.
\r
292 // Number is strict, but Number("055") does not work, though ParseInt("055", 8) does.
\r
293 // need to make sure negative numbers are negative
\r
294 n = Number(n) & 0xFFFFFFFF;
\r
295 return (radix == 8 ? parseInt(n, 8) : n);
\r
298 Integer.decode=Clazz.defineMethod(Integer,"decode", function(n){
\r
299 n = Integer.decodeRaw(n);
\r
300 if (isNaN(n) || n < Integer.MIN_VALUE|| n > Integer.MAX_VALUE)
\r
301 throw new NumberFormatException("Invalid Integer");
\r
302 return new Integer(n);
\r
305 Clazz.overrideMethod(Integer,"hashCode",
\r
307 return this.valueOf();
\r
310 // Note that Long is problematic in JavaScript
\r
312 java.lang.Long=Long=function(){
\r
313 Clazz.instantialize(this,arguments);
\r
315 Clazz.decorateAsType(Long,"Long",Number,Comparable,null,true);
\r
316 Long.prototype.valueOf=function(){return 0;};
\r
317 Long.toString=Long.prototype.toString=function(){
\r
318 if(arguments.length!=0){
\r
319 return""+arguments[0];
\r
320 }else if(this===Long){
\r
321 return"class java.lang.Long";
\r
323 return""+this.valueOf();
\r
326 Clazz.overrideConstructor(Long, function(v){
\r
327 v == null && (v = 0);
\r
328 v = (typeof v == "number" ? Math.round(v) : Integer.parseIntRadix(v, 10));
\r
329 this.valueOf=function(){return v;};
\r
332 //Long.MIN_VALUE=Long.prototype.MIN_VALUE=-0x8000000000000000;
\r
333 //Long.MAX_VALUE=Long.prototype.MAX_VALUE=0x7fffffffffffffff;
\r
334 Long.TYPE=Long.prototype.TYPE=Long;
\r
336 Clazz.defineMethod(Long,"parseLong",
\r
338 return Integer.parseInt(s, radix || 10);
\r
341 Long.parseLong=Long.prototype.parseLong;
\r
343 Clazz.overrideMethod(Long,"$valueOf",
\r
345 return new Long(s);
\r
348 Clazz.defineMethod(Long,"$valueOf",
\r
350 return new Long(s);
\r
353 Clazz.defineMethod(Long,"$valueOf",
\r
355 return new Long(Long.parseLong(s,r));
\r
356 },"String, Number");
\r
358 Long.$valueOf=Long.prototype.$valueOf;
\r
359 Clazz.overrideMethod(Long,"equals",
\r
361 if(s==null||!Clazz.instanceOf(s,Long)){
\r
364 return s.valueOf()==this.valueOf();
\r
366 Long.toHexString=Long.prototype.toHexString=function(i){
\r
367 return i.toString(16);
\r
369 Long.toOctalString=Long.prototype.toOctalString=function(i){
\r
370 return i.toString(8);
\r
372 Long.toBinaryString=Long.prototype.toBinaryString=function(i){
\r
373 return i.toString(2);
\r
377 Long.decode=Clazz.defineMethod(Long,"decode",
\r
379 n = Integer.decodeRaw(n);
\r
381 throw new NumberFormatException("Invalid Long");
\r
382 return new Long(n);
\r
385 java.lang.Short = Short = function () {
\r
386 Clazz.instantialize (this, arguments);
\r
388 Clazz.decorateAsType (Short, "Short", Number, Comparable, null, true);
\r
389 Short.prototype.valueOf = function () { return 0; };
\r
390 Short.toString = Short.prototype.toString = function () {
\r
391 if (arguments.length != 0) {
\r
392 return "" + arguments[0];
\r
393 } else if (this === Short) {
\r
394 return "class java.lang.Short"; // Short.class.toString
\r
396 return "" + this.valueOf ();
\r
399 Clazz.overrideConstructor(Short,
\r
401 v == null && (v = 0);
\r
402 if (typeof v != "number")
\r
403 v = Integer.parseIntRadix(v, 10);
\r
404 v = v.shortValue();
\r
405 this.valueOf = function () {return v;};
\r
409 Short.MIN_VALUE = Short.prototype.MIN_VALUE = -32768;
\r
410 Short.MAX_VALUE = Short.prototype.MAX_VALUE = 32767;
\r
411 Short.TYPE = Short.prototype.TYPE = Short;
\r
413 Clazz.defineMethod(Short, "parseShortRadix",
\r
414 function (s, radix) {
\r
415 return Integer.parseIntRadix(s, radix).shortValue();
\r
416 }, "String, Number");
\r
417 Short.parseShortRadix = Short.prototype.parseShortRadix;
\r
419 Clazz.defineMethod(Short, "parseShort",
\r
421 return Short.parseShortRadix (s, 10);
\r
424 Short.parseShort = Short.prototype.parseShort;
\r
427 Clazz.defineMethod(Short, "$valueOf",
\r
429 return new Short(Short.parseShort (s, 10));
\r
433 Clazz.overrideMethod(Short, "$valueOf",
\r
435 return new Short(s);
\r
439 Clazz.defineMethod(Short, "$valueOf",
\r
441 return new Short(Short.parseShort (s, r));
\r
442 }, "String, Number");
\r
445 Short.$valueOf = Short.prototype.$valueOf;
\r
446 Clazz.overrideMethod(Short, "equals",
\r
448 if(s == null || !Clazz.instanceOf(s, Short) ){
\r
451 return s.valueOf() == this.valueOf();
\r
453 Short.toHexString = Short.prototype.toHexString = function (i) {
\r
454 return i.toString (16);
\r
456 Short.toOctalString = Short.prototype.toOctalString = function (i) {
\r
457 return i.toString (8);
\r
459 Short.toBinaryString = Short.prototype.toBinaryString = function (i) {
\r
460 return i.toString (2);
\r
462 Short.decode = Clazz.defineMethod(Short, "decode",
\r
464 n = Integer.decodeRaw(n);
\r
465 if (isNaN(n) || n < -32768|| n > 32767)
\r
466 throw new NumberFormatException("Invalid Short");
\r
467 return new Short(n);
\r
470 java.lang.Byte=Byte=function(){
\r
471 Clazz.instantialize(this,arguments);
\r
473 Clazz.decorateAsType(Byte,"Byte",Number,Comparable,null,true);
\r
474 Byte.prototype.valueOf=function(){return 0;};
\r
475 Byte.toString=Byte.prototype.toString=function(){
\r
476 if(arguments.length!=0){
\r
477 return""+arguments[0];
\r
478 }else if(this===Byte){
\r
479 return"class java.lang.Byte";
\r
481 return""+this.valueOf();
\r
483 Clazz.makeConstructor(Byte,
\r
485 if (typeof v != "number")
\r
486 v = Integer.parseIntRadix(v, 10);
\r
488 this.valueOf=function(){
\r
493 Byte.serialVersionUID=Byte.prototype.serialVersionUID=-7183698231559129828;
\r
494 Byte.MIN_VALUE=Byte.prototype.MIN_VALUE=-128;
\r
495 Byte.MAX_VALUE=Byte.prototype.MAX_VALUE=127;
\r
496 Byte.SIZE=Byte.prototype.SIZE=8;
\r
497 Byte.TYPE=Byte.prototype.TYPE=Byte;
\r
499 Clazz.defineMethod(Byte,"parseByteRadix",
\r
501 return Integer.parseIntRadix(s, radix).byteValue();
\r
502 },"String, Number");
\r
503 Byte.parseByteRadix=Byte.prototype.parseByteRadix;
\r
505 Clazz.defineMethod(Byte,"parseByte",
\r
507 return Byte.parseByte(s,10);
\r
510 Byte.parseByte=Byte.prototype.parseByte;
\r
512 Clazz.overrideMethod(Byte, "$valueOf",
\r
514 return new Byte(s);
\r
517 Byte.$valueOf=Byte.prototype.$valueOf;
\r
518 Clazz.overrideMethod(Byte,"equals",
\r
520 if(s==null||!Clazz.instanceOf(s,Byte)){
\r
523 return s.valueOf()==this.valueOf();
\r
525 Byte.toHexString=Byte.prototype.toHexString=function(i){
\r
526 return i.toString(16);
\r
528 Byte.toOctalString=Byte.prototype.toOctalString=function(i){
\r
529 return i.toString(8);
\r
531 Byte.toBinaryString=Byte.prototype.toBinaryString=function(i){
\r
532 return i.toString(2);
\r
534 Byte.decode=Clazz.defineMethod(Byte,"decode",
\r
536 n = Integer.decodeRaw(n);
\r
537 if (isNaN(n) || n < -128|| n > 127)
\r
538 throw new NumberFormatException("Invalid Byte");
\r
539 return new Byte(n);
\r
542 Clazz._floatToString = function(f) {
\r
544 if (s.indexOf(".") < 0 && s.indexOf("e") < 0)
\r
549 java.lang.Float=Float=function(){
\r
550 Clazz.instantialize(this,arguments);
\r
552 Clazz.decorateAsType(Float,"Float",Number,Comparable,null,true);
\r
553 Float.prototype.valueOf=function(){return 0;};
\r
554 Float.toString=Float.prototype.toString=function(){
\r
555 if(arguments.length!=0){
\r
556 return Clazz._floatToString(arguments[0]);
\r
557 }else if(this===Float){
\r
558 return"class java.lang.Float";
\r
560 return Clazz._floatToString(this.valueOf());
\r
563 Clazz.overrideConstructor(Float, function(v){
\r
564 v == null && (v = 0);
\r
565 if (typeof v != "number")
\r
567 this.valueOf=function(){return v;}
\r
570 Float.serialVersionUID=Float.prototype.serialVersionUID=-2671257302660747028;
\r
571 Float.MIN_VALUE=Float.prototype.MIN_VALUE=3.4028235e+38;
\r
572 Float.MAX_VALUE=Float.prototype.MAX_VALUE=1.4e-45;
\r
573 Float.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
574 Float.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
575 Float.NaN=Number.NaN;
\r
576 Float.TYPE=Float.prototype.TYPE=Float;
\r
578 Clazz.defineMethod(Float,"parseFloat",
\r
581 throw new NumberFormatException("null");
\r
583 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
584 var floatVal=Number(s);
\r
585 if(isNaN(floatVal)){
\r
586 throw new NumberFormatException("Not a Number : "+s);
\r
590 Float.parseFloat=Float.prototype.parseFloat;
\r
592 Clazz.overrideMethod(Float,"$valueOf",
\r
594 return new Float(s);
\r
597 Float.$valueOf=Float.prototype.$valueOf;
\r
599 Clazz.defineMethod(Float,"isNaN",
\r
603 Float.isNaN=Float.prototype.isNaN;
\r
604 Clazz.defineMethod(Float,"isInfinite",
\r
606 return!isFinite(num);
\r
608 Float.isInfinite=Float.prototype.isInfinite;
\r
610 Clazz.overrideMethod(Float,"equals",
\r
612 if(s==null||!Clazz.instanceOf(s,Float)){
\r
615 return s.valueOf()==this.valueOf();
\r
618 java.lang.Double=Double=function(){
\r
619 Clazz.instantialize(this,arguments);
\r
621 Clazz.decorateAsType(Double,"Double",Number,Comparable,null,true);
\r
622 Double.prototype.valueOf=function(){return 0;};
\r
623 Double.toString=Double.prototype.toString=function(){
\r
624 if(arguments.length!=0){
\r
625 return Clazz._floatToString(arguments[0]);
\r
626 }else if(this===Double){
\r
627 return"class java.lang.Double";
\r
629 return Clazz._floatToString(this.valueOf());
\r
632 Clazz.overrideConstructor(Double, function(v){
\r
633 v == null && (v = 0);
\r
634 if (typeof v != "number")
\r
635 v = Double.parseDouble(v);
\r
636 this.valueOf=function(){return v;};
\r
639 Double.serialVersionUID=Double.prototype.serialVersionUID=-9172774392245257468;
\r
640 Double.MIN_VALUE=Double.prototype.MIN_VALUE=4.9e-324;
\r
641 Double.MAX_VALUE=Double.prototype.MAX_VALUE=1.7976931348623157e+308;
\r
642 Double.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
643 Double.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
644 Double.NaN=Number.NaN;
\r
645 Double.TYPE=Double.prototype.TYPE=Double;
\r
647 Clazz.defineMethod(Double,"isNaN",
\r
651 Double.isNaN=Double.prototype.isNaN;
\r
652 Clazz.defineMethod(Double,"isInfinite",
\r
654 return!isFinite(num);
\r
656 Double.isInfinite=Double.prototype.isInfinite;
\r
658 Clazz.defineMethod(Double,"parseDouble",
\r
661 throw new NumberFormatException("null");
\r
663 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
664 var doubleVal=Number(s);
\r
665 if(isNaN(doubleVal)){
\r
666 throw new NumberFormatException("Not a Number : "+s);
\r
670 Double.parseDouble=Double.prototype.parseDouble;
\r
673 Clazz.defineMethod(Double,"$valueOf",
\r
675 return new Double(this.parseDouble(s));
\r
679 Clazz.defineMethod(Double,"$valueOf",
\r
681 return new Double(v);
\r
684 Double.$valueOf=Double.prototype.$valueOf;
\r
686 Clazz.overrideMethod(Double,"equals",
\r
688 if(s==null||!Clazz.instanceOf(s,Double)){
\r
691 return s.valueOf()==this.valueOf();
\r
695 //java.lang.B00lean = Boolean; ?? BH why this?
\r
696 Boolean = java.lang.Boolean = Boolean || function () {Clazz.instantialize (this, arguments);};
\r
697 if (Clazz._supportsNativeObject) {
\r
698 for (var i = 0; i < Clazz._extendedObjectMethods.length; i++) {
\r
699 var p = Clazz._extendedObjectMethods[i];
\r
700 Boolean.prototype[p] = Clazz._O.prototype[p];
\r
703 Boolean.__CLASS_NAME__="Boolean";
\r
704 Clazz.implementOf(Boolean,[java.io.Serializable,java.lang.Comparable]);
\r
705 Boolean.equals=Clazz._innerFunctions.equals;
\r
706 Boolean.getName=Clazz._innerFunctions.getName;
\r
707 Boolean.serialVersionUID=Boolean.prototype.serialVersionUID=-3665804199014368530;
\r
709 //Clazz.makeConstructor(Boolean,
\r
711 //this.valueOf=function(){
\r
716 Clazz.overrideConstructor(Boolean,
\r
718 var b = ((typeof s == "string" ? Boolean.toBoolean(s) : s) ? true : false);
\r
719 this.valueOf=function(){return b;};
\r
722 Boolean.parseBoolean=Clazz.defineMethod(Boolean,"parseBoolean",
\r
724 return Boolean.toBoolean(s);
\r
726 Clazz.defineMethod(Boolean,"booleanValue",
\r
728 return this.valueOf();
\r
730 Boolean.$valueOf=Clazz.overrideMethod(Boolean,"$valueOf",
\r
732 return((typeof b == "string"? "true".equalsIgnoreCase(b) : b)?Boolean.TRUE:Boolean.FALSE);
\r
736 Boolean.toString=Clazz.defineMethod(Boolean,"toString",
\r
738 return b?"true":"false";
\r
742 Clazz.overrideMethod(Boolean,"toString",
\r
744 return this.valueOf()?"true":"false";
\r
746 Clazz.overrideMethod(Boolean,"hashCode",
\r
748 return this.valueOf()?1231:1237;
\r
750 Clazz.overrideMethod(Boolean,"equals",
\r
752 if(Clazz.instanceOf(obj,Boolean)){
\r
753 return this.booleanValue()==obj.booleanValue();
\r
756 Boolean.getBoolean=Clazz.defineMethod(Boolean,"getBoolean",
\r
760 result=Boolean.toBoolean(System.getProperty(name));
\r
762 if(Clazz.instanceOf(e,IllegalArgumentException)){
\r
763 }else if(Clazz.instanceOf(e,NullPointerException)){
\r
770 Clazz.overrideMethod(Boolean,"compareTo",
\r
772 return(b.value==this.value?0:(this.value?1:-1));
\r
774 Boolean.toBoolean=Clazz.defineMethod(Boolean,"toBoolean",
\r
775 ($fz=function(name){
\r
776 return((name!=null)&&name.equalsIgnoreCase("true"));
\r
777 },$fz.isPrivate=true,$fz),"~S");
\r
778 Boolean.TRUE=Boolean.prototype.TRUE=new Boolean(true);
\r
779 Boolean.FALSE=Boolean.prototype.FALSE=new Boolean(false);
\r
780 Boolean.TYPE=Boolean.prototype.TYPE=Boolean;
\r
783 Clazz._Encoding=new Object();
\r
785 (function(Encoding) {
\r
787 Encoding.UTF8="utf-8";
\r
788 Encoding.UTF16="utf-16";
\r
789 Encoding.ASCII="ascii";
\r
792 Encoding.guessEncoding=function(str){
\r
793 if(str.charCodeAt(0)==0xEF&&str.charCodeAt(1)==0xBB&&str.charCodeAt(2)==0xBF){
\r
794 return Encoding.UTF8;
\r
795 }else if(str.charCodeAt(0)==0xFF&&str.charCodeAt(1)==0xFE){
\r
796 return Encoding.UTF16;
\r
798 return Encoding.ASCII;
\r
802 Encoding.readUTF8=function(str){
\r
803 var encoding=this.guessEncoding(str);
\r
805 if(encoding==Encoding.UTF8){
\r
807 }else if(encoding==Encoding.UTF16){
\r
810 var arrs=new Array();
\r
811 for(var i=startIdx;i<str.length;i++){
\r
812 var charCode=str.charCodeAt(i);
\r
814 arrs[arrs.length]=str.charAt(i);
\r
815 }else if(charCode>0xc0&&charCode<0xe0){
\r
816 var c1=charCode&0x1f;
\r
818 var c2=str.charCodeAt(i)&0x3f;
\r
820 arrs[arrs.length]=String.fromCharCode(c);
\r
821 }else if(charCode>=0xe0){
\r
822 var c1=charCode&0x0f;
\r
824 var c2=str.charCodeAt(i)&0x3f;
\r
826 var c3=str.charCodeAt(i)&0x3f;
\r
827 var c=(c1<<12)+(c2<<6)+c3;
\r
828 arrs[arrs.length]=String.fromCharCode(c);
\r
831 return arrs.join('');
\r
834 Encoding.convert2UTF8=function(str){
\r
835 var encoding=this.guessEncoding(str);
\r
837 if(encoding==Encoding.UTF8){
\r
839 }else if(encoding==Encoding.UTF16){
\r
844 var arrs=new Array(offset+str.length-startIdx);
\r
846 for(var i=startIdx;i<str.length;i++){
\r
847 var charCode=str.charCodeAt(i);
\r
849 arrs[offset+i-startIdx]=str.charAt(i);
\r
850 }else if(charCode<=0x07ff){
\r
851 var c1=0xc0+((charCode&0x07c0)>>6);
\r
852 var c2=0x80+(charCode&0x003f);
\r
853 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2);
\r
855 var c1=0xe0+((charCode&0xf000)>>12);
\r
856 var c2=0x80+((charCode&0x0fc0)>>6);
\r
857 var c3=0x80+(charCode&0x003f);
\r
858 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2)+String.fromCharCode(c3);
\r
861 return arrs.join('');
\r
863 Encoding.base64Chars=new Array(
\r
864 'A','B','C','D','E','F','G','H',
\r
865 'I','J','K','L','M','N','O','P',
\r
866 'Q','R','S','T','U','V','W','X',
\r
867 'Y','Z','a','b','c','d','e','f',
\r
868 'g','h','i','j','k','l','m','n',
\r
869 'o','p','q','r','s','t','u','v',
\r
870 'w','x','y','z','0','1','2','3',
\r
871 '4','5','6','7','8','9','+','/'
\r
873 Encoding.encodeBase64=function(str){
\r
874 if(str==null||str.length==0)return str;
\r
875 var b64=Encoding.base64Chars;
\r
876 var length=str.length;
\r
880 while(index<length){
\r
881 c0=str.charCodeAt(index++);
\r
882 buf[buf.length]=b64[c0>>2];
\r
884 c1=str.charCodeAt(index++);
\r
885 buf[buf.length]=b64[((c0<<4)&0x30)|(c1>>4)];
\r
887 c2=str.charCodeAt(index++);
\r
888 buf[buf.length]=b64[((c1<<2)&0x3c)|(c2>>6)];
\r
889 buf[buf.length]=b64[c2&0x3F];
\r
891 buf[buf.length]=b64[((c1<<2)&0x3c)];
\r
892 buf[buf.length]='=';
\r
895 buf[buf.length]=b64[(c0<<4)&0x30];
\r
896 buf[buf.length]='=';
\r
897 buf[buf.length]='=';
\r
900 return buf.join('');
\r
902 Encoding.decodeBase64=function(str){
\r
903 if(str==null||str.length==0)return str;
\r
904 var b64=Encoding.base64Chars;
\r
905 var xb64=Encoding.xBase64Chars;
\r
906 if(Encoding.xBase64Chars==null){
\r
908 for(var i=0;i<b64.length;i++){
\r
911 Encoding.xBase64Chars=xb64;
\r
913 var length=str.length;
\r
918 while(index<length&&c++<60000){
\r
919 c0=xb64[str.charAt(index++)];
\r
920 c1=xb64[str.charAt(index++)];
\r
921 c2=xb64[str.charAt(index++)];
\r
922 c3=xb64[str.charAt(index++)];
\r
923 buf[buf.length]=String.fromCharCode(((c0<<2)&0xff)|c1>>4);
\r
925 buf[buf.length]=String.fromCharCode(((c1<<4)&0xff)|c2>>2);
\r
927 buf[buf.length]=String.fromCharCode(((c2<<6)&0xff)|c3);
\r
931 return buf.join('');
\r
934 if(String.prototype.$replace==null){
\r
935 java.lang.String=String;
\r
936 if(Clazz._supportsNativeObject){
\r
937 for(var i=0;i<Clazz._extendedObjectMethods.length;i++){
\r
938 var p=Clazz._extendedObjectMethods[i];
\r
939 if("to$tring"==p||"toString"==p||"equals"==p||"hashCode"==p){
\r
942 String.prototype[p]=Clazz._O.prototype[p];
\r
946 Clazz.implementOf(String,[java.io.Serializable,CharSequence,Comparable]);
\r
948 String.getName=Clazz._innerFunctions.getName;
\r
950 String.serialVersionUID=String.prototype.serialVersionUID=-6849794470754667710;
\r
955 sp.$replace=function(c1,c2){
\r
956 if (c1 == c2 || this.indexOf (c1) < 0) return "" + this;
\r
957 if (c1.length == 1) {
\r
958 if ("\\$.*+|?^{}()[]".indexOf(c1) >= 0) c1 = "\\" + c1;
\r
960 c1=c1.replace(/([\\\$\.\*\+\|\?\^\{\}\(\)\[\]])/g,function($0,$1){return"\\"+$1;});
\r
962 return this.replace(new RegExp(c1,"gm"),c2);
\r
964 sp.$generateExpFunction=function(str){
\r
970 for(;i<str.length;i++){
\r
971 var ch=str.charAt(i);
\r
972 if(i!=str.length-1&&ch=='\\'){
\r
974 var c=str.charAt(i);
\r
979 }else if(i!=str.length-1&&ch=='$'){
\r
981 orders[idx]=parseInt(str.charAt(i));
\r
984 }else if(ch=='\r'){
\r
986 }else if(ch=='\n'){
\r
988 }else if(ch=='\t'){
\r
990 }else if(ch=='\"'){
\r
996 var funStr="f = function (";
\r
997 var max=Math.max.apply({},orders);
\r
998 for(i=0;i<=max;i++){
\r
1004 funStr+=") { return ";
\r
1005 for(i=0;i<arr.length-1;i++){
\r
1006 funStr+="\""+arr[i]+"\" + $"+orders[i]+" + ";
\r
1008 funStr+="\""+arr[i]+"\"; }";
\r
1014 sp.replaceAll=function(exp,str){
\r
1015 var regExp=new RegExp(exp,"gm");
\r
1016 return this.replace(regExp,this.$generateExpFunction(str));
\r
1018 sp.replaceFirst=function(exp,str){
\r
1019 var regExp=new RegExp(exp,"m");
\r
1020 return this.replace(regExp,this.$generateExpFunction(str));
\r
1022 sp.matches=function(exp){
\r
1024 exp="^("+exp+")$";
\r
1026 var regExp=new RegExp(exp,"gm");
\r
1027 var m=this.match(regExp);
\r
1028 return m!=null&&m.length!=0;
\r
1030 sp.regionMatches=function(ignoreCase,toffset,
\r
1031 other,ooffset,len){
\r
1033 if(typeof ignoreCase=="number"
\r
1034 ||(ignoreCase!=true&&ignoreCase!=false)){
\r
1038 toffset=ignoreCase;
\r
1044 if((ooffset<0)||(toffset<0)||(toffset>this.length-len)||
\r
1045 (ooffset>other.length-len)){
\r
1048 var s1=this.substring(toffset,toffset+len);
\r
1049 var s2=other.substring(ooffset,ooffset+len);
\r
1051 s1=s1.toLowerCase();
\r
1052 s2=s2.toLowerCase();
\r
1059 sp.$plit=function(regex,limit){
\r
1060 if (!limit && regex == " ")
\r
1061 return this.split(regex);
\r
1063 if(limit!=null&&limit>0){
\r
1067 var regExp=new RegExp("("+regex+")","gm");
\r
1069 var s=this.replace(regExp,function($0,$1){
\r
1073 }else if(count>limit){
\r
1079 regExp=new RegExp(regex,"gm");
\r
1080 var arr=this.split(regExp);
\r
1081 if(arr.length>limit){
\r
1082 arr[limit-1]=s.substring(s.indexOf("@@_@@")+5);
\r
1087 var regExp=new RegExp(regex,"gm");
\r
1088 return this.split(regExp);
\r
1092 sp.trim=function(){
\r
1093 var len=this.length;
\r
1096 while((st<len)&&(this.charAt(st)<=' ')){
\r
1099 while((st<len)&&(this.charAt(len-1)<=' ')){
\r
1102 return((st>0)||(len<len))?this.substring(st,len):this;
\r
1109 sp.trim=function(){
\r
1110 return this.replace(/^\s+/g,'').replace(/\s+$/g,'');
\r
1113 if (!sp.startsWith || !sp.endsWith) {
\r
1114 var sn=function(s, prefix,toffset){
\r
1117 var pc=prefix.length;
\r
1119 if((toffset<0)||(toffset>s.length-pc)){
\r
1123 if(s.charAt(to++)!=prefix.charAt(po++)){
\r
1130 sp.startsWith=function(prefix){
\r
1131 if(arguments.length==1){
\r
1132 return sn(this,arguments[0],0);
\r
1133 }else if(arguments.length==2){
\r
1134 return sn(this,arguments[0],arguments[1]);
\r
1140 sp.endsWith=function(suffix){
\r
1141 return sn(this, suffix,this.length-suffix.length);
\r
1146 sp.equals=function(anObject){
\r
1147 return this.valueOf()==anObject;
\r
1150 sp.equalsIgnoreCase=function(anotherString){
\r
1151 return(anotherString==null)?false:(this==anotherString
\r
1152 ||this.toLowerCase()==anotherString.toLowerCase());
\r
1158 sp.hashCode=function(){
\r
1162 var len=this.length;
\r
1163 for(var i=0;i<len;i++){
\r
1164 h=31*h+this.charCodeAt(off++);
\r
1172 sp.getBytes=function(){
\r
1173 if(arguments.length==4){
\r
1174 return this.getChars(arguments[0],arguments[1],arguments[2],arguments[3]);
\r
1177 if(arguments.length==1){
\r
1178 var cs=arguments[0].toString().toLowerCase();
\r
1180 "utf-8","UTF8","us-ascii","iso-8859-1","8859_1","gb2312","gb18030","gbk"
\r
1182 var existed=false;
\r
1183 for(var i=0;i<charset.length;i++){
\r
1184 if(charset[i]==cs){
\r
1190 throw new java.io.UnsupportedEncodingException();
\r
1192 if(cs=="utf-8"||cs=="utf8"){
\r
1193 s=Encoding.convert2UTF8(this);
\r
1196 var arrs=new Array(s.length);
\r
1198 for(var i=0;i<s.length;i++){
\r
1199 c=s.charCodeAt(i);
\r
1202 arrs[ii+1]=c&0xff;
\r
1203 arrs[ii+2]=(c&0xff00)>>8;
\r
1214 sp.compareTo=function(anotherString){
\r
1215 if(anotherString==null){
\r
1216 throw new java.lang.NullPointerException();
\r
1218 var len1=this.length;
\r
1219 var len2=anotherString.length;
\r
1220 var n=Math.min(len1,len2);
\r
1223 var c1=this.charCodeAt(k);
\r
1224 var c2=anotherString.charCodeAt(k);
\r
1235 sp.contains = function(a) {return this.indexOf(a) >= 0} // bh added
\r
1236 sp.compareTo = function(a){return this > a ? 1 : this < a ? -1 : 0} // bh added
\r
1240 sp.toCharArray=function(){
\r
1241 var result=new Array(this.length);
\r
1242 for(var i=0;i<this.length;i++){
\r
1243 result[i]=this.charAt(i);
\r
1247 String.value0f=String.valueOf;
\r
1248 String.valueOf=function(o){
\r
1249 if(o=="undefined"){
\r
1250 return String.value0f();
\r
1252 if(o instanceof Array){
\r
1253 if(arguments.length==1){
\r
1254 return o.join('');
\r
1256 var off=arguments[1];
\r
1257 var len=arguments[2];
\r
1258 var oo=new Array(len);
\r
1259 for(var i=0;i<len;i++){
\r
1262 return oo.join('');
\r
1268 sp.subSequence=function(beginIndex,endIndex){
\r
1269 return this.substring(beginIndex,endIndex);
\r
1272 sp.compareToIgnoreCase=function(str){
\r
1274 throw new NullPointerException();
\r
1276 var s1=this.toUpperCase();
\r
1277 var s2=str.toUpperCase();
\r
1281 var s1=this.toLowerCase();
\r
1282 var s2=str.toLowerCase();
\r
1293 sp.contentEquals=function(sb){
\r
1294 if(this.length!=sb.length()){
\r
1297 var v=sb.getValue();
\r
1300 var n=this.length;
\r
1302 if(this.charCodeAt(i++)!=v[j++]){
\r
1309 sp.getChars=function(srcBegin,srcEnd,dst,dstBegin){
\r
1311 throw new StringIndexOutOfBoundsException(srcBegin);
\r
1313 if(srcEnd>this.length){
\r
1314 throw new StringIndexOutOfBoundsException(srcEnd);
\r
1316 if(srcBegin>srcEnd){
\r
1317 throw new StringIndexOutOfBoundsException(srcEnd-srcBegin);
\r
1320 throw new NullPointerException();
\r
1322 for(var i=0;i<srcEnd-srcBegin;i++){
\r
1323 dst[dstBegin+i]=this.charAt(srcBegin+i);
\r
1326 sp.$concat=sp.concat;
\r
1327 sp.concat=function(s){
\r
1329 throw new NullPointerException();
\r
1331 return this.$concat(s);
\r
1334 sp.$lastIndexOf=sp.lastIndexOf;
\r
1335 sp.lastIndexOf=function(s,last){
\r
1336 if(last!=null&&last+this.length<=0){
\r
1340 return this.$lastIndexOf(s,last);
\r
1342 return this.$lastIndexOf(s);
\r
1346 sp.intern=function(){
\r
1347 return this.valueOf();
\r
1349 String.copyValueOf=sp.copyValueOf=function(){
\r
1350 if(arguments.length==1){
\r
1351 return String.instantialize(arguments[0]);
\r
1353 return String.instantialize(arguments[0],arguments[1],arguments[2]);
\r
1357 sp.codePointAt || (sp.codePointAt = sp.charCodeAt); // Firefox only
\r
1360 })(String.prototype);
\r
1364 String.indexOf=function(source,sourceOffset,sourceCount,
\r
1365 target,targetOffset,targetCount,fromIndex){
\r
1366 if(fromIndex>=sourceCount){
\r
1367 return(targetCount==0?sourceCount:-1);
\r
1372 if(targetCount==0){
\r
1376 var first=target[targetOffset];
\r
1377 var i=sourceOffset+fromIndex;
\r
1378 var max=sourceOffset+(sourceCount-targetCount);
\r
1380 startSearchForFirstChar:
\r
1383 while(i<=max&&source[i]!=first){
\r
1392 var end=j+targetCount-1;
\r
1393 var k=targetOffset+1;
\r
1395 if(source[j++]!=target[k++]){
\r
1398 continue startSearchForFirstChar;
\r
1401 return i-sourceOffset;
\r
1407 String.instantialize=function(){
\r
1408 if(arguments.length==0){
\r
1409 return new String();
\r
1410 }else if(arguments.length==1){
\r
1411 var x=arguments[0];
\r
1412 if(typeof x=="string"||x instanceof String){
\r
1413 return new String(x);
\r
1414 }else if(x instanceof Array){
\r
1415 if(x.length>0&&typeof x[0]=="number"){
\r
1416 var arr=new Array(x.length);
\r
1417 for(var i=0;i<x.length;i++){
\r
1418 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1420 return Encoding.readUTF8(arr.join(''));
\r
1422 return x.join('');
\r
1423 }else if(x.__CLASS_NAME__=="StringBuffer"
\r
1424 ||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1425 var value=x.shareValue();
\r
1426 var length=x.length();
\r
1427 var valueCopy=new Array(length);
\r
1428 for(var i=0;i<length;i++){
\r
1429 valueCopy[i]=value[i];
\r
1431 return valueCopy.join('')
\r
1436 }else if(arguments.length==2){
\r
1437 var x=arguments[0];
\r
1438 var hibyte=arguments[1];
\r
1439 if(typeof hibyte=="string"){
\r
1440 return String.instantialize(x,0,x.length,hibyte);
\r
1442 return String.instantialize(x,hibyte,0,x.length);
\r
1444 }else if(arguments.length==3){
\r
1445 var bytes=arguments[0];
\r
1446 var offset=arguments[1];
\r
1447 var length=arguments[2];
\r
1448 if(arguments[2]instanceof Array){
\r
1449 bytes=arguments[2];
\r
1450 offset=arguments[0];
\r
1451 length=arguments[1];
\r
1453 var arr=new Array(length);
\r
1454 if(offset<0||length+offset>bytes.length){
\r
1455 throw new IndexOutOfBoundsException();
\r
1458 var isChar=(bytes[offset].length!=null);
\r
1460 for(var i=0;i<length;i++){
\r
1461 arr[i]=bytes[offset+i];
\r
1464 for(var i=0;i<length;i++){
\r
1465 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1469 return arr.join('');
\r
1470 }else if(arguments.length==4){
\r
1471 var bytes=arguments[0];
\r
1472 var y=arguments[3];
\r
1473 if(typeof y=="string"||y instanceof String){
\r
1474 var offset=arguments[1];
\r
1475 var length=arguments[2];
\r
1476 var arr=new Array(length);
\r
1477 for(var i=0;i<length;i++){
\r
1478 arr[i]=bytes[offset+i];
\r
1479 if(typeof arr[i]=="number"){
\r
1480 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1483 var cs=y.toLowerCase();
\r
1484 if(cs=="utf-8"||cs=="utf8"){
\r
1485 return Encoding.readUTF8(arr.join(''));
\r
1487 return arr.join('');
\r
1490 var count=arguments[3];
\r
1491 var offset=arguments[2];
\r
1492 var hibyte=arguments[1];
\r
1493 var value=new Array(count);
\r
1495 for(var i=count;i-->0;){
\r
1496 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1500 for(var i=count;i-->0;){
\r
1501 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1504 return value.join('');
\r
1508 for(var i=0;i<arguments.length;i++){
\r
1519 String.instantialize=function(){
\r
1520 switch (arguments.length) {
\r
1522 return new String();
\r
1524 var x=arguments[0];
\r
1525 if(typeof x=="string"||x instanceof String){
\r
1526 return new String(x);
\r
1528 if(x instanceof Array || x instanceof Int32Array){
\r
1531 if(typeof x[0]!="number")
\r
1532 return x.join('');
\r
1533 var arr=new Array(x.length);
\r
1534 for(var i=0;i<x.length;i++)
\r
1535 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1536 return Encoding.readUTF8(arr.join(''));
\r
1538 if(x.__CLASS_NAME__=="StringBuffer"||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1539 var value=x.shareValue();
\r
1540 var length=x.length();
\r
1541 var valueCopy=new Array(length);
\r
1542 for(var i=0;i<length;i++){
\r
1543 valueCopy[i]=value[i];
\r
1545 return valueCopy.join('')
\r
1549 var x=arguments[0];
\r
1550 var hibyte=arguments[1];
\r
1551 if(typeof hibyte=="string"){
\r
1552 return String.instantialize(x,0,x.length,hibyte);
\r
1554 return String.instantialize(x,hibyte,0,x.length);
\r
1556 var bytes=arguments[0];
\r
1557 var offset=arguments[1];
\r
1558 var length=arguments[2];
\r
1559 if(arguments[2]instanceof Array){
\r
1560 bytes=arguments[2];
\r
1561 offset=arguments[0];
\r
1562 length=arguments[1];
\r
1564 var arr=new Array(length);
\r
1565 if(offset<0||length+offset>bytes.length){
\r
1566 throw new IndexOutOfBoundsException();
\r
1569 var isChar=(bytes[offset].length!=null);
\r
1571 for(var i=0;i<length;i++){
\r
1572 arr[i]=bytes[offset+i];
\r
1575 for(var i=0;i<length;i++){
\r
1576 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1580 return arr.join('');
\r
1582 var bytes=arguments[0];
\r
1583 var y=arguments[3];
\r
1584 if(typeof y=="string"||y instanceof String){
\r
1585 var offset=arguments[1];
\r
1586 var length=arguments[2];
\r
1587 var arr=new Array(length);
\r
1588 for(var i=0;i<length;i++){
\r
1589 arr[i]=bytes[offset+i];
\r
1590 if(typeof arr[i]=="number"){
\r
1591 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1594 var cs=y.toLowerCase();
\r
1595 if(cs=="utf-8"||cs=="utf8"){
\r
1596 return Encoding.readUTF8(arr.join(''));
\r
1598 return arr.join('');
\r
1600 var count=arguments[3];
\r
1601 var offset=arguments[2];
\r
1602 var hibyte=arguments[1];
\r
1603 var value=new Array(count);
\r
1605 for(var i=count;i-->0;){
\r
1606 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1610 for(var i=count;i-->0;){
\r
1611 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1614 return value.join('');
\r
1617 for(var i=0;i<arguments.length;i++){
\r
1624 if(navigator.userAgent.toLowerCase().indexOf("chrome")!=-1){
\r
1625 String.prototype.toString=function(){return this.valueOf();};
\r
1630 })(Clazz._Encoding);
\r
1634 c$=Clazz.decorateAsClass(function(){
\r
1636 Clazz.instantialize(this,arguments);
\r
1637 },java.lang,"Character",null,[java.io.Serializable,Comparable]);
\r
1638 Clazz.makeConstructor(c$,
\r
1642 Clazz.defineMethod(c$,"charValue",
\r
1644 return this.value;
\r
1646 Clazz.overrideMethod(c$,"hashCode",
\r
1648 return(this.value).charCodeAt(0);
\r
1650 Clazz.overrideMethod(c$,"equals",
\r
1652 if(Clazz.instanceOf(obj,Character)){
\r
1653 return(this.value).charCodeAt(0)==((obj).charValue()).charCodeAt(0);
\r
1656 Clazz.overrideMethod(c$,"compareTo",
\r
1658 return(this.value).charCodeAt(0)-(c.value).charCodeAt(0);
\r
1660 c$.toLowerCase=Clazz.defineMethod(c$,"toLowerCase",
\r
1662 return(""+c).toLowerCase().charAt(0);
\r
1664 c$.toUpperCase=Clazz.defineMethod(c$,"toUpperCase",
\r
1666 return(""+c).toUpperCase().charAt(0);
\r
1668 c$.isDigit=Clazz.defineMethod(c$,"isDigit",
\r
1670 c = c.charCodeAt(0);
\r
1671 return (48 <= c && c <= 57);
\r
1673 c$.isUpperCase=Clazz.defineMethod(c$,"isUpperCase",
\r
1675 c = c.charCodeAt(0);
\r
1676 return (65 <= c && c <= 90);
\r
1678 c$.isLowerCase=Clazz.defineMethod(c$,"isLowerCase",
\r
1680 c = c.charCodeAt(0);
\r
1681 return (97 <= c && c <= 122);
\r
1683 c$.isWhitespace=Clazz.defineMethod(c$,"isWhitespace",
\r
1685 c = (c).charCodeAt(0);
\r
1686 return (c >= 0x1c && c <= 0x20 || c >= 0x9 && c <= 0xd || c == 0x1680
\r
1687 || c >= 0x2000 && c != 0x2007 && (c <= 0x200b || c == 0x2028 || c == 0x2029 || c == 0x3000));
\r
1689 c$.isLetter=Clazz.defineMethod(c$,"isLetter",
\r
1691 c = c.charCodeAt(0);
\r
1692 return (65 <= c && c <= 90 || 97 <= c && c <= 122);
\r
1694 c$.isLetterOrDigit=Clazz.defineMethod(c$,"isLetterOrDigit",
\r
1696 c = c.charCodeAt(0);
\r
1697 return (65 <= c && c <= 90 || 97 <= c && c <= 122 || 48 <= c && c <= 57);
\r
1699 c$.isSpaceChar=Clazz.defineMethod(c$,"isSpaceChar",
\r
1701 var i = c.charCodeAt(0);
\r
1702 if(i==0x20||i==0xa0||i==0x1680)return true;
\r
1703 if(i<0x2000)return false;
\r
1704 return i<=0x200b||i==0x2028||i==0x2029||i==0x202f||i==0x3000;
\r
1706 c$.digit=Clazz.defineMethod(c$,"digit",
\r
1707 function(c,radix){
\r
1708 var i = c.charCodeAt(0);
\r
1709 if(radix >= 2 && radix <= 36){
\r
1712 if(48 <= i && i <= 57){
\r
1714 }else if(97 <= i && i <= 122){
\r
1716 }else if(65 <= i && i <= 90){
\r
1719 return (result < radix ? result : -1);
\r
1724 Clazz.overrideMethod(c$,"toString",
\r
1726 var buf=[this.value];
\r
1727 return String.valueOf(buf);
\r
1729 c$.toString=Clazz.overrideMethod(c$,"toString",
\r
1732 if(this===Character){
\r
1733 return"class java.lang.Character";
\r
1735 }return String.valueOf(c);
\r
1737 Clazz.defineStatics(c$,
\r
1738 "MIN_VALUE",'\u0000',
\r
1739 "MAX_VALUE",'\uffff',
\r
1744 java.lang.Character.TYPE=java.lang.Character.prototype.TYPE=java.lang.Character;
\r
1748 Clazz._ArrayWrapper = function(a, type) {
\r
1751 __CLASS_NAME__:"Array",
\r
1752 superClazz: Array,
\r
1753 getComponentType: function() {return type},
\r
1754 instanceOf: function(o) { return Clazz.instanceOf(type, o) },
\r
1755 getName: function() { return this.__CLASS_NAME__ }
\r
1758 c$=Clazz_declareType(java.lang.reflect,"Array");
\r
1759 c$.newInstance=Clazz_defineMethod(c$,"newInstance",
\r
1760 function(componentType,size){
\r
1761 var a = Clazz_newArray(size);
\r
1762 a.getClass = function() { return new Clazz._ArrayWrapper(this, componentType);};
\r
1766 javautil.Date=Date;
\r
1767 Date.TYPE="javautil.Date";
\r
1768 Date.__CLASS_NAME__="Date";
\r
1769 Clazz.implementOf(Date,[java.io.Serializable,java.lang.Comparable]);
\r
1771 Clazz.defineMethod(javautil.Date,"clone",
\r
1773 return new Date(this.getTime());
\r
1776 Clazz.defineMethod(javautil.Date,"before",
\r
1778 return this.getTime()<when.getTime();
\r
1779 },"javautil.Date");
\r
1780 Clazz.defineMethod(javautil.Date,"after",
\r
1782 return this.getTime()>when.getTime();
\r
1783 },"javautil.Date");
\r
1784 Clazz.defineMethod(javautil.Date,"equals",
\r
1786 return Clazz.instanceOf(obj,javautil.Date)&&this.getTime()==(obj).getTime();
\r
1788 Clazz.defineMethod(javautil.Date,"compareTo",
\r
1789 function(anotherDate){
\r
1790 var thisTime=this.getTime();
\r
1791 var anotherTime=anotherDate.getTime();
\r
1792 return(thisTime<anotherTime?-1:(thisTime==anotherTime?0:1));
\r
1793 },"javautil.Date");
\r
1794 Clazz.defineMethod(javautil.Date,"compareTo",
\r
1796 return this.compareTo(o);
\r
1798 Clazz.overrideMethod(javautil.Date,"hashCode",
\r
1800 var ht=this.getTime();
\r
1801 return parseInt(ht)^parseInt((ht>>32));
\r
1804 c$=Clazz.decorateAsClass(function(){
\r
1806 Clazz.instantialize(this,arguments);
\r
1807 },javautil,"EventObject",null,java.io.Serializable);
\r
1808 Clazz.makeConstructor(c$,
\r
1810 if(source!=null)this.source=source;
\r
1811 else throw new IllegalArgumentException();
\r
1813 Clazz.defineMethod(c$,"getSource",
\r
1815 return this.source;
\r
1817 Clazz.overrideMethod(c$,"toString",
\r
1819 return this.getClass().getName()+"[source="+String.valueOf(this.source)+']';
\r
1821 Clazz.declareInterface(javautil,"EventListener");
\r
1823 c$=Clazz.decorateAsClass(function(){
\r
1824 this.listener=null;
\r
1825 Clazz.instantialize(this,arguments);
\r
1826 },javautil,"EventListenerProxy",null,javautil.EventListener);
\r
1827 Clazz.makeConstructor(c$,
\r
1828 function(listener){
\r
1829 this.listener=listener;
\r
1830 },"javautil.EventListener");
\r
1831 Clazz.defineMethod(c$,"getListener",
\r
1833 return this.listener;
\r
1835 Clazz.declareInterface(javautil,"Iterator");
\r
1837 Clazz.declareInterface(javautil,"ListIterator",javautil.Iterator);
\r
1838 Clazz.declareInterface(javautil,"Enumeration");
\r
1839 Clazz.declareInterface(javautil,"Collection",Iterable);
\r
1841 Clazz.declareInterface(javautil,"Set",javautil.Collection);
\r
1842 Clazz.declareInterface(javautil,"Map");
\r
1843 Clazz.declareInterface(javautil.Map,"Entry");
\r
1845 Clazz.declareInterface(javautil,"List",javautil.Collection);
\r
1847 Clazz.declareInterface(javautil,"Queue",javautil.Collection);
\r
1848 Clazz.declareInterface(javautil,"RandomAccess");
\r
1849 c$=Clazz.decorateAsClass(function(){
\r
1850 this.detailMessage=null;
\r
1852 this.stackTrace=null;
\r
1853 Clazz.instantialize(this,arguments);
\r
1854 },java.lang,"Throwable",null,java.io.Serializable);
\r
1855 Clazz.prepareFields(c$,function(){
\r
1857 //alert("e0 "+ arguments.callee.caller.caller.caller.caller.caller)
\r
1859 Clazz.makeConstructor(c$,
\r
1861 this.fillInStackTrace();
\r
1863 Clazz.makeConstructor(c$,
\r
1864 function(message){
\r
1865 this.fillInStackTrace();
\r
1866 this.detailMessage=message;
\r
1868 Clazz.makeConstructor(c$,
\r
1869 function(message,cause){
\r
1870 this.fillInStackTrace();
\r
1871 this.detailMessage=message;
\r
1873 },"~S,Throwable");
\r
1874 Clazz.makeConstructor(c$,
\r
1876 this.fillInStackTrace();
\r
1877 this.detailMessage=(cause==null?null:cause.toString());
\r
1880 Clazz.defineMethod(c$,"getMessage",
\r
1882 return (this.message || this.detailMessage || this.toString());
\r
1884 Clazz.defineMethod(c$,"getLocalizedMessage",
\r
1886 return this.getMessage();
\r
1888 Clazz.defineMethod(c$,"getCause",
\r
1890 return(this.cause===this?null:this.cause);
\r
1892 Clazz.defineMethod(c$,"initCause",
\r
1894 if(this.cause!==this)throw new IllegalStateException("Can't overwrite cause");
\r
1895 if(cause===this)throw new IllegalArgumentException("Self-causation not permitted");
\r
1899 Clazz.overrideMethod(c$,"toString",
\r
1901 var s=this.getClass().getName();
\r
1902 var message=this.message || this.detailMessage;
\r
1903 return(message ? s+": "+message : s);
\r
1905 Clazz.defineMethod(c$,"printStackTrace",
\r
1907 System.err.println(this.getStackTrace ? this.getStackTrace() : this.message + " " + Clazz.getStackTrace());
\r
1910 Clazz.defineMethod(c$,"getStackTrace",
\r
1912 var s = "" + this + "\n";
\r
1913 for(var i=0;i<this.stackTrace.length;i++){
\r
1914 var t=this.stackTrace[i];
\r
1915 var x=t.methodName.indexOf("(");
\r
1916 var n=t.methodName.substring(0,x).replace(/\s+/g,"");
\r
1917 if(n!="construct"||t.nativeClazz==null
\r
1918 ||Clazz.getInheritedLevel(t.nativeClazz,Throwable)<0){
\r
1926 Clazz.defineMethod(c$,"printStackTrace",
\r
1928 this.printStackTrace();
\r
1929 },"java.io.PrintStream");
\r
1930 Clazz.defineMethod(c$,"printStackTrace",
\r
1932 this.printStackTrace();
\r
1933 },"java.io.PrintWriter");
\r
1934 Clazz.defineMethod(c$,"fillInStackTrace",
\r
1936 this.stackTrace=new Array();
\r
1937 var caller=arguments.callee.caller;
\r
1938 var superCaller=null;
\r
1939 var callerList=new Array();
\r
1940 var index=Clazz._callingStackTraces.length-1;
\r
1941 var noLooping=true;
\r
1942 while(index>-1||caller!=null){
\r
1943 var clazzName=null;
\r
1944 var nativeClass=null;
\r
1945 if(!noLooping||caller==Clazz.tryToSearchAndExecute||caller==Clazz.superCall||caller==null){
\r
1950 superCaller=Clazz._callingStackTraces[index].caller;
\r
1951 nativeClass=Clazz._callingStackTraces[index].owner;
\r
1954 superCaller=caller;
\r
1955 if(superCaller.claxxOwner!=null){
\r
1956 nativeClass=superCaller.claxxOwner;
\r
1957 }else if(superCaller.exClazz!=null){
\r
1958 nativeClass=superCaller.exClazz;
\r
1961 var st=new StackTraceElement(
\r
1962 ((nativeClass!=null&&nativeClass.__CLASS_NAME__.length!=0)?
\r
1963 nativeClass.__CLASS_NAME__:"anonymous"),
\r
1964 ((superCaller.exName==null)?"anonymous":superCaller.exName)
\r
1965 +" ("+Clazz.getParamsType(superCaller.arguments)+")",
\r
1967 st.nativeClazz=nativeClass;
\r
1968 this.stackTrace[this.stackTrace.length]=st;
\r
1969 for(var i=0;i<callerList.length;i++){
\r
1970 if(callerList[i]==superCaller){
\r
1972 var st=new StackTraceElement("lost","missing",null,-3);
\r
1973 st.nativeClazz=null;
\r
1974 this.stackTrace[this.stackTrace.length]=st;
\r
1979 if(superCaller!=null){
\r
1980 callerList[callerList.length]=superCaller;
\r
1982 caller=superCaller.arguments.callee.caller;
\r
1984 Clazz._initializingException=false;
\r
1987 Clazz.defineMethod(c$,"setStackTrace",
\r
1988 function(stackTrace){
\r
1989 var defensiveCopy=stackTrace.clone();
\r
1990 for(var i=0;i<defensiveCopy.length;i++)if(defensiveCopy[i]==null)throw new NullPointerException("stackTrace["+i+"]");
\r
1992 this.stackTrace=defensiveCopy;
\r
1995 c$=Clazz.decorateAsClass(function(){
\r
1996 this.declaringClass=null;
\r
1997 this.methodName=null;
\r
1998 this.fileName=null;
\r
1999 this.lineNumber=0;
\r
2000 Clazz.instantialize(this,arguments);
\r
2001 },java.lang,"StackTraceElement",null,java.io.Serializable);
\r
2002 Clazz.makeConstructor(c$,
\r
2003 function(cls,method,file,line){
\r
2004 if(cls==null||method==null){
\r
2005 throw new NullPointerException();
\r
2006 }this.declaringClass=cls;
\r
2007 this.methodName=method;
\r
2008 this.fileName=file;
\r
2009 this.lineNumber=line;
\r
2011 Clazz.overrideMethod(c$,"equals",
\r
2013 if(!(Clazz.instanceOf(obj,StackTraceElement))){
\r
2016 if((this.methodName==null)||(castObj.methodName==null)){
\r
2018 }if(!this.getMethodName().equals(castObj.getMethodName())){
\r
2020 }if(!this.getClassName().equals(castObj.getClassName())){
\r
2022 }var localFileName=this.getFileName();
\r
2023 if(localFileName==null){
\r
2024 if(castObj.getFileName()!=null){
\r
2027 if(!localFileName.equals(castObj.getFileName())){
\r
2029 }}if(this.getLineNumber()!=castObj.getLineNumber()){
\r
2033 Clazz.defineMethod(c$,"getClassName",
\r
2035 return(this.declaringClass==null)?"<unknown class>":this.declaringClass;
\r
2037 Clazz.defineMethod(c$,"getFileName",
\r
2039 return this.fileName;
\r
2041 Clazz.defineMethod(c$,"getLineNumber",
\r
2043 return this.lineNumber;
\r
2045 Clazz.defineMethod(c$,"getMethodName",
\r
2047 return(this.methodName==null)?"<unknown method>":this.methodName;
\r
2049 Clazz.overrideMethod(c$,"hashCode",
\r
2051 if(this.methodName==null){
\r
2053 }return this.methodName.hashCode()^this.declaringClass.hashCode();
\r
2055 Clazz.defineMethod(c$,"isNativeMethod",
\r
2057 return this.lineNumber==-2;
\r
2059 Clazz.overrideMethod(c$,"toString",
\r
2061 var buf=new StringBuilder(80);
\r
2062 buf.append(this.getClassName());
\r
2064 buf.append(this.getMethodName());
\r
2065 if(this.isNativeMethod()){
\r
2066 buf.append("(Native Method)");
\r
2068 var fName=this.getFileName();
\r
2070 buf.append("(Unknown Source)");
\r
2072 var lineNum=this.getLineNumber();
\r
2074 buf.append(fName);
\r
2077 buf.append(lineNum);
\r
2079 }}return buf.toString();
\r
2081 TypeError.prototype.getMessage || (TypeError.prototype.getMessage = function(){ return (this.message || this.toString()) + (this.getStackTrace ? this.getStackTrace() : Clazz.getStackTrace())});
\r
2082 c$=Clazz.declareType(java.lang,"Error",Throwable);
\r
2084 c$=Clazz.declareType(java.lang,"LinkageError",Error);
\r
2086 c$=Clazz.declareType(java.lang,"IncompatibleClassChangeError",LinkageError);
\r
2088 c$=Clazz.declareType(java.lang,"AbstractMethodError",IncompatibleClassChangeError);
\r
2090 c$=Clazz.declareType(java.lang,"AssertionError",Error);
\r
2091 Clazz.makeConstructor(c$,
\r
2092 function(detailMessage){
\r
2093 Clazz.superConstructor(this,AssertionError,[String.valueOf(detailMessage),(Clazz.instanceOf(detailMessage,Throwable)?detailMessage:null)]);
\r
2095 Clazz.makeConstructor(c$,
\r
2096 function(detailMessage){
\r
2097 this.construct("" + detailMessage);
\r
2099 Clazz.makeConstructor(c$,
\r
2100 function(detailMessage){
\r
2101 this.construct("" + detailMessage);
\r
2104 c$=Clazz.declareType(java.lang,"ClassCircularityError",LinkageError);
\r
2106 c$=Clazz.declareType(java.lang,"ClassFormatError",LinkageError);
\r
2108 c$=Clazz.decorateAsClass(function(){
\r
2109 this.exception=null;
\r
2110 Clazz.instantialize(this,arguments);
\r
2111 },java.lang,"ExceptionInInitializerError",LinkageError);
\r
2112 Clazz.makeConstructor(c$,
\r
2114 Clazz.superConstructor(this,ExceptionInInitializerError);
\r
2115 this.initCause(null);
\r
2117 Clazz.makeConstructor(c$,
\r
2118 function(detailMessage){
\r
2119 Clazz.superConstructor(this,ExceptionInInitializerError,[detailMessage]);
\r
2120 this.initCause(null);
\r
2122 Clazz.makeConstructor(c$,
\r
2123 function(exception){
\r
2124 Clazz.superConstructor(this,ExceptionInInitializerError);
\r
2125 this.exception=exception;
\r
2126 this.initCause(exception);
\r
2128 Clazz.defineMethod(c$,"getException",
\r
2130 return this.exception;
\r
2132 Clazz.overrideMethod(c$,"getCause",
\r
2134 return this.exception;
\r
2137 c$=Clazz.declareType(java.lang,"IllegalAccessError",IncompatibleClassChangeError);
\r
2139 c$=Clazz.declareType(java.lang,"InstantiationError",IncompatibleClassChangeError);
\r
2141 c$=Clazz.declareType(java.lang,"VirtualMachineError",Error);
\r
2143 c$=Clazz.declareType(java.lang,"InternalError",VirtualMachineError);
\r
2145 c$=Clazz.declareType(java.lang,"NoClassDefFoundError",LinkageError);
\r
2147 c$=Clazz.declareType(java.lang,"NoSuchFieldError",IncompatibleClassChangeError);
\r
2149 c$=Clazz.declareType(java.lang,"NoSuchMethodError",IncompatibleClassChangeError);
\r
2151 c$=Clazz.declareType(java.lang,"OutOfMemoryError",VirtualMachineError);
\r
2153 c$=Clazz.declareType(java.lang,"StackOverflowError",VirtualMachineError);
\r
2155 c$=Clazz.declareType(java.lang,"UnknownError",VirtualMachineError);
\r
2157 c$=Clazz.declareType(java.lang,"UnsatisfiedLinkError",LinkageError);
\r
2159 c$=Clazz.declareType(java.lang,"UnsupportedClassVersionError",ClassFormatError);
\r
2161 c$=Clazz.declareType(java.lang,"VerifyError",LinkageError);
\r
2163 c$=Clazz.declareType(java.lang,"ThreadDeath",Error);
\r
2164 Clazz.makeConstructor(c$,
\r
2166 Clazz.superConstructor(this,ThreadDeath,[]);
\r
2169 c$=Clazz.declareType(java.lang,"Exception",Throwable);
\r
2171 c$=Clazz.declareType(java.lang,"RuntimeException",Exception);
\r
2173 c$=Clazz.declareType(java.lang,"ArithmeticException",RuntimeException);
\r
2175 c$=Clazz.declareType(java.lang,"IndexOutOfBoundsException",RuntimeException);
\r
2177 c$=Clazz.declareType(java.lang,"ArrayIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2178 Clazz.makeConstructor(c$,
\r
2180 Clazz.superConstructor(this,ArrayIndexOutOfBoundsException,["Array index out of range: "+index]);
\r
2183 c$=Clazz.declareType(java.lang,"ArrayStoreException",RuntimeException);
\r
2185 c$=Clazz.declareType(java.lang,"ClassCastException",RuntimeException);
\r
2187 c$=Clazz.decorateAsClass(function(){
\r
2189 Clazz.instantialize(this,arguments);
\r
2190 },java.lang,"ClassNotFoundException",Exception);
\r
2191 Clazz.makeConstructor(c$,
\r
2193 Clazz.superConstructor(this,ClassNotFoundException,[Clazz.castNullAs("Throwable")]);
\r
2195 Clazz.makeConstructor(c$,
\r
2196 function(detailMessage){
\r
2197 Clazz.superConstructor(this,ClassNotFoundException,[detailMessage,null]);
\r
2199 Clazz.makeConstructor(c$,
\r
2200 function(detailMessage,exception){
\r
2201 Clazz.superConstructor(this,ClassNotFoundException,[detailMessage]);
\r
2202 this.ex=exception;
\r
2203 },"~S,Throwable");
\r
2204 Clazz.defineMethod(c$,"getException",
\r
2208 Clazz.overrideMethod(c$,"getCause",
\r
2213 c$=Clazz.declareType(java.lang,"CloneNotSupportedException",Exception);
\r
2215 c$=Clazz.declareType(java.lang,"IllegalAccessException",Exception);
\r
2217 c$=Clazz.declareType(java.lang,"IllegalArgumentException",RuntimeException);
\r
2218 Clazz.makeConstructor(c$,
\r
2220 Clazz.superConstructor(this,IllegalArgumentException,[(cause==null?null:cause.toString()),cause]);
\r
2223 c$=Clazz.declareType(java.lang,"IllegalMonitorStateException",RuntimeException);
\r
2225 c$=Clazz.declareType(java.lang,"IllegalStateException",RuntimeException);
\r
2226 Clazz.makeConstructor(c$,
\r
2228 Clazz.superConstructor(this,IllegalStateException,[(cause==null?null:cause.toString()),cause]);
\r
2231 c$=Clazz.declareType(java.lang,"IllegalThreadStateException",IllegalArgumentException);
\r
2233 c$=Clazz.declareType(java.lang,"InstantiationException",Exception);
\r
2235 c$=Clazz.declareType(java.lang,"InterruptedException",Exception);
\r
2237 c$=Clazz.declareType(java.lang,"NegativeArraySizeException",RuntimeException);
\r
2239 c$=Clazz.declareType(java.lang,"NoSuchFieldException",Exception);
\r
2241 c$=Clazz.declareType(java.lang,"NoSuchMethodException",Exception);
\r
2243 c$=Clazz.declareType(java.lang,"NullPointerException",RuntimeException);
\r
2245 c$=Clazz.declareType(java.lang,"NumberFormatException",IllegalArgumentException);
\r
2247 c$=Clazz.declareType(java.lang,"SecurityException",RuntimeException);
\r
2248 Clazz.makeConstructor(c$,
\r
2250 Clazz.superConstructor(this,SecurityException,[(cause==null?null:cause.toString()),cause]);
\r
2253 c$=Clazz.declareType(java.lang,"StringIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2254 Clazz.makeConstructor(c$,
\r
2256 Clazz.superConstructor(this,StringIndexOutOfBoundsException,["String index out of range: "+index]);
\r
2259 c$=Clazz.declareType(java.lang,"UnsupportedOperationException",RuntimeException);
\r
2260 Clazz.makeConstructor(c$,
\r
2262 Clazz.superConstructor(this,UnsupportedOperationException,[]);
\r
2264 Clazz.makeConstructor(c$,
\r
2266 Clazz.superConstructor(this,UnsupportedOperationException,[(cause==null?null:cause.toString()),cause]);
\r
2269 c$=Clazz.decorateAsClass(function(){
\r
2271 Clazz.instantialize(this,arguments);
\r
2272 },java.lang.reflect,"InvocationTargetException",Exception);
\r
2273 Clazz.makeConstructor(c$,
\r
2275 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[Clazz.castNullAs("Throwable")]);
\r
2277 Clazz.makeConstructor(c$,
\r
2278 function(exception){
\r
2279 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[null,exception]);
\r
2280 this.target=exception;
\r
2282 Clazz.makeConstructor(c$,
\r
2283 function(exception,detailMessage){
\r
2284 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[detailMessage,exception]);
\r
2285 this.target=exception;
\r
2286 },"Throwable,~S");
\r
2287 Clazz.defineMethod(c$,"getTargetException",
\r
2289 return this.target;
\r
2291 Clazz.overrideMethod(c$,"getCause",
\r
2293 return this.target;
\r
2296 c$=Clazz.decorateAsClass(function(){
\r
2297 this.undeclaredThrowable=null;
\r
2298 Clazz.instantialize(this,arguments);
\r
2299 },java.lang.reflect,"UndeclaredThrowableException",RuntimeException);
\r
2300 Clazz.makeConstructor(c$,
\r
2301 function(exception){
\r
2302 Clazz.superConstructor(this,java.lang.reflect.UndeclaredThrowableException);
\r
2303 this.undeclaredThrowable=exception;
\r
2304 this.initCause(exception);
\r
2306 Clazz.makeConstructor(c$,
\r
2307 function(exception,detailMessage){
\r
2308 Clazz.superConstructor(this,java.lang.reflect.UndeclaredThrowableException,[detailMessage]);
\r
2309 this.undeclaredThrowable=exception;
\r
2310 this.initCause(exception);
\r
2311 },"Throwable,~S");
\r
2312 Clazz.defineMethod(c$,"getUndeclaredThrowable",
\r
2314 return this.undeclaredThrowable;
\r
2316 Clazz.overrideMethod(c$,"getCause",
\r
2318 return this.undeclaredThrowable;
\r
2321 c$=Clazz.declareType(java.io,"IOException",Exception);
\r
2324 c$=Clazz.declareType(java.io,"CharConversionException",java.io.IOException);
\r
2326 c$=Clazz.declareType(java.io,"EOFException",java.io.IOException);
\r
2328 c$=Clazz.declareType(java.io,"FileNotFoundException",java.io.IOException);
\r
2330 c$=Clazz.decorateAsClass(function(){
\r
2331 this.bytesTransferred=0;
\r
2332 Clazz.instantialize(this,arguments);
\r
2333 },java.io,"InterruptedIOException",java.io.IOException);
\r
2335 c$=Clazz.declareType(java.io,"ObjectStreamException",java.io.IOException);
\r
2337 c$=Clazz.decorateAsClass(function(){
\r
2338 this.classname=null;
\r
2339 Clazz.instantialize(this,arguments);
\r
2340 },java.io,"InvalidClassException",java.io.ObjectStreamException);
\r
2341 Clazz.makeConstructor(c$,
\r
2342 function(className,detailMessage){
\r
2343 Clazz.superConstructor(this,java.io.InvalidClassException,[detailMessage]);
\r
2344 this.classname=className;
\r
2346 Clazz.defineMethod(c$,"getMessage",
\r
2348 var msg=Clazz.superCall(this,java.io.InvalidClassException,"getMessage",[]);
\r
2349 if(this.classname!=null){
\r
2350 msg=this.classname+';' + ' '+msg;
\r
2354 c$=Clazz.declareType(java.io,"InvalidObjectException",java.io.ObjectStreamException);
\r
2356 c$=Clazz.declareType(java.io,"NotActiveException",java.io.ObjectStreamException);
\r
2358 c$=Clazz.declareType(java.io,"NotSerializableException",java.io.ObjectStreamException);
\r
2360 c$=Clazz.decorateAsClass(function(){
\r
2363 Clazz.instantialize(this,arguments);
\r
2364 },java.io,"OptionalDataException",java.io.ObjectStreamException);
\r
2366 c$=Clazz.declareType(java.io,"StreamCorruptedException",java.io.ObjectStreamException);
\r
2368 c$=Clazz.declareType(java.io,"SyncFailedException",java.io.IOException);
\r
2370 c$=Clazz.declareType(java.io,"UnsupportedEncodingException",java.io.IOException);
\r
2372 c$=Clazz.declareType(java.io,"UTFDataFormatException",java.io.IOException);
\r
2374 c$=Clazz.decorateAsClass(function(){
\r
2376 Clazz.instantialize(this,arguments);
\r
2377 },java.io,"WriteAbortedException",java.io.ObjectStreamException);
\r
2378 Clazz.makeConstructor(c$,
\r
2379 function(detailMessage,rootCause){
\r
2380 Clazz.superConstructor(this,java.io.WriteAbortedException,[detailMessage]);
\r
2381 this.detail=rootCause;
\r
2382 this.initCause(rootCause);
\r
2383 },"~S,Exception");
\r
2384 Clazz.defineMethod(c$,"getMessage",
\r
2386 var msg=Clazz.superCall(this,java.io.WriteAbortedException,"getMessage",[]);
\r
2387 return (this.detail ? msg + "; "+this.detail.toString() : msg);
\r
2389 Clazz.overrideMethod(c$,"getCause",
\r
2391 return this.detail;
\r
2394 c$=Clazz.declareType(javautil,"ConcurrentModificationException",RuntimeException);
\r
2395 Clazz.makeConstructor(c$,
\r
2397 Clazz.superConstructor(this,javautil.ConcurrentModificationException,[]);
\r
2400 c$=Clazz.declareType(javautil,"EmptyStackException",RuntimeException);
\r
2402 c$=Clazz.decorateAsClass(function(){
\r
2403 this.className=null;
\r
2405 Clazz.instantialize(this,arguments);
\r
2406 },javautil,"MissingResourceException",RuntimeException);
\r
2407 Clazz.makeConstructor(c$,
\r
2408 function(detailMessage,className,resourceName){
\r
2409 Clazz.superConstructor(this,javautil.MissingResourceException,[detailMessage]);
\r
2410 this.className=className;
\r
2411 this.key=resourceName;
\r
2413 Clazz.defineMethod(c$,"getClassName",
\r
2415 return this.className;
\r
2417 Clazz.defineMethod(c$,"getKey",
\r
2422 c$=Clazz.declareType(javautil,"NoSuchElementException",RuntimeException);
\r
2424 c$=Clazz.declareType(javautil,"TooManyListenersException",Exception);
\r
2426 c$=Clazz.declareType(java.lang,"Void");
\r
2427 Clazz.defineStatics(c$,
\r
2430 java.lang.Void.TYPE=java.lang.Void;
\r
2431 }Clazz.declareInterface(java.lang.reflect,"GenericDeclaration");
\r
2432 Clazz.declareInterface(java.lang.reflect,"AnnotatedElement");
\r
2434 c$=Clazz.declareType(java.lang.reflect,"AccessibleObject",null,java.lang.reflect.AnnotatedElement);
\r
2435 Clazz.makeConstructor(c$,
\r
2438 Clazz.defineMethod(c$,"isAccessible",
\r
2442 c$.setAccessible=Clazz.defineMethod(c$,"setAccessible",
\r
2443 function(objects,flag){
\r
2446 Clazz.defineMethod(c$,"setAccessible",
\r
2450 Clazz.overrideMethod(c$,"isAnnotationPresent",
\r
2451 function(annotationType){
\r
2454 Clazz.overrideMethod(c$,"getDeclaredAnnotations",
\r
2456 return new Array(0);
\r
2458 Clazz.overrideMethod(c$,"getAnnotations",
\r
2460 return new Array(0);
\r
2462 Clazz.overrideMethod(c$,"getAnnotation",
\r
2463 function(annotationType){
\r
2466 c$.marshallArguments=Clazz.defineMethod(c$,"marshallArguments",
\r
2467 function(parameterTypes,args){
\r
2470 Clazz.defineMethod(c$,"invokeV",
\r
2471 function(receiver,args){
\r
2474 Clazz.defineMethod(c$,"invokeL",
\r
2475 function(receiver,args){
\r
2478 Clazz.defineMethod(c$,"invokeI",
\r
2479 function(receiver,args){
\r
2482 Clazz.defineMethod(c$,"invokeJ",
\r
2483 function(receiver,args){
\r
2486 Clazz.defineMethod(c$,"invokeF",
\r
2487 function(receiver,args){
\r
2490 Clazz.defineMethod(c$,"invokeD",
\r
2491 function(receiver,args){
\r
2494 c$.emptyArgs=c$.prototype.emptyArgs=new Array(0);
\r
2495 Clazz.declareInterface(java.lang.reflect,"InvocationHandler");
\r
2496 c$=Clazz.declareInterface(java.lang.reflect,"Member");
\r
2497 Clazz.defineStatics(c$,
\r
2501 c$=Clazz.declareType(java.lang.reflect,"Modifier");
\r
2502 Clazz.makeConstructor(c$,
\r
2505 c$.isAbstract=Clazz.defineMethod(c$,"isAbstract",
\r
2506 function(modifiers){
\r
2507 return((modifiers&1024)!=0);
\r
2509 c$.isFinal=Clazz.defineMethod(c$,"isFinal",
\r
2510 function(modifiers){
\r
2511 return((modifiers&16)!=0);
\r
2513 c$.isInterface=Clazz.defineMethod(c$,"isInterface",
\r
2514 function(modifiers){
\r
2515 return((modifiers&512)!=0);
\r
2517 c$.isNative=Clazz.defineMethod(c$,"isNative",
\r
2518 function(modifiers){
\r
2519 return((modifiers&256)!=0);
\r
2521 c$.isPrivate=Clazz.defineMethod(c$,"isPrivate",
\r
2522 function(modifiers){
\r
2523 return((modifiers&2)!=0);
\r
2525 c$.isProtected=Clazz.defineMethod(c$,"isProtected",
\r
2526 function(modifiers){
\r
2527 return((modifiers&4)!=0);
\r
2529 c$.isPublic=Clazz.defineMethod(c$,"isPublic",
\r
2530 function(modifiers){
\r
2531 return((modifiers&1)!=0);
\r
2533 c$.isStatic=Clazz.defineMethod(c$,"isStatic",
\r
2534 function(modifiers){
\r
2535 return((modifiers&8)!=0);
\r
2537 c$.isStrict=Clazz.defineMethod(c$,"isStrict",
\r
2538 function(modifiers){
\r
2539 return((modifiers&2048)!=0);
\r
2541 c$.isSynchronized=Clazz.defineMethod(c$,"isSynchronized",
\r
2542 function(modifiers){
\r
2543 return((modifiers&32)!=0);
\r
2545 c$.isTransient=Clazz.defineMethod(c$,"isTransient",
\r
2546 function(modifiers){
\r
2547 return((modifiers&128)!=0);
\r
2549 c$.isVolatile=Clazz.defineMethod(c$,"isVolatile",
\r
2550 function(modifiers){
\r
2551 return((modifiers&64)!=0);
\r
2553 c$.toString=Clazz.defineMethod(c$,"toString",
\r
2554 function(modifiers){
\r
2555 var sb=new Array(0);
\r
2556 if(java.lang.reflect.Modifier.isPublic(modifiers))sb[sb.length]="public";
\r
2557 if(java.lang.reflect.Modifier.isProtected(modifiers))sb[sb.length]="protected";
\r
2558 if(java.lang.reflect.Modifier.isPrivate(modifiers))sb[sb.length]="private";
\r
2559 if(java.lang.reflect.Modifier.isAbstract(modifiers))sb[sb.length]="abstract";
\r
2560 if(java.lang.reflect.Modifier.isStatic(modifiers))sb[sb.length]="static";
\r
2561 if(java.lang.reflect.Modifier.isFinal(modifiers))sb[sb.length]="final";
\r
2562 if(java.lang.reflect.Modifier.isTransient(modifiers))sb[sb.length]="transient";
\r
2563 if(java.lang.reflect.Modifier.isVolatile(modifiers))sb[sb.length]="volatile";
\r
2564 if(java.lang.reflect.Modifier.isSynchronized(modifiers))sb[sb.length]="synchronized";
\r
2565 if(java.lang.reflect.Modifier.isNative(modifiers))sb[sb.length]="native";
\r
2566 if(java.lang.reflect.Modifier.isStrict(modifiers))sb[sb.length]="strictfp";
\r
2567 if(java.lang.reflect.Modifier.isInterface(modifiers))sb[sb.length]="interface";
\r
2569 return sb.join(" ");
\r
2572 Clazz.defineStatics(c$,
\r
2578 "SYNCHRONIZED",0x20,
\r
2582 "INTERFACE",0x200,
\r
2587 "SYNTHETIC",0x1000,
\r
2588 "ANNOTATION",0x2000,
\r
2591 c$=Clazz.decorateAsClass(function(){
\r
2593 this.parameterTypes=null;
\r
2594 this.exceptionTypes=null;
\r
2596 Clazz.instantialize(this,arguments);
\r
2597 },java.lang.reflect,"Constructor",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2598 Clazz.makeConstructor(c$,
\r
2599 function(declaringClass,parameterTypes,checkedExceptions,modifiers){
\r
2600 Clazz.superConstructor(this,java.lang.reflect.Constructor,[]);
\r
2601 this.clazz=declaringClass;
\r
2602 this.parameterTypes=parameterTypes;
\r
2603 this.exceptionTypes=checkedExceptions;
\r
2604 this.modifiers=modifiers;
\r
2605 },"Class,~A,~A,~N");
\r
2606 Clazz.overrideMethod(c$,"getTypeParameters",
\r
2610 Clazz.defineMethod(c$,"toGenericString",
\r
2614 Clazz.defineMethod(c$,"getGenericParameterTypes",
\r
2618 Clazz.defineMethod(c$,"getGenericExceptionTypes",
\r
2622 Clazz.defineMethod(c$,"getParameterAnnotations",
\r
2626 Clazz.defineMethod(c$,"isVarArgs",
\r
2630 Clazz.overrideMethod(c$,"isSynthetic",
\r
2634 Clazz.overrideMethod(c$,"equals",
\r
2636 if(object!=null&&Clazz.instanceOf(object,java.lang.reflect.Constructor)){
\r
2638 if(this.getDeclaringClass()===other.getDeclaringClass()){
\r
2639 var params1=this.parameterTypes;
\r
2640 var params2=other.parameterTypes;
\r
2641 if(params1.length==params2.length){
\r
2642 for(var i=0;i<params1.length;i++){
\r
2643 if(params1[i]!==params2[i])return false;
\r
2648 Clazz.overrideMethod(c$,"getDeclaringClass",
\r
2650 return this.clazz;
\r
2652 Clazz.defineMethod(c$,"getExceptionTypes",
\r
2654 return this.exceptionTypes;
\r
2656 Clazz.overrideMethod(c$,"getModifiers",
\r
2658 return this.modifiers;
\r
2660 Clazz.overrideMethod(c$,"getName",
\r
2662 return this.getDeclaringClass().getName();
\r
2664 Clazz.defineMethod(c$,"getParameterTypes",
\r
2666 return this.parameterTypes;
\r
2668 Clazz.overrideMethod(c$,"hashCode",
\r
2670 return this.getDeclaringClass().getName().hashCode();
\r
2672 Clazz.defineMethod(c$,"newInstance",
\r
2674 var instance=new this.clazz(Clazz.inheritArgs);
\r
2675 Clazz.instantialize(instance,args);
\r
2678 Clazz.overrideMethod(c$,"toString",
\r
2683 c$=Clazz.declareType(java.lang.reflect,"Field",java.lang.reflect.AccessibleObject,java.lang.reflect.Member);
\r
2684 Clazz.overrideMethod(c$,"isSynthetic",
\r
2688 Clazz.defineMethod(c$,"toGenericString",
\r
2692 Clazz.defineMethod(c$,"isEnumConstant",
\r
2696 Clazz.defineMethod(c$,"getGenericType",
\r
2700 Clazz.overrideMethod(c$,"equals",
\r
2704 Clazz.overrideMethod(c$,"getDeclaringClass",
\r
2708 Clazz.overrideMethod(c$,"getName",
\r
2712 Clazz.defineMethod(c$,"getType",
\r
2716 Clazz.overrideMethod(c$,"hashCode",
\r
2720 Clazz.overrideMethod(c$,"toString",
\r
2725 c$=Clazz.decorateAsClass(function(){
\r
2728 this.returnType=null;
\r
2729 this.parameterTypes=null;
\r
2730 this.exceptionTypes=null;
\r
2732 Clazz.instantialize(this,arguments);
\r
2733 },java.lang.reflect,"Method",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2734 Clazz.makeConstructor(c$,
\r
2735 function(declaringClass,name,parameterTypes,returnType,checkedExceptions,modifiers){
\r
2736 Clazz.superConstructor(this,java.lang.reflect.Method,[]);
\r
2737 this.clazz=declaringClass;
\r
2739 this.parameterTypes=parameterTypes;
\r
2740 this.returnType=returnType;
\r
2741 this.exceptionTypes=checkedExceptions;
\r
2742 this.modifiers=modifiers;
\r
2743 },"Class,~S,~A,Class,~A,~N");
\r
2744 Clazz.overrideMethod(c$,"getTypeParameters",
\r
2748 Clazz.defineMethod(c$,"toGenericString",
\r
2752 Clazz.defineMethod(c$,"getGenericParameterTypes",
\r
2756 Clazz.defineMethod(c$,"getGenericExceptionTypes",
\r
2760 Clazz.defineMethod(c$,"getGenericReturnType",
\r
2764 Clazz.defineMethod(c$,"getParameterAnnotations",
\r
2768 Clazz.defineMethod(c$,"isVarArgs",
\r
2772 Clazz.defineMethod(c$,"isBridge",
\r
2776 Clazz.overrideMethod(c$,"isSynthetic",
\r
2780 Clazz.defineMethod(c$,"getDefaultValue",
\r
2784 Clazz.overrideMethod(c$,"equals",
\r
2786 if(object!=null&&Clazz.instanceOf(object,java.lang.reflect.Method)){
\r
2788 if((this.getDeclaringClass()===other.getDeclaringClass())&&(this.getName()===other.getName())){
\r
2789 var params1=this.parameterTypes;
\r
2790 var params2=other.parameterTypes;
\r
2791 if(params1.length==params2.length){
\r
2792 for(var i=0;i<params1.length;i++){
\r
2793 if(params1[i]!==params2[i])return false;
\r
2798 Clazz.overrideMethod(c$,"getDeclaringClass",
\r
2800 return this.clazz;
\r
2802 Clazz.defineMethod(c$,"getExceptionTypes",
\r
2804 return this.exceptionTypes;
\r
2806 Clazz.overrideMethod(c$,"getModifiers",
\r
2808 return this.modifiers;
\r
2810 Clazz.overrideMethod(c$,"getName",
\r
2814 Clazz.defineMethod(c$,"getParameterTypes",
\r
2816 return this.parameterTypes;
\r
2818 Clazz.defineMethod(c$,"getReturnType",
\r
2820 return this.returnType;
\r
2822 Clazz.overrideMethod(c$,"hashCode",
\r
2824 return this.getDeclaringClass().getName().hashCode()^this.getName().hashCode();
\r
2826 Clazz.defineMethod(c$,"invoke",
\r
2827 function(receiver,args){
\r
2828 var m=this.clazz.prototype[this.getName()];
\r
2830 m=this.clazz[this.getName()];
\r
2833 m.apply(receiver,args);
\r
2838 Clazz.overrideMethod(c$,"toString",
\r