* replaced partial manual declarations of some Java classes with

    automatically generated full declarations by javapp, using the
    command line parameters:
    -protected java.lang.System java.lang.Object java.io.Serializable java.lang.Float java.lang.Double java.lang.String java.lang.StringBuilder java.lang.StringBuffer java.lang.CharSequence java.lang.AbstractStringBuilder java.lang.Appendable java.lang.Number java.lang.IndexOutOfBoundsException java.lang.RuntimeException java.lang.IllegalArgumentException java.lang.Exception java.lang.Throwable java.lang.LinkageError java.lang.Error java.lang.Comparable java.lang.Character java.text.Collator java.lang.Cloneable java.util.Comparator -i -o java_sys

git-svn-id: branches/jvmbackend@18422 -

.gitattributes

@@ -7347,6 +7347,8 @@ rtl/inc/wustrings.inc svneol=native#text/plain
 rtl/java/Makefile svneol=native#text/plain
 rtl/java/Makefile.fpc svneol=native#text/plain
 rtl/java/compproc.inc svneol=native#text/plain
+rtl/java/java_sys.inc svneol=native#text/plain
+rtl/java/java_sysh.inc svneol=native#text/plain
 rtl/java/jdynarrh.inc svneol=native#text/plain
 rtl/java/jmathh.inc svneol=native#text/plain
 rtl/java/objpas.pp svneol=native#text/plain

compiler/jvm/njvmcnv.pas

@@ -370,12 +370,12 @@ implementation
          { use the float/double to raw bits methods to get the bit pattern }
           if fdef.floattype=s32real then
             begin
-              csym:=search_system_type('TJFLOAT');
+              csym:=search_system_type('JLFLOAT');
               psym:=search_struct_member(tobjectdef(csym.typedef),singlemethod);
             end
           else
             begin
-              csym:=search_system_type('TJDOUBLE');
+              csym:=search_system_type('JLDOUBLE');
               psym:=search_struct_member(tobjectdef(csym.typedef),doublemethod);
             end;
           if not assigned(psym) or

compiler/jvm/njvmflw.pas

@@ -73,7 +73,7 @@ implementation
          { Java exceptions must descend from java.lang.Throwable }
          if assigned(left) and
             not(left.resultdef).is_related(java_jlthrowable) then
-           MessagePos2(left.fileinfo,type_e_incompatible_types,left.resultdef.typename,'class(TJLThrowable)');
+           MessagePos2(left.fileinfo,type_e_incompatible_types,left.resultdef.typename,'class(JLThrowable)');
          { Java exceptions cannot be raised "at" a specific location }
          if assigned(right) then
            MessagePos(right.fileinfo,parser_e_illegal_expression);

compiler/pdecobj.pas

@@ -1244,9 +1244,9 @@ implementation
                       class_tobject:=current_objectdef;
                   odt_javaclass:
                     begin
-                      if (current_objectdef.objname^='TOBJECT') then
+                      if (current_objectdef.objname^='JLOBJECT') then
                         java_jlobject:=current_objectdef;
-                      if (current_objectdef.objname^='TJLTHROWABLE') then
+                      if (current_objectdef.objname^='JLTHROWABLE') then
                         java_jlthrowable:=current_objectdef;
                     end;
                 end;

compiler/symdef.pas

@@ -4586,11 +4586,12 @@ implementation
             (objecttype=odt_objcclass) and
             (objname^='PROTOCOL') then
            objc_protocoltype:=self;
-         if (objecttype=odt_javaclass) then
+         if (objecttype=odt_javaclass) and
+            not(oo_is_formal in objectoptions) then
            begin
-             if (objname^='TOBJECT') then
+             if (objname^='JLOBJECT') then
                java_jlobject:=self;
-             if (objname^='TJLTHROWABLE') then
+             if (objname^='JLTHROWABLE') then
                java_jlthrowable:=self;
            end;
          writing_class_record_dbginfo:=false;

rtl/java/java_sys.inc

