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
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 5/31/2015 5:53:04 PM Number.compareTo added
\r
76 // BH 5/21/2015 5:46:30 PM Number("0xFFFFFFFF") is not -1
\r
77 // BH 4/23/2015 9:08:59 AM xx.getComponentType() is nonfunctional. Array.newInstance now defines a wrapper for .getClass().getComponentType() that works
\r
78 // BH 4/12/2015 1:37:44 PM adding Math.rint = Math.round
\r
79 // BH 1/16/2015 10:09:38 AM Chrome failure jqGrig due to new String("x").toString() not being a simple string
\r
80 // BH 8/14/2014 6:49:22 PM Character class efficiencies
\r
81 // BH 7/24/2014 9:02:18 AM most browsers do not support String.codePointAt()
\r
82 // BH 7/11/2014 4:17:22 PM fix for Boolean.valueOf("false") not being false
\r
83 // BH 5/27/2014 6:29:59 AM ensure floats and doubles have decimal point in toString
\r
84 // BH 4/1/2014 12:23:41 PM Encoding moved to Clazz._Encoding;
\r
85 // BH 4/1/2014 7:51:46 AM removing java.lang.B00lean
\r
86 // BH 3/7/2014 9:17:10 AM removing Array.toString; moving that code here from j2sJmol.js
\r
87 // BH 1/30/2014 9:04:25 AM adding Throwable.getStackTrace() as a STRING
\r
88 // BH 12/4/2013 9:20:44 PM fix for reassigning Date.prototype.toString()
\r
89 // BH 12/3/2013 11:43:10 AM bizarre Safari bug in reassigning Boolean (OK, I admit, we shouldn't have done that...)
\r
90 // BH 12/1/2013 6:50:16 AM evit Number.prototype.toString assignment removed!
\r
91 // BH 11/30/2013 1:46:31 PM fixing Byte, Short, Long, Integer, Float, Double to reflect proper bounds and error conditions
\r
92 // BH 11/29/2013 8:58:49 PM removing Boolean.toString(boolean)
\r
93 // BH 11/4/2013 7:34:26 AM changing "var nativeClazz" to "var nativeClass" to avoid ANT replacement of "nativeClazz_" to "nativeClazz_"
\r
94 // BH 10/19/2013 1:29:27 PM fixed String.$replace()
\r
95 // BH 10/18/2013 6:09:23 PM fixed (Double|Float).valueOf(NaN).valueOf(), which should return NaN, not throw an error
\r
96 // BH 10/12/2013 11:18:44 AM fixed bug in Double(String) and Float(String) that was returning typeof "string"
\r
97 // BH 10/10/2013 2:40:20 PM added Math.log10
\r
98 // BH 7/23/2013 7:24:01 AM fixing Number.shortValue() and Number.byteValue() for negative values
\r
99 // BH 6/16/2013 1:31:30 PM adding /| in String.replace -- thank you David Koes
\r
100 // BH 3/13/2013 12:49:23 PM setting Boolean.valueOf() "@"
\r
101 // BH 3/2/2013 10:46:45 PM removed Double.valueOf(String)
\r
102 // BH 11/6/2012 8:26:33 PM added instanceof Int32Array in String.instantialize
\r
103 // BH 10/13/2012 11:38:07 PM corrected Integer.parseInt to allow only +-0123456789; created Integer.parseIntRadix
\r
104 // BH 11/1/2012 added Short
\r
105 // BH 9/10/2012 6:27:21 AM added java.net.URL... classes
\r
106 // BH 1/7/2013 7:40:06 AM added Clazz_dateToString
\r
108 ;(function(Clazz) {
\r
110 // moved here from package.js
\r
111 // these classes will be created as objects prior to any others
\r
112 // and are then available immediately
\r
114 Clazz._Loader.registerPackages("java", [ "io", "lang", "lang.reflect", "util" ]);
\r
116 var sJU = "java.util";
\r
119 //Clazz._Loader.registerPackages (sJU, ["regex", "zip"]);
\r
120 //var javautil = JU;
\r
122 var javautil = java.util;
\r
124 Clazz._Loader.ignore([
\r
125 "net.sf.j2s.ajax.HttpRequest",
\r
126 sJU + ".MapEntry.Type",
\r
127 //"java.net.UnknownServiceException",
\r
128 "java.lang.Runtime",
\r
129 "java.security.AccessController",
\r
130 "java.security.PrivilegedExceptionAction",
\r
132 "java.io.FileInputStream",
\r
133 "java.io.FileWriter",
\r
134 "java.io.OutputStreamWriter",
\r
135 // sJU + ".Calendar", // bypassed in ModelCollection
\r
136 // "java.text.SimpleDateFormat", // not used
\r
137 // "java.text.DateFormat", // not used
\r
138 sJU + ".concurrent.Executors"
\r
141 Math.rint = Math.round;
\r
143 Math.log10||(Math.log10=function(a){return Math.log(a)/2.302585092994046});
\r
145 if(Clazz._supportsNativeObject){
\r
146 // Number and Array are special -- do not override prototype.toString -- "length - 2" here
\r
147 for(var i=0;i<Clazz._extendedObjectMethods.length - 2;i++){
\r
148 var p=Clazz._extendedObjectMethods[i];
\r
149 Array.prototype[p] = Clazz._O.prototype[p];
\r
150 Number.prototype[p] = Clazz._O.prototype[p];
\r
154 java.lang.Number=Number;
\r
155 Number.__CLASS_NAME__="Number";
\r
156 Clazz_implementOf(Number,java.io.Serializable);
\r
157 Number.equals=Clazz._innerFunctions.equals;
\r
158 Number.getName=Clazz._innerFunctions.getName;
\r
159 Number.prototype.compareTo = function(x) { var a = this.value, b = x.value; return (a < b ? -1 : a == b ? 0 : 1) };
\r
161 Clazz_defineMethod(Number,"shortValue",
\r
163 var x = Math.round(this)&0xffff;
\r
164 return (this < 0 && x > 0 ? x - 0x10000 : x);
\r
167 Clazz_defineMethod(Number,"byteValue",
\r
169 var x = Math.round(this)&0xff;
\r
170 return (this < 0 && x > 0 ? x - 0x100 : x);
\r
173 Clazz_defineMethod(Number,"intValue",
\r
175 return Math.round(this)&0xffffffff;
\r
178 Clazz_defineMethod(Number,"longValue",
\r
180 return Math.round(this);
\r
183 Clazz_defineMethod(Number,"floatValue",
\r
185 return this.valueOf();
\r
187 Clazz_defineMethod(Number,"doubleValue",
\r
189 return parseFloat(this.valueOf());
\r
192 Clazz_overrideMethod(Number,"hashCode",
\r
194 return this.valueOf();
\r
197 java.lang.Integer=Integer=function(){
\r
198 Clazz_instantialize(this,arguments);
\r
200 Clazz_decorateAsType(Integer,"Integer",Number,Comparable,null,true);
\r
201 Integer.prototype.valueOf=function(){return 0;};
\r
202 Integer.toString=Integer.prototype.toString=function(){
\r
203 if(arguments.length!=0){
\r
204 return""+arguments[0];
\r
205 } else if(this===Integer){
\r
206 return"class java.lang.Integer";
\r
208 return""+this.valueOf();
\r
213 Clazz_makeConstructor(Integer,
\r
215 this.valueOf=function(){
\r
222 Clazz_overrideConstructor(Integer, function(v){
\r
223 v == null && (v = 0);
\r
224 if (typeof v != "number")
\r
225 v = Integer.parseIntRadix(v, 10);
\r
226 this.valueOf=function(){return v;};
\r
229 Clazz_makeConstructor(Integer,
\r
231 var value=Integer.parseInt(s,10);
\r
232 this.valueOf=function(){
\r
237 Integer.MIN_VALUE=Integer.prototype.MIN_VALUE=-0x80000000;
\r
238 Integer.MAX_VALUE=Integer.prototype.MAX_VALUE=0x7fffffff;
\r
239 Integer.TYPE=Integer.prototype.TYPE=Integer;
\r
242 Clazz_defineMethod(Integer,"bitCount",
\r
244 i = i - ((i >>> 1) & 0x55555555);
\r
245 i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
\r
246 i = (i + (i >>> 4)) & 0x0f0f0f0f;
\r
248 i = i + (i >>> 16);
\r
251 Integer.bitCount=Integer.prototype.bitCount;
\r
253 Clazz_defineMethod(Integer,"numberOfLeadingZeros",
\r
255 if (i == 0) return 32;
\r
257 if (i >>> 16 == 0) { n += 16; i <<= 16; }
\r
258 if (i >>> 24 == 0) { n += 8; i <<= 8; }
\r
259 if (i >>> 28 == 0) { n += 4; i <<= 4; }
\r
260 if (i >>> 30 == 0) { n += 2; i <<= 2; }
\r
264 Integer.numberOfLeadingZeros=Integer.prototype.numberOfLeadingZeros;
\r
266 Clazz_defineMethod(Integer,"numberOfTrailingZeros",
\r
268 if (i == 0) return 32;
\r
270 var y = i <<16; if (y != 0) { n = n -16; i = y; }
\r
271 y = i << 8; if (y != 0) { n = n - 8; i = y; }
\r
272 y = i << 4; if (y != 0) { n = n - 4; i = y; }
\r
273 y = i << 2; if (y != 0) { n = n - 2; i = y; }
\r
274 return n - ((i << 1) >>> 31);
\r
276 Integer.numberOfTrailingZeros=Integer.prototype.numberOfTrailingZeros;
\r
278 Clazz_defineMethod(Integer,"parseIntRadix",
\r
281 throw new NumberFormatException("null");
\r
283 throw new NumberFormatException("radix "+radix+" less than Character.MIN_RADIX");
\r
285 throw new NumberFormatException("radix "+radix+" greater than Character.MAX_RADIX");
\r
288 for (var i = s.length; --i >= 0;) {
\r
289 var c = s.charCodeAt(i);
\r
290 if (c >= 48 && c <= 57) continue;
\r
291 if (i > 0 || c != 43 && c != 45)
\r
292 throw new NumberFormatException("Not a Number : "+s);
\r
296 var i=parseInt(s,radix);
\r
298 throw new NumberFormatException("Not a Number : "+s);
\r
301 },"String, Number");
\r
302 Integer.parseIntRadix=Integer.prototype.parseIntRadix;
\r
304 Clazz_defineMethod(Integer,"parseInt",
\r
306 return Integer.parseIntRadix(s,10);
\r
308 Integer.parseInt=Integer.prototype.parseInt;
\r
311 Clazz_defineMethod(Integer,"$valueOf",
\r
313 return new Integer(Integer.parseIntRadix(s,10));
\r
317 Clazz_overrideMethod(Integer,"$valueOf",
\r
319 return new Integer(s);
\r
323 Clazz_defineMethod(Integer,"$valueOf",
\r
325 return new Integer(Integer.parseIntRadix(s,r));
\r
326 },"String, Number");
\r
329 Integer.$valueOf=Integer.prototype.$valueOf;
\r
332 Clazz_overrideMethod(Integer,"equals",
\r
334 if(s==null||!Clazz_instanceOf(s,Integer)){
\r
337 return s.valueOf()==this.valueOf();
\r
339 Integer.toHexString=Integer.prototype.toHexString=function(d){
\r
340 if(d.valueOf)d=d.valueOf();
\r
342 var b = d & 0xFFFFFF;
\r
343 var c = ((d>>24)&0xFF);
\r
344 return c._numberToString(16) + (b = "000000" + b._numberToString(16)).substring(b.length - 6);
\r
346 return d._numberToString(16);};
\r
347 Integer.toOctalString=Integer.prototype.toOctalString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(8);};
\r
348 Integer.toBinaryString=Integer.prototype.toBinaryString=function(d){if(d.valueOf)d=d.valueOf();return d._numberToString(2);};
\r
350 Integer.decodeRaw=Clazz_defineMethod(Integer,"decodeRaw", function(n){
\r
351 if (n.indexOf(".") >= 0)n = "";
\r
352 var i = (n.startsWith("-") ? 1 : 0);
\r
353 n = n.replace(/\#/, "0x").toLowerCase();
\r
354 var radix=(n.startsWith("0x", i) ? 16 : n.startsWith("0", i) ? 8 : 10);
\r
355 // The general problem with parseInt is that is not strict -- ParseInt("10whatever") == 10.
\r
356 // Number is strict, but Number("055") does not work, though ParseInt("055", 8) does.
\r
357 // need to make sure negative numbers are negative
\r
358 n = Number(n) & 0xFFFFFFFF;
\r
359 return (radix == 8 ? parseInt(n, 8) : n);
\r
362 Integer.decode=Clazz_defineMethod(Integer,"decode", function(n){
\r
363 n = Integer.decodeRaw(n);
\r
364 if (isNaN(n) || n < Integer.MIN_VALUE|| n > Integer.MAX_VALUE)
\r
365 throw new NumberFormatException("Invalid Integer");
\r
366 return new Integer(n);
\r
369 Clazz_overrideMethod(Integer,"hashCode",
\r
371 return this.valueOf();
\r
374 // Note that Long is problematic in JavaScript
\r
376 java.lang.Long=Long=function(){
\r
377 Clazz_instantialize(this,arguments);
\r
379 Clazz_decorateAsType(Long,"Long",Number,Comparable,null,true);
\r
380 Long.prototype.valueOf=function(){return 0;};
\r
381 Long.toString=Long.prototype.toString=function(){
\r
382 if(arguments.length!=0){
\r
383 return""+arguments[0];
\r
384 }else if(this===Long){
\r
385 return"class java.lang.Long";
\r
387 return""+this.valueOf();
\r
390 Clazz_overrideConstructor(Long, function(v){
\r
391 v == null && (v = 0);
\r
392 v = (typeof v == "number" ? Math.round(v) : Integer.parseIntRadix(v, 10));
\r
393 this.valueOf=function(){return v;};
\r
396 //Long.MIN_VALUE=Long.prototype.MIN_VALUE=-0x8000000000000000;
\r
397 //Long.MAX_VALUE=Long.prototype.MAX_VALUE=0x7fffffffffffffff;
\r
398 Long.TYPE=Long.prototype.TYPE=Long;
\r
400 Clazz_defineMethod(Long,"parseLong",
\r
402 return Integer.parseInt(s, radix || 10);
\r
405 Long.parseLong=Long.prototype.parseLong;
\r
407 Clazz_overrideMethod(Long,"$valueOf",
\r
409 return new Long(s);
\r
412 Clazz_defineMethod(Long,"$valueOf",
\r
414 return new Long(s);
\r
417 Clazz_defineMethod(Long,"$valueOf",
\r
419 return new Long(Long.parseLong(s,r));
\r
420 },"String, Number");
\r
422 Long.$valueOf=Long.prototype.$valueOf;
\r
423 Clazz_overrideMethod(Long,"equals",
\r
425 if(s==null||!Clazz_instanceOf(s,Long)){
\r
428 return s.valueOf()==this.valueOf();
\r
430 Long.toHexString=Long.prototype.toHexString=function(i){
\r
431 return i.toString(16);
\r
433 Long.toOctalString=Long.prototype.toOctalString=function(i){
\r
434 return i.toString(8);
\r
436 Long.toBinaryString=Long.prototype.toBinaryString=function(i){
\r
437 return i.toString(2);
\r
441 Long.decode=Clazz_defineMethod(Long,"decode",
\r
443 n = Integer.decodeRaw(n);
\r
445 throw new NumberFormatException("Invalid Long");
\r
446 return new Long(n);
\r
449 java.lang.Short = Short = function () {
\r
450 Clazz_instantialize (this, arguments);
\r
452 Clazz_decorateAsType (Short, "Short", Number, Comparable, null, true);
\r
453 Short.prototype.valueOf = function () { return 0; };
\r
454 Short.toString = Short.prototype.toString = function () {
\r
455 if (arguments.length != 0) {
\r
456 return "" + arguments[0];
\r
457 } else if (this === Short) {
\r
458 return "class java.lang.Short"; // Short.class.toString
\r
460 return "" + this.valueOf ();
\r
463 Clazz_overrideConstructor(Short,
\r
465 v == null && (v = 0);
\r
466 if (typeof v != "number")
\r
467 v = Integer.parseIntRadix(v, 10);
\r
468 v = v.shortValue();
\r
469 this.valueOf = function () {return v;};
\r
473 Short.MIN_VALUE = Short.prototype.MIN_VALUE = -32768;
\r
474 Short.MAX_VALUE = Short.prototype.MAX_VALUE = 32767;
\r
475 Short.TYPE = Short.prototype.TYPE = Short;
\r
477 Clazz_defineMethod(Short, "parseShortRadix",
\r
478 function (s, radix) {
\r
479 return Integer.parseIntRadix(s, radix).shortValue();
\r
480 }, "String, Number");
\r
481 Short.parseShortRadix = Short.prototype.parseShortRadix;
\r
483 Clazz_defineMethod(Short, "parseShort",
\r
485 return Short.parseShortRadix (s, 10);
\r
488 Short.parseShort = Short.prototype.parseShort;
\r
491 Clazz_defineMethod(Short, "$valueOf",
\r
493 return new Short(Short.parseShort (s, 10));
\r
497 Clazz_overrideMethod(Short, "$valueOf",
\r
499 return new Short(s);
\r
503 Clazz_defineMethod(Short, "$valueOf",
\r
505 return new Short(Short.parseShort (s, r));
\r
506 }, "String, Number");
\r
509 Short.$valueOf = Short.prototype.$valueOf;
\r
510 Clazz_overrideMethod(Short, "equals",
\r
512 if(s == null || !Clazz_instanceOf(s, Short) ){
\r
515 return s.valueOf() == this.valueOf();
\r
517 Short.toHexString = Short.prototype.toHexString = function (i) {
\r
518 return i.toString (16);
\r
520 Short.toOctalString = Short.prototype.toOctalString = function (i) {
\r
521 return i.toString (8);
\r
523 Short.toBinaryString = Short.prototype.toBinaryString = function (i) {
\r
524 return i.toString (2);
\r
526 Short.decode = Clazz_defineMethod(Short, "decode",
\r
528 n = Integer.decodeRaw(n);
\r
529 if (isNaN(n) || n < -32768|| n > 32767)
\r
530 throw new NumberFormatException("Invalid Short");
\r
531 return new Short(n);
\r
534 java.lang.Byte=Byte=function(){
\r
535 Clazz_instantialize(this,arguments);
\r
537 Clazz_decorateAsType(Byte,"Byte",Number,Comparable,null,true);
\r
538 Byte.prototype.valueOf=function(){return 0;};
\r
539 Byte.toString=Byte.prototype.toString=function(){
\r
540 if(arguments.length!=0){
\r
541 return""+arguments[0];
\r
542 }else if(this===Byte){
\r
543 return"class java.lang.Byte";
\r
545 return""+this.valueOf();
\r
547 Clazz_makeConstructor(Byte,
\r
549 if (typeof v != "number")
\r
550 v = Integer.parseIntRadix(v, 10);
\r
552 this.valueOf=function(){
\r
557 Byte.serialVersionUID=Byte.prototype.serialVersionUID=-7183698231559129828;
\r
558 Byte.MIN_VALUE=Byte.prototype.MIN_VALUE=-128;
\r
559 Byte.MAX_VALUE=Byte.prototype.MAX_VALUE=127;
\r
560 Byte.SIZE=Byte.prototype.SIZE=8;
\r
561 Byte.TYPE=Byte.prototype.TYPE=Byte;
\r
563 Clazz_defineMethod(Byte,"parseByteRadix",
\r
565 return Integer.parseIntRadix(s, radix).byteValue();
\r
566 },"String, Number");
\r
567 Byte.parseByteRadix=Byte.prototype.parseByteRadix;
\r
569 Clazz_defineMethod(Byte,"parseByte",
\r
571 return Byte.parseByte(s,10);
\r
574 Byte.parseByte=Byte.prototype.parseByte;
\r
576 Clazz_overrideMethod(Byte, "$valueOf",
\r
578 return new Byte(s);
\r
581 Byte.$valueOf=Byte.prototype.$valueOf;
\r
582 Clazz_overrideMethod(Byte,"equals",
\r
584 if(s==null||!Clazz_instanceOf(s,Byte)){
\r
587 return s.valueOf()==this.valueOf();
\r
589 Byte.toHexString=Byte.prototype.toHexString=function(i){
\r
590 return i.toString(16);
\r
592 Byte.toOctalString=Byte.prototype.toOctalString=function(i){
\r
593 return i.toString(8);
\r
595 Byte.toBinaryString=Byte.prototype.toBinaryString=function(i){
\r
596 return i.toString(2);
\r
598 Byte.decode=Clazz_defineMethod(Byte,"decode",
\r
600 n = Integer.decodeRaw(n);
\r
601 if (isNaN(n) || n < -128|| n > 127)
\r
602 throw new NumberFormatException("Invalid Byte");
\r
603 return new Byte(n);
\r
606 Clazz._floatToString = function(f) {
\r
608 if (s.indexOf(".") < 0 && s.indexOf("e") < 0)
\r
613 java.lang.Float=Float=function(){
\r
614 Clazz_instantialize(this,arguments);
\r
616 Clazz_decorateAsType(Float,"Float",Number,Comparable,null,true);
\r
617 Float.prototype.valueOf=function(){return 0;};
\r
618 Float.toString=Float.prototype.toString=function(){
\r
619 if(arguments.length!=0){
\r
620 return Clazz._floatToString(arguments[0]);
\r
621 }else if(this===Float){
\r
622 return"class java.lang.Float";
\r
624 return Clazz._floatToString(this.valueOf());
\r
627 Clazz_overrideConstructor(Float, function(v){
\r
628 v == null && (v = 0);
\r
629 if (typeof v != "number")
\r
631 this.valueOf=function(){return v;}
\r
634 Float.serialVersionUID=Float.prototype.serialVersionUID=-2671257302660747028;
\r
635 Float.MIN_VALUE=Float.prototype.MIN_VALUE=3.4028235e+38;
\r
636 Float.MAX_VALUE=Float.prototype.MAX_VALUE=1.4e-45;
\r
637 Float.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
638 Float.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
639 Float.NaN=Number.NaN;
\r
640 Float.TYPE=Float.prototype.TYPE=Float;
\r
642 Clazz_defineMethod(Float,"parseFloat",
\r
645 throw new NumberFormatException("null");
\r
647 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
648 var floatVal=Number(s);
\r
649 if(isNaN(floatVal)){
\r
650 throw new NumberFormatException("Not a Number : "+s);
\r
654 Float.parseFloat=Float.prototype.parseFloat;
\r
656 Clazz_overrideMethod(Float,"$valueOf",
\r
658 return new Float(s);
\r
661 Float.$valueOf=Float.prototype.$valueOf;
\r
663 Clazz_defineMethod(Float,"isNaN",
\r
667 Float.isNaN=Float.prototype.isNaN;
\r
668 Clazz_defineMethod(Float,"isInfinite",
\r
670 return!isFinite(num);
\r
672 Float.isInfinite=Float.prototype.isInfinite;
\r
674 Clazz_overrideMethod(Float,"equals",
\r
676 if(s==null||!Clazz_instanceOf(s,Float)){
\r
679 return s.valueOf()==this.valueOf();
\r
682 java.lang.Double=Double=function(){
\r
683 Clazz_instantialize(this,arguments);
\r
685 Clazz_decorateAsType(Double,"Double",Number,Comparable,null,true);
\r
686 Double.prototype.valueOf=function(){return 0;};
\r
687 Double.toString=Double.prototype.toString=function(){
\r
688 if(arguments.length!=0){
\r
689 return Clazz._floatToString(arguments[0]);
\r
690 }else if(this===Double){
\r
691 return"class java.lang.Double";
\r
693 return Clazz._floatToString(this.valueOf());
\r
696 Clazz_overrideConstructor(Double, function(v){
\r
697 v == null && (v = 0);
\r
698 if (typeof v != "number")
\r
699 v = Double.parseDouble(v);
\r
700 this.valueOf=function(){return v;};
\r
703 Double.serialVersionUID=Double.prototype.serialVersionUID=-9172774392245257468;
\r
704 Double.MIN_VALUE=Double.prototype.MIN_VALUE=4.9e-324;
\r
705 Double.MAX_VALUE=Double.prototype.MAX_VALUE=1.7976931348623157e+308;
\r
706 Double.NEGATIVE_INFINITY=Number.NEGATIVE_INFINITY;
\r
707 Double.POSITIVE_INFINITY=Number.POSITIVE_INFINITY;
\r
708 Double.NaN=Number.NaN;
\r
709 Double.TYPE=Double.prototype.TYPE=Double;
\r
711 Clazz_defineMethod(Double,"isNaN",
\r
715 Double.isNaN=Double.prototype.isNaN;
\r
716 Clazz_defineMethod(Double,"isInfinite",
\r
718 return!isFinite(num);
\r
720 Double.isInfinite=Double.prototype.isInfinite;
\r
722 Clazz_defineMethod(Double,"parseDouble",
\r
725 throw new NumberFormatException("null");
\r
727 if (typeof s == "number")return s; // important -- typeof NaN is "number" and is OK here
\r
728 var doubleVal=Number(s);
\r
729 if(isNaN(doubleVal)){
\r
730 throw new NumberFormatException("Not a Number : "+s);
\r
734 Double.parseDouble=Double.prototype.parseDouble;
\r
737 Clazz_defineMethod(Double,"$valueOf",
\r
739 return new Double(this.parseDouble(s));
\r
743 Clazz_defineMethod(Double,"$valueOf",
\r
745 return new Double(v);
\r
748 Double.$valueOf=Double.prototype.$valueOf;
\r
750 Clazz_overrideMethod(Double,"equals",
\r
752 if(s==null||!Clazz_instanceOf(s,Double)){
\r
755 return s.valueOf()==this.valueOf();
\r
759 //java.lang.B00lean = Boolean; ?? BH why this?
\r
760 Boolean = java.lang.Boolean = Boolean || function () {Clazz_instantialize (this, arguments);};
\r
761 if (Clazz._supportsNativeObject) {
\r
762 for (var i = 0; i < Clazz._extendedObjectMethods.length; i++) {
\r
763 var p = Clazz._extendedObjectMethods[i];
\r
764 Boolean.prototype[p] = Clazz._O.prototype[p];
\r
767 Boolean.__CLASS_NAME__="Boolean";
\r
768 Clazz_implementOf(Boolean,[java.io.Serializable,java.lang.Comparable]);
\r
769 Boolean.equals=Clazz._innerFunctions.equals;
\r
770 Boolean.getName=Clazz._innerFunctions.getName;
\r
771 Boolean.serialVersionUID=Boolean.prototype.serialVersionUID=-3665804199014368530;
\r
773 //Clazz_makeConstructor(Boolean,
\r
775 //this.valueOf=function(){
\r
780 Clazz_overrideConstructor(Boolean,
\r
782 var b = ((typeof s == "string" ? Boolean.toBoolean(s) : s) ? true : false);
\r
783 this.valueOf=function(){return b;};
\r
786 Boolean.parseBoolean=Clazz_defineMethod(Boolean,"parseBoolean",
\r
788 return Boolean.toBoolean(s);
\r
790 Clazz_defineMethod(Boolean,"booleanValue",
\r
792 return this.valueOf();
\r
794 Boolean.$valueOf=Clazz_overrideMethod(Boolean,"$valueOf",
\r
796 return((typeof b == "string"? "true".equalsIgnoreCase(b) : b)?Boolean.TRUE:Boolean.FALSE);
\r
800 Boolean.toString=Clazz_defineMethod(Boolean,"toString",
\r
802 return b?"true":"false";
\r
806 Clazz_overrideMethod(Boolean,"toString",
\r
808 return this.valueOf()?"true":"false";
\r
810 Clazz_overrideMethod(Boolean,"hashCode",
\r
812 return this.valueOf()?1231:1237;
\r
814 Clazz_overrideMethod(Boolean,"equals",
\r
816 if(Clazz_instanceOf(obj,Boolean)){
\r
817 return this.booleanValue()==obj.booleanValue();
\r
820 Boolean.getBoolean=Clazz_defineMethod(Boolean,"getBoolean",
\r
824 result=Boolean.toBoolean(System.getProperty(name));
\r
826 if(Clazz_instanceOf(e,IllegalArgumentException)){
\r
827 }else if(Clazz_instanceOf(e,NullPointerException)){
\r
834 Clazz_overrideMethod(Boolean,"compareTo",
\r
836 return(b.value==this.value?0:(this.value?1:-1));
\r
838 Boolean.toBoolean=Clazz_defineMethod(Boolean,"toBoolean",
\r
839 ($fz=function(name){
\r
840 return((name!=null)&&name.equalsIgnoreCase("true"));
\r
841 },$fz.isPrivate=true,$fz),"~S");
\r
842 Boolean.TRUE=Boolean.prototype.TRUE=new Boolean(true);
\r
843 Boolean.FALSE=Boolean.prototype.FALSE=new Boolean(false);
\r
844 Boolean.TYPE=Boolean.prototype.TYPE=Boolean;
\r
847 Clazz._Encoding=new Object();
\r
849 (function(Encoding) {
\r
851 Encoding.UTF8="utf-8";
\r
852 Encoding.UTF16="utf-16";
\r
853 Encoding.ASCII="ascii";
\r
856 Encoding.guessEncoding=function(str){
\r
857 if(str.charCodeAt(0)==0xEF&&str.charCodeAt(1)==0xBB&&str.charCodeAt(2)==0xBF){
\r
858 return Encoding.UTF8;
\r
859 }else if(str.charCodeAt(0)==0xFF&&str.charCodeAt(1)==0xFE){
\r
860 return Encoding.UTF16;
\r
862 return Encoding.ASCII;
\r
866 Encoding.readUTF8=function(str){
\r
867 var encoding=this.guessEncoding(str);
\r
869 if(encoding==Encoding.UTF8){
\r
871 }else if(encoding==Encoding.UTF16){
\r
874 var arrs=new Array();
\r
875 for(var i=startIdx;i<str.length;i++){
\r
876 var charCode=str.charCodeAt(i);
\r
878 arrs[arrs.length]=str.charAt(i);
\r
879 }else if(charCode>0xc0&&charCode<0xe0){
\r
880 var c1=charCode&0x1f;
\r
882 var c2=str.charCodeAt(i)&0x3f;
\r
884 arrs[arrs.length]=String.fromCharCode(c);
\r
885 }else if(charCode>=0xe0){
\r
886 var c1=charCode&0x0f;
\r
888 var c2=str.charCodeAt(i)&0x3f;
\r
890 var c3=str.charCodeAt(i)&0x3f;
\r
891 var c=(c1<<12)+(c2<<6)+c3;
\r
892 arrs[arrs.length]=String.fromCharCode(c);
\r
895 return arrs.join('');
\r
898 Encoding.convert2UTF8=function(str){
\r
899 var encoding=this.guessEncoding(str);
\r
901 if(encoding==Encoding.UTF8){
\r
903 }else if(encoding==Encoding.UTF16){
\r
908 var arrs=new Array(offset+str.length-startIdx);
\r
910 for(var i=startIdx;i<str.length;i++){
\r
911 var charCode=str.charCodeAt(i);
\r
913 arrs[offset+i-startIdx]=str.charAt(i);
\r
914 }else if(charCode<=0x07ff){
\r
915 var c1=0xc0+((charCode&0x07c0)>>6);
\r
916 var c2=0x80+(charCode&0x003f);
\r
917 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2);
\r
919 var c1=0xe0+((charCode&0xf000)>>12);
\r
920 var c2=0x80+((charCode&0x0fc0)>>6);
\r
921 var c3=0x80+(charCode&0x003f);
\r
922 arrs[offset+i-startIdx]=String.fromCharCode(c1)+String.fromCharCode(c2)+String.fromCharCode(c3);
\r
925 return arrs.join('');
\r
927 Encoding.base64Chars=new Array(
\r
928 'A','B','C','D','E','F','G','H',
\r
929 'I','J','K','L','M','N','O','P',
\r
930 'Q','R','S','T','U','V','W','X',
\r
931 'Y','Z','a','b','c','d','e','f',
\r
932 'g','h','i','j','k','l','m','n',
\r
933 'o','p','q','r','s','t','u','v',
\r
934 'w','x','y','z','0','1','2','3',
\r
935 '4','5','6','7','8','9','+','/'
\r
937 Encoding.encodeBase64=function(str){
\r
938 if(str==null||str.length==0)return str;
\r
939 var b64=Encoding.base64Chars;
\r
940 var length=str.length;
\r
944 while(index<length){
\r
945 c0=str.charCodeAt(index++);
\r
946 buf[buf.length]=b64[c0>>2];
\r
948 c1=str.charCodeAt(index++);
\r
949 buf[buf.length]=b64[((c0<<4)&0x30)|(c1>>4)];
\r
951 c2=str.charCodeAt(index++);
\r
952 buf[buf.length]=b64[((c1<<2)&0x3c)|(c2>>6)];
\r
953 buf[buf.length]=b64[c2&0x3F];
\r
955 buf[buf.length]=b64[((c1<<2)&0x3c)];
\r
956 buf[buf.length]='=';
\r
959 buf[buf.length]=b64[(c0<<4)&0x30];
\r
960 buf[buf.length]='=';
\r
961 buf[buf.length]='=';
\r
964 return buf.join('');
\r
966 Encoding.decodeBase64=function(str){
\r
967 if(str==null||str.length==0)return str;
\r
968 var b64=Encoding.base64Chars;
\r
969 var xb64=Encoding.xBase64Chars;
\r
970 if(Encoding.xBase64Chars==null){
\r
972 for(var i=0;i<b64.length;i++){
\r
975 Encoding.xBase64Chars=xb64;
\r
977 var length=str.length;
\r
982 while(index<length&&c++<60000){
\r
983 c0=xb64[str.charAt(index++)];
\r
984 c1=xb64[str.charAt(index++)];
\r
985 c2=xb64[str.charAt(index++)];
\r
986 c3=xb64[str.charAt(index++)];
\r
987 buf[buf.length]=String.fromCharCode(((c0<<2)&0xff)|c1>>4);
\r
989 buf[buf.length]=String.fromCharCode(((c1<<4)&0xff)|c2>>2);
\r
991 buf[buf.length]=String.fromCharCode(((c2<<6)&0xff)|c3);
\r
995 return buf.join('');
\r
998 if(String.prototype.$replace==null){
\r
999 java.lang.String=String;
\r
1000 if(Clazz._supportsNativeObject){
\r
1001 for(var i=0;i<Clazz._extendedObjectMethods.length;i++){
\r
1002 var p=Clazz._extendedObjectMethods[i];
\r
1003 if("to$tring"==p||"toString"==p||"equals"==p||"hashCode"==p){
\r
1006 String.prototype[p]=Clazz._O.prototype[p];
\r
1010 Clazz_implementOf(String,[java.io.Serializable,CharSequence,Comparable]);
\r
1012 String.getName=Clazz._innerFunctions.getName;
\r
1014 String.serialVersionUID=String.prototype.serialVersionUID=-6849794470754667710;
\r
1019 sp.$replace=function(c1,c2){
\r
1020 if (c1 == c2 || this.indexOf (c1) < 0) return "" + this;
\r
1021 if (c1.length == 1) {
\r
1022 if ("\\$.*+|?^{}()[]".indexOf(c1) >= 0) c1 = "\\" + c1;
\r
1024 c1=c1.replace(/([\\\$\.\*\+\|\?\^\{\}\(\)\[\]])/g,function($0,$1){return"\\"+$1;});
\r
1026 return this.replace(new RegExp(c1,"gm"),c2);
\r
1028 sp.$generateExpFunction=function(str){
\r
1034 for(;i<str.length;i++){
\r
1035 var ch=str.charAt(i);
\r
1036 if(i!=str.length-1&&ch=='\\'){
\r
1038 var c=str.charAt(i);
\r
1043 }else if(i!=str.length-1&&ch=='$'){
\r
1045 orders[idx]=parseInt(str.charAt(i));
\r
1048 }else if(ch=='\r'){
\r
1050 }else if(ch=='\n'){
\r
1052 }else if(ch=='\t'){
\r
1054 }else if(ch=='\"'){
\r
1060 var funStr="f = function (";
\r
1061 var max=Math.max.apply({},orders);
\r
1062 for(i=0;i<=max;i++){
\r
1068 funStr+=") { return ";
\r
1069 for(i=0;i<arr.length-1;i++){
\r
1070 funStr+="\""+arr[i]+"\" + $"+orders[i]+" + ";
\r
1072 funStr+="\""+arr[i]+"\"; }";
\r
1078 sp.replaceAll=function(exp,str){
\r
1079 var regExp=new RegExp(exp,"gm");
\r
1080 return this.replace(regExp,this.$generateExpFunction(str));
\r
1082 sp.replaceFirst=function(exp,str){
\r
1083 var regExp=new RegExp(exp,"m");
\r
1084 return this.replace(regExp,this.$generateExpFunction(str));
\r
1086 sp.matches=function(exp){
\r
1088 exp="^("+exp+")$";
\r
1090 var regExp=new RegExp(exp,"gm");
\r
1091 var m=this.match(regExp);
\r
1092 return m!=null&&m.length!=0;
\r
1094 sp.regionMatches=function(ignoreCase,toffset,
\r
1095 other,ooffset,len){
\r
1097 if(typeof ignoreCase=="number"
\r
1098 ||(ignoreCase!=true&&ignoreCase!=false)){
\r
1102 toffset=ignoreCase;
\r
1108 if((ooffset<0)||(toffset<0)||(toffset>this.length-len)||
\r
1109 (ooffset>other.length-len)){
\r
1112 var s1=this.substring(toffset,toffset+len);
\r
1113 var s2=other.substring(ooffset,ooffset+len);
\r
1115 s1=s1.toLowerCase();
\r
1116 s2=s2.toLowerCase();
\r
1123 sp.$plit=function(regex,limit){
\r
1124 if (!limit && regex == " ")
\r
1125 return this.split(regex);
\r
1127 if(limit!=null&&limit>0){
\r
1131 var regExp=new RegExp("("+regex+")","gm");
\r
1133 var s=this.replace(regExp,function($0,$1){
\r
1137 }else if(count>limit){
\r
1143 regExp=new RegExp(regex,"gm");
\r
1144 var arr=this.split(regExp);
\r
1145 if(arr.length>limit){
\r
1146 arr[limit-1]=s.substring(s.indexOf("@@_@@")+5);
\r
1151 var regExp=new RegExp(regex,"gm");
\r
1152 return this.split(regExp);
\r
1156 sp.trim=function(){
\r
1157 var len=this.length;
\r
1160 while((st<len)&&(this.charAt(st)<=' ')){
\r
1163 while((st<len)&&(this.charAt(len-1)<=' ')){
\r
1166 return((st>0)||(len<len))?this.substring(st,len):this;
\r
1173 sp.trim=function(){
\r
1174 return this.replace(/^\s+/g,'').replace(/\s+$/g,'');
\r
1177 if (!sp.startsWith || !sp.endsWith) {
\r
1178 var sn=function(s, prefix,toffset){
\r
1181 var pc=prefix.length;
\r
1183 if((toffset<0)||(toffset>s.length-pc)){
\r
1187 if(s.charAt(to++)!=prefix.charAt(po++)){
\r
1194 sp.startsWith=function(prefix){
\r
1195 if(arguments.length==1){
\r
1196 return sn(this,arguments[0],0);
\r
1197 }else if(arguments.length==2){
\r
1198 return sn(this,arguments[0],arguments[1]);
\r
1204 sp.endsWith=function(suffix){
\r
1205 return sn(this, suffix,this.length-suffix.length);
\r
1210 sp.equals=function(anObject){
\r
1211 return this.valueOf()==anObject;
\r
1214 sp.equalsIgnoreCase=function(anotherString){
\r
1215 return(anotherString==null)?false:(this==anotherString
\r
1216 ||this.toLowerCase()==anotherString.toLowerCase());
\r
1222 sp.hashCode=function(){
\r
1226 var len=this.length;
\r
1227 for(var i=0;i<len;i++){
\r
1228 h=31*h+this.charCodeAt(off++);
\r
1236 sp.getBytes=function(){
\r
1237 if(arguments.length==4){
\r
1238 return this.getChars(arguments[0],arguments[1],arguments[2],arguments[3]);
\r
1241 if(arguments.length==1){
\r
1242 var cs=arguments[0].toString().toLowerCase();
\r
1244 "utf-8","UTF8","us-ascii","iso-8859-1","8859_1","gb2312","gb18030","gbk"
\r
1246 var existed=false;
\r
1247 for(var i=0;i<charset.length;i++){
\r
1248 if(charset[i]==cs){
\r
1254 throw new java.io.UnsupportedEncodingException();
\r
1256 if(cs=="utf-8"||cs=="utf8"){
\r
1257 s=Encoding.convert2UTF8(this);
\r
1260 var arrs=new Array(s.length);
\r
1262 for(var i=0;i<s.length;i++){
\r
1263 c=s.charCodeAt(i);
\r
1266 arrs[ii+1]=c&0xff;
\r
1267 arrs[ii+2]=(c&0xff00)>>8;
\r
1278 sp.compareTo=function(anotherString){
\r
1279 if(anotherString==null){
\r
1280 throw new java.lang.NullPointerException();
\r
1282 var len1=this.length;
\r
1283 var len2=anotherString.length;
\r
1284 var n=Math.min(len1,len2);
\r
1287 var c1=this.charCodeAt(k);
\r
1288 var c2=anotherString.charCodeAt(k);
\r
1299 sp.contains = function(a) {return this.indexOf(a) >= 0} // bh added
\r
1300 sp.compareTo = function(a){return this > a ? 1 : this < a ? -1 : 0} // bh added
\r
1304 sp.toCharArray=function(){
\r
1305 var result=new Array(this.length);
\r
1306 for(var i=0;i<this.length;i++){
\r
1307 result[i]=this.charAt(i);
\r
1311 String.value0f=String.valueOf;
\r
1312 String.valueOf=function(o){
\r
1313 if(o=="undefined"){
\r
1314 return String.value0f();
\r
1316 if(o instanceof Array){
\r
1317 if(arguments.length==1){
\r
1318 return o.join('');
\r
1320 var off=arguments[1];
\r
1321 var len=arguments[2];
\r
1322 var oo=new Array(len);
\r
1323 for(var i=0;i<len;i++){
\r
1326 return oo.join('');
\r
1332 sp.subSequence=function(beginIndex,endIndex){
\r
1333 return this.substring(beginIndex,endIndex);
\r
1336 sp.compareToIgnoreCase=function(str){
\r
1338 throw new NullPointerException();
\r
1340 var s1=this.toUpperCase();
\r
1341 var s2=str.toUpperCase();
\r
1345 var s1=this.toLowerCase();
\r
1346 var s2=str.toLowerCase();
\r
1357 sp.contentEquals=function(sb){
\r
1358 if(this.length!=sb.length()){
\r
1361 var v=sb.getValue();
\r
1364 var n=this.length;
\r
1366 if(this.charCodeAt(i++)!=v[j++]){
\r
1373 sp.getChars=function(srcBegin,srcEnd,dst,dstBegin){
\r
1375 throw new StringIndexOutOfBoundsException(srcBegin);
\r
1377 if(srcEnd>this.length){
\r
1378 throw new StringIndexOutOfBoundsException(srcEnd);
\r
1380 if(srcBegin>srcEnd){
\r
1381 throw new StringIndexOutOfBoundsException(srcEnd-srcBegin);
\r
1384 throw new NullPointerException();
\r
1386 for(var i=0;i<srcEnd-srcBegin;i++){
\r
1387 dst[dstBegin+i]=this.charAt(srcBegin+i);
\r
1390 sp.$concat=sp.concat;
\r
1391 sp.concat=function(s){
\r
1393 throw new NullPointerException();
\r
1395 return this.$concat(s);
\r
1398 sp.$lastIndexOf=sp.lastIndexOf;
\r
1399 sp.lastIndexOf=function(s,last){
\r
1400 if(last!=null&&last+this.length<=0){
\r
1404 return this.$lastIndexOf(s,last);
\r
1406 return this.$lastIndexOf(s);
\r
1410 sp.intern=function(){
\r
1411 return this.valueOf();
\r
1413 String.copyValueOf=sp.copyValueOf=function(){
\r
1414 if(arguments.length==1){
\r
1415 return String.instantialize(arguments[0]);
\r
1417 return String.instantialize(arguments[0],arguments[1],arguments[2]);
\r
1421 sp.codePointAt || (sp.codePointAt = sp.charCodeAt); // Firefox only
\r
1424 })(String.prototype);
\r
1428 String.indexOf=function(source,sourceOffset,sourceCount,
\r
1429 target,targetOffset,targetCount,fromIndex){
\r
1430 if(fromIndex>=sourceCount){
\r
1431 return(targetCount==0?sourceCount:-1);
\r
1436 if(targetCount==0){
\r
1440 var first=target[targetOffset];
\r
1441 var i=sourceOffset+fromIndex;
\r
1442 var max=sourceOffset+(sourceCount-targetCount);
\r
1444 startSearchForFirstChar:
\r
1447 while(i<=max&&source[i]!=first){
\r
1456 var end=j+targetCount-1;
\r
1457 var k=targetOffset+1;
\r
1459 if(source[j++]!=target[k++]){
\r
1462 continue startSearchForFirstChar;
\r
1465 return i-sourceOffset;
\r
1471 String.instantialize=function(){
\r
1472 if(arguments.length==0){
\r
1473 return new String();
\r
1474 }else if(arguments.length==1){
\r
1475 var x=arguments[0];
\r
1476 if(typeof x=="string"||x instanceof String){
\r
1477 return new String(x);
\r
1478 }else if(x instanceof Array){
\r
1479 if(x.length>0&&typeof x[0]=="number"){
\r
1480 var arr=new Array(x.length);
\r
1481 for(var i=0;i<x.length;i++){
\r
1482 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1484 return Encoding.readUTF8(arr.join(''));
\r
1486 return x.join('');
\r
1487 }else if(x.__CLASS_NAME__=="StringBuffer"
\r
1488 ||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1489 var value=x.shareValue();
\r
1490 var length=x.length();
\r
1491 var valueCopy=new Array(length);
\r
1492 for(var i=0;i<length;i++){
\r
1493 valueCopy[i]=value[i];
\r
1495 return valueCopy.join('')
\r
1500 }else if(arguments.length==2){
\r
1501 var x=arguments[0];
\r
1502 var hibyte=arguments[1];
\r
1503 if(typeof hibyte=="string"){
\r
1504 return String.instantialize(x,0,x.length,hibyte);
\r
1506 return String.instantialize(x,hibyte,0,x.length);
\r
1508 }else if(arguments.length==3){
\r
1509 var bytes=arguments[0];
\r
1510 var offset=arguments[1];
\r
1511 var length=arguments[2];
\r
1512 if(arguments[2]instanceof Array){
\r
1513 bytes=arguments[2];
\r
1514 offset=arguments[0];
\r
1515 length=arguments[1];
\r
1517 var arr=new Array(length);
\r
1518 if(offset<0||length+offset>bytes.length){
\r
1519 throw new IndexOutOfBoundsException();
\r
1522 var isChar=(bytes[offset].length!=null);
\r
1524 for(var i=0;i<length;i++){
\r
1525 arr[i]=bytes[offset+i];
\r
1528 for(var i=0;i<length;i++){
\r
1529 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1533 return arr.join('');
\r
1534 }else if(arguments.length==4){
\r
1535 var bytes=arguments[0];
\r
1536 var y=arguments[3];
\r
1537 if(typeof y=="string"||y instanceof String){
\r
1538 var offset=arguments[1];
\r
1539 var length=arguments[2];
\r
1540 var arr=new Array(length);
\r
1541 for(var i=0;i<length;i++){
\r
1542 arr[i]=bytes[offset+i];
\r
1543 if(typeof arr[i]=="number"){
\r
1544 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1547 var cs=y.toLowerCase();
\r
1548 if(cs=="utf-8"||cs=="utf8"){
\r
1549 return Encoding.readUTF8(arr.join(''));
\r
1551 return arr.join('');
\r
1554 var count=arguments[3];
\r
1555 var offset=arguments[2];
\r
1556 var hibyte=arguments[1];
\r
1557 var value=new Array(count);
\r
1559 for(var i=count;i-->0;){
\r
1560 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1564 for(var i=count;i-->0;){
\r
1565 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1568 return value.join('');
\r
1572 for(var i=0;i<arguments.length;i++){
\r
1583 String.instantialize=function(){
\r
1584 switch (arguments.length) {
\r
1586 return new String();
\r
1588 var x=arguments[0];
\r
1589 if(typeof x=="string"||x instanceof String){
\r
1590 return new String(x);
\r
1592 if(x instanceof Array || x instanceof Int32Array){
\r
1595 if(typeof x[0]!="number")
\r
1596 return x.join('');
\r
1597 var arr=new Array(x.length);
\r
1598 for(var i=0;i<x.length;i++)
\r
1599 arr[i]=String.fromCharCode(x[i]&0xff);
\r
1600 return Encoding.readUTF8(arr.join(''));
\r
1602 if(x.__CLASS_NAME__=="StringBuffer"||x.__CLASS_NAME__=="java.lang.StringBuffer"){
\r
1603 var value=x.shareValue();
\r
1604 var length=x.length();
\r
1605 var valueCopy=new Array(length);
\r
1606 for(var i=0;i<length;i++){
\r
1607 valueCopy[i]=value[i];
\r
1609 return valueCopy.join('')
\r
1613 var x=arguments[0];
\r
1614 var hibyte=arguments[1];
\r
1615 if(typeof hibyte=="string"){
\r
1616 return String.instantialize(x,0,x.length,hibyte);
\r
1618 return String.instantialize(x,hibyte,0,x.length);
\r
1620 var bytes=arguments[0];
\r
1621 var offset=arguments[1];
\r
1622 var length=arguments[2];
\r
1623 if(arguments[2]instanceof Array){
\r
1624 bytes=arguments[2];
\r
1625 offset=arguments[0];
\r
1626 length=arguments[1];
\r
1628 var arr=new Array(length);
\r
1629 if(offset<0||length+offset>bytes.length){
\r
1630 throw new IndexOutOfBoundsException();
\r
1633 var isChar=(bytes[offset].length!=null);
\r
1635 for(var i=0;i<length;i++){
\r
1636 arr[i]=bytes[offset+i];
\r
1639 for(var i=0;i<length;i++){
\r
1640 arr[i]=String.fromCharCode(bytes[offset+i]);
\r
1644 return arr.join('');
\r
1646 var bytes=arguments[0];
\r
1647 var y=arguments[3];
\r
1648 if(typeof y=="string"||y instanceof String){
\r
1649 var offset=arguments[1];
\r
1650 var length=arguments[2];
\r
1651 var arr=new Array(length);
\r
1652 for(var i=0;i<length;i++){
\r
1653 arr[i]=bytes[offset+i];
\r
1654 if(typeof arr[i]=="number"){
\r
1655 arr[i]=String.fromCharCode(arr[i]&0xff);
\r
1658 var cs=y.toLowerCase();
\r
1659 if(cs=="utf-8"||cs=="utf8"){
\r
1660 return Encoding.readUTF8(arr.join(''));
\r
1662 return arr.join('');
\r
1664 var count=arguments[3];
\r
1665 var offset=arguments[2];
\r
1666 var hibyte=arguments[1];
\r
1667 var value=new Array(count);
\r
1669 for(var i=count;i-->0;){
\r
1670 value[i]=String.fromCharCode(bytes[i+offset]&0xff);
\r
1674 for(var i=count;i-->0;){
\r
1675 value[i]=String.fromCharCode(hibyte|(bytes[i+offset]&0xff));
\r
1678 return value.join('');
\r
1681 for(var i=0;i<arguments.length;i++){
\r
1688 if(navigator.userAgent.toLowerCase().indexOf("chrome")!=-1){
\r
1689 String.prototype.toString=function(){return this.valueOf();};
\r
1694 })(Clazz._Encoding);
\r
1698 c$=Clazz_decorateAsClass(function(){
\r
1700 Clazz_instantialize(this,arguments);
\r
1701 },java.lang,"Character",null,[java.io.Serializable,Comparable]);
\r
1702 Clazz_makeConstructor(c$,
\r
1706 Clazz_defineMethod(c$,"charValue",
\r
1708 return this.value;
\r
1710 Clazz_overrideMethod(c$,"hashCode",
\r
1712 return(this.value).charCodeAt(0);
\r
1714 Clazz_overrideMethod(c$,"equals",
\r
1716 if(Clazz_instanceOf(obj,Character)){
\r
1717 return(this.value).charCodeAt(0)==((obj).charValue()).charCodeAt(0);
\r
1720 Clazz_overrideMethod(c$,"compareTo",
\r
1722 return(this.value).charCodeAt(0)-(c.value).charCodeAt(0);
\r
1724 c$.toLowerCase=Clazz_defineMethod(c$,"toLowerCase",
\r
1726 return(""+c).toLowerCase().charAt(0);
\r
1728 c$.toUpperCase=Clazz_defineMethod(c$,"toUpperCase",
\r
1730 return(""+c).toUpperCase().charAt(0);
\r
1732 c$.isDigit=Clazz_defineMethod(c$,"isDigit",
\r
1734 c = c.charCodeAt(0);
\r
1735 return (48 <= c && c <= 57);
\r
1737 c$.isUpperCase=Clazz_defineMethod(c$,"isUpperCase",
\r
1739 c = c.charCodeAt(0);
\r
1740 return (65 <= c && c <= 90);
\r
1742 c$.isLowerCase=Clazz_defineMethod(c$,"isLowerCase",
\r
1744 c = c.charCodeAt(0);
\r
1745 return (97 <= c && c <= 122);
\r
1747 c$.isWhitespace=Clazz_defineMethod(c$,"isWhitespace",
\r
1749 c = (c).charCodeAt(0);
\r
1750 return (c >= 0x1c && c <= 0x20 || c >= 0x9 && c <= 0xd || c == 0x1680
\r
1751 || c >= 0x2000 && c != 0x2007 && (c <= 0x200b || c == 0x2028 || c == 0x2029 || c == 0x3000));
\r
1753 c$.isLetter=Clazz_defineMethod(c$,"isLetter",
\r
1755 c = c.charCodeAt(0);
\r
1756 return (65 <= c && c <= 90 || 97 <= c && c <= 122);
\r
1758 c$.isLetterOrDigit=Clazz_defineMethod(c$,"isLetterOrDigit",
\r
1760 c = c.charCodeAt(0);
\r
1761 return (65 <= c && c <= 90 || 97 <= c && c <= 122 || 48 <= c && c <= 57);
\r
1763 c$.isSpaceChar=Clazz_defineMethod(c$,"isSpaceChar",
\r
1765 var i = c.charCodeAt(0);
\r
1766 if(i==0x20||i==0xa0||i==0x1680)return true;
\r
1767 if(i<0x2000)return false;
\r
1768 return i<=0x200b||i==0x2028||i==0x2029||i==0x202f||i==0x3000;
\r
1770 c$.digit=Clazz_defineMethod(c$,"digit",
\r
1771 function(c,radix){
\r
1772 var i = c.charCodeAt(0);
\r
1773 if(radix >= 2 && radix <= 36){
\r
1776 if(48 <= i && i <= 57){
\r
1778 }else if(97 <= i && i <= 122){
\r
1780 }else if(65 <= i && i <= 90){
\r
1783 return (result < radix ? result : -1);
\r
1788 Clazz_overrideMethod(c$,"toString",
\r
1790 var buf=[this.value];
\r
1791 return String.valueOf(buf);
\r
1793 c$.toString=Clazz_overrideMethod(c$,"toString",
\r
1796 if(this===Character){
\r
1797 return"class java.lang.Character";
\r
1799 }return String.valueOf(c);
\r
1801 Clazz_defineStatics(c$,
\r
1802 "MIN_VALUE",'\u0000',
\r
1803 "MAX_VALUE",'\uffff',
\r
1808 java.lang.Character.TYPE=java.lang.Character.prototype.TYPE=java.lang.Character;
\r
1812 Clazz._ArrayWrapper = function(a, type) {
\r
1815 __CLASS_NAME__:"Array",
\r
1816 superClazz: Array,
\r
1817 getComponentType: function() {return type},
\r
1818 instanceOf: function(o) { return Clazz_instanceOf(type, o) },
\r
1819 getName: function() { return this.__CLASS_NAME__ }
\r
1822 c$=Clazz_declareType(java.lang.reflect,"Array");
\r
1823 c$.newInstance=Clazz_defineMethod(c$,"newInstance",
\r
1824 function(componentType,size){
\r
1825 var a = Clazz_newArray(size);
\r
1826 a.getClass = function() { return new Clazz._ArrayWrapper(this, componentType);};
\r
1830 javautil.Date=Date;
\r
1831 Date.TYPE="javautil.Date";
\r
1832 Date.__CLASS_NAME__="Date";
\r
1833 Clazz_implementOf(Date,[java.io.Serializable,java.lang.Comparable]);
\r
1835 Clazz_defineMethod(javautil.Date,"clone",
\r
1837 return new Date(this.getTime());
\r
1840 Clazz_defineMethod(javautil.Date,"before",
\r
1842 return this.getTime()<when.getTime();
\r
1843 },"javautil.Date");
\r
1844 Clazz_defineMethod(javautil.Date,"after",
\r
1846 return this.getTime()>when.getTime();
\r
1847 },"javautil.Date");
\r
1848 Clazz_defineMethod(javautil.Date,"equals",
\r
1850 return Clazz_instanceOf(obj,javautil.Date)&&this.getTime()==(obj).getTime();
\r
1852 Clazz_defineMethod(javautil.Date,"compareTo",
\r
1853 function(anotherDate){
\r
1854 var thisTime=this.getTime();
\r
1855 var anotherTime=anotherDate.getTime();
\r
1856 return(thisTime<anotherTime?-1:(thisTime==anotherTime?0:1));
\r
1857 },"javautil.Date");
\r
1858 Clazz_defineMethod(javautil.Date,"compareTo",
\r
1860 return this.compareTo(o);
\r
1862 Clazz_overrideMethod(javautil.Date,"hashCode",
\r
1864 var ht=this.getTime();
\r
1865 return parseInt(ht)^parseInt((ht>>32));
\r
1868 c$=Clazz_decorateAsClass(function(){
\r
1870 Clazz_instantialize(this,arguments);
\r
1871 },javautil,"EventObject",null,java.io.Serializable);
\r
1872 Clazz_makeConstructor(c$,
\r
1874 if(source!=null)this.source=source;
\r
1875 else throw new IllegalArgumentException();
\r
1877 Clazz_defineMethod(c$,"getSource",
\r
1879 return this.source;
\r
1881 Clazz_overrideMethod(c$,"toString",
\r
1883 return this.getClass().getName()+"[source="+String.valueOf(this.source)+']';
\r
1885 Clazz_declareInterface(javautil,"EventListener");
\r
1887 c$=Clazz_decorateAsClass(function(){
\r
1888 this.listener=null;
\r
1889 Clazz_instantialize(this,arguments);
\r
1890 },javautil,"EventListenerProxy",null,javautil.EventListener);
\r
1891 Clazz_makeConstructor(c$,
\r
1892 function(listener){
\r
1893 this.listener=listener;
\r
1894 },"javautil.EventListener");
\r
1895 Clazz_defineMethod(c$,"getListener",
\r
1897 return this.listener;
\r
1899 Clazz_declareInterface(javautil,"Iterator");
\r
1901 Clazz_declareInterface(javautil,"ListIterator",javautil.Iterator);
\r
1902 Clazz_declareInterface(javautil,"Enumeration");
\r
1903 Clazz_declareInterface(javautil,"Collection",Iterable);
\r
1905 Clazz_declareInterface(javautil,"Set",javautil.Collection);
\r
1906 Clazz_declareInterface(javautil,"Map");
\r
1907 Clazz_declareInterface(javautil.Map,"Entry");
\r
1909 Clazz_declareInterface(javautil,"List",javautil.Collection);
\r
1911 Clazz_declareInterface(javautil,"Queue",javautil.Collection);
\r
1912 Clazz_declareInterface(javautil,"RandomAccess");
\r
1913 c$=Clazz_decorateAsClass(function(){
\r
1914 this.detailMessage=null;
\r
1916 this.stackTrace=null;
\r
1917 Clazz_instantialize(this,arguments);
\r
1918 },java.lang,"Throwable",null,java.io.Serializable);
\r
1919 Clazz_prepareFields(c$,function(){
\r
1921 //alert("e0 "+ arguments.callee.caller.caller.caller.caller.caller)
\r
1923 Clazz_makeConstructor(c$,
\r
1925 this.fillInStackTrace();
\r
1927 Clazz_makeConstructor(c$,
\r
1928 function(message){
\r
1929 this.fillInStackTrace();
\r
1930 this.detailMessage=message;
\r
1932 Clazz_makeConstructor(c$,
\r
1933 function(message,cause){
\r
1934 this.fillInStackTrace();
\r
1935 this.detailMessage=message;
\r
1937 },"~S,Throwable");
\r
1938 Clazz_makeConstructor(c$,
\r
1940 this.fillInStackTrace();
\r
1941 this.detailMessage=(cause==null?null:cause.toString());
\r
1944 Clazz_defineMethod(c$,"getMessage",
\r
1946 return (this.message || this.detailMessage || this.toString());
\r
1948 Clazz_defineMethod(c$,"getLocalizedMessage",
\r
1950 return this.getMessage();
\r
1952 Clazz_defineMethod(c$,"getCause",
\r
1954 return(this.cause===this?null:this.cause);
\r
1956 Clazz_defineMethod(c$,"initCause",
\r
1958 if(this.cause!==this)throw new IllegalStateException("Can't overwrite cause");
\r
1959 if(cause===this)throw new IllegalArgumentException("Self-causation not permitted");
\r
1963 Clazz_overrideMethod(c$,"toString",
\r
1965 var s=this.getClass().getName();
\r
1966 var message=this.message || this.detailMessage;
\r
1967 return(message ? s+": "+message : s);
\r
1969 Clazz_defineMethod(c$,"printStackTrace",
\r
1971 System.err.println(this.getStackTrace ? this.getStackTrace() : this.message + " " + Clazz_getStackTrace());
\r
1974 Clazz_defineMethod(c$,"getStackTrace",
\r
1976 var s = "" + this + "\n";
\r
1977 for(var i=0;i<this.stackTrace.length;i++){
\r
1978 var t=this.stackTrace[i];
\r
1979 var x=t.methodName.indexOf("(");
\r
1980 var n=t.methodName.substring(0,x).replace(/\s+/g,"");
\r
1981 if(n!="construct"||t.nativeClazz==null
\r
1982 ||Clazz_getInheritedLevel(t.nativeClazz,Throwable)<0){
\r
1990 Clazz_defineMethod(c$,"printStackTrace",
\r
1992 this.printStackTrace();
\r
1993 },"java.io.PrintStream");
\r
1994 Clazz_defineMethod(c$,"printStackTrace",
\r
1996 this.printStackTrace();
\r
1997 },"java.io.PrintWriter");
\r
1998 Clazz_defineMethod(c$,"fillInStackTrace",
\r
2000 this.stackTrace=new Array();
\r
2001 var caller=arguments.callee.caller;
\r
2002 var superCaller=null;
\r
2003 var callerList=new Array();
\r
2004 var index=Clazz._callingStackTraces.length-1;
\r
2005 var noLooping=true;
\r
2006 while(index>-1||caller!=null){
\r
2007 var clazzName=null;
\r
2008 var nativeClass=null;
\r
2009 if(!noLooping||caller==Clazz_tryToSearchAndExecute||caller==Clazz_superCall||caller==null){
\r
2014 superCaller=Clazz._callingStackTraces[index].caller;
\r
2015 nativeClass=Clazz._callingStackTraces[index].owner;
\r
2018 superCaller=caller;
\r
2019 if(superCaller.claxxOwner!=null){
\r
2020 nativeClass=superCaller.claxxOwner;
\r
2021 }else if(superCaller.exClazz!=null){
\r
2022 nativeClass=superCaller.exClazz;
\r
2025 var st=new StackTraceElement(
\r
2026 ((nativeClass!=null&&nativeClass.__CLASS_NAME__.length!=0)?
\r
2027 nativeClass.__CLASS_NAME__:"anonymous"),
\r
2028 ((superCaller.exName==null)?"anonymous":superCaller.exName)
\r
2029 +" ("+Clazz_getParamsType(superCaller.arguments)+")",
\r
2031 st.nativeClazz=nativeClass;
\r
2032 this.stackTrace[this.stackTrace.length]=st;
\r
2033 for(var i=0;i<callerList.length;i++){
\r
2034 if(callerList[i]==superCaller){
\r
2036 var st=new StackTraceElement("lost","missing",null,-3);
\r
2037 st.nativeClazz=null;
\r
2038 this.stackTrace[this.stackTrace.length]=st;
\r
2043 if(superCaller!=null){
\r
2044 callerList[callerList.length]=superCaller;
\r
2046 caller=superCaller.arguments.callee.caller;
\r
2048 Clazz._initializingException=false;
\r
2051 Clazz_defineMethod(c$,"setStackTrace",
\r
2052 function(stackTrace){
\r
2053 var defensiveCopy=stackTrace.clone();
\r
2054 for(var i=0;i<defensiveCopy.length;i++)if(defensiveCopy[i]==null)throw new NullPointerException("stackTrace["+i+"]");
\r
2056 this.stackTrace=defensiveCopy;
\r
2059 c$=Clazz_decorateAsClass(function(){
\r
2060 this.declaringClass=null;
\r
2061 this.methodName=null;
\r
2062 this.fileName=null;
\r
2063 this.lineNumber=0;
\r
2064 Clazz_instantialize(this,arguments);
\r
2065 },java.lang,"StackTraceElement",null,java.io.Serializable);
\r
2066 Clazz_makeConstructor(c$,
\r
2067 function(cls,method,file,line){
\r
2068 if(cls==null||method==null){
\r
2069 throw new NullPointerException();
\r
2070 }this.declaringClass=cls;
\r
2071 this.methodName=method;
\r
2072 this.fileName=file;
\r
2073 this.lineNumber=line;
\r
2075 Clazz_overrideMethod(c$,"equals",
\r
2077 if(!(Clazz_instanceOf(obj,StackTraceElement))){
\r
2080 if((this.methodName==null)||(castObj.methodName==null)){
\r
2082 }if(!this.getMethodName().equals(castObj.getMethodName())){
\r
2084 }if(!this.getClassName().equals(castObj.getClassName())){
\r
2086 }var localFileName=this.getFileName();
\r
2087 if(localFileName==null){
\r
2088 if(castObj.getFileName()!=null){
\r
2091 if(!localFileName.equals(castObj.getFileName())){
\r
2093 }}if(this.getLineNumber()!=castObj.getLineNumber()){
\r
2097 Clazz_defineMethod(c$,"getClassName",
\r
2099 return(this.declaringClass==null)?"<unknown class>":this.declaringClass;
\r
2101 Clazz_defineMethod(c$,"getFileName",
\r
2103 return this.fileName;
\r
2105 Clazz_defineMethod(c$,"getLineNumber",
\r
2107 return this.lineNumber;
\r
2109 Clazz_defineMethod(c$,"getMethodName",
\r
2111 return(this.methodName==null)?"<unknown method>":this.methodName;
\r
2113 Clazz_overrideMethod(c$,"hashCode",
\r
2115 if(this.methodName==null){
\r
2117 }return this.methodName.hashCode()^this.declaringClass.hashCode();
\r
2119 Clazz_defineMethod(c$,"isNativeMethod",
\r
2121 return this.lineNumber==-2;
\r
2123 Clazz_overrideMethod(c$,"toString",
\r
2125 var buf=new StringBuilder(80);
\r
2126 buf.append(this.getClassName());
\r
2128 buf.append(this.getMethodName());
\r
2129 if(this.isNativeMethod()){
\r
2130 buf.append("(Native Method)");
\r
2132 var fName=this.getFileName();
\r
2134 buf.append("(Unknown Source)");
\r
2136 var lineNum=this.getLineNumber();
\r
2138 buf.append(fName);
\r
2141 buf.append(lineNum);
\r
2143 }}return buf.toString();
\r
2145 TypeError.prototype.getMessage || (TypeError.prototype.getMessage = function(){ return (this.message || this.toString()) + (this.getStackTrace ? this.getStackTrace() : Clazz_getStackTrace())});
\r
2146 c$=Clazz_declareType(java.lang,"Error",Throwable);
\r
2148 c$=Clazz_declareType(java.lang,"LinkageError",Error);
\r
2150 c$=Clazz_declareType(java.lang,"IncompatibleClassChangeError",LinkageError);
\r
2152 c$=Clazz_declareType(java.lang,"AbstractMethodError",IncompatibleClassChangeError);
\r
2154 c$=Clazz_declareType(java.lang,"AssertionError",Error);
\r
2155 Clazz_makeConstructor(c$,
\r
2156 function(detailMessage){
\r
2157 Clazz_superConstructor(this,AssertionError,[String.valueOf(detailMessage),(Clazz_instanceOf(detailMessage,Throwable)?detailMessage:null)]);
\r
2159 Clazz_makeConstructor(c$,
\r
2160 function(detailMessage){
\r
2161 this.construct("" + detailMessage);
\r
2163 Clazz_makeConstructor(c$,
\r
2164 function(detailMessage){
\r
2165 this.construct("" + detailMessage);
\r
2168 c$=Clazz_declareType(java.lang,"ClassCircularityError",LinkageError);
\r
2170 c$=Clazz_declareType(java.lang,"ClassFormatError",LinkageError);
\r
2172 c$=Clazz_decorateAsClass(function(){
\r
2173 this.exception=null;
\r
2174 Clazz_instantialize(this,arguments);
\r
2175 },java.lang,"ExceptionInInitializerError",LinkageError);
\r
2176 Clazz_makeConstructor(c$,
\r
2178 Clazz_superConstructor(this,ExceptionInInitializerError);
\r
2179 this.initCause(null);
\r
2181 Clazz_makeConstructor(c$,
\r
2182 function(detailMessage){
\r
2183 Clazz_superConstructor(this,ExceptionInInitializerError,[detailMessage]);
\r
2184 this.initCause(null);
\r
2186 Clazz_makeConstructor(c$,
\r
2187 function(exception){
\r
2188 Clazz_superConstructor(this,ExceptionInInitializerError);
\r
2189 this.exception=exception;
\r
2190 this.initCause(exception);
\r
2192 Clazz_defineMethod(c$,"getException",
\r
2194 return this.exception;
\r
2196 Clazz_overrideMethod(c$,"getCause",
\r
2198 return this.exception;
\r
2201 c$=Clazz_declareType(java.lang,"IllegalAccessError",IncompatibleClassChangeError);
\r
2203 c$=Clazz_declareType(java.lang,"InstantiationError",IncompatibleClassChangeError);
\r
2205 c$=Clazz_declareType(java.lang,"VirtualMachineError",Error);
\r
2207 c$=Clazz_declareType(java.lang,"InternalError",VirtualMachineError);
\r
2209 c$=Clazz_declareType(java.lang,"NoClassDefFoundError",LinkageError);
\r
2211 c$=Clazz_declareType(java.lang,"NoSuchFieldError",IncompatibleClassChangeError);
\r
2213 c$=Clazz_declareType(java.lang,"NoSuchMethodError",IncompatibleClassChangeError);
\r
2215 c$=Clazz_declareType(java.lang,"OutOfMemoryError",VirtualMachineError);
\r
2217 c$=Clazz_declareType(java.lang,"StackOverflowError",VirtualMachineError);
\r
2219 c$=Clazz_declareType(java.lang,"UnknownError",VirtualMachineError);
\r
2221 c$=Clazz_declareType(java.lang,"UnsatisfiedLinkError",LinkageError);
\r
2223 c$=Clazz_declareType(java.lang,"UnsupportedClassVersionError",ClassFormatError);
\r
2225 c$=Clazz_declareType(java.lang,"VerifyError",LinkageError);
\r
2227 c$=Clazz_declareType(java.lang,"ThreadDeath",Error);
\r
2228 Clazz_makeConstructor(c$,
\r
2230 Clazz_superConstructor(this,ThreadDeath,[]);
\r
2233 c$=Clazz_declareType(java.lang,"Exception",Throwable);
\r
2235 c$=Clazz_declareType(java.lang,"RuntimeException",Exception);
\r
2237 c$=Clazz_declareType(java.lang,"ArithmeticException",RuntimeException);
\r
2239 c$=Clazz_declareType(java.lang,"IndexOutOfBoundsException",RuntimeException);
\r
2241 c$=Clazz_declareType(java.lang,"ArrayIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2242 Clazz_makeConstructor(c$,
\r
2244 Clazz_superConstructor(this,ArrayIndexOutOfBoundsException,["Array index out of range: "+index]);
\r
2247 c$=Clazz_declareType(java.lang,"ArrayStoreException",RuntimeException);
\r
2249 c$=Clazz_declareType(java.lang,"ClassCastException",RuntimeException);
\r
2251 c$=Clazz_decorateAsClass(function(){
\r
2253 Clazz_instantialize(this,arguments);
\r
2254 },java.lang,"ClassNotFoundException",Exception);
\r
2255 Clazz_makeConstructor(c$,
\r
2257 Clazz_superConstructor(this,ClassNotFoundException,[Clazz_castNullAs("Throwable")]);
\r
2259 Clazz_makeConstructor(c$,
\r
2260 function(detailMessage){
\r
2261 Clazz_superConstructor(this,ClassNotFoundException,[detailMessage,null]);
\r
2263 Clazz_makeConstructor(c$,
\r
2264 function(detailMessage,exception){
\r
2265 Clazz_superConstructor(this,ClassNotFoundException,[detailMessage]);
\r
2266 this.ex=exception;
\r
2267 },"~S,Throwable");
\r
2268 Clazz_defineMethod(c$,"getException",
\r
2272 Clazz_overrideMethod(c$,"getCause",
\r
2277 c$=Clazz_declareType(java.lang,"CloneNotSupportedException",Exception);
\r
2279 c$=Clazz_declareType(java.lang,"IllegalAccessException",Exception);
\r
2281 c$=Clazz_declareType(java.lang,"IllegalArgumentException",RuntimeException);
\r
2282 Clazz_makeConstructor(c$,
\r
2284 Clazz_superConstructor(this,IllegalArgumentException,[(cause==null?null:cause.toString()),cause]);
\r
2287 c$=Clazz_declareType(java.lang,"IllegalMonitorStateException",RuntimeException);
\r
2289 c$=Clazz_declareType(java.lang,"IllegalStateException",RuntimeException);
\r
2290 Clazz_makeConstructor(c$,
\r
2292 Clazz_superConstructor(this,IllegalStateException,[(cause==null?null:cause.toString()),cause]);
\r
2295 c$=Clazz_declareType(java.lang,"IllegalThreadStateException",IllegalArgumentException);
\r
2297 c$=Clazz_declareType(java.lang,"InstantiationException",Exception);
\r
2299 c$=Clazz_declareType(java.lang,"InterruptedException",Exception);
\r
2301 c$=Clazz_declareType(java.lang,"NegativeArraySizeException",RuntimeException);
\r
2303 c$=Clazz_declareType(java.lang,"NoSuchFieldException",Exception);
\r
2305 c$=Clazz_declareType(java.lang,"NoSuchMethodException",Exception);
\r
2307 c$=Clazz_declareType(java.lang,"NullPointerException",RuntimeException);
\r
2309 c$=Clazz_declareType(java.lang,"NumberFormatException",IllegalArgumentException);
\r
2311 c$=Clazz_declareType(java.lang,"SecurityException",RuntimeException);
\r
2312 Clazz_makeConstructor(c$,
\r
2314 Clazz_superConstructor(this,SecurityException,[(cause==null?null:cause.toString()),cause]);
\r
2317 c$=Clazz_declareType(java.lang,"StringIndexOutOfBoundsException",IndexOutOfBoundsException);
\r
2318 Clazz_makeConstructor(c$,
\r
2320 Clazz_superConstructor(this,StringIndexOutOfBoundsException,["String index out of range: "+index]);
\r
2323 c$=Clazz_declareType(java.lang,"UnsupportedOperationException",RuntimeException);
\r
2324 Clazz_makeConstructor(c$,
\r
2326 Clazz_superConstructor(this,UnsupportedOperationException,[]);
\r
2328 Clazz_makeConstructor(c$,
\r
2330 Clazz_superConstructor(this,UnsupportedOperationException,[(cause==null?null:cause.toString()),cause]);
\r
2333 c$=Clazz_decorateAsClass(function(){
\r
2335 Clazz_instantialize(this,arguments);
\r
2336 },java.lang.reflect,"InvocationTargetException",Exception);
\r
2337 Clazz_makeConstructor(c$,
\r
2339 Clazz_superConstructor(this,java.lang.reflect.InvocationTargetException,[Clazz_castNullAs("Throwable")]);
\r
2341 Clazz_makeConstructor(c$,
\r
2342 function(exception){
\r
2343 Clazz_superConstructor(this,java.lang.reflect.InvocationTargetException,[null,exception]);
\r
2344 this.target=exception;
\r
2346 Clazz_makeConstructor(c$,
\r
2347 function(exception,detailMessage){
\r
2348 Clazz_superConstructor(this,java.lang.reflect.InvocationTargetException,[detailMessage,exception]);
\r
2349 this.target=exception;
\r
2350 },"Throwable,~S");
\r
2351 Clazz_defineMethod(c$,"getTargetException",
\r
2353 return this.target;
\r
2355 Clazz_overrideMethod(c$,"getCause",
\r
2357 return this.target;
\r
2360 c$=Clazz_decorateAsClass(function(){
\r
2361 this.undeclaredThrowable=null;
\r
2362 Clazz_instantialize(this,arguments);
\r
2363 },java.lang.reflect,"UndeclaredThrowableException",RuntimeException);
\r
2364 Clazz_makeConstructor(c$,
\r
2365 function(exception){
\r
2366 Clazz_superConstructor(this,java.lang.reflect.UndeclaredThrowableException);
\r
2367 this.undeclaredThrowable=exception;
\r
2368 this.initCause(exception);
\r
2370 Clazz_makeConstructor(c$,
\r
2371 function(exception,detailMessage){
\r
2372 Clazz_superConstructor(this,java.lang.reflect.UndeclaredThrowableException,[detailMessage]);
\r
2373 this.undeclaredThrowable=exception;
\r
2374 this.initCause(exception);
\r
2375 },"Throwable,~S");
\r
2376 Clazz_defineMethod(c$,"getUndeclaredThrowable",
\r
2378 return this.undeclaredThrowable;
\r
2380 Clazz_overrideMethod(c$,"getCause",
\r
2382 return this.undeclaredThrowable;
\r
2385 c$=Clazz_declareType(java.io,"IOException",Exception);
\r
2388 c$=Clazz_declareType(java.io,"CharConversionException",java.io.IOException);
\r
2390 c$=Clazz_declareType(java.io,"EOFException",java.io.IOException);
\r
2392 c$=Clazz_declareType(java.io,"FileNotFoundException",java.io.IOException);
\r
2394 c$=Clazz_decorateAsClass(function(){
\r
2395 this.bytesTransferred=0;
\r
2396 Clazz_instantialize(this,arguments);
\r
2397 },java.io,"InterruptedIOException",java.io.IOException);
\r
2399 c$=Clazz_declareType(java.io,"ObjectStreamException",java.io.IOException);
\r
2401 c$=Clazz_decorateAsClass(function(){
\r
2402 this.classname=null;
\r
2403 Clazz_instantialize(this,arguments);
\r
2404 },java.io,"InvalidClassException",java.io.ObjectStreamException);
\r
2405 Clazz_makeConstructor(c$,
\r
2406 function(className,detailMessage){
\r
2407 Clazz_superConstructor(this,java.io.InvalidClassException,[detailMessage]);
\r
2408 this.classname=className;
\r
2410 Clazz_defineMethod(c$,"getMessage",
\r
2412 var msg=Clazz_superCall(this,java.io.InvalidClassException,"getMessage",[]);
\r
2413 if(this.classname!=null){
\r
2414 msg=this.classname+';' + ' '+msg;
\r
2418 c$=Clazz_declareType(java.io,"InvalidObjectException",java.io.ObjectStreamException);
\r
2420 c$=Clazz_declareType(java.io,"NotActiveException",java.io.ObjectStreamException);
\r
2422 c$=Clazz_declareType(java.io,"NotSerializableException",java.io.ObjectStreamException);
\r
2424 c$=Clazz_decorateAsClass(function(){
\r
2427 Clazz_instantialize(this,arguments);
\r
2428 },java.io,"OptionalDataException",java.io.ObjectStreamException);
\r
2430 c$=Clazz_declareType(java.io,"StreamCorruptedException",java.io.ObjectStreamException);
\r
2432 c$=Clazz_declareType(java.io,"SyncFailedException",java.io.IOException);
\r
2434 c$=Clazz_declareType(java.io,"UnsupportedEncodingException",java.io.IOException);
\r
2436 c$=Clazz_declareType(java.io,"UTFDataFormatException",java.io.IOException);
\r
2438 c$=Clazz_decorateAsClass(function(){
\r
2440 Clazz_instantialize(this,arguments);
\r
2441 },java.io,"WriteAbortedException",java.io.ObjectStreamException);
\r
2442 Clazz_makeConstructor(c$,
\r
2443 function(detailMessage,rootCause){
\r
2444 Clazz_superConstructor(this,java.io.WriteAbortedException,[detailMessage]);
\r
2445 this.detail=rootCause;
\r
2446 this.initCause(rootCause);
\r
2447 },"~S,Exception");
\r
2448 Clazz_defineMethod(c$,"getMessage",
\r
2450 var msg=Clazz_superCall(this,java.io.WriteAbortedException,"getMessage",[]);
\r
2451 return (this.detail ? msg + "; "+this.detail.toString() : msg);
\r
2453 Clazz_overrideMethod(c$,"getCause",
\r
2455 return this.detail;
\r
2458 c$=Clazz_declareType(javautil,"ConcurrentModificationException",RuntimeException);
\r
2459 Clazz_makeConstructor(c$,
\r
2461 Clazz_superConstructor(this,javautil.ConcurrentModificationException,[]);
\r
2464 c$=Clazz_declareType(javautil,"EmptyStackException",RuntimeException);
\r
2466 c$=Clazz_decorateAsClass(function(){
\r
2467 this.className=null;
\r
2469 Clazz_instantialize(this,arguments);
\r
2470 },javautil,"MissingResourceException",RuntimeException);
\r
2471 Clazz_makeConstructor(c$,
\r
2472 function(detailMessage,className,resourceName){
\r
2473 Clazz_superConstructor(this,javautil.MissingResourceException,[detailMessage]);
\r
2474 this.className=className;
\r
2475 this.key=resourceName;
\r
2477 Clazz_defineMethod(c$,"getClassName",
\r
2479 return this.className;
\r
2481 Clazz_defineMethod(c$,"getKey",
\r
2486 c$=Clazz_declareType(javautil,"NoSuchElementException",RuntimeException);
\r
2488 c$=Clazz_declareType(javautil,"TooManyListenersException",Exception);
\r
2490 c$=Clazz_declareType(java.lang,"Void");
\r
2491 Clazz_defineStatics(c$,
\r
2494 java.lang.Void.TYPE=java.lang.Void;
\r
2495 }Clazz_declareInterface(java.lang.reflect,"GenericDeclaration");
\r
2496 Clazz_declareInterface(java.lang.reflect,"AnnotatedElement");
\r
2498 c$=Clazz_declareType(java.lang.reflect,"AccessibleObject",null,java.lang.reflect.AnnotatedElement);
\r
2499 Clazz_makeConstructor(c$,
\r
2502 Clazz_defineMethod(c$,"isAccessible",
\r
2506 c$.setAccessible=Clazz_defineMethod(c$,"setAccessible",
\r
2507 function(objects,flag){
\r
2510 Clazz_defineMethod(c$,"setAccessible",
\r
2514 Clazz_overrideMethod(c$,"isAnnotationPresent",
\r
2515 function(annotationType){
\r
2518 Clazz_overrideMethod(c$,"getDeclaredAnnotations",
\r
2520 return new Array(0);
\r
2522 Clazz_overrideMethod(c$,"getAnnotations",
\r
2524 return new Array(0);
\r
2526 Clazz_overrideMethod(c$,"getAnnotation",
\r
2527 function(annotationType){
\r
2530 c$.marshallArguments=Clazz_defineMethod(c$,"marshallArguments",
\r
2531 function(parameterTypes,args){
\r
2534 Clazz_defineMethod(c$,"invokeV",
\r
2535 function(receiver,args){
\r
2538 Clazz_defineMethod(c$,"invokeL",
\r
2539 function(receiver,args){
\r
2542 Clazz_defineMethod(c$,"invokeI",
\r
2543 function(receiver,args){
\r
2546 Clazz_defineMethod(c$,"invokeJ",
\r
2547 function(receiver,args){
\r
2550 Clazz_defineMethod(c$,"invokeF",
\r
2551 function(receiver,args){
\r
2554 Clazz_defineMethod(c$,"invokeD",
\r
2555 function(receiver,args){
\r
2558 c$.emptyArgs=c$.prototype.emptyArgs=new Array(0);
\r
2559 Clazz_declareInterface(java.lang.reflect,"InvocationHandler");
\r
2560 c$=Clazz_declareInterface(java.lang.reflect,"Member");
\r
2561 Clazz_defineStatics(c$,
\r
2565 c$=Clazz_declareType(java.lang.reflect,"Modifier");
\r
2566 Clazz_makeConstructor(c$,
\r
2569 c$.isAbstract=Clazz_defineMethod(c$,"isAbstract",
\r
2570 function(modifiers){
\r
2571 return((modifiers&1024)!=0);
\r
2573 c$.isFinal=Clazz_defineMethod(c$,"isFinal",
\r
2574 function(modifiers){
\r
2575 return((modifiers&16)!=0);
\r
2577 c$.isInterface=Clazz_defineMethod(c$,"isInterface",
\r
2578 function(modifiers){
\r
2579 return((modifiers&512)!=0);
\r
2581 c$.isNative=Clazz_defineMethod(c$,"isNative",
\r
2582 function(modifiers){
\r
2583 return((modifiers&256)!=0);
\r
2585 c$.isPrivate=Clazz_defineMethod(c$,"isPrivate",
\r
2586 function(modifiers){
\r
2587 return((modifiers&2)!=0);
\r
2589 c$.isProtected=Clazz_defineMethod(c$,"isProtected",
\r
2590 function(modifiers){
\r
2591 return((modifiers&4)!=0);
\r
2593 c$.isPublic=Clazz_defineMethod(c$,"isPublic",
\r
2594 function(modifiers){
\r
2595 return((modifiers&1)!=0);
\r
2597 c$.isStatic=Clazz_defineMethod(c$,"isStatic",
\r
2598 function(modifiers){
\r
2599 return((modifiers&8)!=0);
\r
2601 c$.isStrict=Clazz_defineMethod(c$,"isStrict",
\r
2602 function(modifiers){
\r
2603 return((modifiers&2048)!=0);
\r
2605 c$.isSynchronized=Clazz_defineMethod(c$,"isSynchronized",
\r
2606 function(modifiers){
\r
2607 return((modifiers&32)!=0);
\r
2609 c$.isTransient=Clazz_defineMethod(c$,"isTransient",
\r
2610 function(modifiers){
\r
2611 return((modifiers&128)!=0);
\r
2613 c$.isVolatile=Clazz_defineMethod(c$,"isVolatile",
\r
2614 function(modifiers){
\r
2615 return((modifiers&64)!=0);
\r
2617 c$.toString=Clazz_defineMethod(c$,"toString",
\r
2618 function(modifiers){
\r
2619 var sb=new Array(0);
\r
2620 if(java.lang.reflect.Modifier.isPublic(modifiers))sb[sb.length]="public";
\r
2621 if(java.lang.reflect.Modifier.isProtected(modifiers))sb[sb.length]="protected";
\r
2622 if(java.lang.reflect.Modifier.isPrivate(modifiers))sb[sb.length]="private";
\r
2623 if(java.lang.reflect.Modifier.isAbstract(modifiers))sb[sb.length]="abstract";
\r
2624 if(java.lang.reflect.Modifier.isStatic(modifiers))sb[sb.length]="static";
\r
2625 if(java.lang.reflect.Modifier.isFinal(modifiers))sb[sb.length]="final";
\r
2626 if(java.lang.reflect.Modifier.isTransient(modifiers))sb[sb.length]="transient";
\r
2627 if(java.lang.reflect.Modifier.isVolatile(modifiers))sb[sb.length]="volatile";
\r
2628 if(java.lang.reflect.Modifier.isSynchronized(modifiers))sb[sb.length]="synchronized";
\r
2629 if(java.lang.reflect.Modifier.isNative(modifiers))sb[sb.length]="native";
\r
2630 if(java.lang.reflect.Modifier.isStrict(modifiers))sb[sb.length]="strictfp";
\r
2631 if(java.lang.reflect.Modifier.isInterface(modifiers))sb[sb.length]="interface";
\r
2633 return sb.join(" ");
\r
2636 Clazz_defineStatics(c$,
\r
2642 "SYNCHRONIZED",0x20,
\r
2646 "INTERFACE",0x200,
\r
2651 "SYNTHETIC",0x1000,
\r
2652 "ANNOTATION",0x2000,
\r
2655 c$=Clazz_decorateAsClass(function(){
\r
2657 this.parameterTypes=null;
\r
2658 this.exceptionTypes=null;
\r
2660 Clazz_instantialize(this,arguments);
\r
2661 },java.lang.reflect,"Constructor",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2662 Clazz_makeConstructor(c$,
\r
2663 function(declaringClass,parameterTypes,checkedExceptions,modifiers){
\r
2664 Clazz_superConstructor(this,java.lang.reflect.Constructor,[]);
\r
2665 this.clazz=declaringClass;
\r
2666 this.parameterTypes=parameterTypes;
\r
2667 this.exceptionTypes=checkedExceptions;
\r
2668 this.modifiers=modifiers;
\r
2669 },"Class,~A,~A,~N");
\r
2670 Clazz_overrideMethod(c$,"getTypeParameters",
\r
2674 Clazz_defineMethod(c$,"toGenericString",
\r
2678 Clazz_defineMethod(c$,"getGenericParameterTypes",
\r
2682 Clazz_defineMethod(c$,"getGenericExceptionTypes",
\r
2686 Clazz_defineMethod(c$,"getParameterAnnotations",
\r
2690 Clazz_defineMethod(c$,"isVarArgs",
\r
2694 Clazz_overrideMethod(c$,"isSynthetic",
\r
2698 Clazz_overrideMethod(c$,"equals",
\r
2700 if(object!=null&&Clazz_instanceOf(object,java.lang.reflect.Constructor)){
\r
2702 if(this.getDeclaringClass()===other.getDeclaringClass()){
\r
2703 var params1=this.parameterTypes;
\r
2704 var params2=other.parameterTypes;
\r
2705 if(params1.length==params2.length){
\r
2706 for(var i=0;i<params1.length;i++){
\r
2707 if(params1[i]!==params2[i])return false;
\r
2712 Clazz_overrideMethod(c$,"getDeclaringClass",
\r
2714 return this.clazz;
\r
2716 Clazz_defineMethod(c$,"getExceptionTypes",
\r
2718 return this.exceptionTypes;
\r
2720 Clazz_overrideMethod(c$,"getModifiers",
\r
2722 return this.modifiers;
\r
2724 Clazz_overrideMethod(c$,"getName",
\r
2726 return this.getDeclaringClass().getName();
\r
2728 Clazz_defineMethod(c$,"getParameterTypes",
\r
2730 return this.parameterTypes;
\r
2732 Clazz_overrideMethod(c$,"hashCode",
\r
2734 return this.getDeclaringClass().getName().hashCode();
\r
2736 Clazz_defineMethod(c$,"newInstance",
\r
2738 var instance=new this.clazz(Clazz_inheritArgs);
\r
2739 Clazz_instantialize(instance,args);
\r
2742 Clazz_overrideMethod(c$,"toString",
\r
2747 c$=Clazz_declareType(java.lang.reflect,"Field",java.lang.reflect.AccessibleObject,java.lang.reflect.Member);
\r
2748 Clazz_overrideMethod(c$,"isSynthetic",
\r
2752 Clazz_defineMethod(c$,"toGenericString",
\r
2756 Clazz_defineMethod(c$,"isEnumConstant",
\r
2760 Clazz_defineMethod(c$,"getGenericType",
\r
2764 Clazz_overrideMethod(c$,"equals",
\r
2768 Clazz_overrideMethod(c$,"getDeclaringClass",
\r
2772 Clazz_overrideMethod(c$,"getName",
\r
2776 Clazz_defineMethod(c$,"getType",
\r
2780 Clazz_overrideMethod(c$,"hashCode",
\r
2784 Clazz_overrideMethod(c$,"toString",
\r
2789 c$=Clazz_decorateAsClass(function(){
\r
2792 this.returnType=null;
\r
2793 this.parameterTypes=null;
\r
2794 this.exceptionTypes=null;
\r
2796 Clazz_instantialize(this,arguments);
\r
2797 },java.lang.reflect,"Method",java.lang.reflect.AccessibleObject,[java.lang.reflect.GenericDeclaration,java.lang.reflect.Member]);
\r
2798 Clazz_makeConstructor(c$,
\r
2799 function(declaringClass,name,parameterTypes,returnType,checkedExceptions,modifiers){
\r
2800 Clazz_superConstructor(this,java.lang.reflect.Method,[]);
\r
2801 this.clazz=declaringClass;
\r
2803 this.parameterTypes=parameterTypes;
\r
2804 this.returnType=returnType;
\r
2805 this.exceptionTypes=checkedExceptions;
\r
2806 this.modifiers=modifiers;
\r
2807 },"Class,~S,~A,Class,~A,~N");
\r
2808 Clazz_overrideMethod(c$,"getTypeParameters",
\r
2812 Clazz_defineMethod(c$,"toGenericString",
\r
2816 Clazz_defineMethod(c$,"getGenericParameterTypes",
\r
2820 Clazz_defineMethod(c$,"getGenericExceptionTypes",
\r
2824 Clazz_defineMethod(c$,"getGenericReturnType",
\r
2828 Clazz_defineMethod(c$,"getParameterAnnotations",
\r
2832 Clazz_defineMethod(c$,"isVarArgs",
\r
2836 Clazz_defineMethod(c$,"isBridge",
\r
2840 Clazz_overrideMethod(c$,"isSynthetic",
\r
2844 Clazz_defineMethod(c$,"getDefaultValue",
\r
2848 Clazz_overrideMethod(c$,"equals",
\r
2850 if(object!=null&&Clazz_instanceOf(object,java.lang.reflect.Method)){
\r
2852 if((this.getDeclaringClass()===other.getDeclaringClass())&&(this.getName()===other.getName())){
\r
2853 var params1=this.parameterTypes;
\r
2854 var params2=other.parameterTypes;
\r
2855 if(params1.length==params2.length){
\r
2856 for(var i=0;i<params1.length;i++){
\r
2857 if(params1[i]!==params2[i])return false;
\r
2862 Clazz_overrideMethod(c$,"getDeclaringClass",
\r
2864 return this.clazz;
\r
2866 Clazz_defineMethod(c$,"getExceptionTypes",
\r
2868 return this.exceptionTypes;
\r
2870 Clazz_overrideMethod(c$,"getModifiers",
\r
2872 return this.modifiers;
\r
2874 Clazz_overrideMethod(c$,"getName",
\r
2878 Clazz_defineMethod(c$,"getParameterTypes",
\r
2880 return this.parameterTypes;
\r
2882 Clazz_defineMethod(c$,"getReturnType",
\r
2884 return this.returnType;
\r
2886 Clazz_overrideMethod(c$,"hashCode",
\r
2888 return this.getDeclaringClass().getName().hashCode()^this.getName().hashCode();
\r
2890 Clazz_defineMethod(c$,"invoke",
\r
2891 function(receiver,args){
\r
2892 var m=this.clazz.prototype[this.getName()];
\r
2894 m=this.clazz[this.getName()];
\r
2897 m.apply(receiver,args);
\r
2902 Clazz_overrideMethod(c$,"toString",
\r
2909 ,Clazz.getClassName
\r
2910 ,Clazz.newLongArray
\r
2911 ,Clazz.doubleToByte
\r
2912 ,Clazz.doubleToInt
\r
2913 ,Clazz.doubleToLong
\r
2914 ,Clazz.declarePackage
\r
2917 ,Clazz.instantialize
\r
2918 ,Clazz.decorateAsClass
\r
2920 ,Clazz.floatToLong
\r
2921 ,Clazz.makeConstructor
\r
2922 ,Clazz.defineEnumConstant
\r
2923 ,Clazz.exceptionOf
\r
2924 ,Clazz.newIntArray
\r
2925 ,Clazz.defineStatics
\r
2926 ,Clazz.newFloatArray
\r
2927 ,Clazz.declareType
\r
2928 ,Clazz.prepareFields
\r
2929 ,Clazz.superConstructor
\r
2930 ,Clazz.newByteArray
\r
2931 ,Clazz.declareInterface
\r
2934 ,Clazz.newShortArray
\r
2935 ,Clazz.innerTypeInstance
\r
2936 ,Clazz.isClassDefined
\r
2937 ,Clazz.prepareCallback
\r
2940 ,Clazz.floatToShort
\r
2942 ,Clazz.decorateAsType
\r
2943 ,Clazz.newBooleanArray
\r
2944 ,Clazz.newCharArray
\r
2945 ,Clazz.implementOf
\r
2946 ,Clazz.newDoubleArray
\r
2947 ,Clazz.overrideConstructor
\r
2949 ,Clazz.doubleToShort
\r
2950 ,Clazz.getInheritedLevel
\r
2951 ,Clazz.getParamsType
\r
2961 ,Clazz.tryToSearchAndExecute
\r
2962 ,Clazz.getStackTrace
\r
2963 ,Clazz.inheritArgs
\r
2965 ,Clazz.defineMethod
\r
2966 ,Clazz.overrideMethod
\r
2967 ,Clazz.declareAnonymous
\r
2968 ,Clazz.checkPrivateMethod
\r
2969 ,Clazz.cloneFinals
\r