7 ,Clazz_declarePackage
\r
10 ,Clazz_instantialize
\r
11 ,Clazz_decorateAsClass
\r
14 ,Clazz_makeConstructor
\r
15 ,Clazz_defineEnumConstant
\r
18 ,Clazz_defineStatics
\r
19 ,Clazz_newFloatArray
\r
21 ,Clazz_prepareFields
\r
22 ,Clazz_superConstructor
\r
24 ,Clazz_declareInterface
\r
27 ,Clazz_newShortArray
\r
28 ,Clazz_innerTypeInstance
\r
29 ,Clazz_isClassDefined
\r
30 ,Clazz_prepareCallback
\r
35 ,Clazz_decorateAsType
\r
36 ,Clazz_newBooleanArray
\r
39 ,Clazz_newDoubleArray
\r
40 ,Clazz_overrideConstructor
\r
42 ,Clazz_doubleToShort
\r
43 ,Clazz_getInheritedLevel
\r
44 ,Clazz_getParamsType
\r
54 ,Clazz_tryToSearchAndExecute
\r
55 ,Clazz_getStackTrace
\r
59 ,Clazz_overrideMethod
\r
60 ,Clazz_declareAnonymous
\r
61 ,Clazz_checkPrivateMethod
\r
66 // SwingJSJavaExt.js
\r
69 // This library will be wrapped by an additional anonymous function using ANT in
\r
70 // build_03_tojs.xml. This task will also modify variable names. References
\r
71 // to Clazz._ will not be changed, but other Clazz_xxx will be changed to
\r
72 // (local scope) Clazz_xxx, allowing them to be further compressed using
\r
73 // Google Closure Compiler in that same ANT task.
\r
75 // BH 7/24/2015 7:21:51 AM renamed from JSmolJavaExt.js
\r
76 // BH 5/31/2015 5:53:04 PM Number.compareTo added
\r
77 // BH 5/21/2015 5:46:30 PM Number("0xFFFFFFFF") is not -1
\r
78 // BH 4/23/2015 9:08:59 AM xx.getComponentType() is nonfunctional. Array.newInstance now defines a wrapper for .getClass().getComponentType() that works
\r
79 // BH 4/12/2015 1:37:44 PM adding Math.rint = Math.round
\r
80 // BH 1/16/2015 10:09:38 AM Chrome failure jqGrig due to new String("x").toString() not being a simple string
\r
81 // BH 8/14/2014 6:49:22 PM Character class efficiencies
\r
82 // BH 7/24/2014 9:02:18 AM most browsers do not support String.codePointAt()
\r
83 // BH 7/11/2014 4:17:22 PM fix for Boolean.valueOf("false") not being false
\r
84 // BH 5/27/2014 6:29:59 AM ensure floats and doubles have decimal point in toString
\r
85 // BH 4/1/2014 12:23:41 PM Encoding moved to Clazz._Encoding;
\r
86 // BH 4/1/2014 7:51:46 AM removing java.lang.B00lean
\r
87 // BH 3/7/2014 9:17:10 AM removing Array.toString; moving that code here from j2sJmol.js
\r
88 // BH 1/30/2014 9:04:25 AM adding Throwable.getStackTrace() as a STRING
\r
89 // BH 12/4/2013 9:20:44 PM fix for reassigning Date.prototype.toString()
\r
90 // BH 12/3/2013 11:43:10 AM bizarre Safari bug in reassigning Boolean (OK, I admit, we shouldn't have done that...)
\r
91 // BH 12/1/2013 6:50:16 AM evit Number.prototype.toString assignment removed!
\r
92 // BH 11/30/2013 1:46:31 PM fixing Byte, Short, Long, Integer, Float, Double to reflect proper bounds and error conditions
\r
93 // BH 11/29/2013 8:58:49 PM removing Boolean.toString(boolean)
\r
94 // BH 11/4/2013 7:34:26 AM changing "var nativeClazz" to "var nativeClass" to avoid ANT replacement of "nativeClazz_" to "nativeClazz_"
\r
95 // BH 10/19/2013 1:29:27 PM fixed String.$replace()
\r
96 // BH 10/18/2013 6:09:23 PM fixed (Double|Float).valueOf(NaN).valueOf(), which should return NaN, not throw an error
\r
97 // BH 10/12/2013 11:18:44 AM fixed bug in Double(String) and Float(String) that was returning typeof "string"
\r
98 // BH 10/10/2013 2:40:20 PM added Math.log10
\r
99 // BH 7/23/2013 7:24:01 AM fixing Number.shortValue() and Number.byteValue() for negative values
\r
100 // BH 6/16/2013 1:31:30 PM adding /| in String.replace -- thank you David Koes
\r
101 // BH 3/13/2013 12:49:23 PM setting Boolean.valueOf() "@"
\r
102 // BH 3/2/2013 10:46:45 PM removed Double.valueOf(String)
\r
103 // BH 11/6/2012 8:26:33 PM added instanceof Int32Array in String.instantialize
\r
104 // BH 10/13/2012 11:38:07 PM corrected Integer.parseInt to allow only +-0123456789; created Integer.parseIntRadix
\r
105 // BH 11/1/2012 added Short
\r
106 // BH 9/10/2012 6:27:21 AM added java.net.URL... classes
\r
107 // BH 1/7/2013 7:40:06 AM added Clazz_dateToString
\r
109 ;(function(Clazz) {
\r
111 // moved here from package.js
\r
112 // these classes will be created as objects prior to any others
\r
113 // and are then available immediately
\r
115 Clazz._Loader.registerPackages("java", [ "io", "lang", "lang.reflect", "util" ]);
\r
117 var sJU = "java.util";
\r
120 //Clazz._Loader.registerPackages (sJU, ["regex", "zip"]);
\r
121 //var javautil = JU;
\r
123 var javautil = java.util;
\r
125 Clazz._Loader.ignore([
\r
126 "net.sf.j2s.ajax.HttpRequest",
\r
127 sJU + ".MapEntry.Type",
\r
128 //"java.net.UnknownServiceException",
\r
129 "java.lang.Runtime",
\r
130 "java.security.AccessController",
\r
131 "java.security.PrivilegedExceptionAction",
\r
133 "java.io.FileInputStream",
\r
134 "java.io.FileWriter",
\r
135 "java.io.OutputStreamWriter",
\r
136 // sJU + ".Calendar", // bypassed in ModelCollection
\r
137 // "java.text.SimpleDateFormat", // not used
\r
138 // "java.text.DateFormat", // not used
\r
139 sJU + ".concurrent.Executors"
\r
142 Math.rint = Math.round;
\r
144 Math.log10||(Math.log10=function(a){return Math.log(a)/2.302585092994046});
\r
146 if(Clazz._supportsNativeObject){
\r
147 // Number and Array are special -- do not override prototype.toString -- "length - 2" here
\r
148 for(var i=0;i<Clazz._extendedObjectMethods.length - 2;i++){
\r
149 var p=Clazz._extendedObjectMethods[i];
\r
150 Array.prototype[p] = Clazz._O.prototype[p];
\r
151 Number.prototype[p] = Clazz._O.prototype[p];
\r
155 java.lang.Number=Number;
\r
156 Number.__CLASS_NAME__="Number";
\r
157 Clazz_implementOf(Number,java.io.Serializable);
\r
158 Number.equals=Clazz._innerFunctions.equals;
\r
159 Number.getName=Clazz._innerFunctions.getName;
\r
160 Number.prototype.compareTo = function(x) { var a = this.value, b = x.value; return (a < b ? -1 : a == b ? 0 : 1) };
\r
162 Clazz_defineMethod(Number,"shortValue",
\r
164 var x = Math.round(this)&0xffff;
\r
165 return (this < 0 && x > 0 ? x - 0x10000 : x);
\r
168 Clazz_defineMethod(Number,"byteValue",
\r
170 var x = Math.round(this)&0xff;
\r
171 return (this < 0 && x > 0 ? x - 0x100 : x);
\r
174 Clazz_defineMethod(Number,"intValue",
\r
176 return Math.round(this)&0xffffffff;
\r
179 Clazz_defineMethod(Number,"longValue",
\r
181 return Math.round(this);
\r
184 Clazz_defineMethod(Number,"floatValue",
\r
186 return this.valueOf();
\r
188 Clazz_defineMethod(Number,"doubleValue",
\r
190 return parseFloat(this.valueOf());
\r
193 Clazz_overrideMethod(Number,"hashCode",
\r
195 return this.valueOf();
\r
198 java.lang.Integer=Integer=function(){
\r
199 Clazz_instantialize(this,arguments);
\r
201 Clazz_decorateAsType(Integer,"Integer",Number,Comparable,null,true);
\r
202 Integer.prototype.valueOf=function(){return 0;};
\r
203 Integer.toString=Integer.prototype.toString=function(){
\r
204 if(arguments.length!=0){
\r
205 return""+arguments[0];
\r
206 } else if(this===Integer){
\r
207 return"class java.lang.Integer";
\r
209 return""+this.valueOf();
\r
214 Clazz_makeConstructor(Integer,
\r
216 this.valueOf=function(){
\r
223 Clazz_overrideConstructor(Integer, function(v){
\r
224 v == null && (v = 0);
\r
225 if (typeof v != "number")
\r
226 v = Integer.parseIntRadix(v, 10);
\r
227 this.valueOf=function(){return v;};
\r
230 Clazz_makeConstructor(Integer,
\r
232 var value=Integer.parseInt(s,10);
\r
233 this.valueOf=function(){
\r
238 Integer.MIN_VALUE=Integer.prototype.MIN_VALUE=-0x80000000;
\r
239 Integer.MAX_VALUE=Integer.prototype.MAX_VALUE=0x7fffffff;
\r
240 Integer.TYPE=Integer.prototype.TYPE=Integer;
\r
243 Clazz_defineMethod(Integer,"bitCount",
\r
245 i = i - ((i >>> 1) & 0x55555555);
\r
246 i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
\r
247 i = (i + (i >>> 4)) & 0x0f0f0f0f;
\r
249 i = i + (i >>> 16);
\r
252 Integer.bitCount=Integer.prototype.bitCount;
\r
254 Clazz_defineMethod(Integer,"numberOfLeadingZeros",
\r
256 if (i == 0) return 32;
\r
258 if (i >>> 16 == 0) { n += 16; i <<= 16; }
\r
259 if (i >>> 24 == 0) { n += 8; i <<= 8; }
\r
260 if (i >>> 28 == 0) { n += 4; i <<= 4; }
\r
261 if (i >>> 30 == 0) { n += 2; i <<= 2; }
\r
265 Integer.numberOfLeadingZeros=Integer.prototype.numberOfLeadingZeros;
\r
267 Clazz_defineMethod(Integer,"numberOfTrailingZeros",
\r
269 if (i == 0) return 32;
\r
271 var y = i <<16; if (y != 0) { n = n -16; i = y; }
\r
272 y = i << 8; if (y != 0) { n = n - 8; i = y; }
\r
273 y = i << 4; if (y != 0) { n = n - 4; i = y; }
\r
274 y = i << 2; if (y != 0) { n = n - 2; i = y; }
\r
275 return n - ((i << 1) >>> 31);
\r
277 Integer.numberOfTrailingZeros=Integer.prototype.numberOfTrailingZeros;
\r
279 Clazz_defineMethod(Integer,"parseIntRadix",
\r
282 throw new NumberFormatException("null");
\r
284 throw new NumberFormatException("radix "+radix+" less than Character.MIN_RADIX");
\r
286 throw new NumberFormatException("radix "+radix+" greater than Character.MAX_RADIX");
\r
289 for (var i = s.length; --i >= 0;) {
\r
290 var c = s.charCodeAt(i);
\r
291 if (c >= 48 && c <= 57) continue;
\r
292 if (i > 0 || c != 43 && c != 45)
\r
293 throw new NumberFormatException("Not a Number : "+s);
\r
297 var i=parseInt(s,radix);
\r
299 throw new NumberFormatException("Not a Number : "+s);
\r
302 },"String, Number");
\r
303 Integer.parseIntRadix=Integer.prototype.parseIntRadix;
\r
305 Clazz_defineMethod(Integer,"parseInt",
\r
307 return Integer.parseIntRadix(s,10);
\r
309 Integer.parseInt=Integer.prototype.parseInt;
\r
312 Clazz_defineMethod(Integer,"$valueOf",
\r
314 return new Integer(Integer.parseIntRadix(s,10));
\r
318 Clazz_overrideMethod(Integer,"$valueOf",
\r
320 return new Integer(s);
\r
324 Clazz_defineMethod(Integer,"$valueOf",
\r
326 return new Integer(Integer.parseIntRadix(s,r));
\r
327 },"String, Number");
\r
330 Integer.$valueOf=Integer.prototype.$valueOf;
\r
333 Clazz_overrideMethod(Integer,"equals",
\r
335 if(s==null||!Clazz_instanceOf(s,Integer)){
\r
338 return s.valueOf()==this.valueOf();
\r
340 Integer.toHexString=Integer.prototype.toHexString=function(d){
\r
341 if(d.valueOf)d=d.valueOf();
\r
343 var b = d & 0xFFFFFF;
\r
344 var c = ((d>>24)&0xFF);
\r
345 return c._numberToString(16) + (b = "000000" + b._numberToString(16)).substring(b.length - 6);
\r
347 return d._numberToString(16);};
\r
348 Integer.toOctalString=Integer.prototype.toOctalString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(8);};
\r
349 Integer.toBinaryString=Integer.prototype.toBinaryString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(2);};
\r
351 Integer.decodeRaw=Clazz_defineMethod(Integer,"decodeRaw", function(n){
\r
352 if (n.indexOf(".") >= 0)n = "";
\r
353 var i = (n.startsWith("-") ? 1 : 0);
\r
354 n = n.replace(/\#/, "0x").toLowerCase();
\r
355 var radix=(n.startsWith("0x", i) ? 16 : n.startsWith("0", i) ? 8 : 10);
\r
356 // The general problem with parseInt is that is not strict -- ParseInt("10whatever") == 10.
\r
357 // Number is strict, but Number("055") does not work, though ParseInt("055", 8) does.
\r
358 // need to make sure negative numbers are negative
\r
359 n = Number(n) & 0xFFFFFFFF;
\r
360 return (radix == 8 ? parseInt(n, 8) : n);
\r
363 Integer.decode=Clazz_defineMethod(Integer,"decode", function(n){
\r
364 n = Integer.decodeRaw(n);
\r
365 if (isNaN(n) || n < Integer.MIN_VALUE|| n > Integer.MAX_VALUE)
\r
366 throw new NumberFormatException("Invalid Integer");
\r
367 return new Integer(n);
\r
370 Clazz_overrideMethod(Integer,"hashCode",
\r
372 return this.valueOf();
\r
375 // Note that Long is problematic in JavaScript
\r
377 java.lang.Long=Long=function(){
\r
378 Clazz_instantialize(this,arguments);
\r
380 Clazz_decorateAsType(Long,"Long",Number,Comparable,null,true);
\r
381 Long.prototype.valueOf=function(){return 0;};
\r
382 Long.toString=Long.prototype.toString=function(){
\r
383 if(arguments.length!=0){
\r
384 return""+arguments[0];
\r
385 }else if(this===Long){
\r
386 return"class java.lang.Long";
\r
388 return""+this.valueOf();
\r
391 Clazz_overrideConstructor(Long, function(v){
\r
392 v == null && (v = 0);
\r
393 v = (typeof v == "number" ? Math.round(v) : Integer.parseIntRadix(v, 10));
\r
394 this.valueOf=function(){return v;};
\r
397 //Long.MIN_VALUE=Long.prototype.MIN_VALUE=-0x8000000000000000;
\r
398 //Long.MAX_VALUE=Long.prototype.MAX_VALUE=0x7fffffffffffffff;
\r
399 Long.TYPE=Long.prototype.TYPE=Long;
\r
401 Clazz_defineMethod(Long,"parseLong",
\r
403 return Integer.parseInt(s, radix || 10);
\r
406 Long.parseLong=Long.prototype.parseLong;
\r
408 Clazz_overrideMethod(Long,"$valueOf",
\r
410 return new Long(s);
\r
413 Clazz_defineMethod(Long,"$valueOf",
\r
415 return new Long(s);
\r
418 Clazz_defineMethod(Long,"$valueOf",
\r
420 return new Long(Long.parseLong(s,r));
\r
421 },"String, Number");
\r
423 Long.$valueOf=Long.prototype.$valueOf;
\r
424 Clazz_overrideMethod(Long,"equals",
\r
426 if(s==null||!Clazz_instanceOf(s,Long)){
\r
429 return s.valueOf()==this.valueOf();
\r
431 Long.toHexString=Long.prototype.toHexString=function(i){
\r
432 return i.toString(16);
\r
434 Long.toOctalString=Long.prototype.toOctalString=function(i){
\r
435 return i.toString(8);
\r
437 Long.toBinaryString=Long.prototype.toBinaryString=function(i){
\r
438 return i.toString(2);
\r
442 Long.decode=Clazz_defineMethod(Long,"decode",
\r
444 n = Integer.decodeRaw(n);
\r
446 throw new NumberFormatException("Invalid Long");
\r
447 return new Long(n);
\r
450 java.lang.Short = Short = function () {
\r
451 Clazz_instantialize (this, arguments);
\r
453 Clazz_decorateAsType (Short, "Short", Number, Comparable, null, true);
\r
454 Short.prototype.valueOf = function () { return 0; };
\r
455 Short.toString = Short.prototype.toString = function () {
\r
456 if (arguments.length != 0) {
\r
457 return "" + arguments[0];
\r
458 } else if (this === Short) {
\r
459 return "class java.lang.Short"; // Short.class.toString
\r
461 return "" + this.valueOf ();
\r
464 Clazz_overrideConstructor(Short,
\r
466 v == null && (v = 0);
\r
467 if (typeof v != "number")
\r
468 v = Integer.parseIntRadix(v, 10);
\r
469 v = v.shortValue();
\r
470 this.valueOf = function () {return v;};
\r
474 Short.MIN_VALUE = Short.prototype.MIN_VALUE = -32768;
\r
475 Short.MAX_VALUE = Short.prototype.MAX_VALUE = 32767;
\r
476 Short.TYPE = Short.prototype.TYPE = Short;
\r
478 Clazz_defineMethod(Short, "parseShortRadix",
\r
479 function (s, radix) {
\r
480 return Integer.parseIntRadix(s, radix).shortValue();
\r
481 }, "String, Number");
\r
482 Short.parseShortRadix = Short.prototype.parseShortRadix;
\r
484 Clazz_defineMethod(Short, "parseShort",
\r
486 return Short.parseShortRadix (s, 10);
\r
489 Short.parseShort = Short.prototype.parseShort;
\r
492 Clazz_defineMethod(Short, "$valueOf",
\r
494 return new Short(Short.parseShort (s, 10));
\r
498 Clazz_overrideMethod(Short, "$valueOf",
\r
500 return new Short(s);
\r
504 Clazz_defineMethod(Short, "$valueOf",
\r
506 return new Short(Short.parseShort (s, r));
\r
507 }, "String, Number");
\r
510 Short.$valueOf = Short.prototype.$valueOf;
\r
511 Clazz_overrideMethod(Short, "equals",
\r
513 if(s == null || !Clazz_instanceOf(s, Short) ){
\r
516 return s.valueOf() == this.valueOf();
\r
518 Short.toHexString = Short.prototype.toHexString = function (i) {
\r
519 return i.toString (16);
\r
521 Short.toOctalString = Short.prototype.toOctalString = function (i) {
\r
522 return i.toString (8);
\r
524 Short.toBinaryString = Short.prototype.toBinaryString = function (i) {
\r
525 return i.toString (2);
\r
527 Short.decode = Clazz_defineMethod(Short, "decode",
\r
529 n = Integer.decodeRaw(n);
\r
530 if (isNaN(n) || n < -32768|| n > 32767)
\r
531 throw new NumberFormatException("Invalid Short");
\r
532 return new Short(n);
\r
535 java.lang.Byte=Byte=function(){
\r
536 Clazz_instantialize(this,arguments);
\r
538 Clazz_decorateAsType(Byte,"Byte",Number,Comparable,null,true);
\r
539 Byte.prototype.valueOf=function(){return 0;};
\r
540 Byte.toString=Byte.prototype.toString=function(){
\r
541 if(arguments.length!=0){
\r
542 return""+arguments[0];
\r
543 }else if(this===Byte){
\r
544 return"class java.lang.Byte";
\r
546 return""+this.valueOf();
\r
548 Clazz_makeConstructor(Byte,
\r
550 if (typeof v != "number")
\r
551 v = Integer.parseIntRadix(v, 10);
\r
553 this.valueOf=function(){
\r
558 Byte.serialVersionUID=Byte.prototype.serialVersionUID=-7183698231559129828;
\r
559 Byte.MIN_VALUE=Byte.prototype.MIN_VALUE=-128;
\r
560 Byte.MAX_VALUE=Byte.prototype.MAX_VALUE=127;
\r
561 Byte.SIZE=Byte.prototype.SIZE=8;
\r
562 Byte.TYPE=Byte.prototype.TYPE=Byte;
\r
564 Clazz_defineMethod(Byte,"parseByteRadix",
\r
566 return Integer.parseIntRadix(s, radix).byteValue();
\r
567 },"String, Number");
\r
568 Byte.parseByteRadix=Byte.prototype.parseByteRadix;
\r
570 Clazz_defineMethod(Byte,"parseByte",
\r
572 return Byte.parseByte(s,10);
\r
575 Byte.parseByte=Byte.prototype.parseByte;
\r
577 Clazz_overrideMethod(Byte, "$valueOf",
\r
579 return new Byte(s);
\r
582 Byte.$valueOf=Byte.prototype.$valueOf;
\r
583 Clazz_overrideMethod(Byte,"equals",
\r
585 if(s==null||!Clazz_instanceOf(s,Byte)){
\r
588 return s.valueOf()==this.valueOf();
\r
590 Byte.toHexString=Byte.prototype.toHexString=function(i){
\r
591 return i.toString(16);
\r
593 Byte.toOctalString=Byte.prototype.toOctalString=function(i){
\r
594 return i.toString(8);
\r
596 Byte.toBinaryString=Byte.prototype.toBinaryString=function(i){
\r
597 return i.toString(2);
\r
599 Byte.decode=Clazz_defineMethod(Byte,"decode",
\r
601 n = Integer.decodeRaw(n);
\r
602 if (isNaN(n) || n < -128|| n > 127)
\r
603 throw new NumberFormatException("Invalid Byte");
\r
604 return new Byte(n);
\r
607 Clazz._floatToString = function(f) {
\r
609 if (s.indexOf(".") < 0 && s.indexOf("e") < 0)
\r
614 java.lang.Float=Float=function(){
\r
615 Clazz_instantialize(this,arguments);
\r
617 Clazz_decorateAsType(Float,"Float",Number,Comparable,null,true);
\r
618 Float.prototype.valueOf=function(){return 0;};
\r
619 Float.toString=Float.prototype.toString=function(){
\r
620 if(arguments.length!=0){
\r
621 return Clazz._floatToString(arguments[0]);
\r
622 }else if(this===Float){
\r
623 return"class java.lang.Float";
\r
625 return Clazz._floatToString(this.valueOf());
\r
628 Clazz_overrideConstructor(Float, function(v){
\r
629 v == null && (v = 0);
\r
630 if (typeof v != "number")
\r
632 this.valueOf=function(){return v;}
\r
635 Float.serialVersionUID=Float.prototype.serialVersionUID=-2671257302660747028;
\r
636 Float.MIN_VALUE=Float.prototype.MIN_VALUE=3.4028235e+38;
\r
637 Float.MAX_VALUE=Float.prototype.MAX_VALUE=1.4e-45;
\r
638 Float.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
639 Float.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
640 Float.NaN=Number.NaN;
\r
641 Float.TYPE=Float.prototype.TYPE=Float;
\r
643 Clazz_defineMethod(Float,"parseFloat",
\r
646 throw new NumberFormatException("null");
\r
648 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
649 var floatVal=Number(s);
\r
650 if(isNaN(floatVal)){
\r
651 throw new NumberFormatException("Not a Number : "+s);
\r
655 Float.parseFloat=Float.prototype.parseFloat;
\r
657 Clazz_overrideMethod(Float,"$valueOf",
\r
659 return new Float(s);
\r
662 Float.$valueOf=Float.prototype.$valueOf;
\r
664 Clazz_defineMethod(Float,"isNaN",
\r
668 Float.isNaN=Float.prototype.isNaN;
\r
669 Clazz_defineMethod(Float,"isInfinite",
\r
671 return!isFinite(num);
\r
673 Float.isInfinite=Float.prototype.isInfinite;
\r
675 Clazz_overrideMethod(Float,"equals",
\r
677 if(s==null||!Clazz_instanceOf(s,Float)){
\r
680 return s.valueOf()==this.valueOf();
\r
683 java.lang.Double=Double=function(){
\r
684 Clazz_instantialize(this,arguments);
\r
686 Clazz_decorateAsType(Double,"Double",Number,Comparable,null,true);
\r
687 Double.prototype.valueOf=function(){return 0;};
\r
688 Double.toString=Double.prototype.toString=function(){
\r
689 if(arguments.length!=0){
\r
690 return Clazz._floatToString(arguments[0]);
\r
691 }else if(this===Double){
\r
692 return"class java.lang.Double";
\r
694 return Clazz._floatToString(this.valueOf());
\r
697 Clazz_overrideConstructor(Double, function(v){
\r
698 v == null && (v = 0);
\r
699 if (typeof v != "number")
\r
700 v = Double.parseDouble(v);
\r
701 this.valueOf=function(){return v;};
\r
704 Double.serialVersionUID=Double.prototype.serialVersionUID=-9172774392245257468;
\r
705 Double.MIN_VALUE=Double.prototype.MIN_VALUE=4.9e-324;
\r
706 Double.MAX_VALUE=Double.prototype.MAX_VALUE=1.7976931348623157e+308;
\r
707 Double.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
708 Double.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
709 Double.NaN=Number.NaN;
\r
710 Double.TYPE=Double.prototype.TYPE=Double;
\r
712 Clazz_defineMethod(Double,"isNaN",
\r
716 Double.isNaN=Double.prototype.isNaN;
\r
717 Clazz_defineMethod(Double,"isInfinite",
\r
719 return!isFinite(num);
\r
721 Double.isInfinite=Double.prototype.isInfinite;
\r
723 Clazz_defineMethod(Double,"parseDouble",
\r
726 throw new NumberFormatException("null");
\r
728 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
729 var doubleVal=Number(s);
\r
730 if(isNaN(doubleVal)){
\r
731 throw new NumberFormatException("Not a Number : "+s);
\r
735 Double.parseDouble=Double.prototype.parseDouble;
\r
738 Clazz_defineMethod(Double,"$valueOf",
\r
740 return new Double(this.parseDouble(s));
\r
744 Clazz_defineMethod(Double,"$valueOf",
\r
746 return new Double(v);
\r
749 Double.$valueOf=Double.prototype.$valueOf;
\r
751 Clazz_overrideMethod(Double,"equals",
\r
753 if(s==null||!Clazz_instanceOf(s,Double)){
\r
756 return s.valueOf()==this.valueOf();
\r
760 //java.lang.B00lean = Boolean; ?? BH why this?
\r
761 Boolean = java.lang.Boolean = Boolean || function () {Clazz_instantialize (this, arguments);};
\r
762 if (Clazz._supportsNativeObject) {
\r
763 for (var i = 0; i < Clazz._extendedObjectMethods.length; i++) {
\r
764 var p = Clazz._extendedObjectMethods[i];
\r
765 Boolean.prototype[p] = Clazz._O.prototype[p];
\r
768 Boolean.__CLASS_NAME__="Boolean";
\r
769 Clazz_implementOf(Boolean,[java.io.Serializable,java.lang.Comparable]);
\r
770 Boolean.equals=Clazz._innerFunctions.equals;
\r
771 Boolean.getName=Clazz._innerFunctions.getName;
\r
772 Boolean.serialVersionUID=Boolean.prototype.serialVersionUID=-3665804199014368530;
\r
774 //Clazz_makeConstructor(Boolean,
\r
776 //this.valueOf=function(){
\r
781 Clazz_overrideConstructor(Boolean,
\r
783 var b = ((typeof s == "string" ? Boolean.toBoolean(s) : s) ? true : false);
\r
784 this.valueOf=function(){return b;};
\r
787 Boolean.parseBoolean=Clazz_defineMethod(Boolean,"parseBoolean",
\r
789 return Boolean.toBoolean(s);
\r
791 Clazz_defineMethod(Boolean,"booleanValue",
\r
793 return this.valueOf();
\r
795 Boolean.$valueOf=Clazz_overrideMethod(Boolean,"$valueOf",
\r
797 return((typeof b == "string"? "true".equalsIgnoreCase(b) : b)?Boolean.TRUE:Boolean.FALSE);
\r
801 Boolean.toString=Clazz_defineMethod(Boolean,"toString",
\r
803 return b?"true":"false";
\r
807 Clazz_overrideMethod(Boolean,"toString",
\r
809 return this.valueOf()?"true":"false";
\r
811 Clazz_overrideMethod(Boolean,"hashCode",
\r
813 return this.valueOf()?1231:1237;
\r
815 Clazz_overrideMethod(Boolean,"equals",
\r
817 if(Clazz_instanceOf(obj,Boolean)){
\r
818 return this.booleanValue()==obj.booleanValue();
\r
821 Boolean.getBoolean=Clazz_defineMethod(Boolean,"getBoolean",
\r
825 result=Boolean.toBoolean(System.getProperty(name));
\r
827 if(Clazz_instanceOf(e,IllegalArgumentException)){
\r
828 }else if(Clazz_instanceOf(e,NullPointerException)){
\r
835 Clazz_overrideMethod(Boolean,"compareTo",
\r
837 return(b.value==this.value?0:(this.value?1:-1));
\r
839 Boolean.toBoolean=Clazz_defineMethod(Boolean,"toBoolean",
\r
840 ($fz=function(name){
\r
841 return((name!=null)&&name.equalsIgnoreCase("true"));
\r
842 },$fz.isPrivate=true,$fz),"~S");
\r
843 Boolean.TRUE=Boolean.prototype.TRUE=new Boolean(true);
\r
844 Boolean.FALSE=Boolean.prototype.FALSE=new Boolean(false);
\r
845 Boolean.TYPE=Boolean.prototype.TYPE=Boolean;
\r
848 Clazz._Encoding=new Object();
\r
850 (function(Encoding) {
\r
852 Encoding.UTF8="utf-8";
\r
853 Encoding.UTF16="utf-16";
\r
854 Encoding.ASCII="ascii";
\r
857 Encoding.guessEncoding=function(str){
\r
858 if(str.charCodeAt(0)==0xEF&&str.charCodeAt(1)==0xBB&&str.charCodeAt(2)==0xBF){
\r
859 return Encoding.UTF8;
\r
860 }else if(str.charCodeAt(0)==0xFF&&str.charCodeAt(1)==0xFE){
\r
861 return Encoding.UTF16;
\r
863 return Encoding.ASCII;
\r
867 Encoding.readUTF8=function(str){
\r
868 var encoding=this.guessEncoding(str);
\r
870 if(encoding==Encoding.UTF8){
\r
872 }else if(encoding==Encoding.UTF16){
\r
875 var arrs=new Array();
\r
876 for(var i=startIdx;i<str.length;i++){
\r
877 var charCode=str.charCodeAt(i);
\r
879 arrs[arrs.length]=str.charAt(i);
\r
880 }else if(charCode>0xc0&&charCode<0xe0){
\r
881 var c1=charCode&0x1f;
\r
883 var c2=str.charCodeAt(i)&0x3f;
\r
885 arrs[arrs.length]=String.fromCharCode(c);
\r
886 }else if(charCode>=0xe0){
\r
887 var c1=charCode&0x0f;
\r
889 var c2=str.charCodeAt(i)&0x3f;
\r
891 var c3=str.charCodeAt(i)&0x3f;
\r
892 var c=(c1<<12)+(c2<<6)+c3;
\r
893 arrs[arrs.length]=String.fromCharCode(c);
\r
896 return arrs.join('');
\r
899 Encoding.convert2UTF8=function(str){
\r
900 var encoding=this.guessEncoding(str);
\r
902 if(encoding==Encoding.UTF8){
\r
904 }else if(encoding==Encoding.UTF16){
\r
909 var arrs=new Array(offset+str.length-startIdx);
\r
911 for(var i=startIdx;i<str.length;i++){
\r
912 var charCode=str.charCodeAt(i);
\r
914 arrs[offset+i-startIdx]=str.charAt(i);
\r
915 }else if(charCode<=0x07ff){
\r
916 var c1=0xc0+((charCode&0x07c0)>>6);
\r
917 var c2=0x80+(charCode&0x003f);
\r
918 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2);
\r
920 var c1=0xe0+((charCode&0xf000)>>12);
\r
921 var c2=0x80+((charCode&0x0fc0)>>6);
\r
922 var c3=0x80+(charCode&0x003f);
\r
923 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2)+String.fromCharCode(c3);
\r
926 return arrs.join('');
\r
928 Encoding.base64Chars=new Array(
\r
929 'A','B','C','D','E','F','G','H',
\r
930 'I','J','K','L','M','N','O','P',
\r
931 'Q','R','S','T','U','V','W','X',
\r
932 'Y','Z','a','b','c','d','e','f',
\r
933 'g','h','i','j','k','l','m','n',
\r
934 'o','p','q','r','s','t','u','v',
\r
935 'w','x','y','z','0','1','2','3',
\r
936 '4','5','6','7','8','9','+','/'
\r
938 Encoding.encodeBase64=function(str){
\r
939 if(str==null||str.length==0)return str;
\r
940 var b64=Encoding.base64Chars;
\r
941 var length=str.length;
\r
945 while(index<length){
\r
946 c0=str.charCodeAt(index++);
\r
947 buf[buf.length]=b64[c0>>2];
\r
949 c1=str.charCodeAt(index++);
\r
950 buf[buf.length]=b64[((c0<<4)&0x30)|(c1>>4)];
\r
952 c2=str.charCodeAt(index++);
\r
953 buf[buf.length]=b64[((c1<<2)&0x3c)|(c2>>6)];
\r
954 buf[buf.length]=b64[c2&0x3F];
\r
956 buf[buf.length]=b64[((c1<<2)&0x3c)];
\r
957 buf[buf.length]='=';
\r
960 buf[buf.length]=b64[(c0<<4)&0x30];
\r
961 buf[buf.length]='=';
\r
962 buf[buf.length]='=';
\r
965 return buf.join('');
\r
967 Encoding.decodeBase64=function(str){
\r
968 if(str==null||str.length==0)return str;
\r
969 var b64=Encoding.base64Chars;
\r
970 var xb64=Encoding.xBase64Chars;
\r
971 if(Encoding.xBase64Chars==null){
\r
973 for(var i=0;i<b64.length;i++){
\r
976 Encoding.xBase64Chars=xb64;
\r
978 var length=str.length;
\r
983 while(index<length&&c++<60000){
\r
984 c0=xb64[str.charAt(index++)];
\r
985 c1=xb64[str.charAt(index++)];
\r
986 c2=xb64[str.charAt(index++)];
\r
987 c3=xb64[str.charAt(index++)];
\r
988 buf[buf.length]=String.fromCharCode(((c0<<2)&0xff)|c1>>4);
\r
990 buf[buf.length]=String.fromCharCode(((c1<<4)&0xff)|c2>>2);
\r
992 buf[buf.length]=String.fromCharCode(((c2<<6)&0xff)|c3);
\r
996 return buf.join('');
\r
999 if(String.prototype.$replace==null){
\r
1000 java.lang.String=String;
\r
1001 if(Clazz._supportsNativeObject){
\r
1002 for(var i=0;i<Clazz._extendedObjectMethods.length;i++){
\r
1003 var p=Clazz._extendedObjectMethods[i];
\r
1004 if("to$tring"==p||"toString"==p||"equals"==p||"hashCode"==p){
\r
1007 String.prototype[p]=Clazz._O.prototype[p];
\r
1011 Clazz_implementOf(String,[java.io.Serializable,CharSequence,Comparable]);
\r
1013 String.getName=Clazz._innerFunctions.getName;
\r
1015 String.serialVersionUID=String.prototype.serialVersionUID=-6849794470754667710;
\r
1020 sp.$replace=function(c1,c2){
\r
1021 if (c1 == c2 || this.indexOf (c1) < 0) return "" + this;
\r
1022 if (c1.length == 1) {
\r
1023 if ("\\$.*+|?^{}()[]".indexOf(c1) >= 0) c1 = "\\" + c1;
\r
1025 c1=c1.replace(/([\\\$\.\*\+\|\?\^\{\}\(\)\[\]])/g,function($0,$1){return"\\"+$1;});
\r
1027 return this.replace(new RegExp(c1,"gm"),c2);
\r
1029 sp.$generateExpFunction=function(str){
\r
1035 for(;i<str.length;i++){
\r
1036 var ch=str.charAt(i);
\r
1037 if(i!=str.length-1&&ch=='\\'){
\r
1039 var c=str.charAt(i);
\r
1044 }else if(i!=str.length-1&&ch=='$'){
\r
1046 orders[idx]=parseInt(str.charAt(i));
\r
1049 }else if(ch=='\r'){
\r
1051 }else if(ch=='\n'){
\r
1053 }else if(ch=='\t'){
\r
1055 }else if(ch=='\"'){
\r
1061 var funStr="f = function (";
\r
1062 var max=Math.max.apply({},orders);
\r
1063 for(i=0;i<=max;i++){
\r
1069 funStr+=") { return ";
\r
1070 for(i=0;i<arr.length-1;i++){
\r
1071 funStr+="\""+arr[i]+"\" + $"+orders[i]+" + ";
\r
1073 funStr+="\""+arr[i]+"\"; }";
\r
1079 sp.replaceAll=function(exp,str){
\r
1080 var regExp=new RegExp(exp,"gm");
\r
1081 return this.replace(regExp,this.$generateExpFunction(str));
\r
1083 sp.replaceFirst=function(exp,str){
\r
1084 var regExp=new RegExp(exp,"m");
\r
1085 return this.replace(regExp,this.$generateExpFunction(str));
\r
1087 sp.matches=function(exp){
\r
1089 exp="^("+exp+")$";
\r
1091 var regExp=new RegExp(exp,"gm");
\r
1092 var m=this.match(regExp);
\r
1093 return m!=null&&m.length!=0;
\r
1095 sp.regionMatches=function(ignoreCase,toffset,
\r
1096 other,ooffset,len){
\r
1098 if(typeof ignoreCase=="number"
\r
1099 ||(ignoreCase!=true&&ignoreCase!=false)){
\r
1103 toffset=ignoreCase;
\r
1109 if((ooffset<0)||(toffset<0)||(toffset>this.length-len)||
\r
1110 (ooffset>other.length-len)){
\r
1113 var s1=this.substring(toffset,toffset+len);
\r
1114 var s2=other.substring(ooffset,ooffset+len);
\r
1116 s1=s1.toLowerCase();
\r
1117 s2=s2.toLowerCase();
\r
1124 sp.$plit=function(regex,limit){
\r
1125 if (!limit && regex == " ")
\r
1126 return this.split(regex);
\r
1128 if(limit!=null&&limit>0){
\r
1132 var regExp=new RegExp("("+regex+")","gm");
\r
1134 var s=this.replace(regExp,function($0,$1){
\r
1138 }else if(count>limit){
\r
1144 regExp=new RegExp(regex,"gm");
\r
1145 var arr=this.split(regExp);
\r
1146 if(arr.length>limit){
\r
1147 arr[limit-1]=s.substring(s.indexOf("@@_@@")+5);
\r
1152 var regExp=new RegExp(regex,"gm");
\r
1153 return this.split(regExp);
\r
1157 sp.trim=function(){
\r
1158 var len=this.length;
\r
1161 while((st<len)&&(this.charAt(st)<=' ')){
\r
1164 while((st<len)&&(this.charAt(len-1)<=' ')){
\r
1167 return((st>0)||(len<len))?this.substring(st,len):this;
\r
1174 sp.trim=function(){
\r
1175 return this.replace(/^\s+/g,'').replace(/\s+$/g,'');
\r
1178 if (!sp.startsWith || !sp.endsWith) {
\r
1179 var sn=function(s, prefix,toffset){
\r
1182 var pc=prefix.length;
\r
1184 if((toffset<0)||(toffset>s.length-pc)){
\r
1188 if(s.charAt(to++)!=prefix.charAt(po++)){
\r
1195 sp.startsWith=function(prefix){
\r
1196 if(arguments.length==1){
\r
1197 return sn(this,arguments[0],0);
\r
1198 }else if(arguments.length==2){
\r
1199 return sn(this,arguments[0],arguments[1]);
\r
1205 sp.endsWith=function(suffix){
\r
1206 return sn(this, suffix,this.length-suffix.length);
\r
1211 sp.equals=function(anObject){
\r
1212 return this.valueOf()==anObject;
\r
1215 sp.equalsIgnoreCase=function(anotherString){
\r
1216 return(anotherString==null)?false:(this==anotherString
\r
1217 ||this.toLowerCase()==anotherString.toLowerCase());
\r
1223 sp.hashCode=function(){
\r
1227 var len=this.length;
\r
1228 for(var i=0;i<len;i++){
\r
1229 h=31*h+this.charCodeAt(off++);
\r
1237 sp.getBytes=function(){
\r
1238 if(arguments.length==4){
\r
1239 return this.getChars(arguments[0],arguments[1],arguments[2],arguments[3]);
\r
1242 if(arguments.length==1){
\r
1243 var cs=arguments[0].toString().toLowerCase();
\r
1245 "utf-8","UTF8","us-ascii","iso-8859-1","8859_1","gb2312","gb18030","gbk"
\r
1247 var existed=false;
\r
1248 for(var i=0;i<charset.length;i++){
\r
1249 if(charset[i]==cs){
\r
1255 throw new java.io.UnsupportedEncodingException();
\r
1257 if(cs=="utf-8"||cs=="utf8"){
\r
1258 s=Encoding.convert2UTF8(this);
\r
1261 var arrs=new Array(s.length);
\r
1263 for(var i=0;i<s.length;i++){
\r
1264 c=s.charCodeAt(i);
\r
1267 arrs[ii+1]=c&0xff;
\r
1268 arrs[ii+2]=(c&0xff00)>>8;
\r
1279 sp.compareTo=function(anotherString){
\r
1280 if(anotherString==null){
\r
1281 throw new java.lang.NullPointerException();
\r
1283 var len1=this.length;
\r
1284 var len2=anotherString.length;
\r
1285 var n=Math.min(len1,len2);
\r
1288 var c1=this.charCodeAt(k);
\r
1289 var c2=anotherString.charCodeAt(k);
\r
1300 sp.contains = function(a) {return this.indexOf(a) >= 0} // bh added
\r
1301 sp.compareTo = function(a){return this > a ? 1 : this < a ? -1 : 0} // bh added
\r
1305 sp.toCharArray=function(){
\r
1306 var result=new Array(this.length);
\r
1307 for(var i=0;i<this.length;i++){
\r
1308 result[i]=this.charAt(i);
\r
1312 String.value0f=String.valueOf;
\r
1313 String.valueOf=function(o){
\r
1314 if(o=="undefined"){
\r
1315 return String.value0f();
\r
1317 if(o instanceof Array){
\r
1318 if(arguments.length==1){
\r
1319 return o.join('');
\r
1321 var off=arguments[1];
\r
1322 var len=arguments[2];
\r
1323 var oo=new Array(len);
\r
1324 for(var i=0;i<len;i++){
\r
1327 return oo.join('');
\r
1333 sp.subSequence=function(beginIndex,endIndex){
\r
1334 return this.substring(beginIndex,endIndex);
\r
1337 sp.compareToIgnoreCase=function(str){
\r
1339 throw new NullPointerException();
\r
1341 var s1=this.toUpperCase();
\r
1342 var s2=str.toUpperCase();
\r
1346 var s1=this.toLowerCase();
\r
1347 var s2=str.toLowerCase();
\r
1358 sp.contentEquals=function(sb){
\r
1359 if(this.length!=sb.length()){
\r
1362 var v=sb.getValue();
\r
1365 var n=this.length;
\r
1367 if(this.charCodeAt(i++)!=v[j++]){
\r
1374 sp.getChars=function(srcBegin,srcEnd,dst,dstBegin){
\r
1376 throw new StringIndexOutOfBoundsException(srcBegin);
\r
1378 if(srcEnd>this.length){
\r
1379 throw new StringIndexOutOfBoundsException(srcEnd);
\r
1381 if(srcBegin>srcEnd){
\r
1382 throw new StringIndexOutOfBoundsException(srcEnd-srcBegin);
\r
1385 throw new NullPointerException();
\r
1387 for(var i=0;i<srcEnd-srcBegin;i++){
\r
1388 dst[dstBegin+i]=this.charAt(srcBegin+i);
\r
1391 sp.$concat=sp.concat;
\r
1392 sp.concat=function(s){
\r
1394 throw new NullPointerException();
\r
1396 return this.$concat(s);
\r
1399 sp.$lastIndexOf=sp.lastIndexOf;
\r
1400 sp.lastIndexOf=function(s,last){
\r
1401 if(last!=null&&last+this.length<=0){
\r
1405 return this.$lastIndexOf(s,last);
\r
1407 return this.$lastIndexOf(s);
\r
1411 sp.intern=function(){
\r
1412 return this.valueOf();
\r
1414 String.copyValueOf=sp.copyValueOf=function(){
\r
1415 if(arguments.length==1){
\r
1416 return String.instantialize(arguments[0]);
\r
1418 return String.instantialize(arguments[0],arguments[1],arguments[2]);
\r
1422 sp.codePointAt || (sp.codePointAt = sp.charCodeAt); // Firefox only
\r
1425 })(String.prototype);
\r
1429 String.indexOf=function(source,sourceOffset,sourceCount,
\r
1430 target,targetOffset,targetCount,fromIndex){
\r
1431 if(fromIndex>=sourceCount){
\r
1432 return(targetCount==0?sourceCount:-1);
\r
1437 if(targetCount==0){
\r
1441 var first=target[targetOffset];
\r
1442 var i=sourceOffset+fromIndex;
\r
1443 var max=sourceOffset+(sourceCount-targetCount);
\r
1445 startSearchForFirstChar:
\r
1448 while(i<=max&&source[i]!=first){
\r
1457 var end=j+targetCount-1;
\r
1458 var k=targetOffset+1;
\r
1460 if(source[j++]!=target[k++]){
\r
1463 continue startSearchForFirstChar;
\r
1466 return i-sourceOffset;
\r
1472 String.instantialize=function(){
\r
1473 if(arguments.length==0){
\r
1474 return new String();
\r
1475 }else if(arguments.length==1){
\r
1476 var x=arguments[0];
\r
1477 if(typeof x=="string"||x instanceof String){
\r
1478 return new String(x);
\r
1479 }else if(x instanceof Array){
\r
1480 if(x.length>0&&typeof x[0]=="number"){
\r
1481 var arr=new Array(x.length);
\r
1482 for(var i=0;i<x.length;i++){
\r
1483 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1485 return Encoding.readUTF8(arr.join(''));
\r
1487 return x.join('');
\r
1488 }else if(x.__CLASS_NAME__=="StringBuffer"
\r
1489 ||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1490 var value=x.shareValue();
\r
1491 var length=x.length();
\r
1492 var valueCopy=new Array(length);
\r
1493 for(var i=0;i<length;i++){
\r
1494 valueCopy[i]=value[i];
\r
1496 return valueCopy.join('')
\r
1501 }else if(arguments.length==2){
\r
1502 var x=arguments[0];
\r
1503 var hibyte=arguments[1];
\r
1504 if(typeof hibyte=="string"){
\r
1505 return String.instantialize(x,0,x.length,hibyte);
\r
1507 return String.instantialize(x,hibyte,0,x.length);
\r
1509 }else if(arguments.length==3){
\r
1510 var bytes=arguments[0];
\r
1511 var offset=arguments[1];
\r
1512 var length=arguments[2];
\r
1513 if(arguments[2]instanceof Array){
\r
1514 bytes=arguments[2];
\r
1515 offset=arguments[0];
\r
1516 length=arguments[1];
\r
1518 var arr=new Array(length);
\r
1519 if(offset<0||length+offset>bytes.length){
\r
1520 throw new IndexOutOfBoundsException();
\r
1523 var isChar=(bytes[offset].length!=null);
\r
1525 for(var i=0;i<length;i++){
\r
1526 arr[i]=bytes[offset+i];
\r
1529 for(var i=0;i<length;i++){
\r
1530 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1534 return arr.join('');
\r
1535 }else if(arguments.length==4){
\r
1536 var bytes=arguments[0];
\r
1537 var y=arguments[3];
\r
1538 if(typeof y=="string"||y instanceof String){
\r
1539 var offset=arguments[1];
\r
1540 var length=arguments[2];
\r
1541 var arr=new Array(length);
\r
1542 for(var i=0;i<length;i++){
\r
1543 arr[i]=bytes[offset+i];
\r
1544 if(typeof arr[i]=="number"){
\r
1545 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1548 var cs=y.toLowerCase();
\r
1549 if(cs=="utf-8"||cs=="utf8"){
\r
1550 return Encoding.readUTF8(arr.join(''));
\r
1552 return arr.join('');
\r
1555 var count=arguments[3];
\r
1556 var offset=arguments[2];
\r
1557 var hibyte=arguments[1];
\r
1558 var value=new Array(count);
\r
1560 for(var i=count;i-->0;){
\r
1561 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1565 for(var i=count;i-->0;){
\r
1566 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1569 return value.join('');
\r
1573 for(var i=0;i<arguments.length;i++){
\r
1584 String.instantialize=function(){
\r
1585 switch (arguments.length) {
\r
1587 return new String();
\r
1589 var x=arguments[0];
\r
1590 if(typeof x=="string"||x instanceof String){
\r
1591 return new String(x);
\r
1593 if(x instanceof Array || x instanceof Int32Array){
\r
1596 if(typeof x[0]!="number")
\r
1597 return x.join('');
\r
1598 var arr=new Array(x.length);
\r
1599 for(var i=0;i<x.length;i++)
\r
1600 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1601 return Encoding.readUTF8(arr.join(''));
\r
1603 if(x.__CLASS_NAME__=="StringBuffer"||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1604 var value=x.shareValue();
\r
1605 var length=x.length();
\r
1606 var valueCopy=new Array(length);
\r
1607 for(var i=0;i<length;i++){
\r
1608 valueCopy[i]=value[i];
\r
1610 return valueCopy.join('')
\r
1614 var x=arguments[0];
\r
1615 var hibyte=arguments[1];
\r
1616 if(typeof hibyte=="string"){
\r
1617 return String.instantialize(x,0,x.length,hibyte);
\r
1619 return String.instantialize(x,hibyte,0,x.length);
\r
1621 var bytes=arguments[0];
\r
1622 var offset=arguments[1];
\r
1623 var length=arguments[2];
\r
1624 if(arguments[2]instanceof Array){
\r
1625 bytes=arguments[2];
\r
1626 offset=arguments[0];
\r
1627 length=arguments[1];
\r
1629 var arr=new Array(length);
\r
1630 if(offset<0||length+offset>bytes.length){
\r
1631 throw new IndexOutOfBoundsException();
\r
1634 var isChar=(bytes[offset].length!=null);
\r
1636 for(var i=0;i<length;i++){
\r
1637 arr[i]=bytes[offset+i];
\r
1640 for(var i=0;i<length;i++){
\r
1641 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1645 return arr.join('');
\r
1647 var bytes=arguments[0];
\r
1648 var y=arguments[3];
\r
1649 if(typeof y=="string"||y instanceof String){
\r
1650 var offset=arguments[1];
\r
1651 var length=arguments[2];
\r
1652 var arr=new Array(length);
\r
1653 for(var i=0;i<length;i++){
\r
1654 arr[i]=bytes[offset+i];
\r
1655 if(typeof arr[i]=="number"){
\r
1656 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1659 var cs=y.toLowerCase();
\r
1660 if(cs=="utf-8"||cs=="utf8"){
\r
1661 return Encoding.readUTF8(arr.join(''));
\r
1663 return arr.join('');
\r
1665 var count=arguments[3];
\r
1666 var offset=arguments[2];
\r
1667 var hibyte=arguments[1];
\r
1668 var value=new Array(count);
\r
1670 for(var i=count;i-->0;){
\r
1671 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1675 for(var i=count;i-->0;){
\r
1676 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1679 return value.join('');
\r
1682 for(var i=0;i<arguments.length;i++){
\r
1689 if(navigator.userAgent.toLowerCase().indexOf("chrome")!=-1){
\r
1690 String.prototype.toString=function(){return this.valueOf();};
\r
1695 })(Clazz._Encoding);
\r
1699 c$=Clazz_decorateAsClass(function(){
\r
1701 Clazz_instantialize(this,arguments);
\r
1702 },java.lang,"Character",null,[java.io.Serializable,Comparable]);
\r
1703 Clazz_makeConstructor(c$,
\r
1707 Clazz_defineMethod(c$,"charValue",
\r
1709 return this.value;
\r
1711 Clazz_overrideMethod(c$,"hashCode",
\r
1713 return(this.value).charCodeAt(0);
\r
1715 Clazz_overrideMethod(c$,"equals",
\r
1717 if(Clazz_instanceOf(obj,Character)){
\r
1718 return(this.value).charCodeAt(0)==((obj).charValue()).charCodeAt(0);
\r
1721 Clazz_overrideMethod(c$,"compareTo",
\r
1723 return(this.value).charCodeAt(0)-(c.value).charCodeAt(0);
\r
1725 c$.toLowerCase=Clazz_defineMethod(c$,"toLowerCase",
\r
1727 return(""+c).toLowerCase().charAt(0);
\r
1729 c$.toUpperCase=Clazz_defineMethod(c$,"toUpperCase",
\r
1731 return(""+c).toUpperCase().charAt(0);
\r
1733 c$.isDigit=Clazz_defineMethod(c$,"isDigit",
\r
1735 c = c.charCodeAt(0);
\r
1736 return (48 <= c && c <= 57);
\r
1738 c$.isUpperCase=Clazz_defineMethod(c$,"isUpperCase",
\r
1740 c = c.charCodeAt(0);
\r
1741 return (65 <= c && c <= 90);
\r
1743 c$.isLowerCase=Clazz_defineMethod(c$,"isLowerCase",
\r
1745 c = c.charCodeAt(0);
\r
1746 return (97 <= c && c <= 122);
\r
1748 c$.isWhitespace=Clazz_defineMethod(c$,"isWhitespace",
\r
1750 c = (c).charCodeAt(0);
\r
1751 return (c >= 0x1c && c <= 0x20 || c >= 0x9 && c <= 0xd || c == 0x1680
\r
1752 || c >= 0x2000 && c != 0x2007 && (c <= 0x200b || c == 0x2028 || c == 0x2029 || c == 0x3000));
\r
1754 c$.isLetter=Clazz_defineMethod(c$,"isLetter",
\r
1756 c = c.charCodeAt(0);
\r
1757 return (65 <= c && c <= 90 || 97 <= c && c <= 122);
\r
1759 c$.isLetterOrDigit=Clazz_defineMethod(c$,"isLetterOrDigit",
\r
1761 c = c.charCodeAt(0);
\r
1762 return (65 <= c && c <= 90 || 97 <= c && c <= 122 || 48 <= c && c <= 57);
\r
1764 c$.isSpaceChar=Clazz_defineMethod(c$,"isSpaceChar",
\r
1766 var i = c.charCodeAt(0);
\r
1767 if(i==0x20||i==0xa0||i==0x1680)return true;
\r
1768 if(i<0x2000)return false;
\r
1769 return i<=0x200b||i==0x2028||i==0x2029||i==0x202f||i==0x3000;
\r
1771 c$.digit=Clazz_defineMethod(c$,"digit",
\r
1772 function(c,radix){
\r
1773 var i = c.charCodeAt(0);
\r
1774 if(radix >= 2 && radix <= 36){
\r
1777 if(48 <= i && i <= 57){
\r
1779 }else if(97 <= i && i <= 122){
\r
1781 }else if(65 <= i && i <= 90){
\r
1784 return (result < radix ? result : -1);
\r
1789 Clazz_overrideMethod(c$,"toString",
\r
1791 var buf=[this.value];
\r
1792 return String.valueOf(buf);
\r
1794 c$.toString=Clazz_overrideMethod(c$,"toString",
\r
1797 if(this===Character){
\r
1798 return"class java.lang.Character";
\r
1800 }return String.valueOf(c);
\r
1802 Clazz_defineStatics(c$,
\r
1803 "MIN_VALUE",'\u0000',
\r
1804 "MAX_VALUE",'\uffff',
\r
1809 java.lang.Character.TYPE=java.lang.Character.prototype.TYPE=java.lang.Character;
\r
1813 Clazz._ArrayWrapper = function(a, type) {
\r
1816 __CLASS_NAME__:"Array",
\r
1817 superClazz: Array,
\r
1818 getComponentType: function() {return type},
\r
1819 instanceOf: function(o) { return Clazz_instanceOf(type, o) },
\r
1820 getName: function() { return this.__CLASS_NAME__ }
\r
1823 c$=Clazz_declareType(java.lang.reflect,"Array");
\r
1824 c$.newInstance=Clazz_defineMethod(c$,"newInstance",
\r
1825 function(componentType,size){
\r
1826 var a = Clazz_newArray(size);
\r
1827 a.getClass = function() { return new Clazz._ArrayWrapper(this, componentType);};
\r
1831 javautil.Date=Date;
\r
1832 Date.TYPE="javautil.Date";
\r
1833 Date.__CLASS_NAME__="Date";
\r
1834 Clazz_implementOf(Date,[java.io.Serializable,java.lang.Comparable]);
\r
1836 Clazz_defineMethod(javautil.Date,"clone",
\r
1838 return new Date(this.getTime());
\r
1841 Clazz_defineMethod(javautil.Date,"before",
\r
1843 return this.getTime()<when.getTime();
\r
1844 },"javautil.Date");
\r
1845 Clazz_defineMethod(javautil.Date,"after",
\r
1847 return this.getTime()>when.getTime();
\r
1848 },"javautil.Date");
\r
1849 Clazz_defineMethod(javautil.Date,"equals",
\r
1851 return Clazz_instanceOf(obj,javautil.Date)&&this.getTime()==(obj).getTime();
\r
1853 Clazz_defineMethod(javautil.Date,"compareTo",
\r
1854 function(anotherDate){
\r
1855 var thisTime=this.getTime();
\r
1856 var anotherTime=anotherDate.getTime();
\r
1857 return(thisTime<anotherTime?-1:(thisTime==anotherTime?0:1));
\r
1858 },"javautil.Date");
\r
1859 Clazz_defineMethod(javautil.Date,"compareTo",
\r
1861 return this.compareTo(o);
\r
1863 Clazz_overrideMethod(javautil.Date,"hashCode",
\r
1865 var ht=this.getTime();
\r
1866 return parseInt(ht)^parseInt((ht>>32));
\r
1869 c$=Clazz_decorateAsClass(function(){
\r
1871 Clazz_instantialize(this,arguments);
\r
1872 },javautil,"EventObject",null,java.io.Serializable);
\r
1873 Clazz_makeConstructor(c$,
\r
1875 if(source!=null)this.source=source;
\r
1876 else throw new IllegalArgumentException();
\r
1878 Clazz_defineMethod(c$,"getSource",
\r
1880 return this.source;
\r
1882 Clazz_overrideMethod(c$,"toString",
\r
1884 return this.getClass().getName()+"[source="+String.valueOf(this.source)+']';
\r
1886 Clazz_declareInterface(javautil,"EventListener");
\r
1888 c$=Clazz_decorateAsClass(function(){
\r
1889 this.listener=null;
\r
1890 Clazz_instantialize(this,arguments);
\r
1891 },javautil,"EventListenerProxy",null,javautil.EventListener);
\r
1892 Clazz_makeConstructor(c$,
\r
1893 function(listener){
\r
1894 this.listener=listener;
\r
1895 },"javautil.EventListener");
\r
1896 Clazz_defineMethod(c$,"getListener",
\r
1898 return this.listener;
\r
1900 Clazz_declareInterface(javautil,"Iterator");
\r
1902 Clazz_declareInterface(javautil,"ListIterator",javautil.Iterator);
\r
1903 Clazz_declareInterface(javautil,"Enumeration");
\r
1904 Clazz_declareInterface(javautil,"Collection",Iterable);
\r
1906 Clazz_declareInterface(javautil,"Set",javautil.Collection);
\r
1907 Clazz_declareInterface(javautil,"Map");
\r
1908 Clazz_declareInterface(javautil.Map,"Entry");
\r
1910 Clazz_declareInterface(javautil,"List",javautil.Collection);
\r
1912 Clazz_declareInterface(javautil,"Queue",javautil.Collection);
\r
1913 Clazz_declareInterface(javautil,"RandomAccess");
\r
1914 c$=Clazz_decorateAsClass(function(){
\r
1915 this.detailMessage=null;
\r
1917 this.stackTrace=null;
\r
1918 Clazz_instantialize(this,arguments);
\r
1919 },java.lang,"Throwable",null,java.io.Serializable);
\r
1920 Clazz_prepareFields(c$,function(){
\r
1922 //alert("e0 "+ arguments.callee.caller.caller.caller.caller.caller)
\r
1924 Clazz_makeConstructor(c$,
\r
1926 this.fillInStackTrace();
\r
1928 Clazz_makeConstructor(c$,
\r
1929 function(message){
\r
1930 this.fillInStackTrace();
\r
1931 this.detailMessage=message;
\r
1933 Clazz_makeConstructor(c$,
\r
1934 function(message,cause){
\r
1935 this.fillInStackTrace();
\r
1936 this.detailMessage=message;
\r
1938 },"~S,Throwable");
\r
1939 Clazz_makeConstructor(c$,
\r
1941 this.fillInStackTrace();
\r
1942 this.detailMessage=(cause==null?null:cause.toString());
\r
1945 Clazz_defineMethod(c$,"getMessage",
\r
1947 return (this.message || this.detailMessage || this.toString());
\r
1949 Clazz_defineMethod(c$,"getLocalizedMessage",
\r
1951 return this.getMessage();
\r
1953 Clazz_defineMethod(c$,"getCause",
\r
1955 return(this.cause===this?null:this.cause);
\r
1957 Clazz_defineMethod(c$,"initCause",
\r
1959 if(this.cause!==this)throw new IllegalStateException("Can't overwrite cause");
\r
1960 if(cause===this)throw new IllegalArgumentException("Self-causation not permitted");
\r
1964 Clazz_overrideMethod(c$,"toString",
\r
1966 var s=this.getClass().getName();
\r
1967 var message=this.message || this.detailMessage;
\r
1968 return(message ? s+": "+message : s);
\r
1970 Clazz_defineMethod(c$,"printStackTrace",
\r
1972 System.err.println(this.getStackTrace ? this.getStackTrace() : this.message + " " + Clazz_getStackTrace());
\r
1975 Clazz_defineMethod(c$,"getStackTrace",
\r
1977 var s = "" + this + "\n";
\r
1978 for(var i=0;i<this.stackTrace.length;i++){
\r
1979 var t=this.stackTrace[i];
\r
1980 var x=t.methodName.indexOf("(");
\r
1981 var n=t.methodName.substring(0,x).replace(/\s+/g,"");
\r
1982 if(n!="construct"||t.nativeClazz==null
\r
1983 ||Clazz_getInheritedLevel(t.nativeClazz,Throwable)<0){
\r
1991 Clazz_defineMethod(c$,"printStackTrace",
\r
1993 this.printStackTrace();
\r
1994 },"java.io.PrintStream");
\r
1995 Clazz_defineMethod(c$,"printStackTrace",
\r
1997 this.printStackTrace();
\r
1998 },"java.io.PrintWriter");
\r
1999 Clazz_defineMethod(c$,"fillInStackTrace",
\r
2001 this.stackTrace=new Array();
\r
2002 var caller=arguments.callee.caller;
\r
2003 var superCaller=null;
\r
2004 var callerList=new Array();
\r
2005 var index=Clazz._callingStackTraces.length-1;
\r
2006 var noLooping=true;
\r
2007 while(index>-1||caller!=null){
\r
2008 var clazzName=null;
\r
2009 var nativeClass=null;
\r
2010 if(!noLooping||caller==Clazz_tryToSearchAndExecute||caller==Clazz_superCall||caller==null){
\r
2015 superCaller=Clazz._callingStackTraces[index].caller;
\r
2016 nativeClass=Clazz._callingStackTraces[index].owner;
\r
2019 superCaller=caller;
\r
2020 if(superCaller.claxxOwner!=null){
\r
2021 nativeClass=superCaller.claxxOwner;
\r
2022 }else if(superCaller.exClazz!=null){
\r
2023 nativeClass=superCaller.exClazz;
\r
2026 var st=new StackTraceElement(
\r
2027 ((nativeClass!=null&&nativeClass.__CLASS_NAME__.length!=0)?
\r
2028 nativeClass.__CLASS_NAME__:"anonymous"),
\r
2029 ((superCaller.exName==null)?"anonymous":superCaller.exName)
\r
2030 +" ("+Clazz_getParamsType(superCaller.arguments)+")",
\r
2032 st.nativeClazz=nativeClass;
\r
2033 this.stackTrace[this.stackTrace.length]=st;
\r
2034 for(var i=0;i<callerList.length;i++){
\r
2035 if(callerList[i]==superCaller){
\r
2037 var st=new StackTraceElement("lost","missing",null,-3);
\r
2038 st.nativeClazz=null;
\r
2039 this.stackTrace[this.stackTrace.length]=st;
\r
2044 if(superCaller!=null){
\r
2045 callerList[callerList.length]=superCaller;
\r
2047 caller=superCaller.arguments.callee.caller;
\r
2049 Clazz._initializingException=false;
\r
2052 Clazz_defineMethod(c$,"setStackTrace",
\r
2053 function(stackTrace){
\r
2054 var defensiveCopy=stackTrace.clone();
\r
2055 for(var i=0;i<defensiveCopy.length;i++)if(defensiveCopy[i]==null)throw new NullPointerException("stackTrace["+i+"]");
\r
2057 this.stackTrace=defensiveCopy;
\r
2060 c$=Clazz_decorateAsClass(function(){
\r
2061 this.declaringClass=null;
\r
2062 this.methodName=null;
\r
2063 this.fileName=null;
\r
2064 this.lineNumber=0;
\r
2065 Clazz_instantialize(this,arguments);
\r
2066 },java.lang,"StackTraceElement",null,java.io.Serializable);
\r
2067 Clazz_makeConstructor(c$,
\r
2068 function(cls,method,file,line){
\r
2069 if(cls==null||method==null){
\r
2070 throw new NullPointerException();
\r
2071 }this.declaringClass=cls;
\r
2072 this.methodName=method;
\r
2073 this.fileName=file;
\r
2074 this.lineNumber=line;
\r
2076 Clazz_overrideMethod(c$,"equals",
\r
2078 if(!(Clazz_instanceOf(obj,StackTraceElement))){
\r
2081 if((this.methodName==null)||(castObj.methodName==null)){
\r
2083 }if(!this.getMethodName().equals(castObj.getMethodName())){
\r
2085 }if(!this.getClassName().equals(castObj.getClassName())){
\r
2087 }var localFileName=this.getFileName();
\r
2088 if(localFileName==null){
\r
2089 if(castObj.getFileName()!=null){
\r
2092 if(!localFileName.equals(castObj.getFileName())){
\r
2094 }}if(this.getLineNumber()!=castObj.getLineNumber()){
\r
2098 Clazz_defineMethod(c$,"getClassName",
\r
2100 return(this.declaringClass==null)?"<unknown class>":this.declaringClass;
\r
2102 Clazz_defineMethod(c$,"getFileName",
\r
2104 return this.fileName;
\r
2106 Clazz_defineMethod(c$,"getLineNumber",
\r
2108 return this.lineNumber;
\r
2110 Clazz_defineMethod(c$,"getMethodName",
\r
2112 return(this.methodName==null)?"<unknown method>":this.methodName;
\r
2114 Clazz_overrideMethod(c$,"hashCode",
\r
2116 if(this.methodName==null){
\r
2118 }return this.methodName.hashCode()^this.declaringClass.hashCode();
\r
2120 Clazz_defineMethod(c$,"isNativeMethod",
\r
2122 return this.lineNumber==-2;
\r
2124 Clazz_overrideMethod(c$,"toString",
\r
2126 var buf=new StringBuilder(80);
\r
2127 buf.append(this.getClassName());
\r
2129 buf.append(this.getMethodName());
\r
2130 if(this.isNativeMethod()){
\r
2131 buf.append("(Native Method)");
\r
2133 var fName=this.getFileName();
\r
2135 buf.append("(Unknown Source)");
\r
2137 var lineNum=this.getLineNumber();
\r
2139 buf.append(fName);
\r
2142 buf.append(lineNum);
\r
2144 }}return buf.toString();
\r
2146 TypeError.prototype.getMessage || (TypeError.prototype.getMessage = function(){ return (this.message || this.toString()) + (this.getStackTrace ? this.getStackTrace() : Clazz_getStackTrace())});
\r
2147 c$=Clazz_declareType(java.lang,"Error",Throwable);
\r
2149 c$=Clazz_declareType(java.lang,"LinkageError",Error);
\r
2151 c$=Clazz_declareType(java.lang,"IncompatibleClassChangeError",LinkageError);
\r
2153 c$=Clazz_declareType(java.lang,"AbstractMethodError",IncompatibleClassChangeError);
\r
2155 c$=Clazz_declareType(java.lang,"AssertionError",Error);
\r
2156 Clazz_makeConstructor(c$,
\r
2157 function(detailMessage){
\r
2158 Clazz_superConstructor(this,AssertionError,[String.valueOf(detailMessage),(Clazz_instanceOf(detailMessage,Throwable)?detailMessage:null)]);
\r
2160 Clazz_makeConstructor(c$,
\r
2161 function(detailMessage){
\r
2162 this.construct("" + detailMessage);
\r
2164 Clazz_makeConstructor(c$,
\r
2165 function(detailMessage){
\r
2166 this.construct("" + detailMessage);
\r
2169 c$=Clazz_declareType(java.lang,"ClassCircularityError",LinkageError);
\r
2171 c$=Clazz_declareType(java.lang,"ClassFormatError",LinkageError);
\r
2173 c$=Clazz_decorateAsClass(function(){
\r
2174 this.exception=null;
\r
2175 Clazz_instantialize(this,arguments);
\r
2176 },java.lang,"ExceptionInInitializerError",LinkageError);
\r
2177 Clazz_makeConstructor(c$,
\r
2179 Clazz_superConstructor(this,ExceptionInInitializerError);
\r
2180 this.initCause(null);
\r
2182 Clazz_makeConstructor(c$,
\r
2183 function(detailMessage){
\r
2184 Clazz_superConstructor(this,ExceptionInInitializerError,[detailMessage]);
\r
2185 this.initCause(null);
\r
2187 Clazz_makeConstructor(c$,
\r
2188 function(exception){
\r
2189 Clazz_superConstructor(this,ExceptionInInitializerError);
\r
2190 this.exception=exception;
\r
2191 this.initCause(exception);
\r
2193 Clazz_defineMethod(c$,"getException",
\r
2195 return this.exception;
\r
2197 Clazz_overrideMethod(c$,"getCause",
\r
2199 return this.exception;
\r
2202 c$=Clazz_declareType(java.lang,"IllegalAccessError",IncompatibleClassChangeError);
\r
2204 c$=Clazz_declareType(java.lang,"InstantiationError",IncompatibleClassChangeError);
\r
2206 c$=Clazz_declareType(java.lang,"VirtualMachineError",Error);
\r
2208 c$=Clazz_declareType(java.lang,"InternalError",VirtualMachineError);
\r
2210 c$=Clazz_declareType(java.lang,"NoClassDefFoundError",LinkageError);
\r
2212 c$=Clazz_declareType(java.lang,"NoSuchFieldError",IncompatibleClassChangeError);
\r
2214 c$=Clazz_declareType(java.lang,"NoSuchMethodError",IncompatibleClassChangeError);
\r
2216 c$=Clazz_declareType(java.lang,"OutOfMemoryError",VirtualMachineError);
\r
2218 c$=Clazz_declareType(java.lang,"StackOverflowError",VirtualMachineError);
\r
2220 c$=Clazz_declareType(java.lang,"UnknownError",VirtualMachineError);
\r
2222 c$=Clazz_declareType(java.lang,"UnsatisfiedLinkError",LinkageError);
\r
2224 c$=Clazz_declareType(java.lang,"UnsupportedClassVersionError",ClassFormatError);
\r
2226 c$=Clazz_declareType(java.lang,"VerifyError",LinkageError);
\r
2228 c$=Clazz_declareType(java.lang,"ThreadDeath",Error);
\r
2229 Clazz_makeConstructor(c$,
\r
2231 Clazz_superConstructor(this,ThreadDeath,[]);
\r
2234 c$=Clazz_declareType(java.lang,"Exception",Throwable);
\r
2236 c$=Clazz_declareType(java.lang,"RuntimeException",Exception);
\r
2238 c$=Clazz_declareType(java.lang,"ArithmeticException",RuntimeException);
\r
2240 c$=Clazz_declareType(java.lang,"IndexOutOfBoundsException",RuntimeException);
\r
2242 c$=Clazz_declareType(java.lang,"ArrayIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2243 Clazz_makeConstructor(c$,
\r
2245 Clazz_superConstructor(this,ArrayIndexOutOfBoundsException,["Array index out of range: "+index]);
\r
2248 c$=Clazz_declareType(java.lang,"ArrayStoreException",RuntimeException);
\r
2250 c$=Clazz_declareType(java.lang,"ClassCastException",RuntimeException);
\r
2252 c$=Clazz_decorateAsClass(function(){
\r
2254 Clazz_instantialize(this,arguments);
\r
2255 },java.lang,"ClassNotFoundException",Exception);
\r
2256 Clazz_makeConstructor(c$,
\r
2258 Clazz_superConstructor(this,ClassNotFoundException,[Clazz_castNullAs("Throwable")]);
\r
2260 Clazz_makeConstructor(c$,
\r
2261 function(detailMessage){
\r
2262 Clazz_superConstructor(this,ClassNotFoundException,[detailMessage,null]);
\r
2264 Clazz_makeConstructor(c$,
\r
2265 function(detailMessage,exception){
\r
2266 Clazz_superConstructor(this,ClassNotFoundException,[detailMessage]);
\r
2267 this.ex=exception;
\r
2268 },"~S,Throwable");
\r
2269 Clazz_defineMethod(c$,"getException",
\r
2273 Clazz_overrideMethod(c$,"getCause",
\r
2278 c$=Clazz_declareType(java.lang,"CloneNotSupportedException",Exception);
\r
2280 c$=Clazz_declareType(java.lang,"IllegalAccessException",Exception);
\r
2282 c$=Clazz_declareType(java.lang,"IllegalArgumentException",RuntimeException);
\r
2283 Clazz_makeConstructor(c$,
\r
2285 Clazz_superConstructor(this,IllegalArgumentException,[(cause==null?null:cause.toString()),cause]);
\r
2288 c$=Clazz_declareType(java.lang,"IllegalMonitorStateException",RuntimeException);
\r
2290 c$=Clazz_declareType(java.lang,"IllegalStateException",RuntimeException);
\r
2291 Clazz_makeConstructor(c$,
\r
2293 Clazz_superConstructor(this,IllegalStateException,[(cause==null?null:cause.toString()),cause]);
\r
2296 c$=Clazz_declareType(java.lang,"IllegalThreadStateException",IllegalArgumentException);
\r
2298 c$=Clazz_declareType(java.lang,"InstantiationException",Exception);
\r
2300 c$=Clazz_declareType(java.lang,"InterruptedException",Exception);
\r
2302 c$=Clazz_declareType(java.lang,"NegativeArraySizeException",RuntimeException);
\r
2304 c$=Clazz_declareType(java.lang,"NoSuchFieldException",Exception);
\r
2306 c$=Clazz_declareType(java.lang,"NoSuchMethodException",Exception);
\r
2308 c$=Clazz_declareType(java.lang,"NullPointerException",RuntimeException);
\r
2310 c$=Clazz_declareType(java.lang,"NumberFormatException",IllegalArgumentException);
\r
2312 c$=Clazz_declareType(java.lang,"SecurityException",RuntimeException);
\r
2313 Clazz_makeConstructor(c$,
\r
2315 Clazz_superConstructor(this,SecurityException,[(cause==null?null:cause.toString()),cause]);
\r
2318 c$=Clazz_declareType(java.lang,"StringIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2319 Clazz_makeConstructor(c$,
\r
2321 Clazz_superConstructor(this,StringIndexOutOfBoundsException,["String index out of range: "+index]);
\r
2324 c$=Clazz_declareType(java.lang,"UnsupportedOperationException",RuntimeException);
\r
2325 Clazz_makeConstructor(c$,
\r
2327 Clazz_superConstructor(this,UnsupportedOperationException,[]);
\r
2329 Clazz_makeConstructor(c$,
\r
2331 Clazz_superConstructor(this,UnsupportedOperationException,[(cause==null?null:cause.toString()),cause]);
\r
2334 c$=Clazz_decorateAsClass(function(){
\r
2336 Clazz_instantialize(this,arguments);
\r
2337 },java.lang.reflect,"InvocationTargetException",Exception);
\r
2338 Clazz_makeConstructor(c$,
\r
2340 Clazz_superConstructor(this,java.lang.reflect.InvocationTargetException,[Clazz_castNullAs("Throwable")]);
\r
2342 Clazz_makeConstructor(c$,
\r
2343 function(exception){
\r
2344 Clazz_superConstructor(this,java.lang.reflect.InvocationTargetException,[null,exception]);
\r
2345 this.target=exception;
\r
2347 Clazz_makeConstructor(c$,
\r
2348 function(exception,detailMessage){
\r
2349 Clazz_superConstructor(this,java.lang.reflect.InvocationTargetException,[detailMessage,exception]);
\r
2350 this.target=exception;
\r
2351 },"Throwable,~S");
\r
2352 Clazz_defineMethod(c$,"getTargetException",
\r
2354 return this.target;
\r
2356 Clazz_overrideMethod(c$,"getCause",
\r
2358 return this.target;
\r
2361 c$=Clazz_decorateAsClass(function(){
\r
2362 this.undeclaredThrowable=null;
\r
2363 Clazz_instantialize(this,arguments);
\r
2364 },java.lang.reflect,"UndeclaredThrowableException",RuntimeException);
\r
2365 Clazz_makeConstructor(c$,
\r
2366 function(exception){
\r
2367 Clazz_superConstructor(this,java.lang.reflect.UndeclaredThrowableException);
\r
2368 this.undeclaredThrowable=exception;
\r
2369 this.initCause(exception);
\r
2371 Clazz_makeConstructor(c$,
\r
2372 function(exception,detailMessage){
\r
2373 Clazz_superConstructor(this,java.lang.reflect.UndeclaredThrowableException,[detailMessage]);
\r
2374 this.undeclaredThrowable=exception;
\r
2375 this.initCause(exception);
\r
2376 },"Throwable,~S");
\r
2377 Clazz_defineMethod(c$,"getUndeclaredThrowable",
\r
2379 return this.undeclaredThrowable;
\r
2381 Clazz_overrideMethod(c$,"getCause",
\r
2383 return this.undeclaredThrowable;
\r
2386 c$=Clazz_declareType(java.io,"IOException",Exception);
\r
2389 c$=Clazz_declareType(java.io,"CharConversionException",java.io.IOException);
\r
2391 c$=Clazz_declareType(java.io,"EOFException",java.io.IOException);
\r
2393 c$=Clazz_declareType(java.io,"FileNotFoundException",java.io.IOException);
\r
2395 c$=Clazz_decorateAsClass(function(){
\r
2396 this.bytesTransferred=0;
\r
2397 Clazz_instantialize(this,arguments);
\r
2398 },java.io,"InterruptedIOException",java.io.IOException);
\r
2400 c$=Clazz_declareType(java.io,"ObjectStreamException",java.io.IOException);
\r
2402 c$=Clazz_decorateAsClass(function(){
\r
2403 this.classname=null;
\r
2404 Clazz_instantialize(this,arguments);
\r
2405 },java.io,"InvalidClassException",java.io.ObjectStreamException);
\r
2406 Clazz_makeConstructor(c$,
\r
2407 function(className,detailMessage){
\r
2408 Clazz_superConstructor(this,java.io.InvalidClassException,[detailMessage]);
\r
2409 this.classname=className;
\r
2411 Clazz_defineMethod(c$,"getMessage",
\r
2413 var msg=Clazz_superCall(this,java.io.InvalidClassException,"getMessage",[]);
\r
2414 if(this.classname!=null){
\r
2415 msg=this.classname+';' + ' '+msg;
\r
2419 c$=Clazz_declareType(java.io,"InvalidObjectException",java.io.ObjectStreamException);
\r
2421 c$=Clazz_declareType(java.io,"NotActiveException",java.io.ObjectStreamException);
\r
2423 c$=Clazz_declareType(java.io,"NotSerializableException",java.io.ObjectStreamException);
\r
2425 c$=Clazz_decorateAsClass(function(){
\r
2428 Clazz_instantialize(this,arguments);
\r
2429 },java.io,"OptionalDataException",java.io.ObjectStreamException);
\r
2431 c$=Clazz_declareType(java.io,"StreamCorruptedException",java.io.ObjectStreamException);
\r
2433 c$=Clazz_declareType(java.io,"SyncFailedException",java.io.IOException);
\r
2435 c$=Clazz_declareType(java.io,"UnsupportedEncodingException",java.io.IOException);
\r
2437 c$=Clazz_declareType(java.io,"UTFDataFormatException",java.io.IOException);
\r
2439 c$=Clazz_decorateAsClass(function(){
\r
2441 Clazz_instantialize(this,arguments);
\r
2442 },java.io,"WriteAbortedException",java.io.ObjectStreamException);
\r
2443 Clazz_makeConstructor(c$,
\r
2444 function(detailMessage,rootCause){
\r
2445 Clazz_superConstructor(this,java.io.WriteAbortedException,[detailMessage]);
\r
2446 this.detail=rootCause;
\r
2447 this.initCause(rootCause);
\r
2448 },"~S,Exception");
\r
2449 Clazz_defineMethod(c$,"getMessage",
\r
2451 var msg=Clazz_superCall(this,java.io.WriteAbortedException,"getMessage",[]);
\r
2452 return (this.detail ? msg + "; "+this.detail.toString() : msg);
\r
2454 Clazz_overrideMethod(c$,"getCause",
\r
2456 return this.detail;
\r
2459 c$=Clazz_declareType(javautil,"ConcurrentModificationException",RuntimeException);
\r
2460 Clazz_makeConstructor(c$,
\r
2462 Clazz_superConstructor(this,javautil.ConcurrentModificationException,[]);
\r
2465 c$=Clazz_declareType(javautil,"EmptyStackException",RuntimeException);
\r
2467 c$=Clazz_decorateAsClass(function(){
\r
2468 this.className=null;
\r
2470 Clazz_instantialize(this,arguments);
\r
2471 },javautil,"MissingResourceException",RuntimeException);
\r
2472 Clazz_makeConstructor(c$,
\r
2473 function(detailMessage,className,resourceName){
\r
2474 Clazz_superConstructor(this,javautil.MissingResourceException,[detailMessage]);
\r
2475 this.className=className;
\r
2476 this.key=resourceName;
\r
2478 Clazz_defineMethod(c$,"getClassName",
\r
2480 return this.className;
\r
2482 Clazz_defineMethod(c$,"getKey",
\r
2487 c$=Clazz_declareType(javautil,"NoSuchElementException",RuntimeException);
\r
2489 c$=Clazz_declareType(javautil,"TooManyListenersException",Exception);
\r
2491 c$=Clazz_declareType(java.lang,"Void");
\r
2492 Clazz_defineStatics(c$,
\r
2495 java.lang.Void.TYPE=java.lang.Void;
\r
2496 }Clazz_declareInterface(java.lang.reflect,"GenericDeclaration");
\r
2497 Clazz_declareInterface(java.lang.reflect,"AnnotatedElement");
\r
2499 c$=Clazz_declareType(java.lang.reflect,"AccessibleObject",null,java.lang.reflect.AnnotatedElement);
\r
2500 Clazz_makeConstructor(c$,
\r
2503 Clazz_defineMethod(c$,"isAccessible",
\r
2507 c$.setAccessible=Clazz_defineMethod(c$,"setAccessible",
\r
2508 function(objects,flag){
\r
2511 Clazz_defineMethod(c$,"setAccessible",
\r
2515 Clazz_overrideMethod(c$,"isAnnotationPresent",
\r
2516 function(annotationType){
\r
2519 Clazz_overrideMethod(c$,"getDeclaredAnnotations",
\r
2521 return new Array(0);
\r
2523 Clazz_overrideMethod(c$,"getAnnotations",
\r
2525 return new Array(0);
\r
2527 Clazz_overrideMethod(c$,"getAnnotation",
\r
2528 function(annotationType){
\r
2531 c$.marshallArguments=Clazz_defineMethod(c$,"marshallArguments",
\r
2532 function(parameterTypes,args){
\r
2535 Clazz_defineMethod(c$,"invokeV",
\r
2536 function(receiver,args){
\r
2539 Clazz_defineMethod(c$,"invokeL",
\r
2540 function(receiver,args){
\r
2543 Clazz_defineMethod(c$,"invokeI",
\r
2544 function(receiver,args){
\r
2547 Clazz_defineMethod(c$,"invokeJ",
\r
2548 function(receiver,args){
\r
2551 Clazz_defineMethod(c$,"invokeF",
\r
2552 function(receiver,args){
\r
2555 Clazz_defineMethod(c$,"invokeD",
\r
2556 function(receiver,args){
\r
2559 c$.emptyArgs=c$.prototype.emptyArgs=new Array(0);
\r
2560 Clazz_declareInterface(java.lang.reflect,"InvocationHandler");
\r
2561 c$=Clazz_declareInterface(java.lang.reflect,"Member");
\r
2562 Clazz_defineStatics(c$,
\r
2566 c$=Clazz_declareType(java.lang.reflect,"Modifier");
\r
2567 Clazz_makeConstructor(c$,
\r
2570 c$.isAbstract=Clazz_defineMethod(c$,"isAbstract",
\r
2571 function(modifiers){
\r
2572 return((modifiers&1024)!=0);
\r
2574 c$.isFinal=Clazz_defineMethod(c$,"isFinal",
\r
2575 function(modifiers){
\r
2576 return((modifiers&16)!=0);
\r
2578 c$.isInterface=Clazz_defineMethod(c$,"isInterface",
\r
2579 function(modifiers){
\r
2580 return((modifiers&512)!=0);
\r
2582 c$.isNative=Clazz_defineMethod(c$,"isNative",
\r
2583 function(modifiers){
\r
2584 return((modifiers&256)!=0);
\r
2586 c$.isPrivate=Clazz_defineMethod(c$,"isPrivate",
\r
2587 function(modifiers){
\r
2588 return((modifiers&2)!=0);
\r
2590 c$.isProtected=Clazz_defineMethod(c$,"isProtected",
\r
2591 function(modifiers){
\r
2592 return((modifiers&4)!=0);
\r
2594 c$.isPublic=Clazz_defineMethod(c$,"isPublic",
\r
2595 function(modifiers){
\r
2596 return((modifiers&1)!=0);
\r
2598 c$.isStatic=Clazz_defineMethod(c$,"isStatic",
\r
2599 function(modifiers){
\r
2600 return((modifiers&8)!=0);
\r
2602 c$.isStrict=Clazz_defineMethod(c$,"isStrict",
\r
2603 function(modifiers){
\r
2604 return((modifiers&2048)!=0);
\r
2606 c$.isSynchronized=Clazz_defineMethod(c$,"isSynchronized",
\r
2607 function(modifiers){
\r
2608 return((modifiers&32)!=0);
\r
2610 c$.isTransient=Clazz_defineMethod(c$,"isTransient",
\r
2611 function(modifiers){
\r
2612 return((modifiers&128)!=0);
\r
2614 c$.isVolatile=Clazz_defineMethod(c$,"isVolatile",
\r
2615 function(modifiers){
\r
2616 return((modifiers&64)!=0);
\r
2618 c$.toString=Clazz_defineMethod(c$,"toString",
\r
2619 function(modifiers){
\r
2620 var sb=new Array(0);
\r
2621 if(java.lang.reflect.Modifier.isPublic(modifiers))sb[sb.length]="public";
\r
2622 if(java.lang.reflect.Modifier.isProtected(modifiers))sb[sb.length]="protected";
\r
2623 if(java.lang.reflect.Modifier.isPrivate(modifiers))sb[sb.length]="private";
\r
2624 if(java.lang.reflect.Modifier.isAbstract(modifiers))sb[sb.length]="abstract";
\r
2625 if(java.lang.reflect.Modifier.isStatic(modifiers))sb[sb.length]="static";
\r
2626 if(java.lang.reflect.Modifier.isFinal(modifiers))sb[sb.length]="final";
\r
2627 if(java.lang.reflect.Modifier.isTransient(modifiers))sb[sb.length]="transient";
\r
2628 if(java.lang.reflect.Modifier.isVolatile(modifiers))sb[sb.length]="volatile";
\r
2629 if(java.lang.reflect.Modifier.isSynchronized(modifiers))sb[sb.length]="synchronized";
\r
2630 if(java.lang.reflect.Modifier.isNative(modifiers))sb[sb.length]="native";
\r
2631 if(java.lang.reflect.Modifier.isStrict(modifiers))sb[sb.length]="strictfp";
\r
2632 if(java.lang.reflect.Modifier.isInterface(modifiers))sb[sb.length]="interface";
\r
2634 return sb.join(" ");
\r
2637 Clazz_defineStatics(c$,
\r
2643 "SYNCHRONIZED",0x20,
\r
2647 "INTERFACE",0x200,
\r
2652 "SYNTHETIC",0x1000,
\r
2653 "ANNOTATION",0x2000,
\r
2656 c$=Clazz_decorateAsClass(function(){
\r
2658 this.parameterTypes=null;
\r
2659 this.exceptionTypes=null;
\r
2661 Clazz_instantialize(this,arguments);
\r
2662 },java.lang.reflect,"Constructor",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2663 Clazz_makeConstructor(c$,
\r
2664 function(declaringClass,parameterTypes,checkedExceptions,modifiers){
\r
2665 Clazz_superConstructor(this,java.lang.reflect.Constructor,[]);
\r
2666 this.clazz=declaringClass;
\r
2667 this.parameterTypes=parameterTypes;
\r
2668 this.exceptionTypes=checkedExceptions;
\r
2669 this.modifiers=modifiers;
\r
2670 },"Class,~A,~A,~N");
\r
2671 Clazz_overrideMethod(c$,"getTypeParameters",
\r
2675 Clazz_defineMethod(c$,"toGenericString",
\r
2679 Clazz_defineMethod(c$,"getGenericParameterTypes",
\r
2683 Clazz_defineMethod(c$,"getGenericExceptionTypes",
\r
2687 Clazz_defineMethod(c$,"getParameterAnnotations",
\r
2691 Clazz_defineMethod(c$,"isVarArgs",
\r
2695 Clazz_overrideMethod(c$,"isSynthetic",
\r
2699 Clazz_overrideMethod(c$,"equals",
\r
2701 if(object!=null&&Clazz_instanceOf(object,java.lang.reflect.Constructor)){
\r
2703 if(this.getDeclaringClass()===other.getDeclaringClass()){
\r
2704 var params1=this.parameterTypes;
\r
2705 var params2=other.parameterTypes;
\r
2706 if(params1.length==params2.length){
\r
2707 for(var i=0;i<params1.length;i++){
\r
2708 if(params1[i]!==params2[i])return false;
\r
2713 Clazz_overrideMethod(c$,"getDeclaringClass",
\r
2715 return this.clazz;
\r
2717 Clazz_defineMethod(c$,"getExceptionTypes",
\r
2719 return this.exceptionTypes;
\r
2721 Clazz_overrideMethod(c$,"getModifiers",
\r
2723 return this.modifiers;
\r
2725 Clazz_overrideMethod(c$,"getName",
\r
2727 return this.getDeclaringClass().getName();
\r
2729 Clazz_defineMethod(c$,"getParameterTypes",
\r
2731 return this.parameterTypes;
\r
2733 Clazz_overrideMethod(c$,"hashCode",
\r
2735 return this.getDeclaringClass().getName().hashCode();
\r
2737 Clazz_defineMethod(c$,"newInstance",
\r
2739 var instance=new this.clazz(Clazz_inheritArgs);
\r
2740 Clazz_instantialize(instance,args);
\r
2743 Clazz_overrideMethod(c$,"toString",
\r
2748 c$=Clazz_declareType(java.lang.reflect,"Field",java.lang.reflect.AccessibleObject,java.lang.reflect.Member);
\r
2749 Clazz_overrideMethod(c$,"isSynthetic",
\r
2753 Clazz_defineMethod(c$,"toGenericString",
\r
2757 Clazz_defineMethod(c$,"isEnumConstant",
\r
2761 Clazz_defineMethod(c$,"getGenericType",
\r
2765 Clazz_overrideMethod(c$,"equals",
\r
2769 Clazz_overrideMethod(c$,"getDeclaringClass",
\r
2773 Clazz_overrideMethod(c$,"getName",
\r
2777 Clazz_defineMethod(c$,"getType",
\r
2781 Clazz_overrideMethod(c$,"hashCode",
\r
2785 Clazz_overrideMethod(c$,"toString",
\r
2790 c$=Clazz_decorateAsClass(function(){
\r
2793 this.returnType=null;
\r
2794 this.parameterTypes=null;
\r
2795 this.exceptionTypes=null;
\r
2797 Clazz_instantialize(this,arguments);
\r
2798 },java.lang.reflect,"Method",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2799 Clazz_makeConstructor(c$,
\r
2800 function(declaringClass,name,parameterTypes,returnType,checkedExceptions,modifiers){
\r
2801 Clazz_superConstructor(this,java.lang.reflect.Method,[]);
\r
2802 this.clazz=declaringClass;
\r
2804 this.parameterTypes=parameterTypes;
\r
2805 this.returnType=returnType;
\r
2806 this.exceptionTypes=checkedExceptions;
\r
2807 this.modifiers=modifiers;
\r
2808 },"Class,~S,~A,Class,~A,~N");
\r
2809 Clazz_overrideMethod(c$,"getTypeParameters",
\r
2813 Clazz_defineMethod(c$,"toGenericString",
\r
2817 Clazz_defineMethod(c$,"getGenericParameterTypes",
\r
2821 Clazz_defineMethod(c$,"getGenericExceptionTypes",
\r
2825 Clazz_defineMethod(c$,"getGenericReturnType",
\r
2829 Clazz_defineMethod(c$,"getParameterAnnotations",
\r
2833 Clazz_defineMethod(c$,"isVarArgs",
\r
2837 Clazz_defineMethod(c$,"isBridge",
\r
2841 Clazz_overrideMethod(c$,"isSynthetic",
\r
2845 Clazz_defineMethod(c$,"getDefaultValue",
\r
2849 Clazz_overrideMethod(c$,"equals",
\r
2851 if(object!=null&&Clazz_instanceOf(object,java.lang.reflect.Method)){
\r
2853 if((this.getDeclaringClass()===other.getDeclaringClass())&&(this.getName()===other.getName())){
\r
2854 var params1=this.parameterTypes;
\r
2855 var params2=other.parameterTypes;
\r
2856 if(params1.length==params2.length){
\r
2857 for(var i=0;i<params1.length;i++){
\r
2858 if(params1[i]!==params2[i])return false;
\r
2863 Clazz_overrideMethod(c$,"getDeclaringClass",
\r
2865 return this.clazz;
\r
2867 Clazz_defineMethod(c$,"getExceptionTypes",
\r
2869 return this.exceptionTypes;
\r
2871 Clazz_overrideMethod(c$,"getModifiers",
\r
2873 return this.modifiers;
\r
2875 Clazz_overrideMethod(c$,"getName",
\r
2879 Clazz_defineMethod(c$,"getParameterTypes",
\r
2881 return this.parameterTypes;
\r
2883 Clazz_defineMethod(c$,"getReturnType",
\r
2885 return this.returnType;
\r
2887 Clazz_overrideMethod(c$,"hashCode",
\r
2889 return this.getDeclaringClass().getName().hashCode()^this.getName().hashCode();
\r
2891 Clazz_defineMethod(c$,"invoke",
\r
2892 function(receiver,args){
\r
2893 var m=this.clazz.prototype[this.getName()];
\r
2895 m=this.clazz[this.getName()];
\r
2898 m.apply(receiver,args);
\r
2903 Clazz_overrideMethod(c$,"toString",
\r
2909 Clazz_declarePackage ("JU");
\r
2910 c$ = Clazz_declareType (JU, "DebugJS");
\r
2911 c$._ = Clazz_defineMethod (c$, "_",
\r
2914 if (Clazz._debugging) {
\r
2919 ,Clazz.getClassName
\r
2920 ,Clazz.newLongArray
\r
2921 ,Clazz.doubleToByte
\r
2922 ,Clazz.doubleToInt
\r
2923 ,Clazz.doubleToLong
\r
2924 ,Clazz.declarePackage
\r
2927 ,Clazz.instantialize
\r
2928 ,Clazz.decorateAsClass
\r
2930 ,Clazz.floatToLong
\r
2931 ,Clazz.makeConstructor
\r
2932 ,Clazz.defineEnumConstant
\r
2933 ,Clazz.exceptionOf
\r
2934 ,Clazz.newIntArray
\r
2935 ,Clazz.defineStatics
\r
2936 ,Clazz.newFloatArray
\r
2937 ,Clazz.declareType
\r
2938 ,Clazz.prepareFields
\r
2939 ,Clazz.superConstructor
\r
2940 ,Clazz.newByteArray
\r
2941 ,Clazz.declareInterface
\r
2944 ,Clazz.newShortArray
\r
2945 ,Clazz.innerTypeInstance
\r
2946 ,Clazz.isClassDefined
\r
2947 ,Clazz.prepareCallback
\r
2950 ,Clazz.floatToShort
\r
2952 ,Clazz.decorateAsType
\r
2953 ,Clazz.newBooleanArray
\r
2954 ,Clazz.newCharArray
\r
2955 ,Clazz.implementOf
\r
2956 ,Clazz.newDoubleArray
\r
2957 ,Clazz.overrideConstructor
\r
2959 ,Clazz.doubleToShort
\r
2960 ,Clazz.getInheritedLevel
\r
2961 ,Clazz.getParamsType
\r
2971 ,Clazz.tryToSearchAndExecute
\r
2972 ,Clazz.getStackTrace
\r
2973 ,Clazz.inheritArgs
\r
2975 ,Clazz.defineMethod
\r
2976 ,Clazz.overrideMethod
\r
2977 ,Clazz.declareAnonymous
\r
2978 ,Clazz.checkPrivateMethod
\r
2979 ,Clazz.cloneFinals
\r