@@ -0,0 +1,986 @@
+  JLObject = class external 'java.lang' name 'Object' 
+  public
+    constructor create(); overload;
+    function getClass(): JLClass; overload; final;
+    function hashCode(): jint; overload;
+    function equals(para1: JLObject): jboolean; overload;
+  strict protected
+    function clone(): JLObject; overload;  // throws java.lang.CloneNotSupportedException
+  public
+    function toString(): JLString; overload;
+    procedure notify(); overload; final;
+    procedure notifyAll(); overload; final;
+    procedure wait(para1: jlong); overload; final;  // throws java.lang.InterruptedException
+    procedure wait(para1: jlong; para2: jint); overload; final;  // throws java.lang.InterruptedException
+    procedure wait(); overload; final;  // throws java.lang.InterruptedException
+  strict protected
+    procedure finalize(); overload;  // throws java.lang.Throwable
+  end;
+
+  JISerializable = interface external 'java.io' name 'Serializable' 
+  end;
+
+  JLAppendable = interface external 'java.lang' name 'Appendable' 
+    function append(para1: JLCharSequence): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: JLCharSequence; para2: jint; para3: jint): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: jchar): JLAppendable; overload;  // throws java.io.IOException
+  end;
+
+  JLCharSequence = interface external 'java.lang' name 'CharSequence' 
+    function length(): jint; overload;
+    function charAt(para1: jint): jchar; overload;
+    function subSequence(para1: jint; para2: jint): JLCharSequence; overload;
+    function toString(): JLString; overload;
+  end;
+
+  JLCloneable = interface external 'java.lang' name 'Cloneable' 
+  end;
+
+  JLComparable = interface external 'java.lang' name 'Comparable' 
+    function compareTo(para1: JLObject): jint; overload;
+  end;
+
+  JLSystem = class sealed external 'java.lang' name 'System' (JLObject)
+  public
+    final class var
+      fin: JIInputStream; external name 'in';
+      fout: JIPrintStream; external name 'out';
+      ferr: JIPrintStream; external name 'err';
+  public
+    class procedure setIn(para1: JIInputStream); static; overload;
+    class procedure setOut(para1: JIPrintStream); static; overload;
+    class procedure setErr(para1: JIPrintStream); static; overload;
+    class function console(): JIConsole; static; overload;
+    class function inheritedChannel(): JNCChannel; static; overload;  // throws java.io.IOException
+    class procedure setSecurityManager(para1: JLSecurityManager); static; overload;
+    class function getSecurityManager(): JLSecurityManager; static; overload;
+    class function currentTimeMillis(): jlong; static; overload;
+    class function nanoTime(): jlong; static; overload;
+    class procedure arraycopy(para1: JLObject; para2: jint; para3: JLObject; para4: jint; para5: jint); static; overload;
+    class function identityHashCode(para1: JLObject): jint; static; overload;
+    class function getProperties(): JUProperties; static; overload;
+    class procedure setProperties(para1: JUProperties); static; overload;
+    class function getProperty(para1: JLString): JLString; static; overload;
+    class function getProperty(para1: JLString; para2: JLString): JLString; static; overload;
+    class function setProperty(para1: JLString; para2: JLString): JLString; static; overload;
+    class function clearProperty(para1: JLString): JLString; static; overload;
+    class function getenv(para1: JLString): JLString; static; overload;
+    class function getenv(): JUMap; static; overload;
+    class procedure exit(para1: jint); static; overload;
+    class procedure gc(); static; overload;
+    class procedure runFinalization(); static; overload;
+    class procedure runFinalizersOnExit(para1: jboolean); static; overload;
+    class procedure load(para1: JLString); static; overload;
+    class procedure loadLibrary(para1: JLString); static; overload;
+    class function mapLibraryName(para1: JLString): JLString; static; overload;
+  end;
+
+  JUComparator = interface external 'java.util' name 'Comparator' 
+    function compare(para1: JLObject; para2: JLObject): jint; overload;
+    function equals(para1: JLObject): jboolean; overload;
+  end;
+
+  JLNumber = class abstract external 'java.lang' name 'Number' (JLObject, JISerializable)
+  public
+    constructor create(); overload;
+    function intValue(): jint; overload; abstract;
+    function longValue(): jlong; overload; abstract;
+    function floatValue(): jfloat; overload; abstract;
+    function doubleValue(): jdouble; overload; abstract;
+    function byteValue(): jbyte; overload;
+    function shortValue(): jshort; overload;
+  end;
+
+  JLThrowable = class external 'java.lang' name 'Throwable' (JLObject, JISerializable)
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: JLString; para2: JLThrowable); overload;
+    constructor create(para1: JLThrowable); overload;
+    function getMessage(): JLString; overload;
+    function getLocalizedMessage(): JLString; overload;
+    function getCause(): JLThrowable; overload;
+    function initCause(para1: JLThrowable): JLThrowable; overload;
+    function toString(): JLString; overload;
+    procedure printStackTrace(); overload;
+    procedure printStackTrace(para1: JIPrintStream); overload;
+    procedure printStackTrace(para1: JIPrintWriter); overload;
+    function fillInStackTrace(): JLThrowable; overload;
+    function getStackTrace(): Arr1JLStackTraceElement; overload;
+    procedure setStackTrace(para1: Arr1JLStackTraceElement); overload;
+
+    procedure setStackTrace(var para1: array of JLStackTraceElement); overload;  end;
+
+  JLAbstractStringBuilder = class abstract external 'java.lang' name 'AbstractStringBuilder' (JLObject, JLAppendable, JLCharSequence)
+  public
+    function length(): jint; overload;
+    function capacity(): jint; overload;
+    procedure ensureCapacity(para1: jint); overload;
+    procedure trimToSize(); overload;
+    procedure setLength(para1: jint); overload;
+    function charAt(para1: jint): jchar; overload;
+    function codePointAt(para1: jint): jint; overload;
+    function codePointBefore(para1: jint): jint; overload;
+    function codePointCount(para1: jint; para2: jint): jint; overload;
+    function offsetByCodePoints(para1: jint; para2: jint): jint; overload;
+    procedure getChars(para1: jint; para2: jint; para3: Arr1jchar; para4: jint); overload;
+
+    procedure getChars(para1: jint; para2: jint; var para3: array of jchar; para4: jint); overload;    procedure setCharAt(para1: jint; para2: jchar); overload;
+    function append(para1: JLObject): JLAbstractStringBuilder; overload;
+    function append(para1: JLString): JLAbstractStringBuilder; overload;
+    function append(para1: JLStringBuffer): JLAbstractStringBuilder; overload;
+    function append(para1: JLCharSequence): JLAbstractStringBuilder; overload;
+    function append(para1: JLCharSequence; para2: jint; para3: jint): JLAbstractStringBuilder; overload;
+    function append(para1: Arr1jchar): JLAbstractStringBuilder; overload;
+
+    function append(var para1: array of jchar): JLAbstractStringBuilder; overload;    function append(para1: Arr1jchar; para2: jint; para3: jint): JLAbstractStringBuilder; overload;
+
+    function append(var para1: array of jchar; para2: jint; para3: jint): JLAbstractStringBuilder; overload;    function append(para1: jboolean): JLAbstractStringBuilder; overload;
+    function append(para1: jchar): JLAbstractStringBuilder; overload;
+    function append(para1: jint): JLAbstractStringBuilder; overload;
+    function append(para1: jlong): JLAbstractStringBuilder; overload;
+    function append(para1: jfloat): JLAbstractStringBuilder; overload;
+    function append(para1: jdouble): JLAbstractStringBuilder; overload;
+    function delete(para1: jint; para2: jint): JLAbstractStringBuilder; overload;
+    function appendCodePoint(para1: jint): JLAbstractStringBuilder; overload;
+    function deleteCharAt(para1: jint): JLAbstractStringBuilder; overload;
+    function replace(para1: jint; para2: jint; para3: JLString): JLAbstractStringBuilder; overload;
+    function substring(para1: jint): JLString; overload;
+    function subSequence(para1: jint; para2: jint): JLCharSequence; overload;
+    function substring(para1: jint; para2: jint): JLString; overload;
+    function insert(para1: jint; para2: Arr1jchar; para3: jint; para4: jint): JLAbstractStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar; para3: jint; para4: jint): JLAbstractStringBuilder; overload;    function insert(para1: jint; para2: JLObject): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLString): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: Arr1jchar): JLAbstractStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar): JLAbstractStringBuilder; overload;    function insert(para1: jint; para2: JLCharSequence): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLCharSequence; para3: jint; para4: jint): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jboolean): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jchar): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jint): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jlong): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jfloat): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jdouble): JLAbstractStringBuilder; overload;
+    function indexOf(para1: JLString): jint; overload;
+    function indexOf(para1: JLString; para2: jint): jint; overload;
+    function lastIndexOf(para1: JLString): jint; overload;
+    function lastIndexOf(para1: JLString; para2: jint): jint; overload;
+    function reverse(): JLAbstractStringBuilder; overload;
+    function toString(): JLString; overload; abstract;
+    function append(para1: jchar): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: JLCharSequence; para2: jint; para3: jint): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: JLCharSequence): JLAppendable; overload;  // throws java.io.IOException
+  end;
+
+  JLCharacter = class sealed external 'java.lang' name 'Character' (JLObject, JISerializable, JLComparable)
+  public
+    type
+      InnerCharacterCache = class;
+      Arr1InnerCharacterCache = array of InnerCharacterCache;
+      Arr2InnerCharacterCache = array of Arr1InnerCharacterCache;
+      Arr3InnerCharacterCache = array of Arr2InnerCharacterCache;
+      InnerCharacterCache = class external 'java.lang' name 'Character$CharacterCache' 
+      end;
+
+  public
+    type
+      InnerSubset = class;
+      Arr1InnerSubset = array of InnerSubset;
+      Arr2InnerSubset = array of Arr1InnerSubset;
+      Arr3InnerSubset = array of Arr2InnerSubset;
+      InnerUnicodeBlock = class;
+      Arr1InnerUnicodeBlock = array of InnerUnicodeBlock;
+      Arr2InnerUnicodeBlock = array of Arr1InnerUnicodeBlock;
+      Arr3InnerUnicodeBlock = array of Arr2InnerUnicodeBlock;
+      InnerSubset = class external 'java.lang' name 'Character$Subset' (JLObject)
+      strict protected
+        constructor create(para1: JLString); overload;
+      public
+        function equals(para1: JLObject): jboolean; overload; final;
+        function hashCode(): jint; overload; final;
+        function toString(): JLString; overload; final;
+      end;
+
+      InnerUnicodeBlock = class sealed external 'java.lang' name 'Character$UnicodeBlock' (InnerSubset)
+      public
+        final class var
+          fBASIC_LATIN: JLCharacter.InnerUnicodeBlock; external name 'BASIC_LATIN';
+          fLATIN_1_SUPPLEMENT: JLCharacter.InnerUnicodeBlock; external name 'LATIN_1_SUPPLEMENT';
+          fLATIN_EXTENDED_A: JLCharacter.InnerUnicodeBlock; external name 'LATIN_EXTENDED_A';
+          fLATIN_EXTENDED_B: JLCharacter.InnerUnicodeBlock; external name 'LATIN_EXTENDED_B';
+          fIPA_EXTENSIONS: JLCharacter.InnerUnicodeBlock; external name 'IPA_EXTENSIONS';
+          fSPACING_MODIFIER_LETTERS: JLCharacter.InnerUnicodeBlock; external name 'SPACING_MODIFIER_LETTERS';
+          fCOMBINING_DIACRITICAL_MARKS: JLCharacter.InnerUnicodeBlock; external name 'COMBINING_DIACRITICAL_MARKS';
+          fGREEK: JLCharacter.InnerUnicodeBlock; external name 'GREEK';
+          fCYRILLIC: JLCharacter.InnerUnicodeBlock; external name 'CYRILLIC';
+          fARMENIAN: JLCharacter.InnerUnicodeBlock; external name 'ARMENIAN';
+          fHEBREW: JLCharacter.InnerUnicodeBlock; external name 'HEBREW';
+          fARABIC: JLCharacter.InnerUnicodeBlock; external name 'ARABIC';
+          fDEVANAGARI: JLCharacter.InnerUnicodeBlock; external name 'DEVANAGARI';
+          fBENGALI: JLCharacter.InnerUnicodeBlock; external name 'BENGALI';
+          fGURMUKHI: JLCharacter.InnerUnicodeBlock; external name 'GURMUKHI';
+          fGUJARATI: JLCharacter.InnerUnicodeBlock; external name 'GUJARATI';
+          fORIYA: JLCharacter.InnerUnicodeBlock; external name 'ORIYA';
+          fTAMIL: JLCharacter.InnerUnicodeBlock; external name 'TAMIL';
+          fTELUGU: JLCharacter.InnerUnicodeBlock; external name 'TELUGU';
+          fKANNADA: JLCharacter.InnerUnicodeBlock; external name 'KANNADA';
+          fMALAYALAM: JLCharacter.InnerUnicodeBlock; external name 'MALAYALAM';
+          fTHAI: JLCharacter.InnerUnicodeBlock; external name 'THAI';
+          fLAO: JLCharacter.InnerUnicodeBlock; external name 'LAO';
+          fTIBETAN: JLCharacter.InnerUnicodeBlock; external name 'TIBETAN';
+          fGEORGIAN: JLCharacter.InnerUnicodeBlock; external name 'GEORGIAN';
+          fHANGUL_JAMO: JLCharacter.InnerUnicodeBlock; external name 'HANGUL_JAMO';
+          fLATIN_EXTENDED_ADDITIONAL: JLCharacter.InnerUnicodeBlock; external name 'LATIN_EXTENDED_ADDITIONAL';
+          fGREEK_EXTENDED: JLCharacter.InnerUnicodeBlock; external name 'GREEK_EXTENDED';
+          fGENERAL_PUNCTUATION: JLCharacter.InnerUnicodeBlock; external name 'GENERAL_PUNCTUATION';
+          fSUPERSCRIPTS_AND_SUBSCRIPTS: JLCharacter.InnerUnicodeBlock; external name 'SUPERSCRIPTS_AND_SUBSCRIPTS';
+          fCURRENCY_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'CURRENCY_SYMBOLS';
+          fCOMBINING_MARKS_FOR_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'COMBINING_MARKS_FOR_SYMBOLS';
+          fLETTERLIKE_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'LETTERLIKE_SYMBOLS';
+          fNUMBER_FORMS: JLCharacter.InnerUnicodeBlock; external name 'NUMBER_FORMS';
+          fARROWS: JLCharacter.InnerUnicodeBlock; external name 'ARROWS';
+          fMATHEMATICAL_OPERATORS: JLCharacter.InnerUnicodeBlock; external name 'MATHEMATICAL_OPERATORS';
+          fMISCELLANEOUS_TECHNICAL: JLCharacter.InnerUnicodeBlock; external name 'MISCELLANEOUS_TECHNICAL';
+          fCONTROL_PICTURES: JLCharacter.InnerUnicodeBlock; external name 'CONTROL_PICTURES';
+          fOPTICAL_CHARACTER_RECOGNITION: JLCharacter.InnerUnicodeBlock; external name 'OPTICAL_CHARACTER_RECOGNITION';
+          fENCLOSED_ALPHANUMERICS: JLCharacter.InnerUnicodeBlock; external name 'ENCLOSED_ALPHANUMERICS';
+          fBOX_DRAWING: JLCharacter.InnerUnicodeBlock; external name 'BOX_DRAWING';
+          fBLOCK_ELEMENTS: JLCharacter.InnerUnicodeBlock; external name 'BLOCK_ELEMENTS';
+          fGEOMETRIC_SHAPES: JLCharacter.InnerUnicodeBlock; external name 'GEOMETRIC_SHAPES';
+          fMISCELLANEOUS_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'MISCELLANEOUS_SYMBOLS';
+          fDINGBATS: JLCharacter.InnerUnicodeBlock; external name 'DINGBATS';
+          fCJK_SYMBOLS_AND_PUNCTUATION: JLCharacter.InnerUnicodeBlock; external name 'CJK_SYMBOLS_AND_PUNCTUATION';
+          fHIRAGANA: JLCharacter.InnerUnicodeBlock; external name 'HIRAGANA';
+          fKATAKANA: JLCharacter.InnerUnicodeBlock; external name 'KATAKANA';
+          fBOPOMOFO: JLCharacter.InnerUnicodeBlock; external name 'BOPOMOFO';
+          fHANGUL_COMPATIBILITY_JAMO: JLCharacter.InnerUnicodeBlock; external name 'HANGUL_COMPATIBILITY_JAMO';
+          fKANBUN: JLCharacter.InnerUnicodeBlock; external name 'KANBUN';
+          fENCLOSED_CJK_LETTERS_AND_MONTHS: JLCharacter.InnerUnicodeBlock; external name 'ENCLOSED_CJK_LETTERS_AND_MONTHS';
+          fCJK_COMPATIBILITY: JLCharacter.InnerUnicodeBlock; external name 'CJK_COMPATIBILITY';
+          fCJK_UNIFIED_IDEOGRAPHS: JLCharacter.InnerUnicodeBlock; external name 'CJK_UNIFIED_IDEOGRAPHS';
+          fHANGUL_SYLLABLES: JLCharacter.InnerUnicodeBlock; external name 'HANGUL_SYLLABLES';
+          fPRIVATE_USE_AREA: JLCharacter.InnerUnicodeBlock; external name 'PRIVATE_USE_AREA';
+          fCJK_COMPATIBILITY_IDEOGRAPHS: JLCharacter.InnerUnicodeBlock; external name 'CJK_COMPATIBILITY_IDEOGRAPHS';
+          fALPHABETIC_PRESENTATION_FORMS: JLCharacter.InnerUnicodeBlock; external name 'ALPHABETIC_PRESENTATION_FORMS';
+          fARABIC_PRESENTATION_FORMS_A: JLCharacter.InnerUnicodeBlock; external name 'ARABIC_PRESENTATION_FORMS_A';
+          fCOMBINING_HALF_MARKS: JLCharacter.InnerUnicodeBlock; external name 'COMBINING_HALF_MARKS';
+          fCJK_COMPATIBILITY_FORMS: JLCharacter.InnerUnicodeBlock; external name 'CJK_COMPATIBILITY_FORMS';
+          fSMALL_FORM_VARIANTS: JLCharacter.InnerUnicodeBlock; external name 'SMALL_FORM_VARIANTS';
+          fARABIC_PRESENTATION_FORMS_B: JLCharacter.InnerUnicodeBlock; external name 'ARABIC_PRESENTATION_FORMS_B';
+          fHALFWIDTH_AND_FULLWIDTH_FORMS: JLCharacter.InnerUnicodeBlock; external name 'HALFWIDTH_AND_FULLWIDTH_FORMS';
+          fSPECIALS: JLCharacter.InnerUnicodeBlock; external name 'SPECIALS';
+          fSURROGATES_AREA: JLCharacter.InnerUnicodeBlock deprecated; external name 'SURROGATES_AREA';
+          fSYRIAC: JLCharacter.InnerUnicodeBlock; external name 'SYRIAC';
+          fTHAANA: JLCharacter.InnerUnicodeBlock; external name 'THAANA';
+          fSINHALA: JLCharacter.InnerUnicodeBlock; external name 'SINHALA';
+          fMYANMAR: JLCharacter.InnerUnicodeBlock; external name 'MYANMAR';
+          fETHIOPIC: JLCharacter.InnerUnicodeBlock; external name 'ETHIOPIC';
+          fCHEROKEE: JLCharacter.InnerUnicodeBlock; external name 'CHEROKEE';
+          fUNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: JLCharacter.InnerUnicodeBlock; external name 'UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS';
+          fOGHAM: JLCharacter.InnerUnicodeBlock; external name 'OGHAM';
+          fRUNIC: JLCharacter.InnerUnicodeBlock; external name 'RUNIC';
+          fKHMER: JLCharacter.InnerUnicodeBlock; external name 'KHMER';
+          fMONGOLIAN: JLCharacter.InnerUnicodeBlock; external name 'MONGOLIAN';
+          fBRAILLE_PATTERNS: JLCharacter.InnerUnicodeBlock; external name 'BRAILLE_PATTERNS';
+          fCJK_RADICALS_SUPPLEMENT: JLCharacter.InnerUnicodeBlock; external name 'CJK_RADICALS_SUPPLEMENT';
+          fKANGXI_RADICALS: JLCharacter.InnerUnicodeBlock; external name 'KANGXI_RADICALS';
+          fIDEOGRAPHIC_DESCRIPTION_CHARACTERS: JLCharacter.InnerUnicodeBlock; external name 'IDEOGRAPHIC_DESCRIPTION_CHARACTERS';
+          fBOPOMOFO_EXTENDED: JLCharacter.InnerUnicodeBlock; external name 'BOPOMOFO_EXTENDED';
+          fCJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: JLCharacter.InnerUnicodeBlock; external name 'CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A';
+          fYI_SYLLABLES: JLCharacter.InnerUnicodeBlock; external name 'YI_SYLLABLES';
+          fYI_RADICALS: JLCharacter.InnerUnicodeBlock; external name 'YI_RADICALS';
+          fCYRILLIC_SUPPLEMENTARY: JLCharacter.InnerUnicodeBlock; external name 'CYRILLIC_SUPPLEMENTARY';
+          fTAGALOG: JLCharacter.InnerUnicodeBlock; external name 'TAGALOG';
+          fHANUNOO: JLCharacter.InnerUnicodeBlock; external name 'HANUNOO';
+          fBUHID: JLCharacter.InnerUnicodeBlock; external name 'BUHID';
+          fTAGBANWA: JLCharacter.InnerUnicodeBlock; external name 'TAGBANWA';
+          fLIMBU: JLCharacter.InnerUnicodeBlock; external name 'LIMBU';
+          fTAI_LE: JLCharacter.InnerUnicodeBlock; external name 'TAI_LE';
+          fKHMER_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'KHMER_SYMBOLS';
+          fPHONETIC_EXTENSIONS: JLCharacter.InnerUnicodeBlock; external name 'PHONETIC_EXTENSIONS';
+          fMISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: JLCharacter.InnerUnicodeBlock; external name 'MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A';
+          fSUPPLEMENTAL_ARROWS_A: JLCharacter.InnerUnicodeBlock; external name 'SUPPLEMENTAL_ARROWS_A';
+          fSUPPLEMENTAL_ARROWS_B: JLCharacter.InnerUnicodeBlock; external name 'SUPPLEMENTAL_ARROWS_B';
+          fMISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: JLCharacter.InnerUnicodeBlock; external name 'MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B';
+          fSUPPLEMENTAL_MATHEMATICAL_OPERATORS: JLCharacter.InnerUnicodeBlock; external name 'SUPPLEMENTAL_MATHEMATICAL_OPERATORS';
+          fMISCELLANEOUS_SYMBOLS_AND_ARROWS: JLCharacter.InnerUnicodeBlock; external name 'MISCELLANEOUS_SYMBOLS_AND_ARROWS';
+          fKATAKANA_PHONETIC_EXTENSIONS: JLCharacter.InnerUnicodeBlock; external name 'KATAKANA_PHONETIC_EXTENSIONS';
+          fYIJING_HEXAGRAM_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'YIJING_HEXAGRAM_SYMBOLS';
+          fVARIATION_SELECTORS: JLCharacter.InnerUnicodeBlock; external name 'VARIATION_SELECTORS';
+          fLINEAR_B_SYLLABARY: JLCharacter.InnerUnicodeBlock; external name 'LINEAR_B_SYLLABARY';
+          fLINEAR_B_IDEOGRAMS: JLCharacter.InnerUnicodeBlock; external name 'LINEAR_B_IDEOGRAMS';
+          fAEGEAN_NUMBERS: JLCharacter.InnerUnicodeBlock; external name 'AEGEAN_NUMBERS';
+          fOLD_ITALIC: JLCharacter.InnerUnicodeBlock; external name 'OLD_ITALIC';
+          fGOTHIC: JLCharacter.InnerUnicodeBlock; external name 'GOTHIC';
+          fUGARITIC: JLCharacter.InnerUnicodeBlock; external name 'UGARITIC';
+          fDESERET: JLCharacter.InnerUnicodeBlock; external name 'DESERET';
+          fSHAVIAN: JLCharacter.InnerUnicodeBlock; external name 'SHAVIAN';
+          fOSMANYA: JLCharacter.InnerUnicodeBlock; external name 'OSMANYA';
+          fCYPRIOT_SYLLABARY: JLCharacter.InnerUnicodeBlock; external name 'CYPRIOT_SYLLABARY';
+          fBYZANTINE_MUSICAL_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'BYZANTINE_MUSICAL_SYMBOLS';
+          fMUSICAL_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'MUSICAL_SYMBOLS';
+          fTAI_XUAN_JING_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'TAI_XUAN_JING_SYMBOLS';
+          fMATHEMATICAL_ALPHANUMERIC_SYMBOLS: JLCharacter.InnerUnicodeBlock; external name 'MATHEMATICAL_ALPHANUMERIC_SYMBOLS';
+          fCJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: JLCharacter.InnerUnicodeBlock; external name 'CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B';
+          fCJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: JLCharacter.InnerUnicodeBlock; external name 'CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT';
+          fTAGS: JLCharacter.InnerUnicodeBlock; external name 'TAGS';
+          fVARIATION_SELECTORS_SUPPLEMENT: JLCharacter.InnerUnicodeBlock; external name 'VARIATION_SELECTORS_SUPPLEMENT';
+          fSUPPLEMENTARY_PRIVATE_USE_AREA_A: JLCharacter.InnerUnicodeBlock; external name 'SUPPLEMENTARY_PRIVATE_USE_AREA_A';
+          fSUPPLEMENTARY_PRIVATE_USE_AREA_B: JLCharacter.InnerUnicodeBlock; external name 'SUPPLEMENTARY_PRIVATE_USE_AREA_B';
+          fHIGH_SURROGATES: JLCharacter.InnerUnicodeBlock; external name 'HIGH_SURROGATES';
+          fHIGH_PRIVATE_USE_SURROGATES: JLCharacter.InnerUnicodeBlock; external name 'HIGH_PRIVATE_USE_SURROGATES';
+          fLOW_SURROGATES: JLCharacter.InnerUnicodeBlock; external name 'LOW_SURROGATES';
+      public
+        class function &of(para1: jchar): JLCharacter.InnerUnicodeBlock; static; overload;
+        class function &of(para1: jint): JLCharacter.InnerUnicodeBlock; static; overload;
+        class function forName(para1: JLString): JLCharacter.InnerUnicodeBlock; static; overload; final;
+      end;
+
+  public
+    const
+      MIN_RADIX = 2;
+      MAX_RADIX = 36;
+      MIN_VALUE = 0;
+      MAX_VALUE = 65535;
+  public
+    final class var
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    const
+      UNASSIGNED = 0;
+      UPPERCASE_LETTER = 1;
+      LOWERCASE_LETTER = 2;
+      TITLECASE_LETTER = 3;
+      MODIFIER_LETTER = 4;
+      OTHER_LETTER = 5;
+      NON_SPACING_MARK = 6;
+      ENCLOSING_MARK = 7;
+      COMBINING_SPACING_MARK = 8;
+      DECIMAL_DIGIT_NUMBER = 9;
+      LETTER_NUMBER = 10;
+      OTHER_NUMBER = 11;
+      SPACE_SEPARATOR = 12;
+      LINE_SEPARATOR = 13;
+      PARAGRAPH_SEPARATOR = 14;
+      CONTROL = 15;
+      FORMAT = 16;
+      PRIVATE_USE = 18;
+      SURROGATE = 19;
+      DASH_PUNCTUATION = 20;
+      START_PUNCTUATION = 21;
+      END_PUNCTUATION = 22;
+      CONNECTOR_PUNCTUATION = 23;
+      OTHER_PUNCTUATION = 24;
+      MATH_SYMBOL = 25;
+      CURRENCY_SYMBOL = 26;
+      MODIFIER_SYMBOL = 27;
+      OTHER_SYMBOL = 28;
+      INITIAL_QUOTE_PUNCTUATION = 29;
+      FINAL_QUOTE_PUNCTUATION = 30;
+      DIRECTIONALITY_UNDEFINED = -1;
+      DIRECTIONALITY_LEFT_TO_RIGHT = 0;
+      DIRECTIONALITY_RIGHT_TO_LEFT = 1;
+      DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
+      DIRECTIONALITY_EUROPEAN_NUMBER = 3;
+      DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
+      DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
+      DIRECTIONALITY_ARABIC_NUMBER = 6;
+      DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
+      DIRECTIONALITY_NONSPACING_MARK = 8;
+      DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
+      DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
+      DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
+      DIRECTIONALITY_WHITESPACE = 12;
+      DIRECTIONALITY_OTHER_NEUTRALS = 13;
+      DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
+      DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
+      DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
+      DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
+      DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
+      MIN_HIGH_SURROGATE = 55296;
+      MAX_HIGH_SURROGATE = 56319;
+      MIN_LOW_SURROGATE = 56320;
+      MAX_LOW_SURROGATE = 57343;
+      MIN_SURROGATE = 55296;
+      MAX_SURROGATE = 57343;
+      MIN_SUPPLEMENTARY_CODE_POINT = 65536;
+      MIN_CODE_POINT = 0;
+      MAX_CODE_POINT = 1114111;
+      SIZE = 16;
+  public
+    constructor create(para1: jchar); overload;
+    class function valueOf(para1: jchar): JLCharacter; static; overload;
+    function charValue(): jchar; overload;
+    function hashCode(): jint; overload;
+    function equals(para1: JLObject): jboolean; overload;
+    function toString(): JLString; overload;
+    class function toString(para1: jchar): JLString; static; overload;
+    class function isValidCodePoint(para1: jint): jboolean; static; overload;
+    class function isSupplementaryCodePoint(para1: jint): jboolean; static; overload;
+    class function isHighSurrogate(para1: jchar): jboolean; static; overload;
+    class function isLowSurrogate(para1: jchar): jboolean; static; overload;
+    class function isSurrogatePair(para1: jchar; para2: jchar): jboolean; static; overload;
+    class function charCount(para1: jint): jint; static; overload;
+    class function toCodePoint(para1: jchar; para2: jchar): jint; static; overload;
+    class function codePointAt(para1: JLCharSequence; para2: jint): jint; static; overload;
+    class function codePointAt(para1: Arr1jchar; para2: jint): jint; static; overload;
+
+    class function codePointAt(var para1: array of jchar; para2: jint): jint; static; overload;    class function codePointAt(para1: Arr1jchar; para2: jint; para3: jint): jint; static; overload;
+
+    class function codePointAt(var para1: array of jchar; para2: jint; para3: jint): jint; static; overload;    class function codePointBefore(para1: JLCharSequence; para2: jint): jint; static; overload;
+    class function codePointBefore(para1: Arr1jchar; para2: jint): jint; static; overload;
+
+    class function codePointBefore(var para1: array of jchar; para2: jint): jint; static; overload;    class function codePointBefore(para1: Arr1jchar; para2: jint; para3: jint): jint; static; overload;
+
+    class function codePointBefore(var para1: array of jchar; para2: jint; para3: jint): jint; static; overload;    class function toChars(para1: jint; para2: Arr1jchar; para3: jint): jint; static; overload;
+
+    class function toChars(para1: jint; var para2: array of jchar; para3: jint): jint; static; overload;    class function toChars(para1: jint): Arr1jchar; static; overload;
+    class function codePointCount(para1: JLCharSequence; para2: jint; para3: jint): jint; static; overload;
+    class function codePointCount(para1: Arr1jchar; para2: jint; para3: jint): jint; static; overload;
+
+    class function codePointCount(var para1: array of jchar; para2: jint; para3: jint): jint; static; overload;    class function offsetByCodePoints(para1: JLCharSequence; para2: jint; para3: jint): jint; static; overload;
+    class function offsetByCodePoints(para1: Arr1jchar; para2: jint; para3: jint; para4: jint; para5: jint): jint; static; overload;
+
+    class function offsetByCodePoints(var para1: array of jchar; para2: jint; para3: jint; para4: jint; para5: jint): jint; static; overload;    class function isLowerCase(para1: jchar): jboolean; static; overload;
+    class function isLowerCase(para1: jint): jboolean; static; overload;
+    class function isUpperCase(para1: jchar): jboolean; static; overload;
+    class function isUpperCase(para1: jint): jboolean; static; overload;
+    class function isTitleCase(para1: jchar): jboolean; static; overload;
+    class function isTitleCase(para1: jint): jboolean; static; overload;
+    class function isDigit(para1: jchar): jboolean; static; overload;
+    class function isDigit(para1: jint): jboolean; static; overload;
+    class function isDefined(para1: jchar): jboolean; static; overload;
+    class function isDefined(para1: jint): jboolean; static; overload;
+    class function isLetter(para1: jchar): jboolean; static; overload;
+    class function isLetter(para1: jint): jboolean; static; overload;
+    class function isLetterOrDigit(para1: jchar): jboolean; static; overload;
+    class function isLetterOrDigit(para1: jint): jboolean; static; overload;
+    class function isJavaLetter(para1: jchar): jboolean; static; overload;
+    class function isJavaLetterOrDigit(para1: jchar): jboolean; static; overload;
+    class function isJavaIdentifierStart(para1: jchar): jboolean; static; overload;
+    class function isJavaIdentifierStart(para1: jint): jboolean; static; overload;
+    class function isJavaIdentifierPart(para1: jchar): jboolean; static; overload;
+    class function isJavaIdentifierPart(para1: jint): jboolean; static; overload;
+    class function isUnicodeIdentifierStart(para1: jchar): jboolean; static; overload;
+    class function isUnicodeIdentifierStart(para1: jint): jboolean; static; overload;
+    class function isUnicodeIdentifierPart(para1: jchar): jboolean; static; overload;
+    class function isUnicodeIdentifierPart(para1: jint): jboolean; static; overload;
+    class function isIdentifierIgnorable(para1: jchar): jboolean; static; overload;
+    class function isIdentifierIgnorable(para1: jint): jboolean; static; overload;
+    class function toLowerCase(para1: jchar): jchar; static; overload;
+    class function toLowerCase(para1: jint): jint; static; overload;
+    class function toUpperCase(para1: jchar): jchar; static; overload;
+    class function toUpperCase(para1: jint): jint; static; overload;
+    class function toTitleCase(para1: jchar): jchar; static; overload;
+    class function toTitleCase(para1: jint): jint; static; overload;
+    class function digit(para1: jchar; para2: jint): jint; static; overload;
+    class function digit(para1: jint; para2: jint): jint; static; overload;
+    class function getNumericValue(para1: jchar): jint; static; overload;
+    class function getNumericValue(para1: jint): jint; static; overload;
+    class function isSpace(para1: jchar): jboolean; static; overload;
+    class function isSpaceChar(para1: jchar): jboolean; static; overload;
+    class function isSpaceChar(para1: jint): jboolean; static; overload;
+    class function isWhitespace(para1: jchar): jboolean; static; overload;
+    class function isWhitespace(para1: jint): jboolean; static; overload;
+    class function isISOControl(para1: jchar): jboolean; static; overload;
+    class function isISOControl(para1: jint): jboolean; static; overload;
+    class function getType(para1: jchar): jint; static; overload;
+    class function getType(para1: jint): jint; static; overload;
+    class function forDigit(para1: jint; para2: jint): jchar; static; overload;
+    class function getDirectionality(para1: jchar): jbyte; static; overload;
+    class function getDirectionality(para1: jint): jbyte; static; overload;
+    class function isMirrored(para1: jchar): jboolean; static; overload;
+    class function isMirrored(para1: jint): jboolean; static; overload;
+    function compareTo(para1: JLCharacter): jint; overload;
+    class function reverseBytes(para1: jchar): jchar; static; overload;
+    function compareTo(para1: JLObject): jint; overload;
+  end;
+
+  JLString = class sealed external 'java.lang' name 'String' (JLObject, JISerializable, JLComparable, JLCharSequence)
+  public
+    type
+      InnerCaseInsensitiveComparator = class;
+      Arr1InnerCaseInsensitiveComparator = array of InnerCaseInsensitiveComparator;
+      Arr2InnerCaseInsensitiveComparator = array of Arr1InnerCaseInsensitiveComparator;
+      Arr3InnerCaseInsensitiveComparator = array of Arr2InnerCaseInsensitiveComparator;
+      InnerCaseInsensitiveComparator = class external 'java.lang' name 'String$CaseInsensitiveComparator' 
+      end;
+
+  public
+    final class var
+      fCASE_INSENSITIVE_ORDER: JUComparator; external name 'CASE_INSENSITIVE_ORDER';
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: Arr1jchar); overload;
+    constructor create(const para1: array of jchar); overload;
+    constructor create(para1: Arr1jchar; para2: jint; para3: jint); overload;
+    constructor create(const para1: array of jchar; para2: jint; para3: jint); overload;
+    constructor create(para1: Arr1jint; para2: jint; para3: jint); overload;
+    constructor create(const para1: array of jint; para2: jint; para3: jint); overload;
+    constructor create(para1: Arr1jbyte; para2: jint; para3: jint; para4: jint); overload;
+    constructor create(const para1: array of jbyte; para2: jint; para3: jint; para4: jint); overload;
+    constructor create(para1: Arr1jbyte; para2: jint); overload;
+    constructor create(const para1: array of jbyte; para2: jint); overload;
+    constructor create(para1: Arr1jbyte; para2: jint; para3: jint; para4: JLString); overload;  // throws java.io.UnsupportedEncodingException
+    constructor create(const para1: array of jbyte; para2: jint; para3: jint; para4: JLString); overload;  // throws java.io.UnsupportedEncodingException
+    constructor create(para1: Arr1jbyte; para2: jint; para3: jint; para4: JNCCharset); overload;
+    constructor create(const para1: array of jbyte; para2: jint; para3: jint; para4: JNCCharset); overload;
+    constructor create(para1: Arr1jbyte; para2: JLString); overload;  // throws java.io.UnsupportedEncodingException
+    constructor create(const para1: array of jbyte; para2: JLString); overload;  // throws java.io.UnsupportedEncodingException
+    constructor create(para1: Arr1jbyte; para2: JNCCharset); overload;
+    constructor create(const para1: array of jbyte; para2: JNCCharset); overload;
+    constructor create(para1: Arr1jbyte; para2: jint; para3: jint); overload;
+    constructor create(const para1: array of jbyte; para2: jint; para3: jint); overload;
+    constructor create(para1: Arr1jbyte); overload;
+    constructor create(const para1: array of jbyte); overload;
+    constructor create(para1: JLStringBuffer); overload;
+    constructor create(para1: JLStringBuilder); overload;
+    function length(): jint; overload;
+    function isEmpty(): jboolean; overload;
+    function charAt(para1: jint): jchar; overload;
+    function codePointAt(para1: jint): jint; overload;
+    function codePointBefore(para1: jint): jint; overload;
+    function codePointCount(para1: jint; para2: jint): jint; overload;
+    function offsetByCodePoints(para1: jint; para2: jint): jint; overload;
+    procedure getChars(para1: jint; para2: jint; para3: Arr1jchar; para4: jint); overload;
+
+    procedure getChars(para1: jint; para2: jint; var para3: array of jchar; para4: jint); overload;    procedure getBytes(para1: jint; para2: jint; para3: Arr1jbyte; para4: jint); overload;
+
+    procedure getBytes(para1: jint; para2: jint; var para3: array of jbyte; para4: jint); overload;    function getBytes(para1: JLString): Arr1jbyte; overload;  // throws java.io.UnsupportedEncodingException
+    function getBytes(para1: JNCCharset): Arr1jbyte; overload;
+    function getBytes(): Arr1jbyte; overload;
+    function equals(para1: JLObject): jboolean; overload;
+    function contentEquals(para1: JLStringBuffer): jboolean; overload;
+    function contentEquals(para1: JLCharSequence): jboolean; overload;
+    function equalsIgnoreCase(para1: JLString): jboolean; overload;
+    function compareTo(para1: JLString): jint; overload;
+    function compareToIgnoreCase(para1: JLString): jint; overload;
+    function regionMatches(para1: jint; para2: JLString; para3: jint; para4: jint): jboolean; overload;
+    function regionMatches(para1: jboolean; para2: jint; para3: JLString; para4: jint; para5: jint): jboolean; overload;
+    function startsWith(para1: JLString; para2: jint): jboolean; overload;
+    function startsWith(para1: JLString): jboolean; overload;
+    function endsWith(para1: JLString): jboolean; overload;
+    function hashCode(): jint; overload;
+    function indexOf(para1: jint): jint; overload;
+    function indexOf(para1: jint; para2: jint): jint; overload;
+    function lastIndexOf(para1: jint): jint; overload;
+    function lastIndexOf(para1: jint; para2: jint): jint; overload;
+    function indexOf(para1: JLString): jint; overload;
+    function indexOf(para1: JLString; para2: jint): jint; overload;
+    function lastIndexOf(para1: JLString): jint; overload;
+    function lastIndexOf(para1: JLString; para2: jint): jint; overload;
+    function substring(para1: jint): JLString; overload;
+    function substring(para1: jint; para2: jint): JLString; overload;
+    function subSequence(para1: jint; para2: jint): JLCharSequence; overload;
+    function concat(para1: JLString): JLString; overload;
+    function replace(para1: jchar; para2: jchar): JLString; overload;
+    function matches(para1: JLString): jboolean; overload;
+    function contains(para1: JLCharSequence): jboolean; overload;
+    function replaceFirst(para1: JLString; para2: JLString): JLString; overload;
+    function replaceAll(para1: JLString; para2: JLString): JLString; overload;
+    function replace(para1: JLCharSequence; para2: JLCharSequence): JLString; overload;
+    function split(para1: JLString; para2: jint): Arr1JLString; overload;
+    function split(para1: JLString): Arr1JLString; overload;
+    function toLowerCase(para1: JULocale): JLString; overload;
+    function toLowerCase(): JLString; overload;
+    function toUpperCase(para1: JULocale): JLString; overload;
+    function toUpperCase(): JLString; overload;
+    function trim(): JLString; overload;
+    function toString(): JLString; overload;
+    function toCharArray(): Arr1jchar; overload;
+    class function format(para1: JLString; para2: Arr1JLObject): JLString; static; overload;
+
+    class function format(para1: JLString; var para2: array of JLObject): JLString; static; overload;    class function format(para1: JULocale; para2: JLString; para3: Arr1JLObject): JLString; static; overload;
+
+    class function format(para1: JULocale; para2: JLString; var para3: array of JLObject): JLString; static; overload;    class function valueOf(para1: JLObject): JLString; static; overload;
+    class function valueOf(para1: Arr1jchar): JLString; static; overload;
+
+    class function valueOf(var para1: array of jchar): JLString; static; overload;    class function valueOf(para1: Arr1jchar; para2: jint; para3: jint): JLString; static; overload;
+
+    class function valueOf(var para1: array of jchar; para2: jint; para3: jint): JLString; static; overload;    class function copyValueOf(para1: Arr1jchar; para2: jint; para3: jint): JLString; static; overload;
+
+    class function copyValueOf(var para1: array of jchar; para2: jint; para3: jint): JLString; static; overload;    class function copyValueOf(para1: Arr1jchar): JLString; static; overload;
+
+    class function copyValueOf(var para1: array of jchar): JLString; static; overload;    class function valueOf(para1: jboolean): JLString; static; overload;
+    class function valueOf(para1: jchar): JLString; static; overload;
+    class function valueOf(para1: jint): JLString; static; overload;
+    class function valueOf(para1: jlong): JLString; static; overload;
+    class function valueOf(para1: jfloat): JLString; static; overload;
+    class function valueOf(para1: jdouble): JLString; static; overload;
+    function intern(): JLString; overload;
+    function compareTo(para1: JLObject): jint; overload;
+  end;
+
+  JTCollator = class abstract external 'java.text' name 'Collator' (JLObject, JUComparator, JLCloneable)
+  public
+    type
+      InnerCollatorGetter = class;
+      Arr1InnerCollatorGetter = array of InnerCollatorGetter;
+      Arr2InnerCollatorGetter = array of Arr1InnerCollatorGetter;
+      Arr3InnerCollatorGetter = array of Arr2InnerCollatorGetter;
+      InnerCollatorGetter = class external 'java.text' name 'Collator$CollatorGetter' 
+      end;
+
+  public
+    const
+      PRIMARY = 0;
+      SECONDARY = 1;
+      TERTIARY = 2;
+      IDENTICAL = 3;
+      NO_DECOMPOSITION = 0;
+      CANONICAL_DECOMPOSITION = 1;
+      FULL_DECOMPOSITION = 2;
+  public
+    class function getInstance(): JTCollator; static; overload;
+    class function getInstance(para1: JULocale): JTCollator; static; overload;
+    function compare(para1: JLString; para2: JLString): jint; overload; abstract;
+    function compare(para1: JLObject; para2: JLObject): jint; overload;
+    function getCollationKey(para1: JLString): JTCollationKey; overload; abstract;
+    function equals(para1: JLString; para2: JLString): jboolean; overload;
+    function getStrength(): jint; overload;
+    procedure setStrength(para1: jint); overload;
+    function getDecomposition(): jint; overload;
+    procedure setDecomposition(para1: jint); overload;
+    class function getAvailableLocales(): Arr1JULocale; static; overload;
+    function clone(): JLObject; overload;
+    function equals(para1: JLObject): jboolean; overload;
+    function hashCode(): jint; overload; abstract;
+  strict protected
+    constructor create(); overload;
+  end;
+
+  JLDouble = class sealed external 'java.lang' name 'Double' (JLNumber, JLComparable)
+  public
+    const
+      POSITIVE_INFINITY = jdouble(1.0/0.0);
+      NEGATIVE_INFINITY = jdouble(-1.0/0.0);
+      NaN = jdouble(0.0/0.0);
+      MAX_VALUE = jdouble(1.7976931348623157E308);
+      MIN_NORMAL = jdouble(2.2250738585072014E-308);
+      MIN_VALUE = jdouble(4.9E-324);
+      MAX_EXPONENT = 1023;
+      MIN_EXPONENT = -1022;
+      SIZE = 64;
+  public
+    final class var
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    class function toString(para1: jdouble): JLString; static; overload;
+    class function toHexString(para1: jdouble): JLString; static; overload;
+    class function valueOf(para1: JLString): JLDouble; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: jdouble): JLDouble; static; overload;
+    class function parseDouble(para1: JLString): jdouble; static; overload;  // throws java.lang.NumberFormatException
+    class function isNaN(para1: jdouble): jboolean; static; overload;
+    class function isInfinite(para1: jdouble): jboolean; static; overload;
+    constructor create(para1: jdouble); overload;
+    constructor create(para1: JLString); overload;  // throws java.lang.NumberFormatException
+    function isNaN(): jboolean; overload;
+    function isInfinite(): jboolean; overload;
+    function toString(): JLString; overload;
+    function byteValue(): jbyte; overload;
+    function shortValue(): jshort; overload;
+    function intValue(): jint; overload;
+    function longValue(): jlong; overload;
+    function floatValue(): jfloat; overload;
+    function doubleValue(): jdouble; overload;
+    function hashCode(): jint; overload;
+    function equals(para1: JLObject): jboolean; overload;
+    class function doubleToLongBits(para1: jdouble): jlong; static; overload;
+    class function doubleToRawLongBits(para1: jdouble): jlong; static; overload;
+    class function longBitsToDouble(para1: jlong): jdouble; static; overload;
+    function compareTo(para1: JLDouble): jint; overload;
+    class function compare(para1: jdouble; para2: jdouble): jint; static; overload;
+    function compareTo(para1: JLObject): jint; overload;
+  end;
+
+  JLFloat = class sealed external 'java.lang' name 'Float' (JLNumber, JLComparable)
+  public
+    const
+      POSITIVE_INFINITY = jfloat(1.0/0.0);
+      NEGATIVE_INFINITY = jfloat(-1.0/0.0);
+      NaN = jfloat(0.0/0.0);
+      MAX_VALUE = jfloat(3.4028235E38);
+      MIN_NORMAL = jfloat(1.17549435E-38);
+      MIN_VALUE = jfloat(1.4E-45);
+      MAX_EXPONENT = 127;
+      MIN_EXPONENT = -126;
+      SIZE = 32;
+  public
+    final class var
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    class function toString(para1: jfloat): JLString; static; overload;
+    class function toHexString(para1: jfloat): JLString; static; overload;
+    class function valueOf(para1: JLString): JLFloat; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: jfloat): JLFloat; static; overload;
+    class function parseFloat(para1: JLString): jfloat; static; overload;  // throws java.lang.NumberFormatException
+    class function isNaN(para1: jfloat): jboolean; static; overload;
+    class function isInfinite(para1: jfloat): jboolean; static; overload;
+    constructor create(para1: jfloat); overload;
+    constructor create(para1: jdouble); overload;
+    constructor create(para1: JLString); overload;  // throws java.lang.NumberFormatException
+    function isNaN(): jboolean; overload;
+    function isInfinite(): jboolean; overload;
+    function toString(): JLString; overload;
+    function byteValue(): jbyte; overload;
+    function shortValue(): jshort; overload;
+    function intValue(): jint; overload;
+    function longValue(): jlong; overload;
+    function floatValue(): jfloat; overload;
+    function doubleValue(): jdouble; overload;
+    function hashCode(): jint; overload;
+    function equals(para1: JLObject): jboolean; overload;
+    class function floatToIntBits(para1: jfloat): jint; static; overload;
+    class function floatToRawIntBits(para1: jfloat): jint; static; overload;
+    class function intBitsToFloat(para1: jint): jfloat; static; overload;
+    function compareTo(para1: JLFloat): jint; overload;
+    class function compare(para1: jfloat; para2: jfloat): jint; static; overload;
+    function compareTo(para1: JLObject): jint; overload;
+  end;
+
+  JLError = class external 'java.lang' name 'Error' (JLThrowable)
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: JLString; para2: JLThrowable); overload;
+    constructor create(para1: JLThrowable); overload;
+  end;
+
+  JLException = class external 'java.lang' name 'Exception' (JLThrowable)
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: JLString; para2: JLThrowable); overload;
+    constructor create(para1: JLThrowable); overload;
+  end;
+
+  JLStringBuffer = class sealed external 'java.lang' name 'StringBuffer' (JLAbstractStringBuilder, JISerializable, JLCharSequence)
+  public
+    constructor create(); overload;
+    constructor create(para1: jint); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: JLCharSequence); overload;
+    function length(): jint; overload;
+    function capacity(): jint; overload;
+    procedure ensureCapacity(para1: jint); overload;
+    procedure trimToSize(); overload;
+    procedure setLength(para1: jint); overload;
+    function charAt(para1: jint): jchar; overload;
+    function codePointAt(para1: jint): jint; overload;
+    function codePointBefore(para1: jint): jint; overload;
+    function codePointCount(para1: jint; para2: jint): jint; overload;
+    function offsetByCodePoints(para1: jint; para2: jint): jint; overload;
+    procedure getChars(para1: jint; para2: jint; para3: Arr1jchar; para4: jint); overload;
+
+    procedure getChars(para1: jint; para2: jint; var para3: array of jchar; para4: jint); overload;    procedure setCharAt(para1: jint; para2: jchar); overload;
+    function append(para1: JLObject): JLStringBuffer; overload;
+    function append(para1: JLString): JLStringBuffer; overload;
+    function append(para1: JLStringBuffer): JLStringBuffer; overload;
+    function append(para1: JLCharSequence): JLStringBuffer; overload;
+    function append(para1: JLCharSequence; para2: jint; para3: jint): JLStringBuffer; overload;
+    function append(para1: Arr1jchar): JLStringBuffer; overload;
+
+    function append(var para1: array of jchar): JLStringBuffer; overload;    function append(para1: Arr1jchar; para2: jint; para3: jint): JLStringBuffer; overload;
+
+    function append(var para1: array of jchar; para2: jint; para3: jint): JLStringBuffer; overload;    function append(para1: jboolean): JLStringBuffer; overload;
+    function append(para1: jchar): JLStringBuffer; overload;
+    function append(para1: jint): JLStringBuffer; overload;
+    function appendCodePoint(para1: jint): JLStringBuffer; overload;
+    function append(para1: jlong): JLStringBuffer; overload;
+    function append(para1: jfloat): JLStringBuffer; overload;
+    function append(para1: jdouble): JLStringBuffer; overload;
+    function delete(para1: jint; para2: jint): JLStringBuffer; overload;
+    function deleteCharAt(para1: jint): JLStringBuffer; overload;
+    function replace(para1: jint; para2: jint; para3: JLString): JLStringBuffer; overload;
+    function substring(para1: jint): JLString; overload;
+    function subSequence(para1: jint; para2: jint): JLCharSequence; overload;
+    function substring(para1: jint; para2: jint): JLString; overload;
+    function insert(para1: jint; para2: Arr1jchar; para3: jint; para4: jint): JLStringBuffer; overload;
+
+    function insert(para1: jint; var para2: array of jchar; para3: jint; para4: jint): JLStringBuffer; overload;    function insert(para1: jint; para2: JLObject): JLStringBuffer; overload;
+    function insert(para1: jint; para2: JLString): JLStringBuffer; overload;
+    function insert(para1: jint; para2: Arr1jchar): JLStringBuffer; overload;
+
+    function insert(para1: jint; var para2: array of jchar): JLStringBuffer; overload;    function insert(para1: jint; para2: JLCharSequence): JLStringBuffer; overload;
+    function insert(para1: jint; para2: JLCharSequence; para3: jint; para4: jint): JLStringBuffer; overload;
+    function insert(para1: jint; para2: jboolean): JLStringBuffer; overload;
+    function insert(para1: jint; para2: jchar): JLStringBuffer; overload;
+    function insert(para1: jint; para2: jint): JLStringBuffer; overload;
+    function insert(para1: jint; para2: jlong): JLStringBuffer; overload;
+    function insert(para1: jint; para2: jfloat): JLStringBuffer; overload;
+    function insert(para1: jint; para2: jdouble): JLStringBuffer; overload;
+    function indexOf(para1: JLString): jint; overload;
+    function indexOf(para1: JLString; para2: jint): jint; overload;
+    function lastIndexOf(para1: JLString): jint; overload;
+    function lastIndexOf(para1: JLString; para2: jint): jint; overload;
+    function reverse(): JLStringBuffer; overload;
+    function toString(): JLString; overload;
+    function reverse(): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jdouble): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jfloat): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jlong): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jint): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jchar): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jboolean): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLCharSequence; para3: jint; para4: jint): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLCharSequence): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: Arr1jchar): JLAbstractStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar): JLAbstractStringBuilder; overload;    function insert(para1: jint; para2: JLString): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLObject): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: Arr1jchar; para3: jint; para4: jint): JLAbstractStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar; para3: jint; para4: jint): JLAbstractStringBuilder; overload;    function replace(para1: jint; para2: jint; para3: JLString): JLAbstractStringBuilder; overload;
+    function deleteCharAt(para1: jint): JLAbstractStringBuilder; overload;
+    function appendCodePoint(para1: jint): JLAbstractStringBuilder; overload;
+    function delete(para1: jint; para2: jint): JLAbstractStringBuilder; overload;
+    function append(para1: jdouble): JLAbstractStringBuilder; overload;
+    function append(para1: jfloat): JLAbstractStringBuilder; overload;
+    function append(para1: jlong): JLAbstractStringBuilder; overload;
+    function append(para1: jint): JLAbstractStringBuilder; overload;
+    function append(para1: jchar): JLAbstractStringBuilder; overload;
+    function append(para1: jboolean): JLAbstractStringBuilder; overload;
+    function append(para1: Arr1jchar; para2: jint; para3: jint): JLAbstractStringBuilder; overload;
+
+    function append(var para1: array of jchar; para2: jint; para3: jint): JLAbstractStringBuilder; overload;    function append(para1: Arr1jchar): JLAbstractStringBuilder; overload;
+
+    function append(var para1: array of jchar): JLAbstractStringBuilder; overload;    function append(para1: JLCharSequence; para2: jint; para3: jint): JLAbstractStringBuilder; overload;
+    function append(para1: JLCharSequence): JLAbstractStringBuilder; overload;
+    function append(para1: JLStringBuffer): JLAbstractStringBuilder; overload;
+    function append(para1: JLString): JLAbstractStringBuilder; overload;
+    function append(para1: JLObject): JLAbstractStringBuilder; overload;
+    function append(para1: jchar): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: JLCharSequence; para2: jint; para3: jint): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: JLCharSequence): JLAppendable; overload;  // throws java.io.IOException
+  end;
+
+  JLStringBuilder = class sealed external 'java.lang' name 'StringBuilder' (JLAbstractStringBuilder, JISerializable, JLCharSequence)
+  public
+    constructor create(); overload;
+    constructor create(para1: jint); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: JLCharSequence); overload;
+    function append(para1: JLObject): JLStringBuilder; overload;
+    function append(para1: JLString): JLStringBuilder; overload;
+    function append(para1: JLStringBuffer): JLStringBuilder; overload;
+    function append(para1: JLCharSequence): JLStringBuilder; overload;
+    function append(para1: JLCharSequence; para2: jint; para3: jint): JLStringBuilder; overload;
+    function append(para1: Arr1jchar): JLStringBuilder; overload;
+
+    function append(var para1: array of jchar): JLStringBuilder; overload;    function append(para1: Arr1jchar; para2: jint; para3: jint): JLStringBuilder; overload;
+
+    function append(var para1: array of jchar; para2: jint; para3: jint): JLStringBuilder; overload;    function append(para1: jboolean): JLStringBuilder; overload;
+    function append(para1: jchar): JLStringBuilder; overload;
+    function append(para1: jint): JLStringBuilder; overload;
+    function append(para1: jlong): JLStringBuilder; overload;
+    function append(para1: jfloat): JLStringBuilder; overload;
+    function append(para1: jdouble): JLStringBuilder; overload;
+    function appendCodePoint(para1: jint): JLStringBuilder; overload;
+    function delete(para1: jint; para2: jint): JLStringBuilder; overload;
+    function deleteCharAt(para1: jint): JLStringBuilder; overload;
+    function replace(para1: jint; para2: jint; para3: JLString): JLStringBuilder; overload;
+    function insert(para1: jint; para2: Arr1jchar; para3: jint; para4: jint): JLStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar; para3: jint; para4: jint): JLStringBuilder; overload;    function insert(para1: jint; para2: JLObject): JLStringBuilder; overload;
+    function insert(para1: jint; para2: JLString): JLStringBuilder; overload;
+    function insert(para1: jint; para2: Arr1jchar): JLStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar): JLStringBuilder; overload;    function insert(para1: jint; para2: JLCharSequence): JLStringBuilder; overload;
+    function insert(para1: jint; para2: JLCharSequence; para3: jint; para4: jint): JLStringBuilder; overload;
+    function insert(para1: jint; para2: jboolean): JLStringBuilder; overload;
+    function insert(para1: jint; para2: jchar): JLStringBuilder; overload;
+    function insert(para1: jint; para2: jint): JLStringBuilder; overload;
+    function insert(para1: jint; para2: jlong): JLStringBuilder; overload;
+    function insert(para1: jint; para2: jfloat): JLStringBuilder; overload;
+    function insert(para1: jint; para2: jdouble): JLStringBuilder; overload;
+    function indexOf(para1: JLString): jint; overload;
+    function indexOf(para1: JLString; para2: jint): jint; overload;
+    function lastIndexOf(para1: JLString): jint; overload;
+    function lastIndexOf(para1: JLString; para2: jint): jint; overload;
+    function reverse(): JLStringBuilder; overload;
+    function toString(): JLString; overload;
+    function reverse(): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jdouble): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jfloat): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jlong): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jint): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jchar): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: jboolean): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLCharSequence; para3: jint; para4: jint): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLCharSequence): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: Arr1jchar): JLAbstractStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar): JLAbstractStringBuilder; overload;    function insert(para1: jint; para2: JLString): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: JLObject): JLAbstractStringBuilder; overload;
+    function insert(para1: jint; para2: Arr1jchar; para3: jint; para4: jint): JLAbstractStringBuilder; overload;
+
+    function insert(para1: jint; var para2: array of jchar; para3: jint; para4: jint): JLAbstractStringBuilder; overload;    function substring(para1: jint; para2: jint): JLString; overload;
+    function subSequence(para1: jint; para2: jint): JLCharSequence; overload;
+    function substring(para1: jint): JLString; overload;
+    function replace(para1: jint; para2: jint; para3: JLString): JLAbstractStringBuilder; overload;
+    function deleteCharAt(para1: jint): JLAbstractStringBuilder; overload;
+    function appendCodePoint(para1: jint): JLAbstractStringBuilder; overload;
+    function delete(para1: jint; para2: jint): JLAbstractStringBuilder; overload;
+    function append(para1: jdouble): JLAbstractStringBuilder; overload;
+    function append(para1: jfloat): JLAbstractStringBuilder; overload;
+    function append(para1: jlong): JLAbstractStringBuilder; overload;
+    function append(para1: jint): JLAbstractStringBuilder; overload;
+    function append(para1: jchar): JLAbstractStringBuilder; overload;
+    function append(para1: jboolean): JLAbstractStringBuilder; overload;
+    function append(para1: Arr1jchar; para2: jint; para3: jint): JLAbstractStringBuilder; overload;
+
+    function append(var para1: array of jchar; para2: jint; para3: jint): JLAbstractStringBuilder; overload;    function append(para1: Arr1jchar): JLAbstractStringBuilder; overload;
+
+    function append(var para1: array of jchar): JLAbstractStringBuilder; overload;    function append(para1: JLCharSequence; para2: jint; para3: jint): JLAbstractStringBuilder; overload;
+    function append(para1: JLCharSequence): JLAbstractStringBuilder; overload;
+    function append(para1: JLStringBuffer): JLAbstractStringBuilder; overload;
+    function append(para1: JLString): JLAbstractStringBuilder; overload;
+    function append(para1: JLObject): JLAbstractStringBuilder; overload;
+    procedure setCharAt(para1: jint; para2: jchar); overload;
+    procedure getChars(para1: jint; para2: jint; para3: Arr1jchar; para4: jint); overload;
+
+    procedure getChars(para1: jint; para2: jint; var para3: array of jchar; para4: jint); overload;    function offsetByCodePoints(para1: jint; para2: jint): jint; overload;
+    function codePointCount(para1: jint; para2: jint): jint; overload;
+    function codePointBefore(para1: jint): jint; overload;
+    function codePointAt(para1: jint): jint; overload;
+    function charAt(para1: jint): jchar; overload;
+    procedure setLength(para1: jint); overload;
+    procedure trimToSize(); overload;
+    procedure ensureCapacity(para1: jint); overload;
+    function capacity(): jint; overload;
+    function length(): jint; overload;
+    function append(para1: jchar): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: JLCharSequence; para2: jint; para3: jint): JLAppendable; overload;  // throws java.io.IOException
+    function append(para1: JLCharSequence): JLAppendable; overload;  // throws java.io.IOException
+  end;
+
+  JLLinkageError = class external 'java.lang' name 'LinkageError' (JLError)
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+  end;
+
+  JLRuntimeException = class external 'java.lang' name 'RuntimeException' (JLException)
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: JLString; para2: JLThrowable); overload;
+    constructor create(para1: JLThrowable); overload;
+  end;
+
+  JLIllegalArgumentException = class external 'java.lang' name 'IllegalArgumentException' (JLRuntimeException)
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+    constructor create(para1: JLString; para2: JLThrowable); overload;
+    constructor create(para1: JLThrowable); overload;
+  end;
+
+  JLIndexOutOfBoundsException = class external 'java.lang' name 'IndexOutOfBoundsException' (JLRuntimeException)
+  public
+    constructor create(); overload;
+    constructor create(para1: JLString); overload;
+  end;
+

