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 5/31/2015 5:53:04 PM Number.compareTo added
\r
11 // BH 5/21/2015 5:46:30 PM Number("0xFFFFFFFF") is not -1
\r
12 // BH 4/23/2015 9:08:59 AM xx.getComponentType() is nonfunctional. Array.newInstance now defines a wrapper for .getClass().getComponentType() that works
\r
13 // BH 4/12/2015 1:37:44 PM adding Math.rint = Math.round
\r
14 // BH 1/16/2015 10:09:38 AM Chrome failure jqGrig due to new String("x").toString() not being a simple string
\r
15 // BH 8/14/2014 6:49:22 PM Character class efficiencies
\r
16 // BH 7/24/2014 9:02:18 AM most browsers do not support String.codePointAt()
\r
17 // BH 7/11/2014 4:17:22 PM fix for Boolean.valueOf("false") not being false
\r
18 // BH 5/27/2014 6:29:59 AM ensure floats and doubles have decimal point in toString
\r
19 // BH 4/1/2014 12:23:41 PM Encoding moved to Clazz._Encoding;
\r
20 // BH 4/1/2014 7:51:46 AM removing java.lang.B00lean
\r
21 // BH 3/7/2014 9:17:10 AM removing Array.toString; moving that code here from j2sJmol.js
\r
22 // BH 1/30/2014 9:04:25 AM adding Throwable.getStackTrace() as a STRING
\r
23 // BH 12/4/2013 9:20:44 PM fix for reassigning Date.prototype.toString()
\r
24 // BH 12/3/2013 11:43:10 AM bizarre Safari bug in reassigning Boolean (OK, I admit, we shouldn't have done that...)
\r
25 // BH 12/1/2013 6:50:16 AM evit Number.prototype.toString assignment removed!
\r
26 // BH 11/30/2013 1:46:31 PM fixing Byte, Short, Long, Integer, Float, Double to reflect proper bounds and error conditions
\r
27 // BH 11/29/2013 8:58:49 PM removing Boolean.toString(boolean)
\r
28 // BH 11/4/2013 7:34:26 AM changing "var nativeClazz" to "var nativeClass" to avoid ANT replacement of "nativeClazz." to "nativeClazz_"
\r
29 // BH 10/19/2013 1:29:27 PM fixed String.$replace()
\r
30 // BH 10/18/2013 6:09:23 PM fixed (Double|Float).valueOf(NaN).valueOf(), which should return NaN, not throw an error
\r
31 // BH 10/12/2013 11:18:44 AM fixed bug in Double(String) and Float(String) that was returning typeof "string"
\r
32 // BH 10/10/2013 2:40:20 PM added Math.log10
\r
33 // BH 7/23/2013 7:24:01 AM fixing Number.shortValue() and Number.byteValue() for negative values
\r
34 // BH 6/16/2013 1:31:30 PM adding /| in String.replace -- thank you David Koes
\r
35 // BH 3/13/2013 12:49:23 PM setting Boolean.valueOf() "@"
\r
36 // BH 3/2/2013 10:46:45 PM removed Double.valueOf(String)
\r
37 // BH 11/6/2012 8:26:33 PM added instanceof Int32Array in String.instantialize
\r
38 // BH 10/13/2012 11:38:07 PM corrected Integer.parseInt to allow only +-0123456789; created Integer.parseIntRadix
\r
39 // BH 11/1/2012 added Short
\r
40 // BH 9/10/2012 6:27:21 AM added java.net.URL... classes
\r
41 // BH 1/7/2013 7:40:06 AM added Clazz.dateToString
\r
45 // moved here from package.js
\r
46 // these classes will be created as objects prior to any others
\r
47 // and are then available immediately
\r
49 Clazz._Loader.registerPackages("java", [ "io", "lang", "lang.reflect", "util" ]);
\r
51 var sJU = "java.util";
\r
54 //Clazz._Loader.registerPackages (sJU, ["regex", "zip"]);
\r
55 //var javautil = JU;
\r
57 var javautil = java.util;
\r
59 Clazz._Loader.ignore([
\r
60 "net.sf.j2s.ajax.HttpRequest",
\r
61 sJU + ".MapEntry.Type",
\r
62 //"java.net.UnknownServiceException",
\r
63 "java.lang.Runtime",
\r
64 "java.security.AccessController",
\r
65 "java.security.PrivilegedExceptionAction",
\r
67 "java.io.FileInputStream",
\r
68 "java.io.FileWriter",
\r
69 "java.io.OutputStreamWriter",
\r
70 // sJU + ".Calendar", // bypassed in ModelCollection
\r
71 // "java.text.SimpleDateFormat", // not used
\r
72 // "java.text.DateFormat", // not used
\r
73 sJU + ".concurrent.Executors"
\r
76 Math.rint = Math.round;
\r
78 Math.log10||(Math.log10=function(a){return Math.log(a)/2.302585092994046});
\r
80 if(Clazz._supportsNativeObject){
\r
81 // Number and Array are special -- do not override prototype.toString -- "length - 2" here
\r
82 for(var i=0;i<Clazz._extendedObjectMethods.length - 2;i++){
\r
83 var p=Clazz._extendedObjectMethods[i];
\r
84 Array.prototype[p] = Clazz._O.prototype[p];
\r
85 Number.prototype[p] = Clazz._O.prototype[p];
\r
89 java.lang.Number=Number;
\r
90 Number.__CLASS_NAME__="Number";
\r
91 Clazz.implementOf(Number,java.io.Serializable);
\r
92 Number.equals=Clazz._innerFunctions.equals;
\r
93 Number.getName=Clazz._innerFunctions.getName;
\r
94 Number.prototype.compareTo = function(x) { var a = this.value, b = x.value; return (a < b ? -1 : a == b ? 0 : 1) };
\r
96 Clazz.defineMethod(Number,"shortValue",
\r
98 var x = Math.round(this)&0xffff;
\r
99 return (this < 0 && x > 0 ? x - 0x10000 : x);
\r
102 Clazz.defineMethod(Number,"byteValue",
\r
104 var x = Math.round(this)&0xff;
\r
105 return (this < 0 && x > 0 ? x - 0x100 : x);
\r
108 Clazz.defineMethod(Number,"intValue",
\r
110 return Math.round(this)&0xffffffff;
\r
113 Clazz.defineMethod(Number,"longValue",
\r
115 return Math.round(this);
\r
118 Clazz.defineMethod(Number,"floatValue",
\r
120 return this.valueOf();
\r
122 Clazz.defineMethod(Number,"doubleValue",
\r
124 return parseFloat(this.valueOf());
\r
127 Clazz.overrideMethod(Number,"hashCode",
\r
129 return this.valueOf();
\r
132 java.lang.Integer=Integer=function(){
\r
133 Clazz.instantialize(this,arguments);
\r
135 Clazz.decorateAsType(Integer,"Integer",Number,Comparable,null,true);
\r
136 Integer.prototype.valueOf=function(){return 0;};
\r
137 Integer.toString=Integer.prototype.toString=function(){
\r
138 if(arguments.length!=0){
\r
139 return""+arguments[0];
\r
140 } else if(this===Integer){
\r
141 return"class java.lang.Integer";
\r
143 return""+this.valueOf();
\r
148 Clazz.makeConstructor(Integer,
\r
150 this.valueOf=function(){
\r
157 Clazz.overrideConstructor(Integer, function(v){
\r
158 v == null && (v = 0);
\r
159 if (typeof v != "number")
\r
160 v = Integer.parseIntRadix(v, 10);
\r
161 this.valueOf=function(){return v;};
\r
164 Clazz.makeConstructor(Integer,
\r
166 var value=Integer.parseInt(s,10);
\r
167 this.valueOf=function(){
\r
172 Integer.MIN_VALUE=Integer.prototype.MIN_VALUE=-0x80000000;
\r
173 Integer.MAX_VALUE=Integer.prototype.MAX_VALUE=0x7fffffff;
\r
174 Integer.TYPE=Integer.prototype.TYPE=Integer;
\r
177 Clazz.defineMethod(Integer,"bitCount",
\r
179 i = i - ((i >>> 1) & 0x55555555);
\r
180 i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
\r
181 i = (i + (i >>> 4)) & 0x0f0f0f0f;
\r
183 i = i + (i >>> 16);
\r
186 Integer.bitCount=Integer.prototype.bitCount;
\r
188 Clazz.defineMethod(Integer,"numberOfLeadingZeros",
\r
190 if (i == 0) return 32;
\r
192 if (i >>> 16 == 0) { n += 16; i <<= 16; }
\r
193 if (i >>> 24 == 0) { n += 8; i <<= 8; }
\r
194 if (i >>> 28 == 0) { n += 4; i <<= 4; }
\r
195 if (i >>> 30 == 0) { n += 2; i <<= 2; }
\r
199 Integer.numberOfLeadingZeros=Integer.prototype.numberOfLeadingZeros;
\r
201 Clazz.defineMethod(Integer,"numberOfTrailingZeros",
\r
203 if (i == 0) return 32;
\r
205 var y = i <<16; if (y != 0) { n = n -16; i = y; }
\r
206 y = i << 8; if (y != 0) { n = n - 8; i = y; }
\r
207 y = i << 4; if (y != 0) { n = n - 4; i = y; }
\r
208 y = i << 2; if (y != 0) { n = n - 2; i = y; }
\r
209 return n - ((i << 1) >>> 31);
\r
211 Integer.numberOfTrailingZeros=Integer.prototype.numberOfTrailingZeros;
\r
213 Clazz.defineMethod(Integer,"parseIntRadix",
\r
216 throw new NumberFormatException("null");
\r
218 throw new NumberFormatException("radix "+radix+" less than Character.MIN_RADIX");
\r
220 throw new NumberFormatException("radix "+radix+" greater than Character.MAX_RADIX");
\r
223 for (var i = s.length; --i >= 0;) {
\r
224 var c = s.charCodeAt(i);
\r
225 if (c >= 48 && c <= 57) continue;
\r
226 if (i > 0 || c != 43 && c != 45)
\r
227 throw new NumberFormatException("Not a Number : "+s);
\r
231 var i=parseInt(s,radix);
\r
233 throw new NumberFormatException("Not a Number : "+s);
\r
236 },"String, Number");
\r
237 Integer.parseIntRadix=Integer.prototype.parseIntRadix;
\r
239 Clazz.defineMethod(Integer,"parseInt",
\r
241 return Integer.parseIntRadix(s,10);
\r
243 Integer.parseInt=Integer.prototype.parseInt;
\r
246 Clazz.defineMethod(Integer,"$valueOf",
\r
248 return new Integer(Integer.parseIntRadix(s,10));
\r
252 Clazz.overrideMethod(Integer,"$valueOf",
\r
254 return new Integer(s);
\r
258 Clazz.defineMethod(Integer,"$valueOf",
\r
260 return new Integer(Integer.parseIntRadix(s,r));
\r
261 },"String, Number");
\r
264 Integer.$valueOf=Integer.prototype.$valueOf;
\r
267 Clazz.overrideMethod(Integer,"equals",
\r
269 if(s==null||!Clazz.instanceOf(s,Integer)){
\r
272 return s.valueOf()==this.valueOf();
\r
274 Integer.toHexString=Integer.prototype.toHexString=function(d){
\r
275 if(d.valueOf)d=d.valueOf();
\r
277 var b = d & 0xFFFFFF;
\r
278 var c = ((d>>24)&0xFF);
\r
279 return c._numberToString(16) + (b = "000000" + b._numberToString(16)).substring(b.length - 6);
\r
281 return d._numberToString(16);};
\r
282 Integer.toOctalString=Integer.prototype.toOctalString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(8);};
\r
283 Integer.toBinaryString=Integer.prototype.toBinaryString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(2);};
\r
285 Integer.decodeRaw=Clazz.defineMethod(Integer,"decodeRaw", function(n){
\r
286 if (n.indexOf(".") >= 0)n = "";
\r
287 var i = (n.startsWith("-") ? 1 : 0);
\r
288 n = n.replace(/\#/, "0x").toLowerCase();
\r
289 var radix=(n.startsWith("0x", i) ? 16 : n.startsWith("0", i) ? 8 : 10);
\r
290 // The general problem with parseInt is that is not strict -- ParseInt("10whatever") == 10.
\r
291 // Number is strict, but Number("055") does not work, though ParseInt("055", 8) does.
\r
292 // need to make sure negative numbers are negative
\r
293 n = Number(n) & 0xFFFFFFFF;
\r
294 return (radix == 8 ? parseInt(n, 8) : n);
\r
297 Integer.decode=Clazz.defineMethod(Integer,"decode", function(n){
\r
298 n = Integer.decodeRaw(n);
\r
299 if (isNaN(n) || n < Integer.MIN_VALUE|| n > Integer.MAX_VALUE)
\r
300 throw new NumberFormatException("Invalid Integer");
\r
301 return new Integer(n);
\r
304 Clazz.overrideMethod(Integer,"hashCode",
\r
306 return this.valueOf();
\r
309 // Note that Long is problematic in JavaScript
\r
311 java.lang.Long=Long=function(){
\r
312 Clazz.instantialize(this,arguments);
\r
314 Clazz.decorateAsType(Long,"Long",Number,Comparable,null,true);
\r
315 Long.prototype.valueOf=function(){return 0;};
\r
316 Long.toString=Long.prototype.toString=function(){
\r
317 if(arguments.length!=0){
\r
318 return""+arguments[0];
\r
319 }else if(this===Long){
\r
320 return"class java.lang.Long";
\r
322 return""+this.valueOf();
\r
325 Clazz.overrideConstructor(Long, function(v){
\r
326 v == null && (v = 0);
\r
327 v = (typeof v == "number" ? Math.round(v) : Integer.parseIntRadix(v, 10));
\r
328 this.valueOf=function(){return v;};
\r
331 //Long.MIN_VALUE=Long.prototype.MIN_VALUE=-0x8000000000000000;
\r
332 //Long.MAX_VALUE=Long.prototype.MAX_VALUE=0x7fffffffffffffff;
\r
333 Long.TYPE=Long.prototype.TYPE=Long;
\r
335 Clazz.defineMethod(Long,"parseLong",
\r
337 return Integer.parseInt(s, radix || 10);
\r
340 Long.parseLong=Long.prototype.parseLong;
\r
342 Clazz.overrideMethod(Long,"$valueOf",
\r
344 return new Long(s);
\r
347 Clazz.defineMethod(Long,"$valueOf",
\r
349 return new Long(s);
\r
352 Clazz.defineMethod(Long,"$valueOf",
\r
354 return new Long(Long.parseLong(s,r));
\r
355 },"String, Number");
\r
357 Long.$valueOf=Long.prototype.$valueOf;
\r
358 Clazz.overrideMethod(Long,"equals",
\r
360 if(s==null||!Clazz.instanceOf(s,Long)){
\r
363 return s.valueOf()==this.valueOf();
\r
365 Long.toHexString=Long.prototype.toHexString=function(i){
\r
366 return i.toString(16);
\r
368 Long.toOctalString=Long.prototype.toOctalString=function(i){
\r
369 return i.toString(8);
\r
371 Long.toBinaryString=Long.prototype.toBinaryString=function(i){
\r
372 return i.toString(2);
\r
376 Long.decode=Clazz.defineMethod(Long,"decode",
\r
378 n = Integer.decodeRaw(n);
\r
380 throw new NumberFormatException("Invalid Long");
\r
381 return new Long(n);
\r
384 java.lang.Short = Short = function () {
\r
385 Clazz.instantialize (this, arguments);
\r
387 Clazz.decorateAsType (Short, "Short", Number, Comparable, null, true);
\r
388 Short.prototype.valueOf = function () { return 0; };
\r
389 Short.toString = Short.prototype.toString = function () {
\r
390 if (arguments.length != 0) {
\r
391 return "" + arguments[0];
\r
392 } else if (this === Short) {
\r
393 return "class java.lang.Short"; // Short.class.toString
\r
395 return "" + this.valueOf ();
\r
398 Clazz.overrideConstructor(Short,
\r
400 v == null && (v = 0);
\r
401 if (typeof v != "number")
\r
402 v = Integer.parseIntRadix(v, 10);
\r
403 v = v.shortValue();
\r
404 this.valueOf = function () {return v;};
\r
408 Short.MIN_VALUE = Short.prototype.MIN_VALUE = -32768;
\r
409 Short.MAX_VALUE = Short.prototype.MAX_VALUE = 32767;
\r
410 Short.TYPE = Short.prototype.TYPE = Short;
\r
412 Clazz.defineMethod(Short, "parseShortRadix",
\r
413 function (s, radix) {
\r
414 return Integer.parseIntRadix(s, radix).shortValue();
\r
415 }, "String, Number");
\r
416 Short.parseShortRadix = Short.prototype.parseShortRadix;
\r
418 Clazz.defineMethod(Short, "parseShort",
\r
420 return Short.parseShortRadix (s, 10);
\r
423 Short.parseShort = Short.prototype.parseShort;
\r
426 Clazz.defineMethod(Short, "$valueOf",
\r
428 return new Short(Short.parseShort (s, 10));
\r
432 Clazz.overrideMethod(Short, "$valueOf",
\r
434 return new Short(s);
\r
438 Clazz.defineMethod(Short, "$valueOf",
\r
440 return new Short(Short.parseShort (s, r));
\r
441 }, "String, Number");
\r
444 Short.$valueOf = Short.prototype.$valueOf;
\r
445 Clazz.overrideMethod(Short, "equals",
\r
447 if(s == null || !Clazz.instanceOf(s, Short) ){
\r
450 return s.valueOf() == this.valueOf();
\r
452 Short.toHexString = Short.prototype.toHexString = function (i) {
\r
453 return i.toString (16);
\r
455 Short.toOctalString = Short.prototype.toOctalString = function (i) {
\r
456 return i.toString (8);
\r
458 Short.toBinaryString = Short.prototype.toBinaryString = function (i) {
\r
459 return i.toString (2);
\r
461 Short.decode = Clazz.defineMethod(Short, "decode",
\r
463 n = Integer.decodeRaw(n);
\r
464 if (isNaN(n) || n < -32768|| n > 32767)
\r
465 throw new NumberFormatException("Invalid Short");
\r
466 return new Short(n);
\r
469 java.lang.Byte=Byte=function(){
\r
470 Clazz.instantialize(this,arguments);
\r
472 Clazz.decorateAsType(Byte,"Byte",Number,Comparable,null,true);
\r
473 Byte.prototype.valueOf=function(){return 0;};
\r
474 Byte.toString=Byte.prototype.toString=function(){
\r
475 if(arguments.length!=0){
\r
476 return""+arguments[0];
\r
477 }else if(this===Byte){
\r
478 return"class java.lang.Byte";
\r
480 return""+this.valueOf();
\r
482 Clazz.makeConstructor(Byte,
\r
484 if (typeof v != "number")
\r
485 v = Integer.parseIntRadix(v, 10);
\r
487 this.valueOf=function(){
\r
492 Byte.serialVersionUID=Byte.prototype.serialVersionUID=-7183698231559129828;
\r
493 Byte.MIN_VALUE=Byte.prototype.MIN_VALUE=-128;
\r
494 Byte.MAX_VALUE=Byte.prototype.MAX_VALUE=127;
\r
495 Byte.SIZE=Byte.prototype.SIZE=8;
\r
496 Byte.TYPE=Byte.prototype.TYPE=Byte;
\r
498 Clazz.defineMethod(Byte,"parseByteRadix",
\r
500 return Integer.parseIntRadix(s, radix).byteValue();
\r
501 },"String, Number");
\r
502 Byte.parseByteRadix=Byte.prototype.parseByteRadix;
\r
504 Clazz.defineMethod(Byte,"parseByte",
\r
506 return Byte.parseByte(s,10);
\r
509 Byte.parseByte=Byte.prototype.parseByte;
\r
511 Clazz.overrideMethod(Byte, "$valueOf",
\r
513 return new Byte(s);
\r
516 Byte.$valueOf=Byte.prototype.$valueOf;
\r
517 Clazz.overrideMethod(Byte,"equals",
\r
519 if(s==null||!Clazz.instanceOf(s,Byte)){
\r
522 return s.valueOf()==this.valueOf();
\r
524 Byte.toHexString=Byte.prototype.toHexString=function(i){
\r
525 return i.toString(16);
\r
527 Byte.toOctalString=Byte.prototype.toOctalString=function(i){
\r
528 return i.toString(8);
\r
530 Byte.toBinaryString=Byte.prototype.toBinaryString=function(i){
\r
531 return i.toString(2);
\r
533 Byte.decode=Clazz.defineMethod(Byte,"decode",
\r
535 n = Integer.decodeRaw(n);
\r
536 if (isNaN(n) || n < -128|| n > 127)
\r
537 throw new NumberFormatException("Invalid Byte");
\r
538 return new Byte(n);
\r
541 Clazz._floatToString = function(f) {
\r
543 if (s.indexOf(".") < 0 && s.indexOf("e") < 0)
\r
548 java.lang.Float=Float=function(){
\r
549 Clazz.instantialize(this,arguments);
\r
551 Clazz.decorateAsType(Float,"Float",Number,Comparable,null,true);
\r
552 Float.prototype.valueOf=function(){return 0;};
\r
553 Float.toString=Float.prototype.toString=function(){
\r
554 if(arguments.length!=0){
\r
555 return Clazz._floatToString(arguments[0]);
\r
556 }else if(this===Float){
\r
557 return"class java.lang.Float";
\r
559 return Clazz._floatToString(this.valueOf());
\r
562 Clazz.overrideConstructor(Float, function(v){
\r
563 v == null && (v = 0);
\r
564 if (typeof v != "number")
\r
566 this.valueOf=function(){return v;}
\r
569 Float.serialVersionUID=Float.prototype.serialVersionUID=-2671257302660747028;
\r
570 Float.MIN_VALUE=Float.prototype.MIN_VALUE=3.4028235e+38;
\r
571 Float.MAX_VALUE=Float.prototype.MAX_VALUE=1.4e-45;
\r
572 Float.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
573 Float.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
574 Float.NaN=Number.NaN;
\r
575 Float.TYPE=Float.prototype.TYPE=Float;
\r
577 Clazz.defineMethod(Float,"parseFloat",
\r
580 throw new NumberFormatException("null");
\r
582 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
583 var floatVal=Number(s);
\r
584 if(isNaN(floatVal)){
\r
585 throw new NumberFormatException("Not a Number : "+s);
\r
589 Float.parseFloat=Float.prototype.parseFloat;
\r
591 Clazz.overrideMethod(Float,"$valueOf",
\r
593 return new Float(s);
\r
596 Float.$valueOf=Float.prototype.$valueOf;
\r
598 Clazz.defineMethod(Float,"isNaN",
\r
602 Float.isNaN=Float.prototype.isNaN;
\r
603 Clazz.defineMethod(Float,"isInfinite",
\r
605 return!isFinite(num);
\r
607 Float.isInfinite=Float.prototype.isInfinite;
\r
609 Clazz.overrideMethod(Float,"equals",
\r
611 if(s==null||!Clazz.instanceOf(s,Float)){
\r
614 return s.valueOf()==this.valueOf();
\r
617 java.lang.Double=Double=function(){
\r
618 Clazz.instantialize(this,arguments);
\r
620 Clazz.decorateAsType(Double,"Double",Number,Comparable,null,true);
\r
621 Double.prototype.valueOf=function(){return 0;};
\r
622 Double.toString=Double.prototype.toString=function(){
\r
623 if(arguments.length!=0){
\r
624 return Clazz._floatToString(arguments[0]);
\r
625 }else if(this===Double){
\r
626 return"class java.lang.Double";
\r
628 return Clazz._floatToString(this.valueOf());
\r
631 Clazz.overrideConstructor(Double, function(v){
\r
632 v == null && (v = 0);
\r
633 if (typeof v != "number")
\r
634 v = Double.parseDouble(v);
\r
635 this.valueOf=function(){return v;};
\r
638 Double.serialVersionUID=Double.prototype.serialVersionUID=-9172774392245257468;
\r
639 Double.MIN_VALUE=Double.prototype.MIN_VALUE=4.9e-324;
\r
640 Double.MAX_VALUE=Double.prototype.MAX_VALUE=1.7976931348623157e+308;
\r
641 Double.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
642 Double.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
643 Double.NaN=Number.NaN;
\r
644 Double.TYPE=Double.prototype.TYPE=Double;
\r
646 Clazz.defineMethod(Double,"isNaN",
\r
650 Double.isNaN=Double.prototype.isNaN;
\r
651 Clazz.defineMethod(Double,"isInfinite",
\r
653 return!isFinite(num);
\r
655 Double.isInfinite=Double.prototype.isInfinite;
\r
657 Clazz.defineMethod(Double,"parseDouble",
\r
660 throw new NumberFormatException("null");
\r
662 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
663 var doubleVal=Number(s);
\r
664 if(isNaN(doubleVal)){
\r
665 throw new NumberFormatException("Not a Number : "+s);
\r
669 Double.parseDouble=Double.prototype.parseDouble;
\r
672 Clazz.defineMethod(Double,"$valueOf",
\r
674 return new Double(this.parseDouble(s));
\r
678 Clazz.defineMethod(Double,"$valueOf",
\r
680 return new Double(v);
\r
683 Double.$valueOf=Double.prototype.$valueOf;
\r
685 Clazz.overrideMethod(Double,"equals",
\r
687 if(s==null||!Clazz.instanceOf(s,Double)){
\r
690 return s.valueOf()==this.valueOf();
\r
694 //java.lang.B00lean = Boolean; ?? BH why this?
\r
695 Boolean = java.lang.Boolean = Boolean || function () {Clazz.instantialize (this, arguments);};
\r
696 if (Clazz._supportsNativeObject) {
\r
697 for (var i = 0; i < Clazz._extendedObjectMethods.length; i++) {
\r
698 var p = Clazz._extendedObjectMethods[i];
\r
699 Boolean.prototype[p] = Clazz._O.prototype[p];
\r
702 Boolean.__CLASS_NAME__="Boolean";
\r
703 Clazz.implementOf(Boolean,[java.io.Serializable,java.lang.Comparable]);
\r
704 Boolean.equals=Clazz._innerFunctions.equals;
\r
705 Boolean.getName=Clazz._innerFunctions.getName;
\r
706 Boolean.serialVersionUID=Boolean.prototype.serialVersionUID=-3665804199014368530;
\r
708 //Clazz.makeConstructor(Boolean,
\r
710 //this.valueOf=function(){
\r
715 Clazz.overrideConstructor(Boolean,
\r
717 var b = ((typeof s == "string" ? Boolean.toBoolean(s) : s) ? true : false);
\r
718 this.valueOf=function(){return b;};
\r
721 Boolean.parseBoolean=Clazz.defineMethod(Boolean,"parseBoolean",
\r
723 return Boolean.toBoolean(s);
\r
725 Clazz.defineMethod(Boolean,"booleanValue",
\r
727 return this.valueOf();
\r
729 Boolean.$valueOf=Clazz.overrideMethod(Boolean,"$valueOf",
\r
731 return((typeof b == "string"? "true".equalsIgnoreCase(b) : b)?Boolean.TRUE:Boolean.FALSE);
\r
735 Boolean.toString=Clazz.defineMethod(Boolean,"toString",
\r
737 return b?"true":"false";
\r
741 Clazz.overrideMethod(Boolean,"toString",
\r
743 return this.valueOf()?"true":"false";
\r
745 Clazz.overrideMethod(Boolean,"hashCode",
\r
747 return this.valueOf()?1231:1237;
\r
749 Clazz.overrideMethod(Boolean,"equals",
\r
751 if(Clazz.instanceOf(obj,Boolean)){
\r
752 return this.booleanValue()==obj.booleanValue();
\r
755 Boolean.getBoolean=Clazz.defineMethod(Boolean,"getBoolean",
\r
759 result=Boolean.toBoolean(System.getProperty(name));
\r
761 if(Clazz.instanceOf(e,IllegalArgumentException)){
\r
762 }else if(Clazz.instanceOf(e,NullPointerException)){
\r
769 Clazz.overrideMethod(Boolean,"compareTo",
\r
771 return(b.value==this.value?0:(this.value?1:-1));
\r
773 Boolean.toBoolean=Clazz.defineMethod(Boolean,"toBoolean",
\r
774 ($fz=function(name){
\r
775 return((name!=null)&&name.equalsIgnoreCase("true"));
\r
776 },$fz.isPrivate=true,$fz),"~S");
\r
777 Boolean.TRUE=Boolean.prototype.TRUE=new Boolean(true);
\r
778 Boolean.FALSE=Boolean.prototype.FALSE=new Boolean(false);
\r
779 Boolean.TYPE=Boolean.prototype.TYPE=Boolean;
\r
782 Clazz._Encoding=new Object();
\r
784 (function(Encoding) {
\r
786 Encoding.UTF8="utf-8";
\r
787 Encoding.UTF16="utf-16";
\r
788 Encoding.ASCII="ascii";
\r
791 Encoding.guessEncoding=function(str){
\r
792 if(str.charCodeAt(0)==0xEF&&str.charCodeAt(1)==0xBB&&str.charCodeAt(2)==0xBF){
\r
793 return Encoding.UTF8;
\r
794 }else if(str.charCodeAt(0)==0xFF&&str.charCodeAt(1)==0xFE){
\r
795 return Encoding.UTF16;
\r
797 return Encoding.ASCII;
\r
801 Encoding.readUTF8=function(str){
\r
802 var encoding=this.guessEncoding(str);
\r
804 if(encoding==Encoding.UTF8){
\r
806 }else if(encoding==Encoding.UTF16){
\r
809 var arrs=new Array();
\r
810 for(var i=startIdx;i<str.length;i++){
\r
811 var charCode=str.charCodeAt(i);
\r
813 arrs[arrs.length]=str.charAt(i);
\r
814 }else if(charCode>0xc0&&charCode<0xe0){
\r
815 var c1=charCode&0x1f;
\r
817 var c2=str.charCodeAt(i)&0x3f;
\r
819 arrs[arrs.length]=String.fromCharCode(c);
\r
820 }else if(charCode>=0xe0){
\r
821 var c1=charCode&0x0f;
\r
823 var c2=str.charCodeAt(i)&0x3f;
\r
825 var c3=str.charCodeAt(i)&0x3f;
\r
826 var c=(c1<<12)+(c2<<6)+c3;
\r
827 arrs[arrs.length]=String.fromCharCode(c);
\r
830 return arrs.join('');
\r
833 Encoding.convert2UTF8=function(str){
\r
834 var encoding=this.guessEncoding(str);
\r
836 if(encoding==Encoding.UTF8){
\r
838 }else if(encoding==Encoding.UTF16){
\r
843 var arrs=new Array(offset+str.length-startIdx);
\r
845 for(var i=startIdx;i<str.length;i++){
\r
846 var charCode=str.charCodeAt(i);
\r
848 arrs[offset+i-startIdx]=str.charAt(i);
\r
849 }else if(charCode<=0x07ff){
\r
850 var c1=0xc0+((charCode&0x07c0)>>6);
\r
851 var c2=0x80+(charCode&0x003f);
\r
852 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2);
\r
854 var c1=0xe0+((charCode&0xf000)>>12);
\r
855 var c2=0x80+((charCode&0x0fc0)>>6);
\r
856 var c3=0x80+(charCode&0x003f);
\r
857 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2)+String.fromCharCode(c3);
\r
860 return arrs.join('');
\r
862 Encoding.base64Chars=new Array(
\r
863 'A','B','C','D','E','F','G','H',
\r
864 'I','J','K','L','M','N','O','P',
\r
865 'Q','R','S','T','U','V','W','X',
\r
866 'Y','Z','a','b','c','d','e','f',
\r
867 'g','h','i','j','k','l','m','n',
\r
868 'o','p','q','r','s','t','u','v',
\r
869 'w','x','y','z','0','1','2','3',
\r
870 '4','5','6','7','8','9','+','/'
\r
872 Encoding.encodeBase64=function(str){
\r
873 if(str==null||str.length==0)return str;
\r
874 var b64=Encoding.base64Chars;
\r
875 var length=str.length;
\r
879 while(index<length){
\r
880 c0=str.charCodeAt(index++);
\r
881 buf[buf.length]=b64[c0>>2];
\r
883 c1=str.charCodeAt(index++);
\r
884 buf[buf.length]=b64[((c0<<4)&0x30)|(c1>>4)];
\r
886 c2=str.charCodeAt(index++);
\r
887 buf[buf.length]=b64[((c1<<2)&0x3c)|(c2>>6)];
\r
888 buf[buf.length]=b64[c2&0x3F];
\r
890 buf[buf.length]=b64[((c1<<2)&0x3c)];
\r
891 buf[buf.length]='=';
\r
894 buf[buf.length]=b64[(c0<<4)&0x30];
\r
895 buf[buf.length]='=';
\r
896 buf[buf.length]='=';
\r
899 return buf.join('');
\r
901 Encoding.decodeBase64=function(str){
\r
902 if(str==null||str.length==0)return str;
\r
903 var b64=Encoding.base64Chars;
\r
904 var xb64=Encoding.xBase64Chars;
\r
905 if(Encoding.xBase64Chars==null){
\r
907 for(var i=0;i<b64.length;i++){
\r
910 Encoding.xBase64Chars=xb64;
\r
912 var length=str.length;
\r
917 while(index<length&&c++<60000){
\r
918 c0=xb64[str.charAt(index++)];
\r
919 c1=xb64[str.charAt(index++)];
\r
920 c2=xb64[str.charAt(index++)];
\r
921 c3=xb64[str.charAt(index++)];
\r
922 buf[buf.length]=String.fromCharCode(((c0<<2)&0xff)|c1>>4);
\r
924 buf[buf.length]=String.fromCharCode(((c1<<4)&0xff)|c2>>2);
\r
926 buf[buf.length]=String.fromCharCode(((c2<<6)&0xff)|c3);
\r
930 return buf.join('');
\r
933 if(String.prototype.$replace==null){
\r
934 java.lang.String=String;
\r
935 if(Clazz._supportsNativeObject){
\r
936 for(var i=0;i<Clazz._extendedObjectMethods.length;i++){
\r
937 var p=Clazz._extendedObjectMethods[i];
\r
938 if("to$tring"==p||"toString"==p||"equals"==p||"hashCode"==p){
\r
941 String.prototype[p]=Clazz._O.prototype[p];
\r
945 Clazz.implementOf(String,[java.io.Serializable,CharSequence,Comparable]);
\r
947 String.getName=Clazz._innerFunctions.getName;
\r
949 String.serialVersionUID=String.prototype.serialVersionUID=-6849794470754667710;
\r
954 sp.$replace=function(c1,c2){
\r
955 if (c1 == c2 || this.indexOf (c1) < 0) return "" + this;
\r
956 if (c1.length == 1) {
\r
957 if ("\\$.*+|?^{}()[]".indexOf(c1) >= 0) c1 = "\\" + c1;
\r
959 c1=c1.replace(/([\\\$\.\*\+\|\?\^\{\}\(\)\[\]])/g,function($0,$1){return"\\"+$1;});
\r
961 return this.replace(new RegExp(c1,"gm"),c2);
\r
963 sp.$generateExpFunction=function(str){
\r
969 for(;i<str.length;i++){
\r
970 var ch=str.charAt(i);
\r
971 if(i!=str.length-1&&ch=='\\'){
\r
973 var c=str.charAt(i);
\r
978 }else if(i!=str.length-1&&ch=='$'){
\r
980 orders[idx]=parseInt(str.charAt(i));
\r
983 }else if(ch=='\r'){
\r
985 }else if(ch=='\n'){
\r
987 }else if(ch=='\t'){
\r
989 }else if(ch=='\"'){
\r
995 var funStr="f = function (";
\r
996 var max=Math.max.apply({},orders);
\r
997 for(i=0;i<=max;i++){
\r
1003 funStr+=") { return ";
\r
1004 for(i=0;i<arr.length-1;i++){
\r
1005 funStr+="\""+arr[i]+"\" + $"+orders[i]+" + ";
\r
1007 funStr+="\""+arr[i]+"\"; }";
\r
1013 sp.replaceAll=function(exp,str){
\r
1014 var regExp=new RegExp(exp,"gm");
\r
1015 return this.replace(regExp,this.$generateExpFunction(str));
\r
1017 sp.replaceFirst=function(exp,str){
\r
1018 var regExp=new RegExp(exp,"m");
\r
1019 return this.replace(regExp,this.$generateExpFunction(str));
\r
1021 sp.matches=function(exp){
\r
1023 exp="^("+exp+")$";
\r
1025 var regExp=new RegExp(exp,"gm");
\r
1026 var m=this.match(regExp);
\r
1027 return m!=null&&m.length!=0;
\r
1029 sp.regionMatches=function(ignoreCase,toffset,
\r
1030 other,ooffset,len){
\r
1032 if(typeof ignoreCase=="number"
\r
1033 ||(ignoreCase!=true&&ignoreCase!=false)){
\r
1037 toffset=ignoreCase;
\r
1043 if((ooffset<0)||(toffset<0)||(toffset>this.length-len)||
\r
1044 (ooffset>other.length-len)){
\r
1047 var s1=this.substring(toffset,toffset+len);
\r
1048 var s2=other.substring(ooffset,ooffset+len);
\r
1050 s1=s1.toLowerCase();
\r
1051 s2=s2.toLowerCase();
\r
1058 sp.$plit=function(regex,limit){
\r
1059 if (!limit && regex == " ")
\r
1060 return this.split(regex);
\r
1062 if(limit!=null&&limit>0){
\r
1066 var regExp=new RegExp("("+regex+")","gm");
\r
1068 var s=this.replace(regExp,function($0,$1){
\r
1072 }else if(count>limit){
\r
1078 regExp=new RegExp(regex,"gm");
\r
1079 var arr=this.split(regExp);
\r
1080 if(arr.length>limit){
\r
1081 arr[limit-1]=s.substring(s.indexOf("@@_@@")+5);
\r
1086 var regExp=new RegExp(regex,"gm");
\r
1087 return this.split(regExp);
\r
1091 sp.trim=function(){
\r
1092 var len=this.length;
\r
1095 while((st<len)&&(this.charAt(st)<=' ')){
\r
1098 while((st<len)&&(this.charAt(len-1)<=' ')){
\r
1101 return((st>0)||(len<len))?this.substring(st,len):this;
\r
1108 sp.trim=function(){
\r
1109 return this.replace(/^\s+/g,'').replace(/\s+$/g,'');
\r
1112 if (!sp.startsWith || !sp.endsWith) {
\r
1113 var sn=function(s, prefix,toffset){
\r
1116 var pc=prefix.length;
\r
1118 if((toffset<0)||(toffset>s.length-pc)){
\r
1122 if(s.charAt(to++)!=prefix.charAt(po++)){
\r
1129 sp.startsWith=function(prefix){
\r
1130 if(arguments.length==1){
\r
1131 return sn(this,arguments[0],0);
\r
1132 }else if(arguments.length==2){
\r
1133 return sn(this,arguments[0],arguments[1]);
\r
1139 sp.endsWith=function(suffix){
\r
1140 return sn(this, suffix,this.length-suffix.length);
\r
1145 sp.equals=function(anObject){
\r
1146 return this.valueOf()==anObject;
\r
1149 sp.equalsIgnoreCase=function(anotherString){
\r
1150 return(anotherString==null)?false:(this==anotherString
\r
1151 ||this.toLowerCase()==anotherString.toLowerCase());
\r
1157 sp.hashCode=function(){
\r
1161 var len=this.length;
\r
1162 for(var i=0;i<len;i++){
\r
1163 h=31*h+this.charCodeAt(off++);
\r
1171 sp.getBytes=function(){
\r
1172 if(arguments.length==4){
\r
1173 return this.getChars(arguments[0],arguments[1],arguments[2],arguments[3]);
\r
1176 if(arguments.length==1){
\r
1177 var cs=arguments[0].toString().toLowerCase();
\r
1179 "utf-8","UTF8","us-ascii","iso-8859-1","8859_1","gb2312","gb18030","gbk"
\r
1181 var existed=false;
\r
1182 for(var i=0;i<charset.length;i++){
\r
1183 if(charset[i]==cs){
\r
1189 throw new java.io.UnsupportedEncodingException();
\r
1191 if(cs=="utf-8"||cs=="utf8"){
\r
1192 s=Encoding.convert2UTF8(this);
\r
1195 var arrs=new Array(s.length);
\r
1197 for(var i=0;i<s.length;i++){
\r
1198 c=s.charCodeAt(i);
\r
1201 arrs[ii+1]=c&0xff;
\r
1202 arrs[ii+2]=(c&0xff00)>>8;
\r
1213 sp.compareTo=function(anotherString){
\r
1214 if(anotherString==null){
\r
1215 throw new java.lang.NullPointerException();
\r
1217 var len1=this.length;
\r
1218 var len2=anotherString.length;
\r
1219 var n=Math.min(len1,len2);
\r
1222 var c1=this.charCodeAt(k);
\r
1223 var c2=anotherString.charCodeAt(k);
\r
1234 sp.contains = function(a) {return this.indexOf(a) >= 0} // bh added
\r
1235 sp.compareTo = function(a){return this > a ? 1 : this < a ? -1 : 0} // bh added
\r
1239 sp.toCharArray=function(){
\r
1240 var result=new Array(this.length);
\r
1241 for(var i=0;i<this.length;i++){
\r
1242 result[i]=this.charAt(i);
\r
1246 String.value0f=String.valueOf;
\r
1247 String.valueOf=function(o){
\r
1248 if(o=="undefined"){
\r
1249 return String.value0f();
\r
1251 if(o instanceof Array){
\r
1252 if(arguments.length==1){
\r
1253 return o.join('');
\r
1255 var off=arguments[1];
\r
1256 var len=arguments[2];
\r
1257 var oo=new Array(len);
\r
1258 for(var i=0;i<len;i++){
\r
1261 return oo.join('');
\r
1267 sp.subSequence=function(beginIndex,endIndex){
\r
1268 return this.substring(beginIndex,endIndex);
\r
1271 sp.compareToIgnoreCase=function(str){
\r
1273 throw new NullPointerException();
\r
1275 var s1=this.toUpperCase();
\r
1276 var s2=str.toUpperCase();
\r
1280 var s1=this.toLowerCase();
\r
1281 var s2=str.toLowerCase();
\r
1292 sp.contentEquals=function(sb){
\r
1293 if(this.length!=sb.length()){
\r
1296 var v=sb.getValue();
\r
1299 var n=this.length;
\r
1301 if(this.charCodeAt(i++)!=v[j++]){
\r
1308 sp.getChars=function(srcBegin,srcEnd,dst,dstBegin){
\r
1310 throw new StringIndexOutOfBoundsException(srcBegin);
\r
1312 if(srcEnd>this.length){
\r
1313 throw new StringIndexOutOfBoundsException(srcEnd);
\r
1315 if(srcBegin>srcEnd){
\r
1316 throw new StringIndexOutOfBoundsException(srcEnd-srcBegin);
\r
1319 throw new NullPointerException();
\r
1321 for(var i=0;i<srcEnd-srcBegin;i++){
\r
1322 dst[dstBegin+i]=this.charAt(srcBegin+i);
\r
1325 sp.$concat=sp.concat;
\r
1326 sp.concat=function(s){
\r
1328 throw new NullPointerException();
\r
1330 return this.$concat(s);
\r
1333 sp.$lastIndexOf=sp.lastIndexOf;
\r
1334 sp.lastIndexOf=function(s,last){
\r
1335 if(last!=null&&last+this.length<=0){
\r
1339 return this.$lastIndexOf(s,last);
\r
1341 return this.$lastIndexOf(s);
\r
1345 sp.intern=function(){
\r
1346 return this.valueOf();
\r
1348 String.copyValueOf=sp.copyValueOf=function(){
\r
1349 if(arguments.length==1){
\r
1350 return String.instantialize(arguments[0]);
\r
1352 return String.instantialize(arguments[0],arguments[1],arguments[2]);
\r
1356 sp.codePointAt || (sp.codePointAt = sp.charCodeAt); // Firefox only
\r
1359 })(String.prototype);
\r
1363 String.indexOf=function(source,sourceOffset,sourceCount,
\r
1364 target,targetOffset,targetCount,fromIndex){
\r
1365 if(fromIndex>=sourceCount){
\r
1366 return(targetCount==0?sourceCount:-1);
\r
1371 if(targetCount==0){
\r
1375 var first=target[targetOffset];
\r
1376 var i=sourceOffset+fromIndex;
\r
1377 var max=sourceOffset+(sourceCount-targetCount);
\r
1379 startSearchForFirstChar:
\r
1382 while(i<=max&&source[i]!=first){
\r
1391 var end=j+targetCount-1;
\r
1392 var k=targetOffset+1;
\r
1394 if(source[j++]!=target[k++]){
\r
1397 continue startSearchForFirstChar;
\r
1400 return i-sourceOffset;
\r
1406 String.instantialize=function(){
\r
1407 if(arguments.length==0){
\r
1408 return new String();
\r
1409 }else if(arguments.length==1){
\r
1410 var x=arguments[0];
\r
1411 if(typeof x=="string"||x instanceof String){
\r
1412 return new String(x);
\r
1413 }else if(x instanceof Array){
\r
1414 if(x.length>0&&typeof x[0]=="number"){
\r
1415 var arr=new Array(x.length);
\r
1416 for(var i=0;i<x.length;i++){
\r
1417 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1419 return Encoding.readUTF8(arr.join(''));
\r
1421 return x.join('');
\r
1422 }else if(x.__CLASS_NAME__=="StringBuffer"
\r
1423 ||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1424 var value=x.shareValue();
\r
1425 var length=x.length();
\r
1426 var valueCopy=new Array(length);
\r
1427 for(var i=0;i<length;i++){
\r
1428 valueCopy[i]=value[i];
\r
1430 return valueCopy.join('')
\r
1435 }else if(arguments.length==2){
\r
1436 var x=arguments[0];
\r
1437 var hibyte=arguments[1];
\r
1438 if(typeof hibyte=="string"){
\r
1439 return String.instantialize(x,0,x.length,hibyte);
\r
1441 return String.instantialize(x,hibyte,0,x.length);
\r
1443 }else if(arguments.length==3){
\r
1444 var bytes=arguments[0];
\r
1445 var offset=arguments[1];
\r
1446 var length=arguments[2];
\r
1447 if(arguments[2]instanceof Array){
\r
1448 bytes=arguments[2];
\r
1449 offset=arguments[0];
\r
1450 length=arguments[1];
\r
1452 var arr=new Array(length);
\r
1453 if(offset<0||length+offset>bytes.length){
\r
1454 throw new IndexOutOfBoundsException();
\r
1457 var isChar=(bytes[offset].length!=null);
\r
1459 for(var i=0;i<length;i++){
\r
1460 arr[i]=bytes[offset+i];
\r
1463 for(var i=0;i<length;i++){
\r
1464 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1468 return arr.join('');
\r
1469 }else if(arguments.length==4){
\r
1470 var bytes=arguments[0];
\r
1471 var y=arguments[3];
\r
1472 if(typeof y=="string"||y instanceof String){
\r
1473 var offset=arguments[1];
\r
1474 var length=arguments[2];
\r
1475 var arr=new Array(length);
\r
1476 for(var i=0;i<length;i++){
\r
1477 arr[i]=bytes[offset+i];
\r
1478 if(typeof arr[i]=="number"){
\r
1479 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1482 var cs=y.toLowerCase();
\r
1483 if(cs=="utf-8"||cs=="utf8"){
\r
1484 return Encoding.readUTF8(arr.join(''));
\r
1486 return arr.join('');
\r
1489 var count=arguments[3];
\r
1490 var offset=arguments[2];
\r
1491 var hibyte=arguments[1];
\r
1492 var value=new Array(count);
\r
1494 for(var i=count;i-->0;){
\r
1495 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1499 for(var i=count;i-->0;){
\r
1500 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1503 return value.join('');
\r
1507 for(var i=0;i<arguments.length;i++){
\r
1518 String.instantialize=function(){
\r
1519 switch (arguments.length) {
\r
1521 return new String();
\r
1523 var x=arguments[0];
\r
1524 if(typeof x=="string"||x instanceof String){
\r
1525 return new String(x);
\r
1527 if(x instanceof Array || x instanceof Int32Array){
\r
1530 if(typeof x[0]!="number")
\r
1531 return x.join('');
\r
1532 var arr=new Array(x.length);
\r
1533 for(var i=0;i<x.length;i++)
\r
1534 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1535 return Encoding.readUTF8(arr.join(''));
\r
1537 if(x.__CLASS_NAME__=="StringBuffer"||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1538 var value=x.shareValue();
\r
1539 var length=x.length();
\r
1540 var valueCopy=new Array(length);
\r
1541 for(var i=0;i<length;i++){
\r
1542 valueCopy[i]=value[i];
\r
1544 return valueCopy.join('')
\r
1548 var x=arguments[0];
\r
1549 var hibyte=arguments[1];
\r
1550 if(typeof hibyte=="string"){
\r
1551 return String.instantialize(x,0,x.length,hibyte);
\r
1553 return String.instantialize(x,hibyte,0,x.length);
\r
1555 var bytes=arguments[0];
\r
1556 var offset=arguments[1];
\r
1557 var length=arguments[2];
\r
1558 if(arguments[2]instanceof Array){
\r
1559 bytes=arguments[2];
\r
1560 offset=arguments[0];
\r
1561 length=arguments[1];
\r
1563 var arr=new Array(length);
\r
1564 if(offset<0||length+offset>bytes.length){
\r
1565 throw new IndexOutOfBoundsException();
\r
1568 var isChar=(bytes[offset].length!=null);
\r
1570 for(var i=0;i<length;i++){
\r
1571 arr[i]=bytes[offset+i];
\r
1574 for(var i=0;i<length;i++){
\r
1575 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1579 return arr.join('');
\r
1581 var bytes=arguments[0];
\r
1582 var y=arguments[3];
\r
1583 if(typeof y=="string"||y instanceof String){
\r
1584 var offset=arguments[1];
\r
1585 var length=arguments[2];
\r
1586 var arr=new Array(length);
\r
1587 for(var i=0;i<length;i++){
\r
1588 arr[i]=bytes[offset+i];
\r
1589 if(typeof arr[i]=="number"){
\r
1590 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1593 var cs=y.toLowerCase();
\r
1594 if(cs=="utf-8"||cs=="utf8"){
\r
1595 return Encoding.readUTF8(arr.join(''));
\r
1597 return arr.join('');
\r
1599 var count=arguments[3];
\r
1600 var offset=arguments[2];
\r
1601 var hibyte=arguments[1];
\r
1602 var value=new Array(count);
\r
1604 for(var i=count;i-->0;){
\r
1605 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1609 for(var i=count;i-->0;){
\r
1610 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1613 return value.join('');
\r
1616 for(var i=0;i<arguments.length;i++){
\r
1623 if(navigator.userAgent.toLowerCase().indexOf("chrome")!=-1){
\r
1624 String.prototype.toString=function(){return this.valueOf();};
\r
1629 })(Clazz._Encoding);
\r
1633 c$=Clazz.decorateAsClass(function(){
\r
1635 Clazz.instantialize(this,arguments);
\r
1636 },java.lang,"Character",null,[java.io.Serializable,Comparable]);
\r
1637 Clazz.makeConstructor(c$,
\r
1641 Clazz.defineMethod(c$,"charValue",
\r
1643 return this.value;
\r
1645 Clazz.overrideMethod(c$,"hashCode",
\r
1647 return(this.value).charCodeAt(0);
\r
1649 Clazz.overrideMethod(c$,"equals",
\r
1651 if(Clazz.instanceOf(obj,Character)){
\r
1652 return(this.value).charCodeAt(0)==((obj).charValue()).charCodeAt(0);
\r
1655 Clazz.overrideMethod(c$,"compareTo",
\r
1657 return(this.value).charCodeAt(0)-(c.value).charCodeAt(0);
\r
1659 c$.toLowerCase=Clazz.defineMethod(c$,"toLowerCase",
\r
1661 return(""+c).toLowerCase().charAt(0);
\r
1663 c$.toUpperCase=Clazz.defineMethod(c$,"toUpperCase",
\r
1665 return(""+c).toUpperCase().charAt(0);
\r
1667 c$.isDigit=Clazz.defineMethod(c$,"isDigit",
\r
1669 c = c.charCodeAt(0);
\r
1670 return (48 <= c && c <= 57);
\r
1672 c$.isUpperCase=Clazz.defineMethod(c$,"isUpperCase",
\r
1674 c = c.charCodeAt(0);
\r
1675 return (65 <= c && c <= 90);
\r
1677 c$.isLowerCase=Clazz.defineMethod(c$,"isLowerCase",
\r
1679 c = c.charCodeAt(0);
\r
1680 return (97 <= c && c <= 122);
\r
1682 c$.isWhitespace=Clazz.defineMethod(c$,"isWhitespace",
\r
1684 c = (c).charCodeAt(0);
\r
1685 return (c >= 0x1c && c <= 0x20 || c >= 0x9 && c <= 0xd || c == 0x1680
\r
1686 || c >= 0x2000 && c != 0x2007 && (c <= 0x200b || c == 0x2028 || c == 0x2029 || c == 0x3000));
\r
1688 c$.isLetter=Clazz.defineMethod(c$,"isLetter",
\r
1690 c = c.charCodeAt(0);
\r
1691 return (65 <= c && c <= 90 || 97 <= c && c <= 122);
\r
1693 c$.isLetterOrDigit=Clazz.defineMethod(c$,"isLetterOrDigit",
\r
1695 c = c.charCodeAt(0);
\r
1696 return (65 <= c && c <= 90 || 97 <= c && c <= 122 || 48 <= c && c <= 57);
\r
1698 c$.isSpaceChar=Clazz.defineMethod(c$,"isSpaceChar",
\r
1700 var i = c.charCodeAt(0);
\r
1701 if(i==0x20||i==0xa0||i==0x1680)return true;
\r
1702 if(i<0x2000)return false;
\r
1703 return i<=0x200b||i==0x2028||i==0x2029||i==0x202f||i==0x3000;
\r
1705 c$.digit=Clazz.defineMethod(c$,"digit",
\r
1706 function(c,radix){
\r
1707 var i = c.charCodeAt(0);
\r
1708 if(radix >= 2 && radix <= 36){
\r
1711 if(48 <= i && i <= 57){
\r
1713 }else if(97 <= i && i <= 122){
\r
1715 }else if(65 <= i && i <= 90){
\r
1718 return (result < radix ? result : -1);
\r
1723 Clazz.overrideMethod(c$,"toString",
\r
1725 var buf=[this.value];
\r
1726 return String.valueOf(buf);
\r
1728 c$.toString=Clazz.overrideMethod(c$,"toString",
\r
1731 if(this===Character){
\r
1732 return"class java.lang.Character";
\r
1734 }return String.valueOf(c);
\r
1736 Clazz.defineStatics(c$,
\r
1737 "MIN_VALUE",'\u0000',
\r
1738 "MAX_VALUE",'\uffff',
\r
1743 java.lang.Character.TYPE=java.lang.Character.prototype.TYPE=java.lang.Character;
\r
1747 Clazz._ArrayWrapper = function(a, type) {
\r
1750 __CLASS_NAME__:"Array",
\r
1751 superClazz: Array,
\r
1752 getComponentType: function() {return type},
\r
1753 instanceOf: function(o) { return Clazz.instanceOf(type, o) },
\r
1754 getName: function() { return this.__CLASS_NAME__ }
\r
1757 c$=Clazz_declareType(java.lang.reflect,"Array");
\r
1758 c$.newInstance=Clazz_defineMethod(c$,"newInstance",
\r
1759 function(componentType,size){
\r
1760 var a = Clazz_newArray(size);
\r
1761 a.getClass = function() { return new Clazz._ArrayWrapper(this, componentType);};
\r
1765 javautil.Date=Date;
\r
1766 Date.TYPE="javautil.Date";
\r
1767 Date.__CLASS_NAME__="Date";
\r
1768 Clazz.implementOf(Date,[java.io.Serializable,java.lang.Comparable]);
\r
1770 Clazz.defineMethod(javautil.Date,"clone",
\r
1772 return new Date(this.getTime());
\r
1775 Clazz.defineMethod(javautil.Date,"before",
\r
1777 return this.getTime()<when.getTime();
\r
1778 },"javautil.Date");
\r
1779 Clazz.defineMethod(javautil.Date,"after",
\r
1781 return this.getTime()>when.getTime();
\r
1782 },"javautil.Date");
\r
1783 Clazz.defineMethod(javautil.Date,"equals",
\r
1785 return Clazz.instanceOf(obj,javautil.Date)&&this.getTime()==(obj).getTime();
\r
1787 Clazz.defineMethod(javautil.Date,"compareTo",
\r
1788 function(anotherDate){
\r
1789 var thisTime=this.getTime();
\r
1790 var anotherTime=anotherDate.getTime();
\r
1791 return(thisTime<anotherTime?-1:(thisTime==anotherTime?0:1));
\r
1792 },"javautil.Date");
\r
1793 Clazz.defineMethod(javautil.Date,"compareTo",
\r
1795 return this.compareTo(o);
\r
1797 Clazz.overrideMethod(javautil.Date,"hashCode",
\r
1799 var ht=this.getTime();
\r
1800 return parseInt(ht)^parseInt((ht>>32));
\r
1803 c$=Clazz.decorateAsClass(function(){
\r
1805 Clazz.instantialize(this,arguments);
\r
1806 },javautil,"EventObject",null,java.io.Serializable);
\r
1807 Clazz.makeConstructor(c$,
\r
1809 if(source!=null)this.source=source;
\r
1810 else throw new IllegalArgumentException();
\r
1812 Clazz.defineMethod(c$,"getSource",
\r
1814 return this.source;
\r
1816 Clazz.overrideMethod(c$,"toString",
\r
1818 return this.getClass().getName()+"[source="+String.valueOf(this.source)+']';
\r
1820 Clazz.declareInterface(javautil,"EventListener");
\r
1822 c$=Clazz.decorateAsClass(function(){
\r
1823 this.listener=null;
\r
1824 Clazz.instantialize(this,arguments);
\r
1825 },javautil,"EventListenerProxy",null,javautil.EventListener);
\r
1826 Clazz.makeConstructor(c$,
\r
1827 function(listener){
\r
1828 this.listener=listener;
\r
1829 },"javautil.EventListener");
\r
1830 Clazz.defineMethod(c$,"getListener",
\r
1832 return this.listener;
\r
1834 Clazz.declareInterface(javautil,"Iterator");
\r
1836 Clazz.declareInterface(javautil,"ListIterator",javautil.Iterator);
\r
1837 Clazz.declareInterface(javautil,"Enumeration");
\r
1838 Clazz.declareInterface(javautil,"Collection",Iterable);
\r
1840 Clazz.declareInterface(javautil,"Set",javautil.Collection);
\r
1841 Clazz.declareInterface(javautil,"Map");
\r
1842 Clazz.declareInterface(javautil.Map,"Entry");
\r
1844 Clazz.declareInterface(javautil,"List",javautil.Collection);
\r
1846 Clazz.declareInterface(javautil,"Queue",javautil.Collection);
\r
1847 Clazz.declareInterface(javautil,"RandomAccess");
\r
1848 c$=Clazz.decorateAsClass(function(){
\r
1849 this.detailMessage=null;
\r
1851 this.stackTrace=null;
\r
1852 Clazz.instantialize(this,arguments);
\r
1853 },java.lang,"Throwable",null,java.io.Serializable);
\r
1854 Clazz.prepareFields(c$,function(){
\r
1856 //alert("e0 "+ arguments.callee.caller.caller.caller.caller.caller)
\r
1858 Clazz.makeConstructor(c$,
\r
1860 this.fillInStackTrace();
\r
1862 Clazz.makeConstructor(c$,
\r
1863 function(message){
\r
1864 this.fillInStackTrace();
\r
1865 this.detailMessage=message;
\r
1867 Clazz.makeConstructor(c$,
\r
1868 function(message,cause){
\r
1869 this.fillInStackTrace();
\r
1870 this.detailMessage=message;
\r
1872 },"~S,Throwable");
\r
1873 Clazz.makeConstructor(c$,
\r
1875 this.fillInStackTrace();
\r
1876 this.detailMessage=(cause==null?null:cause.toString());
\r
1879 Clazz.defineMethod(c$,"getMessage",
\r
1881 return (this.message || this.detailMessage || this.toString());
\r
1883 Clazz.defineMethod(c$,"getLocalizedMessage",
\r
1885 return this.getMessage();
\r
1887 Clazz.defineMethod(c$,"getCause",
\r
1889 return(this.cause===this?null:this.cause);
\r
1891 Clazz.defineMethod(c$,"initCause",
\r
1893 if(this.cause!==this)throw new IllegalStateException("Can't overwrite cause");
\r
1894 if(cause===this)throw new IllegalArgumentException("Self-causation not permitted");
\r
1898 Clazz.overrideMethod(c$,"toString",
\r
1900 var s=this.getClass().getName();
\r
1901 var message=this.message || this.detailMessage;
\r
1902 return(message ? s+": "+message : s);
\r
1904 Clazz.defineMethod(c$,"printStackTrace",
\r
1906 System.err.println(this.getStackTrace ? this.getStackTrace() : this.message + " " + Clazz.getStackTrace());
\r
1909 Clazz.defineMethod(c$,"getStackTrace",
\r
1911 var s = "" + this + "\n";
\r
1912 for(var i=0;i<this.stackTrace.length;i++){
\r
1913 var t=this.stackTrace[i];
\r
1914 var x=t.methodName.indexOf("(");
\r
1915 var n=t.methodName.substring(0,x).replace(/\s+/g,"");
\r
1916 if(n!="construct"||t.nativeClazz==null
\r
1917 ||Clazz.getInheritedLevel(t.nativeClazz,Throwable)<0){
\r
1925 Clazz.defineMethod(c$,"printStackTrace",
\r
1927 this.printStackTrace();
\r
1928 },"java.io.PrintStream");
\r
1929 Clazz.defineMethod(c$,"printStackTrace",
\r
1931 this.printStackTrace();
\r
1932 },"java.io.PrintWriter");
\r
1933 Clazz.defineMethod(c$,"fillInStackTrace",
\r
1935 this.stackTrace=new Array();
\r
1936 var caller=arguments.callee.caller;
\r
1937 var superCaller=null;
\r
1938 var callerList=new Array();
\r
1939 var index=Clazz._callingStackTraces.length-1;
\r
1940 var noLooping=true;
\r
1941 while(index>-1||caller!=null){
\r
1942 var clazzName=null;
\r
1943 var nativeClass=null;
\r
1944 if(!noLooping||caller==Clazz.tryToSearchAndExecute||caller==Clazz.superCall||caller==null){
\r
1949 superCaller=Clazz._callingStackTraces[index].caller;
\r
1950 nativeClass=Clazz._callingStackTraces[index].owner;
\r
1953 superCaller=caller;
\r
1954 if(superCaller.claxxOwner!=null){
\r
1955 nativeClass=superCaller.claxxOwner;
\r
1956 }else if(superCaller.exClazz!=null){
\r
1957 nativeClass=superCaller.exClazz;
\r
1960 var st=new StackTraceElement(
\r
1961 ((nativeClass!=null&&nativeClass.__CLASS_NAME__.length!=0)?
\r
1962 nativeClass.__CLASS_NAME__:"anonymous"),
\r
1963 ((superCaller.exName==null)?"anonymous":superCaller.exName)
\r
1964 +" ("+Clazz.getParamsType(superCaller.arguments)+")",
\r
1966 st.nativeClazz=nativeClass;
\r
1967 this.stackTrace[this.stackTrace.length]=st;
\r
1968 for(var i=0;i<callerList.length;i++){
\r
1969 if(callerList[i]==superCaller){
\r
1971 var st=new StackTraceElement("lost","missing",null,-3);
\r
1972 st.nativeClazz=null;
\r
1973 this.stackTrace[this.stackTrace.length]=st;
\r
1978 if(superCaller!=null){
\r
1979 callerList[callerList.length]=superCaller;
\r
1981 caller=superCaller.arguments.callee.caller;
\r
1983 Clazz._initializingException=false;
\r
1986 Clazz.defineMethod(c$,"setStackTrace",
\r
1987 function(stackTrace){
\r
1988 var defensiveCopy=stackTrace.clone();
\r
1989 for(var i=0;i<defensiveCopy.length;i++)if(defensiveCopy[i]==null)throw new NullPointerException("stackTrace["+i+"]");
\r
1991 this.stackTrace=defensiveCopy;
\r
1994 c$=Clazz.decorateAsClass(function(){
\r
1995 this.declaringClass=null;
\r
1996 this.methodName=null;
\r
1997 this.fileName=null;
\r
1998 this.lineNumber=0;
\r
1999 Clazz.instantialize(this,arguments);
\r
2000 },java.lang,"StackTraceElement",null,java.io.Serializable);
\r
2001 Clazz.makeConstructor(c$,
\r
2002 function(cls,method,file,line){
\r
2003 if(cls==null||method==null){
\r
2004 throw new NullPointerException();
\r
2005 }this.declaringClass=cls;
\r
2006 this.methodName=method;
\r
2007 this.fileName=file;
\r
2008 this.lineNumber=line;
\r
2010 Clazz.overrideMethod(c$,"equals",
\r
2012 if(!(Clazz.instanceOf(obj,StackTraceElement))){
\r
2015 if((this.methodName==null)||(castObj.methodName==null)){
\r
2017 }if(!this.getMethodName().equals(castObj.getMethodName())){
\r
2019 }if(!this.getClassName().equals(castObj.getClassName())){
\r
2021 }var localFileName=this.getFileName();
\r
2022 if(localFileName==null){
\r
2023 if(castObj.getFileName()!=null){
\r
2026 if(!localFileName.equals(castObj.getFileName())){
\r
2028 }}if(this.getLineNumber()!=castObj.getLineNumber()){
\r
2032 Clazz.defineMethod(c$,"getClassName",
\r
2034 return(this.declaringClass==null)?"<unknown class>":this.declaringClass;
\r
2036 Clazz.defineMethod(c$,"getFileName",
\r
2038 return this.fileName;
\r
2040 Clazz.defineMethod(c$,"getLineNumber",
\r
2042 return this.lineNumber;
\r
2044 Clazz.defineMethod(c$,"getMethodName",
\r
2046 return(this.methodName==null)?"<unknown method>":this.methodName;
\r
2048 Clazz.overrideMethod(c$,"hashCode",
\r
2050 if(this.methodName==null){
\r
2052 }return this.methodName.hashCode()^this.declaringClass.hashCode();
\r
2054 Clazz.defineMethod(c$,"isNativeMethod",
\r
2056 return this.lineNumber==-2;
\r
2058 Clazz.overrideMethod(c$,"toString",
\r
2060 var buf=new StringBuilder(80);
\r
2061 buf.append(this.getClassName());
\r
2063 buf.append(this.getMethodName());
\r
2064 if(this.isNativeMethod()){
\r
2065 buf.append("(Native Method)");
\r
2067 var fName=this.getFileName();
\r
2069 buf.append("(Unknown Source)");
\r
2071 var lineNum=this.getLineNumber();
\r
2073 buf.append(fName);
\r
2076 buf.append(lineNum);
\r
2078 }}return buf.toString();
\r
2080 TypeError.prototype.getMessage || (TypeError.prototype.getMessage = function(){ return (this.message || this.toString()) + (this.getStackTrace ? this.getStackTrace() : Clazz.getStackTrace())});
\r
2081 c$=Clazz.declareType(java.lang,"Error",Throwable);
\r
2083 c$=Clazz.declareType(java.lang,"LinkageError",Error);
\r
2085 c$=Clazz.declareType(java.lang,"IncompatibleClassChangeError",LinkageError);
\r
2087 c$=Clazz.declareType(java.lang,"AbstractMethodError",IncompatibleClassChangeError);
\r
2089 c$=Clazz.declareType(java.lang,"AssertionError",Error);
\r
2090 Clazz.makeConstructor(c$,
\r
2091 function(detailMessage){
\r
2092 Clazz.superConstructor(this,AssertionError,[String.valueOf(detailMessage),(Clazz.instanceOf(detailMessage,Throwable)?detailMessage:null)]);
\r
2094 Clazz.makeConstructor(c$,
\r
2095 function(detailMessage){
\r
2096 this.construct("" + detailMessage);
\r
2098 Clazz.makeConstructor(c$,
\r
2099 function(detailMessage){
\r
2100 this.construct("" + detailMessage);
\r
2103 c$=Clazz.declareType(java.lang,"ClassCircularityError",LinkageError);
\r
2105 c$=Clazz.declareType(java.lang,"ClassFormatError",LinkageError);
\r
2107 c$=Clazz.decorateAsClass(function(){
\r
2108 this.exception=null;
\r
2109 Clazz.instantialize(this,arguments);
\r
2110 },java.lang,"ExceptionInInitializerError",LinkageError);
\r
2111 Clazz.makeConstructor(c$,
\r
2113 Clazz.superConstructor(this,ExceptionInInitializerError);
\r
2114 this.initCause(null);
\r
2116 Clazz.makeConstructor(c$,
\r
2117 function(detailMessage){
\r
2118 Clazz.superConstructor(this,ExceptionInInitializerError,[detailMessage]);
\r
2119 this.initCause(null);
\r
2121 Clazz.makeConstructor(c$,
\r
2122 function(exception){
\r
2123 Clazz.superConstructor(this,ExceptionInInitializerError);
\r
2124 this.exception=exception;
\r
2125 this.initCause(exception);
\r
2127 Clazz.defineMethod(c$,"getException",
\r
2129 return this.exception;
\r
2131 Clazz.overrideMethod(c$,"getCause",
\r
2133 return this.exception;
\r
2136 c$=Clazz.declareType(java.lang,"IllegalAccessError",IncompatibleClassChangeError);
\r
2138 c$=Clazz.declareType(java.lang,"InstantiationError",IncompatibleClassChangeError);
\r
2140 c$=Clazz.declareType(java.lang,"VirtualMachineError",Error);
\r
2142 c$=Clazz.declareType(java.lang,"InternalError",VirtualMachineError);
\r
2144 c$=Clazz.declareType(java.lang,"NoClassDefFoundError",LinkageError);
\r
2146 c$=Clazz.declareType(java.lang,"NoSuchFieldError",IncompatibleClassChangeError);
\r
2148 c$=Clazz.declareType(java.lang,"NoSuchMethodError",IncompatibleClassChangeError);
\r
2150 c$=Clazz.declareType(java.lang,"OutOfMemoryError",VirtualMachineError);
\r
2152 c$=Clazz.declareType(java.lang,"StackOverflowError",VirtualMachineError);
\r
2154 c$=Clazz.declareType(java.lang,"UnknownError",VirtualMachineError);
\r
2156 c$=Clazz.declareType(java.lang,"UnsatisfiedLinkError",LinkageError);
\r
2158 c$=Clazz.declareType(java.lang,"UnsupportedClassVersionError",ClassFormatError);
\r
2160 c$=Clazz.declareType(java.lang,"VerifyError",LinkageError);
\r
2162 c$=Clazz.declareType(java.lang,"ThreadDeath",Error);
\r
2163 Clazz.makeConstructor(c$,
\r
2165 Clazz.superConstructor(this,ThreadDeath,[]);
\r
2168 c$=Clazz.declareType(java.lang,"Exception",Throwable);
\r
2170 c$=Clazz.declareType(java.lang,"RuntimeException",Exception);
\r
2172 c$=Clazz.declareType(java.lang,"ArithmeticException",RuntimeException);
\r
2174 c$=Clazz.declareType(java.lang,"IndexOutOfBoundsException",RuntimeException);
\r
2176 c$=Clazz.declareType(java.lang,"ArrayIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2177 Clazz.makeConstructor(c$,
\r
2179 Clazz.superConstructor(this,ArrayIndexOutOfBoundsException,["Array index out of range: "+index]);
\r
2182 c$=Clazz.declareType(java.lang,"ArrayStoreException",RuntimeException);
\r
2184 c$=Clazz.declareType(java.lang,"ClassCastException",RuntimeException);
\r
2186 c$=Clazz.decorateAsClass(function(){
\r
2188 Clazz.instantialize(this,arguments);
\r
2189 },java.lang,"ClassNotFoundException",Exception);
\r
2190 Clazz.makeConstructor(c$,
\r
2192 Clazz.superConstructor(this,ClassNotFoundException,[Clazz.castNullAs("Throwable")]);
\r
2194 Clazz.makeConstructor(c$,
\r
2195 function(detailMessage){
\r
2196 Clazz.superConstructor(this,ClassNotFoundException,[detailMessage,null]);
\r
2198 Clazz.makeConstructor(c$,
\r
2199 function(detailMessage,exception){
\r
2200 Clazz.superConstructor(this,ClassNotFoundException,[detailMessage]);
\r
2201 this.ex=exception;
\r
2202 },"~S,Throwable");
\r
2203 Clazz.defineMethod(c$,"getException",
\r
2207 Clazz.overrideMethod(c$,"getCause",
\r
2212 c$=Clazz.declareType(java.lang,"CloneNotSupportedException",Exception);
\r
2214 c$=Clazz.declareType(java.lang,"IllegalAccessException",Exception);
\r
2216 c$=Clazz.declareType(java.lang,"IllegalArgumentException",RuntimeException);
\r
2217 Clazz.makeConstructor(c$,
\r
2219 Clazz.superConstructor(this,IllegalArgumentException,[(cause==null?null:cause.toString()),cause]);
\r
2222 c$=Clazz.declareType(java.lang,"IllegalMonitorStateException",RuntimeException);
\r
2224 c$=Clazz.declareType(java.lang,"IllegalStateException",RuntimeException);
\r
2225 Clazz.makeConstructor(c$,
\r
2227 Clazz.superConstructor(this,IllegalStateException,[(cause==null?null:cause.toString()),cause]);
\r
2230 c$=Clazz.declareType(java.lang,"IllegalThreadStateException",IllegalArgumentException);
\r
2232 c$=Clazz.declareType(java.lang,"InstantiationException",Exception);
\r
2234 c$=Clazz.declareType(java.lang,"InterruptedException",Exception);
\r
2236 c$=Clazz.declareType(java.lang,"NegativeArraySizeException",RuntimeException);
\r
2238 c$=Clazz.declareType(java.lang,"NoSuchFieldException",Exception);
\r
2240 c$=Clazz.declareType(java.lang,"NoSuchMethodException",Exception);
\r
2242 c$=Clazz.declareType(java.lang,"NullPointerException",RuntimeException);
\r
2244 c$=Clazz.declareType(java.lang,"NumberFormatException",IllegalArgumentException);
\r
2246 c$=Clazz.declareType(java.lang,"SecurityException",RuntimeException);
\r
2247 Clazz.makeConstructor(c$,
\r
2249 Clazz.superConstructor(this,SecurityException,[(cause==null?null:cause.toString()),cause]);
\r
2252 c$=Clazz.declareType(java.lang,"StringIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2253 Clazz.makeConstructor(c$,
\r
2255 Clazz.superConstructor(this,StringIndexOutOfBoundsException,["String index out of range: "+index]);
\r
2258 c$=Clazz.declareType(java.lang,"UnsupportedOperationException",RuntimeException);
\r
2259 Clazz.makeConstructor(c$,
\r
2261 Clazz.superConstructor(this,UnsupportedOperationException,[]);
\r
2263 Clazz.makeConstructor(c$,
\r
2265 Clazz.superConstructor(this,UnsupportedOperationException,[(cause==null?null:cause.toString()),cause]);
\r
2268 c$=Clazz.decorateAsClass(function(){
\r
2270 Clazz.instantialize(this,arguments);
\r
2271 },java.lang.reflect,"InvocationTargetException",Exception);
\r
2272 Clazz.makeConstructor(c$,
\r
2274 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[Clazz.castNullAs("Throwable")]);
\r
2276 Clazz.makeConstructor(c$,
\r
2277 function(exception){
\r
2278 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[null,exception]);
\r
2279 this.target=exception;
\r
2281 Clazz.makeConstructor(c$,
\r
2282 function(exception,detailMessage){
\r
2283 Clazz.superConstructor(this,java.lang.reflect.InvocationTargetException,[detailMessage,exception]);
\r
2284 this.target=exception;
\r
2285 },"Throwable,~S");
\r
2286 Clazz.defineMethod(c$,"getTargetException",
\r
2288 return this.target;
\r
2290 Clazz.overrideMethod(c$,"getCause",
\r
2292 return this.target;
\r
2295 c$=Clazz.decorateAsClass(function(){
\r
2296 this.undeclaredThrowable=null;
\r
2297 Clazz.instantialize(this,arguments);
\r
2298 },java.lang.reflect,"UndeclaredThrowableException",RuntimeException);
\r
2299 Clazz.makeConstructor(c$,
\r
2300 function(exception){
\r
2301 Clazz.superConstructor(this,java.lang.reflect.UndeclaredThrowableException);
\r
2302 this.undeclaredThrowable=exception;
\r
2303 this.initCause(exception);
\r
2305 Clazz.makeConstructor(c$,
\r
2306 function(exception,detailMessage){
\r
2307 Clazz.superConstructor(this,java.lang.reflect.UndeclaredThrowableException,[detailMessage]);
\r
2308 this.undeclaredThrowable=exception;
\r
2309 this.initCause(exception);
\r
2310 },"Throwable,~S");
\r
2311 Clazz.defineMethod(c$,"getUndeclaredThrowable",
\r
2313 return this.undeclaredThrowable;
\r
2315 Clazz.overrideMethod(c$,"getCause",
\r
2317 return this.undeclaredThrowable;
\r
2320 c$=Clazz.declareType(java.io,"IOException",Exception);
\r
2323 c$=Clazz.declareType(java.io,"CharConversionException",java.io.IOException);
\r
2325 c$=Clazz.declareType(java.io,"EOFException",java.io.IOException);
\r
2327 c$=Clazz.declareType(java.io,"FileNotFoundException",java.io.IOException);
\r
2329 c$=Clazz.decorateAsClass(function(){
\r
2330 this.bytesTransferred=0;
\r
2331 Clazz.instantialize(this,arguments);
\r
2332 },java.io,"InterruptedIOException",java.io.IOException);
\r
2334 c$=Clazz.declareType(java.io,"ObjectStreamException",java.io.IOException);
\r
2336 c$=Clazz.decorateAsClass(function(){
\r
2337 this.classname=null;
\r
2338 Clazz.instantialize(this,arguments);
\r
2339 },java.io,"InvalidClassException",java.io.ObjectStreamException);
\r
2340 Clazz.makeConstructor(c$,
\r
2341 function(className,detailMessage){
\r
2342 Clazz.superConstructor(this,java.io.InvalidClassException,[detailMessage]);
\r
2343 this.classname=className;
\r
2345 Clazz.defineMethod(c$,"getMessage",
\r
2347 var msg=Clazz.superCall(this,java.io.InvalidClassException,"getMessage",[]);
\r
2348 if(this.classname!=null){
\r
2349 msg=this.classname+';' + ' '+msg;
\r
2353 c$=Clazz.declareType(java.io,"InvalidObjectException",java.io.ObjectStreamException);
\r
2355 c$=Clazz.declareType(java.io,"NotActiveException",java.io.ObjectStreamException);
\r
2357 c$=Clazz.declareType(java.io,"NotSerializableException",java.io.ObjectStreamException);
\r
2359 c$=Clazz.decorateAsClass(function(){
\r
2362 Clazz.instantialize(this,arguments);
\r
2363 },java.io,"OptionalDataException",java.io.ObjectStreamException);
\r
2365 c$=Clazz.declareType(java.io,"StreamCorruptedException",java.io.ObjectStreamException);
\r
2367 c$=Clazz.declareType(java.io,"SyncFailedException",java.io.IOException);
\r
2369 c$=Clazz.declareType(java.io,"UnsupportedEncodingException",java.io.IOException);
\r
2371 c$=Clazz.declareType(java.io,"UTFDataFormatException",java.io.IOException);
\r
2373 c$=Clazz.decorateAsClass(function(){
\r
2375 Clazz.instantialize(this,arguments);
\r
2376 },java.io,"WriteAbortedException",java.io.ObjectStreamException);
\r
2377 Clazz.makeConstructor(c$,
\r
2378 function(detailMessage,rootCause){
\r
2379 Clazz.superConstructor(this,java.io.WriteAbortedException,[detailMessage]);
\r
2380 this.detail=rootCause;
\r
2381 this.initCause(rootCause);
\r
2382 },"~S,Exception");
\r
2383 Clazz.defineMethod(c$,"getMessage",
\r
2385 var msg=Clazz.superCall(this,java.io.WriteAbortedException,"getMessage",[]);
\r
2386 return (this.detail ? msg + "; "+this.detail.toString() : msg);
\r
2388 Clazz.overrideMethod(c$,"getCause",
\r
2390 return this.detail;
\r
2393 c$=Clazz.declareType(javautil,"ConcurrentModificationException",RuntimeException);
\r
2394 Clazz.makeConstructor(c$,
\r
2396 Clazz.superConstructor(this,javautil.ConcurrentModificationException,[]);
\r
2399 c$=Clazz.declareType(javautil,"EmptyStackException",RuntimeException);
\r
2401 c$=Clazz.decorateAsClass(function(){
\r
2402 this.className=null;
\r
2404 Clazz.instantialize(this,arguments);
\r
2405 },javautil,"MissingResourceException",RuntimeException);
\r
2406 Clazz.makeConstructor(c$,
\r
2407 function(detailMessage,className,resourceName){
\r
2408 Clazz.superConstructor(this,javautil.MissingResourceException,[detailMessage]);
\r
2409 this.className=className;
\r
2410 this.key=resourceName;
\r
2412 Clazz.defineMethod(c$,"getClassName",
\r
2414 return this.className;
\r
2416 Clazz.defineMethod(c$,"getKey",
\r
2421 c$=Clazz.declareType(javautil,"NoSuchElementException",RuntimeException);
\r
2423 c$=Clazz.declareType(javautil,"TooManyListenersException",Exception);
\r
2425 c$=Clazz.declareType(java.lang,"Void");
\r
2426 Clazz.defineStatics(c$,
\r
2429 java.lang.Void.TYPE=java.lang.Void;
\r
2430 }Clazz.declareInterface(java.lang.reflect,"GenericDeclaration");
\r
2431 Clazz.declareInterface(java.lang.reflect,"AnnotatedElement");
\r
2433 c$=Clazz.declareType(java.lang.reflect,"AccessibleObject",null,java.lang.reflect.AnnotatedElement);
\r
2434 Clazz.makeConstructor(c$,
\r
2437 Clazz.defineMethod(c$,"isAccessible",
\r
2441 c$.setAccessible=Clazz.defineMethod(c$,"setAccessible",
\r
2442 function(objects,flag){
\r
2445 Clazz.defineMethod(c$,"setAccessible",
\r
2449 Clazz.overrideMethod(c$,"isAnnotationPresent",
\r
2450 function(annotationType){
\r
2453 Clazz.overrideMethod(c$,"getDeclaredAnnotations",
\r
2455 return new Array(0);
\r
2457 Clazz.overrideMethod(c$,"getAnnotations",
\r
2459 return new Array(0);
\r
2461 Clazz.overrideMethod(c$,"getAnnotation",
\r
2462 function(annotationType){
\r
2465 c$.marshallArguments=Clazz.defineMethod(c$,"marshallArguments",
\r
2466 function(parameterTypes,args){
\r
2469 Clazz.defineMethod(c$,"invokeV",
\r
2470 function(receiver,args){
\r
2473 Clazz.defineMethod(c$,"invokeL",
\r
2474 function(receiver,args){
\r
2477 Clazz.defineMethod(c$,"invokeI",
\r
2478 function(receiver,args){
\r
2481 Clazz.defineMethod(c$,"invokeJ",
\r
2482 function(receiver,args){
\r
2485 Clazz.defineMethod(c$,"invokeF",
\r
2486 function(receiver,args){
\r
2489 Clazz.defineMethod(c$,"invokeD",
\r
2490 function(receiver,args){
\r
2493 c$.emptyArgs=c$.prototype.emptyArgs=new Array(0);
\r
2494 Clazz.declareInterface(java.lang.reflect,"InvocationHandler");
\r
2495 c$=Clazz.declareInterface(java.lang.reflect,"Member");
\r
2496 Clazz.defineStatics(c$,
\r
2500 c$=Clazz.declareType(java.lang.reflect,"Modifier");
\r
2501 Clazz.makeConstructor(c$,
\r
2504 c$.isAbstract=Clazz.defineMethod(c$,"isAbstract",
\r
2505 function(modifiers){
\r
2506 return((modifiers&1024)!=0);
\r
2508 c$.isFinal=Clazz.defineMethod(c$,"isFinal",
\r
2509 function(modifiers){
\r
2510 return((modifiers&16)!=0);
\r
2512 c$.isInterface=Clazz.defineMethod(c$,"isInterface",
\r
2513 function(modifiers){
\r
2514 return((modifiers&512)!=0);
\r
2516 c$.isNative=Clazz.defineMethod(c$,"isNative",
\r
2517 function(modifiers){
\r
2518 return((modifiers&256)!=0);
\r
2520 c$.isPrivate=Clazz.defineMethod(c$,"isPrivate",
\r
2521 function(modifiers){
\r
2522 return((modifiers&2)!=0);
\r
2524 c$.isProtected=Clazz.defineMethod(c$,"isProtected",
\r
2525 function(modifiers){
\r
2526 return((modifiers&4)!=0);
\r
2528 c$.isPublic=Clazz.defineMethod(c$,"isPublic",
\r
2529 function(modifiers){
\r
2530 return((modifiers&1)!=0);
\r
2532 c$.isStatic=Clazz.defineMethod(c$,"isStatic",
\r
2533 function(modifiers){
\r
2534 return((modifiers&8)!=0);
\r
2536 c$.isStrict=Clazz.defineMethod(c$,"isStrict",
\r
2537 function(modifiers){
\r
2538 return((modifiers&2048)!=0);
\r
2540 c$.isSynchronized=Clazz.defineMethod(c$,"isSynchronized",
\r
2541 function(modifiers){
\r
2542 return((modifiers&32)!=0);
\r
2544 c$.isTransient=Clazz.defineMethod(c$,"isTransient",
\r
2545 function(modifiers){
\r
2546 return((modifiers&128)!=0);
\r
2548 c$.isVolatile=Clazz.defineMethod(c$,"isVolatile",
\r
2549 function(modifiers){
\r
2550 return((modifiers&64)!=0);
\r
2552 c$.toString=Clazz.defineMethod(c$,"toString",
\r
2553 function(modifiers){
\r
2554 var sb=new Array(0);
\r
2555 if(java.lang.reflect.Modifier.isPublic(modifiers))sb[sb.length]="public";
\r
2556 if(java.lang.reflect.Modifier.isProtected(modifiers))sb[sb.length]="protected";
\r
2557 if(java.lang.reflect.Modifier.isPrivate(modifiers))sb[sb.length]="private";
\r
2558 if(java.lang.reflect.Modifier.isAbstract(modifiers))sb[sb.length]="abstract";
\r
2559 if(java.lang.reflect.Modifier.isStatic(modifiers))sb[sb.length]="static";
\r
2560 if(java.lang.reflect.Modifier.isFinal(modifiers))sb[sb.length]="final";
\r
2561 if(java.lang.reflect.Modifier.isTransient(modifiers))sb[sb.length]="transient";
\r
2562 if(java.lang.reflect.Modifier.isVolatile(modifiers))sb[sb.length]="volatile";
\r
2563 if(java.lang.reflect.Modifier.isSynchronized(modifiers))sb[sb.length]="synchronized";
\r
2564 if(java.lang.reflect.Modifier.isNative(modifiers))sb[sb.length]="native";
\r
2565 if(java.lang.reflect.Modifier.isStrict(modifiers))sb[sb.length]="strictfp";
\r
2566 if(java.lang.reflect.Modifier.isInterface(modifiers))sb[sb.length]="interface";
\r
2568 return sb.join(" ");
\r
2571 Clazz.defineStatics(c$,
\r
2577 "SYNCHRONIZED",0x20,
\r
2581 "INTERFACE",0x200,
\r
2586 "SYNTHETIC",0x1000,
\r
2587 "ANNOTATION",0x2000,
\r
2590 c$=Clazz.decorateAsClass(function(){
\r
2592 this.parameterTypes=null;
\r
2593 this.exceptionTypes=null;
\r
2595 Clazz.instantialize(this,arguments);
\r
2596 },java.lang.reflect,"Constructor",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2597 Clazz.makeConstructor(c$,
\r
2598 function(declaringClass,parameterTypes,checkedExceptions,modifiers){
\r
2599 Clazz.superConstructor(this,java.lang.reflect.Constructor,[]);
\r
2600 this.clazz=declaringClass;
\r
2601 this.parameterTypes=parameterTypes;
\r
2602 this.exceptionTypes=checkedExceptions;
\r
2603 this.modifiers=modifiers;
\r
2604 },"Class,~A,~A,~N");
\r
2605 Clazz.overrideMethod(c$,"getTypeParameters",
\r
2609 Clazz.defineMethod(c$,"toGenericString",
\r
2613 Clazz.defineMethod(c$,"getGenericParameterTypes",
\r
2617 Clazz.defineMethod(c$,"getGenericExceptionTypes",
\r
2621 Clazz.defineMethod(c$,"getParameterAnnotations",
\r
2625 Clazz.defineMethod(c$,"isVarArgs",
\r
2629 Clazz.overrideMethod(c$,"isSynthetic",
\r
2633 Clazz.overrideMethod(c$,"equals",
\r
2635 if(object!=null&&Clazz.instanceOf(object,java.lang.reflect.Constructor)){
\r
2637 if(this.getDeclaringClass()===other.getDeclaringClass()){
\r
2638 var params1=this.parameterTypes;
\r
2639 var params2=other.parameterTypes;
\r
2640 if(params1.length==params2.length){
\r
2641 for(var i=0;i<params1.length;i++){
\r
2642 if(params1[i]!==params2[i])return false;
\r
2647 Clazz.overrideMethod(c$,"getDeclaringClass",
\r
2649 return this.clazz;
\r
2651 Clazz.defineMethod(c$,"getExceptionTypes",
\r
2653 return this.exceptionTypes;
\r
2655 Clazz.overrideMethod(c$,"getModifiers",
\r
2657 return this.modifiers;
\r
2659 Clazz.overrideMethod(c$,"getName",
\r
2661 return this.getDeclaringClass().getName();
\r
2663 Clazz.defineMethod(c$,"getParameterTypes",
\r
2665 return this.parameterTypes;
\r
2667 Clazz.overrideMethod(c$,"hashCode",
\r
2669 return this.getDeclaringClass().getName().hashCode();
\r
2671 Clazz.defineMethod(c$,"newInstance",
\r
2673 var instance=new this.clazz(Clazz.inheritArgs);
\r
2674 Clazz.instantialize(instance,args);
\r
2677 Clazz.overrideMethod(c$,"toString",
\r
2682 c$=Clazz.declareType(java.lang.reflect,"Field",java.lang.reflect.AccessibleObject,java.lang.reflect.Member);
\r
2683 Clazz.overrideMethod(c$,"isSynthetic",
\r
2687 Clazz.defineMethod(c$,"toGenericString",
\r
2691 Clazz.defineMethod(c$,"isEnumConstant",
\r
2695 Clazz.defineMethod(c$,"getGenericType",
\r
2699 Clazz.overrideMethod(c$,"equals",
\r
2703 Clazz.overrideMethod(c$,"getDeclaringClass",
\r
2707 Clazz.overrideMethod(c$,"getName",
\r
2711 Clazz.defineMethod(c$,"getType",
\r
2715 Clazz.overrideMethod(c$,"hashCode",
\r
2719 Clazz.overrideMethod(c$,"toString",
\r
2724 c$=Clazz.decorateAsClass(function(){
\r
2727 this.returnType=null;
\r
2728 this.parameterTypes=null;
\r
2729 this.exceptionTypes=null;
\r
2731 Clazz.instantialize(this,arguments);
\r
2732 },java.lang.reflect,"Method",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2733 Clazz.makeConstructor(c$,
\r
2734 function(declaringClass,name,parameterTypes,returnType,checkedExceptions,modifiers){
\r
2735 Clazz.superConstructor(this,java.lang.reflect.Method,[]);
\r
2736 this.clazz=declaringClass;
\r
2738 this.parameterTypes=parameterTypes;
\r
2739 this.returnType=returnType;
\r
2740 this.exceptionTypes=checkedExceptions;
\r
2741 this.modifiers=modifiers;
\r
2742 },"Class,~S,~A,Class,~A,~N");
\r
2743 Clazz.overrideMethod(c$,"getTypeParameters",
\r
2747 Clazz.defineMethod(c$,"toGenericString",
\r
2751 Clazz.defineMethod(c$,"getGenericParameterTypes",
\r
2755 Clazz.defineMethod(c$,"getGenericExceptionTypes",
\r
2759 Clazz.defineMethod(c$,"getGenericReturnType",
\r
2763 Clazz.defineMethod(c$,"getParameterAnnotations",
\r
2767 Clazz.defineMethod(c$,"isVarArgs",
\r
2771 Clazz.defineMethod(c$,"isBridge",
\r
2775 Clazz.overrideMethod(c$,"isSynthetic",
\r
2779 Clazz.defineMethod(c$,"getDefaultValue",
\r
2783 Clazz.overrideMethod(c$,"equals",
\r
2785 if(object!=null&&Clazz.instanceOf(object,java.lang.reflect.Method)){
\r
2787 if((this.getDeclaringClass()===other.getDeclaringClass())&&(this.getName()===other.getName())){
\r
2788 var params1=this.parameterTypes;
\r
2789 var params2=other.parameterTypes;
\r
2790 if(params1.length==params2.length){
\r
2791 for(var i=0;i<params1.length;i++){
\r
2792 if(params1[i]!==params2[i])return false;
\r
2797 Clazz.overrideMethod(c$,"getDeclaringClass",
\r
2799 return this.clazz;
\r
2801 Clazz.defineMethod(c$,"getExceptionTypes",
\r
2803 return this.exceptionTypes;
\r
2805 Clazz.overrideMethod(c$,"getModifiers",
\r
2807 return this.modifiers;
\r
2809 Clazz.overrideMethod(c$,"getName",
\r
2813 Clazz.defineMethod(c$,"getParameterTypes",
\r
2815 return this.parameterTypes;
\r
2817 Clazz.defineMethod(c$,"getReturnType",
\r
2819 return this.returnType;
\r
2821 Clazz.overrideMethod(c$,"hashCode",
\r
2823 return this.getDeclaringClass().getName().hashCode()^this.getName().hashCode();
\r
2825 Clazz.defineMethod(c$,"invoke",
\r
2826 function(receiver,args){
\r
2827 var m=this.clazz.prototype[this.getName()];
\r
2829 m=this.clazz[this.getName()];
\r
2832 m.apply(receiver,args);
\r
2837 Clazz.overrideMethod(c$,"toString",
\r