rtl/java/java_sysh.inc

@@ -0,0 +1,188 @@
+{ Imports for Java packages/classes: java.io.Serializable, java.lang.AbstractStringBuilder, java.lang.Appendable, java.lang.CharSequence, java.lang.Character, java.lang.Cloneable, java.lang.Comparable, java.lang.Double, java.lang.Error, java.lang.Exception, java.lang.Float, java.lang.IllegalArgumentException, java.lang.IndexOutOfBoundsException, java.lang.LinkageError, java.lang.Number, java.lang.Object, java.lang.RuntimeException, java.lang.String, java.lang.StringBuffer, java.lang.StringBuilder, java.lang.System, java.lang.Throwable, java.text.Collator, java.util.Comparator }
+type
+  JLStringBuffer = class;
+  Arr1JLStringBuffer = array of JLStringBuffer;
+  Arr2JLStringBuffer = array of Arr1JLStringBuffer;
+  Arr3JLStringBuffer = array of Arr2JLStringBuffer;
+
+  JLObject = class;
+  Arr1JLObject = array of JLObject;
+  Arr2JLObject = array of Arr1JLObject;
+  Arr3JLObject = array of Arr2JLObject;
+
+  JLThrowable = class;
+  Arr1JLThrowable = array of JLThrowable;
+  Arr2JLThrowable = array of Arr1JLThrowable;
+  Arr3JLThrowable = array of Arr2JLThrowable;
+
+  JLStringBuilder = class;
+  Arr1JLStringBuilder = array of JLStringBuilder;
+  Arr2JLStringBuilder = array of Arr1JLStringBuilder;
+  Arr3JLStringBuilder = array of Arr2JLStringBuilder;
+
+  JLAbstractStringBuilder = class;
+  Arr1JLAbstractStringBuilder = array of JLAbstractStringBuilder;
+  Arr2JLAbstractStringBuilder = array of Arr1JLAbstractStringBuilder;
+  Arr3JLAbstractStringBuilder = array of Arr2JLAbstractStringBuilder;
+
+  JLLinkageError = class;
+  Arr1JLLinkageError = array of JLLinkageError;
+  Arr2JLLinkageError = array of Arr1JLLinkageError;
+  Arr3JLLinkageError = array of Arr2JLLinkageError;
+
+  JLError = class;
+  Arr1JLError = array of JLError;
+  Arr2JLError = array of Arr1JLError;
+  Arr3JLError = array of Arr2JLError;
+
+  JLNumber = class;
+  Arr1JLNumber = array of JLNumber;
+  Arr2JLNumber = array of Arr1JLNumber;
+  Arr3JLNumber = array of Arr2JLNumber;
+
+  JLException = class;
+  Arr1JLException = array of JLException;
+  Arr2JLException = array of Arr1JLException;
+  Arr3JLException = array of Arr2JLException;
+
+  JLIndexOutOfBoundsException = class;
+  Arr1JLIndexOutOfBoundsException = array of JLIndexOutOfBoundsException;
+  Arr2JLIndexOutOfBoundsException = array of Arr1JLIndexOutOfBoundsException;
+  Arr3JLIndexOutOfBoundsException = array of Arr2JLIndexOutOfBoundsException;
+
+  JLCharacter = class;
+  Arr1JLCharacter = array of JLCharacter;
+  Arr2JLCharacter = array of Arr1JLCharacter;
+  Arr3JLCharacter = array of Arr2JLCharacter;
+
+  JLDouble = class;
+  Arr1JLDouble = array of JLDouble;
+  Arr2JLDouble = array of Arr1JLDouble;
+  Arr3JLDouble = array of Arr2JLDouble;
+
+  JTCollator = class;
+  Arr1JTCollator = array of JTCollator;
+  Arr2JTCollator = array of Arr1JTCollator;
+  Arr3JTCollator = array of Arr2JTCollator;
+
+  JLIllegalArgumentException = class;
+  Arr1JLIllegalArgumentException = array of JLIllegalArgumentException;
+  Arr2JLIllegalArgumentException = array of Arr1JLIllegalArgumentException;
+  Arr3JLIllegalArgumentException = array of Arr2JLIllegalArgumentException;
+
+  JLString = class;
+  Arr1JLString = array of JLString;
+  Arr2JLString = array of Arr1JLString;
+  Arr3JLString = array of Arr2JLString;
+
+  JLFloat = class;
+  Arr1JLFloat = array of JLFloat;
+  Arr2JLFloat = array of Arr1JLFloat;
+  Arr3JLFloat = array of Arr2JLFloat;
+
+  JLSystem = class;
+  Arr1JLSystem = array of JLSystem;
+  Arr2JLSystem = array of Arr1JLSystem;
+  Arr3JLSystem = array of Arr2JLSystem;
+
+  JLRuntimeException = class;
+  Arr1JLRuntimeException = array of JLRuntimeException;
+  Arr2JLRuntimeException = array of Arr1JLRuntimeException;
+  Arr3JLRuntimeException = array of Arr2JLRuntimeException;
+
+  JLCharSequence = interface;
+  Arr1JLCharSequence = array of JLCharSequence;
+  Arr2JLCharSequence = array of Arr1JLCharSequence;
+  Arr3JLCharSequence = array of Arr2JLCharSequence;
+
+  JLCloneable = interface;
+  Arr1JLCloneable = array of JLCloneable;
+  Arr2JLCloneable = array of Arr1JLCloneable;
+  Arr3JLCloneable = array of Arr2JLCloneable;
+
+  JUComparator = interface;
+  Arr1JUComparator = array of JUComparator;
+  Arr2JUComparator = array of Arr1JUComparator;
+  Arr3JUComparator = array of Arr2JUComparator;
+
+  JLAppendable = interface;
+  Arr1JLAppendable = array of JLAppendable;
+  Arr2JLAppendable = array of Arr1JLAppendable;
+  Arr3JLAppendable = array of Arr2JLAppendable;
+
+  JISerializable = interface;
+  Arr1JISerializable = array of JISerializable;
+  Arr2JISerializable = array of Arr1JISerializable;
+  Arr3JISerializable = array of Arr2JISerializable;
+
+  JLComparable = interface;
+  Arr1JLComparable = array of JLComparable;
+  Arr2JLComparable = array of Arr1JLComparable;
+  Arr3JLComparable = array of Arr2JLComparable;
+
+  JLStackTraceElement = class external 'java.lang' name 'StackTraceElement';
+  Arr1JLStackTraceElement = array of JLStackTraceElement;
+  Arr2JLStackTraceElement = array of Arr1JLStackTraceElement;
+  Arr3JLStackTraceElement = array of Arr2JLStackTraceElement;
+
+  JTCollationKey = class external 'java.text' name 'CollationKey';
+  Arr1JTCollationKey = array of JTCollationKey;
+  Arr2JTCollationKey = array of Arr1JTCollationKey;
+  Arr3JTCollationKey = array of Arr2JTCollationKey;
+
+  JIPrintWriter = class external 'java.io' name 'PrintWriter';
+  Arr1JIPrintWriter = array of JIPrintWriter;
+  Arr2JIPrintWriter = array of Arr1JIPrintWriter;
+  Arr3JIPrintWriter = array of Arr2JIPrintWriter;
+
+  JUProperties = class external 'java.util' name 'Properties';
+  Arr1JUProperties = array of JUProperties;
+  Arr2JUProperties = array of Arr1JUProperties;
+  Arr3JUProperties = array of Arr2JUProperties;
+
+  JIInputStream = class external 'java.io' name 'InputStream';
+  Arr1JIInputStream = array of JIInputStream;
+  Arr2JIInputStream = array of Arr1JIInputStream;
+  Arr3JIInputStream = array of Arr2JIInputStream;
+
+  JIConsole = class external 'java.io' name 'Console';
+  Arr1JIConsole = array of JIConsole;
+  Arr2JIConsole = array of Arr1JIConsole;
+  Arr3JIConsole = array of Arr2JIConsole;
+
+  JLClass = class external 'java.lang' name 'Class';
+  Arr1JLClass = array of JLClass;
+  Arr2JLClass = array of Arr1JLClass;
+  Arr3JLClass = array of Arr2JLClass;
+
+  JULocale = class external 'java.util' name 'Locale';
+  Arr1JULocale = array of JULocale;
+  Arr2JULocale = array of Arr1JULocale;
+  Arr3JULocale = array of Arr2JULocale;
+
+  JLSecurityManager = class external 'java.lang' name 'SecurityManager';
+  Arr1JLSecurityManager = array of JLSecurityManager;
+  Arr2JLSecurityManager = array of Arr1JLSecurityManager;
+  Arr3JLSecurityManager = array of Arr2JLSecurityManager;
+
+  JNCCharset = class external 'java.nio.charset' name 'Charset';
+  Arr1JNCCharset = array of JNCCharset;
+  Arr2JNCCharset = array of Arr1JNCCharset;
+  Arr3JNCCharset = array of Arr2JNCCharset;
+
+  JIPrintStream = class external 'java.io' name 'PrintStream';
+  Arr1JIPrintStream = array of JIPrintStream;
+  Arr2JIPrintStream = array of Arr1JIPrintStream;
+  Arr3JIPrintStream = array of Arr2JIPrintStream;
+
+  JNCChannel = interface external 'java.nio.channels' name 'Channel';
+  Arr1JNCChannel = array of JNCChannel;
+  Arr2JNCChannel = array of Arr1JNCChannel;
+  Arr3JNCChannel = array of Arr2JNCChannel;
+
+  JUMap = interface external 'java.util' name 'Map';
+  Arr1JUMap = array of JUMap;
+  Arr2JUMap = array of Arr1JUMap;
+  Arr3JUMap = array of Arr2JUMap;
+
+

rtl/java/jdynarrh.inc

@@ -23,7 +23,7 @@ type
   TJCharArray = array of jchar;
   TJFloatArray = array of jfloat;
   TJDoubleArray = array of jdouble;
-  TJObjectArray = array of tobject;
+  TJObjectArray = array of JLObject;
 
 const
   FPCJDynArrTypeJByte   = 'B';

rtl/java/system.pp

@@ -87,38 +87,13 @@ const
 
   maxint   = maxsmallint;
 
-type
-  { Java base class type }
-  TObject = class external 'java.lang' name 'Object'
-   protected
-    function clone: TObject;
-   public
-    constructor create;
-    function equals(obj: TObject): boolean;
-    function hashcode: longint;
-  end;
-  TJLObject = TObject;
 
-  TJISerializable = interface external 'java.lang' name 'Serializable'
-  end;
-
-  TJLThrowable = class external 'java.lang' name 'Throwable' (TObject,TJISerializable)
-    constructor create;
-  end;
+{ Java base class type }
+{$i java_sysh.inc}
+{$i java_sys.inc}
 
-  { Java Float class type }
-  TJFloat = class external 'java.lang' name 'Float'
-   constructor create(f: jfloat);
-   class function floatToRawIntBits(f: jfloat): jint; static;
-   class function intBitsToFloat(j: jint): jfloat; static;
-  end;
-
-  { Java Dloat class type }
-  TJDouble = class external 'java.lang' name 'Double'
-   constructor create(d: jdouble);
-   class function doubleToRawLongBits(d: jdouble): jlong; static;
-   class function longBitsToDouble(l: jlong): jdouble; static;
-  end;
+type
+  TObject = JLObject;
 
 {$i innr.inc}
 {$i jmathh.inc}