+ generate java.lang.Enum descendant classes for Pascal enum types

   o these classes get an "enum" flag in the class files
   o these classes get a class field (whose type is that same enum
     class) per enum in the type, which also gets the "enum" flag
   o those class fields are initialised in the class constructor
     with the name of the enum and their order in the declaration
   o if the enum has jumps in FPC (lowest value is not 0, or not
     all values are contiguous), then we add an extra field
     to hold the FPC ordinal value of the enum
   o these classes get a class field valled $VALUES that contains
     a reference to the aforementioned class fields in order of
     declaration (= ordinal->instance mapping, JDK-mandated)
   o apart from the JDK-mandated instance methods (values, valueOf),
     also add FPCOrdinal (returns FPC ordinal value; same as order
     of declaration in case of no jumps) instance method and FPCValueOf
     (returns enum corresponding to FPC ordinal value) static class
     method
   o the mapping between FPC ordinals and enum instances in case of
     jumps is stored in a hashmap whose size is the next prime number
     greater or equal than the number of enum elements
   o moved several extra JDK types to the system unit for the enum
     support, and for future boxing and Java set support
   o several new synthetic method identifiers to generate the enum class
     methods/constructor/class constructor
   o enums with jumps are ordered by FPC ordinal value in the JVM
     $VALUES array so that the java.lang.Enum.doCompare() method
     will properly compare them

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

compiler/agjasmin.pas

@@ -572,6 +572,8 @@ implementation
                           AsmWrite('final ');
                         if toplevelowner.symtabletype=globalsymtable then
                           AsmWrite('public ');
+                        if (oo_is_enum_class in tobjectdef(obj).objectoptions) then
+                          AsmWrite('enum ');
                         AsmWriteln(obj.jvm_full_typename(true));
                         superclass:=tobjectdef(obj).childof;
                       end;
@@ -598,6 +600,10 @@ implementation
                   AsmWrite(superclass.import_lib^+'/');
                 AsmWriteln(superclass.objextname^);
               end;
+            { signature for enum classes (must come after superclass) }
+            if (obj.typ=objectdef) and
+               (oo_is_enum_class in tobjectdef(obj).objectoptions) then
+              AsmWriteln('.signature "Ljava/lang/Enum<'+obj.jvm_full_typename(true)+';>;"');
             { implemented interfaces }
             if (obj.typ=objectdef) and
                assigned(tobjectdef(obj).ImplementedInterfaces) then
@@ -828,6 +834,16 @@ implementation
           result:=result+'final ';
         if sp_internal in sym.symoptions then
           result:=result+'synthetic ';
+        { mark the class fields of enum classes that contain the initialised
+          enum instances as "enum" (recognise them by the fact that their type
+          is the same as their parent class, and that this parent class is
+          marked as oo_is_enum_class) }
+        if assigned(sym.owner.defowner) and
+           (tdef(sym.owner.defowner).typ=objectdef) and
+           (oo_is_enum_class in tobjectdef(sym.owner.defowner).objectoptions) and
+           (sym.typ=staticvarsym) and
+           (tstaticvarsym(sym).vardef=tdef(sym.owner.defowner)) then
+          result:=result+'enum ';
         result:=result+jvmmangledbasename(sym,true);
       end;
 

compiler/cutils.pas

@@ -52,6 +52,8 @@ interface
     {# Return @var(b) with the bit order reversed }
     function reverse_byte(b: byte): byte;
 
+    function next_prime(l: longint): longint;
+
     function used_align(varalign,minalign,maxalign:shortint):shortint;
     function isbetteralignedthan(new, org, limit: cardinal): boolean;
     function size_2_align(len : longint) : shortint;
@@ -317,6 +319,33 @@ implementation
       end;
 
 
+    function next_prime(l: longint): longint;
+      var
+        check, checkbound: longint;
+        ok: boolean;
+      begin
+        result:=l or 1;
+        while l<high(longint) do
+          begin
+            ok:=true;
+            checkbound:=trunc(sqrt(l));
+            check:=3;
+            while check<checkbound do
+              begin
+                if (l mod check) = 0 then
+                  begin
+                    ok:=false;
+                    break;
+                  end;
+                inc(check,2);
+              end;
+            if ok then
+              exit;
+            inc(l);
+          end;
+      end;
+
+
     function used_align(varalign,minalign,maxalign:shortint):shortint;
       begin
         { varalign  : minimum alignment required for the variable

compiler/ngenutil.pas

@@ -278,13 +278,15 @@ implementation
                     pd.struct.tcinitcode:=nil;
                   end;
                 psym:=tsym(pd.struct.symtable.find('FPC_INIT_TYPED_CONSTS_HELPER'));
-                if not assigned(psym) or
-                   (psym.typ<>procsym) or
-                   (tprocsym(psym).procdeflist.count<>1) then
-                  internalerror(2011040301);
-                tcinitproc:=tprocdef(tprocsym(psym).procdeflist[0]);
-                addstatement(stat,ccallnode.create(nil,tprocsym(psym),
-                  pd.struct.symtable,nil,[]));
+                if assigned(psym) then
+                  begin
+                    if (psym.typ<>procsym) or
+                       (tprocsym(psym).procdeflist.count<>1) then
+                      internalerror(2011040301);
+                    tcinitproc:=tprocdef(tprocsym(psym).procdeflist[0]);
+                    addstatement(stat,ccallnode.create(nil,tprocsym(psym),
+                      pd.struct.symtable,nil,[]));
+                  end;
                 addstatement(stat,result);
                 result:=block
               end;

compiler/pdecobj.pas

@@ -1299,6 +1299,8 @@ implementation
                         java_ansistring:=current_objectdef
                       else if (current_objectdef.objname^='SHORTSTRINGCLASS') then
                         java_shortstring:=current_objectdef
+                      else if (current_objectdef.objname^='JLENUM') then
+                        java_jlenum:=current_objectdef
                     end;
                 end;
               end;

compiler/pdecvar.pas

@@ -53,7 +53,7 @@ implementation
        globtype,globals,tokens,verbose,constexp,
        systems,
        { symtable }
-       symconst,symbase,symtype,symtable,defutil,defcmp,
+       symconst,symbase,symtype,symtable,defutil,defcmp,symcreat,
 {$ifdef jvm}
        jvmdef,
 {$endif}
@@ -1372,7 +1372,7 @@ implementation
 {$endif}
 
              read_anon_type(hdef,false);
-             jvm_guarantee_record_typesym(hdef,symtablestack.top);
+             maybe_guarantee_record_typesym(hdef,symtablestack.top);
              for i:=0 to sc.count-1 do
                begin
                  vs:=tabstractvarsym(sc[i]);
@@ -1587,7 +1587,7 @@ implementation
                  symtablestack.pop(recst);
                end;
              read_anon_type(hdef,false);
-             jvm_guarantee_record_typesym(hdef,symtablestack.top);
+             maybe_guarantee_record_typesym(hdef,symtablestack.top);
              block_type:=bt_var;
              { allow only static fields reference to struct where they are declared }
              if not (vd_class in options) and

compiler/pjvm.pas

@@ -27,7 +27,8 @@ unit pjvm;
 interface
 
     uses
-     symtype,symbase,symdef;
+      globtype,
+      symtype,symbase,symdef;
 
     { the JVM specs require that you add a default parameterless
       constructor in case the programmer hasn't specified any }
@@ -38,13 +39,13 @@ interface
       to initialse dynamic arrays }
     procedure add_java_default_record_methods_intf(def: trecorddef);
 
-    procedure jvm_guarantee_record_typesym(var def: tdef; st: tsymtable);
+    procedure jvm_maybe_create_enum_class(const name: TIDString; def: tdef);
+
 
 
 implementation
 
   uses
-    globtype,
     cutils,cclasses,
     verbose,systems,
     fmodule,
@@ -195,20 +196,137 @@ implementation
       end;
 
 
-    procedure jvm_guarantee_record_typesym(var def: tdef; st: tsymtable);
+    procedure jvm_maybe_create_enum_class(const name: TIDString; def: tdef);
       var
-        ts: ttypesym;
+        arrdef: tarraydef;
+        arrsym: ttypesym;
+        juhashmap: tdef;
+        enumclass: tobjectdef;
+        pd: tprocdef;
+        old_current_structdef: tabstractrecorddef;
+        i: longint;
+        sym: tstaticvarsym;
+        fsym: tfieldvarsym;
+        sstate: symcreat.tscannerstate;
+        sl: tpropaccesslist;
       begin
-        { create a dummy typesym for the JVM target, because the record
-          has to be wrapped by a class }
-        if (target_info.system=system_jvm_java32) and
-           (def.typ=recorddef) and
-           not assigned(def.typesym) then
+        { if it's a subrange type, don't create a new class }
+        if assigned(tenumdef(def).basedef) then
+          exit;
+        replace_scanner('jvm_enum_class',sstate);
+        { create new class (different internal name than enum to prevent name clash) }
+        enumclass:=tobjectdef.create(odt_javaclass,'$'+name+'$InternEnum',java_jlenum);
+        tenumdef(def).classdef:=enumclass;
+        include(enumclass.objectoptions,oo_is_enum_class);
+        include(enumclass.objectoptions,oo_is_sealed);
+        { create an alias for this type inside itself: this way we can choose a
+          name that can be used in generated Pascal code without risking an
+          identifier conflict (since it is local to this class; the global name
+          is unique because it's an identifier that contains $-signs) }
+        enumclass.symtable.insert(ttypesym.create('__FPC_TEnumClassAlias',enumclass));
+        { also create an alias for the enum type so that we can iterate over
+          all enum values when creating the body of the class constructor }
+        enumclass.symtable.insert(ttypesym.create('__FPC_TEnumAlias',def));
+        { but the name of the class as far as the JVM is concerned will match
+          the enum's original name (the enum type itself won't be output in
+          any class file, so no conflict there) }
+        enumclass.objextname:=stringdup(name);
+        { now add a bunch of extra things to the enum class }
+        old_current_structdef:=current_structdef;
+        current_structdef:=enumclass;
+        symtablestack.push(enumclass.symtable);
+        { create static fields representing all enums }
+        for i:=0 to tenumdef(def).symtable.symlist.count-1 do
           begin
-            ts:=ttypesym.create(trecorddef(def).symtable.realname^,def);
-            st.insert(ts);
-            ts.visibility:=vis_strictprivate;
+            sym:=tstaticvarsym.create(tenumsym(tenumdef(def).symtable.symlist[i]).realname,vs_final,enumclass,[]);
+            enumclass.symtable.insert(sym);
+            { alias for consistency with parsed staticvarsyms }
+            sl:=tpropaccesslist.create;
+            sl.addsym(sl_load,sym);
+            enumclass.symtable.insert(tabsolutevarsym.create_ref('$'+internal_static_field_name(sym.name),enumclass,sl));
           end;
+        { create local "array of enumtype" type for the "values" functionality
+          (used internally by the JDK) }
+        arrdef:=tarraydef.create(0,tenumdef(def).symtable.symlist.count-1,s32inttype);
+        arrdef.elementdef:=enumclass;
+        arrsym:=ttypesym.create('__FPC_TEnumValues',arrdef);
+        enumclass.symtable.insert(arrsym);
+        { insert "public static values: array of enumclass" that returns $VALUES.clone()
+          (rather than a dynamic array and using clone --which we don't support yet for arrays--
+           simply use a fixed length array and copy it) }
+        if not str_parse_method_dec('function values: __FPC_TEnumValues;',potype_function,true,enumclass,pd) then
+          internalerror(2011062301);
+        include(pd.procoptions,po_staticmethod);
+        pd.synthetickind:=tsk_jvm_enum_values;
+        { do we have to store the ordinal value separately? (if no jumps, we can
+          just call the default ordinal() java.lang.Enum function) }
+        if tenumdef(def).has_jumps then
+          begin
+            { add field for the value }
+            fsym:=tfieldvarsym.create('__fpc_fenumval',vs_final,s32inttype,[]);
+            enumclass.symtable.insert(fsym);
+            tobjectsymtable(enumclass.symtable).addfield(fsym,vis_strictprivate);
+            { add class field with hash table that maps from FPC-declared ordinal value -> enum instance }
+            juhashmap:=search_system_type('JUHASHMAP').typedef;
+            sym:=tstaticvarsym.create('__fpc_ord2enum',vs_final,juhashmap,[]);
+            enumclass.symtable.insert(sym);
+            { alias for consistency with parsed staticvarsyms }
+            sl:=tpropaccesslist.create;
+            sl.addsym(sl_load,sym);
+            enumclass.symtable.insert(tabsolutevarsym.create_ref('$'+internal_static_field_name(sym.name),enumclass,sl));
+            { add custom constructor }
+            if not str_parse_method_dec('constructor Create(const __fpc_name: JLString; const __fpc_ord, __fpc_initenumval: longint);',potype_constructor,false,enumclass,pd) then
+              internalerror(2011062401);
+            pd.synthetickind:=tsk_jvm_enum_jumps_constr;
+            pd.visibility:=vis_strictprivate;
+          end
+        else
+          begin
+            { insert "private constructor(string,int,int)" that calls inherited and
+              initialises the FPC value field }
+            add_missing_parent_constructors_intf(enumclass,vis_strictprivate);
+          end;
+        { add instance method to get the enum's value as declared in FPC }
+        if not str_parse_method_dec('function FPCOrdinal: longint;',potype_function,false,enumclass,pd) then
+          internalerror(2011062402);
+        pd.synthetickind:=tsk_jvm_enum_fpcordinal;
+        { add static class method to convert an ordinal to the corresponding enum }
+        if not str_parse_method_dec('function FPCValueOf(__fpc_int: longint): __FPC_TEnumClassAlias; static;',potype_function,true,enumclass,pd) then
+          internalerror(2011062402);
+        pd.synthetickind:=tsk_jvm_enum_fpcvalueof;
+
+        { insert "public static valueOf(string): tenumclass" that returns tenumclass(inherited valueOf(tenumclass,string)) }
+        if not str_parse_method_dec('function valueOf(const __fpc_str: JLString): __FPC_TEnumClassAlias; static;',potype_function,true,enumclass,pd) then
+          internalerror(2011062302);
+        include(pd.procoptions,po_staticmethod);
+        pd.synthetickind:=tsk_jvm_enum_valueof;
+        { create array called "$VALUES" that will contain a reference to all
+          enum instances (JDK convention)
+          Disable duplicate identifier checking when inserting, because it will
+          check for a conflict with "VALUES" ($<id> normally means "check for
+          <id> without uppercasing first"), which will conflict with the
+          "Values" instance method -- that's also the reason why we insert the
+          field only now, because we cannot disable duplicate identifier
+          checking when creating the "Values" method }
+        sym:=tstaticvarsym.create('$VALUES',vs_final,arrdef,[]);
+        sym.visibility:=vis_strictprivate;
+        enumclass.symtable.insert(sym,false);
+        { alias for consistency with parsed staticvarsyms }
+        sl:=tpropaccesslist.create;
+        sl.addsym(sl_load,sym);
+        enumclass.symtable.insert(tabsolutevarsym.create_ref('$'+internal_static_field_name(sym.name),arrdef,sl));
+        { alias for accessing the field in generated Pascal code }
+        sl:=tpropaccesslist.create;
+        sl.addsym(sl_load,sym);
+        enumclass.symtable.insert(tabsolutevarsym.create_ref('__fpc_FVALUES',arrdef,sl));
+        { add initialization of the static class fields created above }
+        if not str_parse_method_dec('constructor fpc_enum_class_constructor;',potype_class_constructor,true,enumclass,pd) then
+          internalerror(2011062303);
+        pd.synthetickind:=tsk_jvm_enum_classconstr;
+
+        symtablestack.pop(enumclass.symtable);
+        current_structdef:=old_current_structdef;
+        restore_scanner(sstate);
       end;
 
 end.

compiler/ptype.pas

@@ -1544,6 +1544,9 @@ implementation
                 until not try_to_consume(_COMMA);
                 def:=aktenumdef;
                 consume(_RKLAMMER);
+{$ifdef jvm}
+                jvm_maybe_create_enum_class(name,def);
+{$endif}
               end;
             _ARRAY:
               begin

compiler/symconst.pas

@@ -381,7 +381,8 @@ type
     oo_is_formal,         { the class is only formally defined in this module (x = objcclass; external [name 'x'];) }
     oo_is_classhelper,    { objcclasses that represent categories, and Delpi-style class helpers, are marked like this }
     oo_has_class_constructor, { the object/class has a class constructor }
-    oo_has_class_destructor   { the object/class has a class destructor  }
+    oo_has_class_destructor,  { the object/class has a class destructor  }
+    oo_is_enum_class      { the class represents an enum (JVM) }
   );
   tobjectoptions=set of tobjectoption;
 

compiler/symcreat.pas

@@ -28,7 +28,8 @@ interface
 
   uses
     finput,tokens,scanner,globtype,
-    symconst,symbase,symtype,symdef;
+    aasmdata,
+    symconst,symbase,symtype,symdef,symsym;
 
 
   type
@@ -94,19 +95,20 @@ interface
   { finalises the parentfpstruct (alignment padding, ...) }
   procedure finish_parentfpstruct(pd: tprocdef);
 
+  procedure maybe_guarantee_record_typesym(var def: tdef; st: tsymtable);
 
 implementation
 
   uses
-    cutils,globals,verbose,systems,comphook,fmodule,
-    symsym,symtable,defutil,
-    pbase,pdecobj,pdecsub,psub,
+    cutils,cclasses,globals,verbose,systems,comphook,fmodule,
+    symtable,defutil,
+    pbase,pdecobj,pdecsub,psub,ptconst,
+{$ifdef jvm}
+    pjvm,
+{$endif jvm}
     node,nbas,nld,nmem,
     defcmp,
-    paramgr
-    {$ifdef jvm}
-    ,pjvm
-    {$endif};
+    paramgr;
 
   procedure replace_scanner(const tempname: string; out sstate: tscannerstate);
     var
@@ -356,6 +358,116 @@ implementation
     end;
 
 
+  procedure implement_jvm_enum_values(pd: tprocdef);
+    begin
+      str_parse_method_impl('begin result:=__fpc_FVALUES end;',pd,true);
+    end;
+
+
+  procedure implement_jvm_enum_valuof(pd: tprocdef);
+    begin
+      str_parse_method_impl('begin result:=__FPC_TEnumClassAlias(inherited valueOf(JLClass(__FPC_TEnumClassAlias),__fpc_str)) end;',pd,true);
+    end;
+
+
+  procedure implement_jvm_enum_jumps_constr(pd: tprocdef);
+    begin
+      str_parse_method_impl('begin inherited create(__fpc_name,__fpc_ord); __fpc_fenumval:=__fpc_initenumval end;',pd,false);
+    end;
+
+
+  procedure implement_jvm_enum_fpcordinal(pd: tprocdef);
+    var
+      enumclass: tobjectdef;
+      enumdef: tenumdef;
+    begin
+      enumclass:=tobjectdef(pd.owner.defowner);
+      enumdef:=tenumdef(ttypesym(search_struct_member(enumclass,'__FPC_TENUMALIAS')).typedef);
+      if not enumdef.has_jumps then
+        str_parse_method_impl('begin result:=ordinal end;',pd,false)
+      else
+        str_parse_method_impl('begin result:=__fpc_fenumval end;',pd,false);
+    end;
+
+
+  procedure implement_jvm_enum_fpcvalueof(pd: tprocdef);
+    var
+      enumclass: tobjectdef;
+      enumdef: tenumdef;
+    begin
+      enumclass:=tobjectdef(pd.owner.defowner);
+      enumdef:=tenumdef(ttypesym(search_struct_member(enumclass,'__FPC_TENUMALIAS')).typedef);
+      { convert integer to corresponding enum instance: in case of no jumps
+        get it from the $VALUES array, otherwise from the __fpc_ord2enum
+        hashmap }
+      if not enumdef.has_jumps then
+        str_parse_method_impl('begin result:=__fpc_FVALUES[__fpc_int] end;',pd,false)
+      else
+        str_parse_method_impl('begin result:=__FPC_TEnumClassAlias(__fpc_ord2enum.get(JLInteger.valueOf(__fpc_int))) end;',pd,true);
+    end;
+
+
+  function CompareEnumSyms(Item1, Item2: Pointer): Integer;
+    var
+      I1 : tenumsym absolute Item1;
+      I2 : tenumsym absolute Item2;
+    begin
+      Result:=I1.value-I2.value;
+    end;
+
+
+  procedure implement_jvm_enum_classconstr(pd: tprocdef);
+    var
+      enumclass: tobjectdef;
+      enumdef: tenumdef;
+      str: ansistring;
+      i: longint;
+      enumsym: tenumsym;
+      classfield: tstaticvarsym;
+      orderedenums: tfpobjectlist;
+    begin
+      enumclass:=tobjectdef(pd.owner.defowner);
+      enumdef:=tenumdef(ttypesym(search_struct_member(enumclass,'__FPC_TENUMALIAS')).typedef);
+      if not assigned(enumdef) then
+        internalerror(2011062305);
+      str:='begin ';
+      if enumdef.has_jumps then
+        { init hashmap for ordinal -> enum instance mapping; don't let it grow,
+          and set the capacity to the next prime following the total number of
+          enum elements to minimise the number of collisions }
+        str:=str+'__fpc_ord2enum:=JUHashMap.Create('+tostr(next_prime(enumdef.symtable.symlist.count))+',1.0);';
+      { iterate over all enum elements and initialise the class fields, and
+        store them in the values array. Since the java.lang.Enum doCompare
+        method is final and hardcoded to compare based on declaration order
+        (= java.lang.Enum.ordinal() value), we have to create them in order of
+        ascending FPC ordinal values (which may not be the same as the FPC
+        declaration order in case of jumps }
+      orderedenums:=tfpobjectlist.create(false);
+      for i:=0 to enumdef.symtable.symlist.count-1 do
+        orderedenums.add(enumdef.symtable.symlist[i]);
+      if enumdef.has_jumps then
+        orderedenums.sort(@CompareEnumSyms);
+      for i:=0 to orderedenums.count-1 do
+        begin
+          enumsym:=tenumsym(orderedenums[i]);
+          classfield:=tstaticvarsym(search_struct_member(enumclass,enumsym.name));
+          if not assigned(classfield) then
+            internalerror(2011062306);
+          str:=str+classfield.name+':=__FPC_TEnumClassAlias.Create('''+enumsym.realname+''','+tostr(i);
+          if enumdef.has_jumps then
+            str:=str+','+tostr(enumsym.value);
+          str:=str+');';
+          { alias for $VALUES array used internally by the JDK, and also by FPC
+            in case of no jumps }
+          str:=str+'__fpc_FVALUES['+tostr(i)+']:='+classfield.name+';';
+          if enumdef.has_jumps then
+            str:=str+'__fpc_ord2enum.put(JLInteger.valueOf('+tostr(enumsym.value)+'),'+classfield.name+');';
+        end;
+      orderedenums.free;
+      str:=str+' end;';
+      str_parse_method_impl(str,pd,true);
+    end;
+
 
   procedure add_synthetic_method_implementations_for_struct(struct: tabstractrecorddef);
     var
@@ -382,6 +494,18 @@ implementation
             { special handling for this one is done in tnodeutils.wrap_proc_body }
             tsk_tcinit:
               implement_empty(pd);
+            tsk_jvm_enum_values:
+              implement_jvm_enum_values(pd);
+            tsk_jvm_enum_valueof:
+              implement_jvm_enum_valuof(pd);
+            tsk_jvm_enum_classconstr:
+              implement_jvm_enum_classconstr(pd);
+            tsk_jvm_enum_jumps_constr:
+              implement_jvm_enum_jumps_constr(pd);
+            tsk_jvm_enum_fpcordinal:
+              implement_jvm_enum_fpcordinal(pd);
+            tsk_jvm_enum_fpcvalueof:
+              implement_jvm_enum_fpcvalueof(pd);
             else
               internalerror(2011032801);
           end;
@@ -492,7 +616,7 @@ implementation
       nestedvarsst:=trecordsymtable.create(current_module.realmodulename^+'$$_fpc_nestedvars$'+tostr(pd.defid),current_settings.alignment.localalignmax);
       nestedvarsdef:=trecorddef.create(nestedvarsst.name^,nestedvarsst);
 {$ifdef jvm}
-      jvm_guarantee_record_typesym(nestedvarsdef,nestedvarsdef.owner);
+      maybe_guarantee_record_typesym(nestedvarsdef,nestedvarsdef.owner);
       { don't add clone/FpcDeepCopy, because the field names are not all
         representable in source form and we don't need them anyway }
       symtablestack.push(trecorddef(nestedvarsdef).symtable);
@@ -624,6 +748,21 @@ implementation
     end;
 
 
+  procedure maybe_guarantee_record_typesym(var def: tdef; st: tsymtable);
+    var
+      ts: ttypesym;
+    begin
+      { create a dummy typesym for the JVM target, because the record
+        has to be wrapped by a class }
+      if (target_info.system=system_jvm_java32) and
+         (def.typ=recorddef) and
+         not assigned(def.typesym) then
+        begin
+          ts:=ttypesym.create(trecorddef(def).symtable.realname^,def);
+          st.insert(ts);
+          ts.visibility:=vis_strictprivate;
+        end;
+    end;
 
 
 end.

compiler/symdef.pas

@@ -496,7 +496,13 @@ interface
          tsk_jvm_clone,             // Java-style clone method
          tsk_record_deepcopy,       // deepcopy for records field by field
          tsk_empty,                 // an empty routine
-         tsk_tcinit                 // initialisation of typed constants
+         tsk_tcinit,                // initialisation of typed constants
+         tsk_jvm_enum_values,       // Java "values" class method of JLEnum descendants
+         tsk_jvm_enum_valueof,      // Java "valueOf" class method of JLEnum descendants
+         tsk_jvm_enum_classconstr,  // Java class constructor for JLEnum descendants
+         tsk_jvm_enum_jumps_constr, // Java constructor for JLEnum descendants for enums with jumps
+         tsk_jvm_enum_fpcordinal,   // Java FPCOrdinal function that returns the enum's ordinal value from an FPC POV
+         tsk_jvm_enum_fpcvalueof    // Java FPCValueOf function that returns the enum instance corresponding to an ordinal from an FPC POV
        );
 
 {$ifdef oldregvars}
@@ -672,6 +678,11 @@ interface
           basedef   : tenumdef;
           basedefderef : tderef;
           symtable  : TSymtable;
+{$ifdef jvm}
+          { class representing this enum on the Java side }
+          classdef  : tobjectdef;
+          classdefderef : tderef;
+{$endif}
           has_jumps : boolean;
           constructor create;
           constructor create_subrange(_basedef:tenumdef;_min,_max:asizeint);
@@ -815,6 +826,8 @@ interface
        java_fpcbaserecordtype    : tobjectdef;
        { java.lang.String }
        java_jlstring             : tobjectdef;
+       { java.lang.Enum }
+       java_jlenum               : tobjectdef;
        { FPC java implementation of ansistrings }
        java_ansistring           : tobjectdef;
        { FPC java implementation of shortstrings }
@@ -1707,6 +1720,9 @@ implementation
          maxval:=ppufile.getaint;
          savesize:=ppufile.getaint;
          has_jumps:=false;
+{$ifdef jvm}
+        ppufile.getderef(classdefderef);
+{$endif}
          if df_copied_def in defoptions then
            begin
              symtable:=nil;
@@ -1742,6 +1758,9 @@ implementation
             tenumdef(result).symtable:=symtable.getcopy;
             tenumdef(result).basedef:=self;
           end;
+{$ifdef jvm}
+        tenumdef(result).classdef:=classdef;
+{$endif}
         tenumdef(result).has_jumps:=has_jumps;
         tenumdef(result).basedefderef:=basedefderef;
         include(tenumdef(result).defoptions,df_copied_def);
@@ -1832,6 +1851,9 @@ implementation
           basedefderef.build(basedef)
         else
           tenumsymtable(symtable).buildderef;
+{$ifdef jvm}
+        classdefderef.build(classdef);
+{$endif}
       end;
 
 
@@ -1845,6 +1867,9 @@ implementation
           end
         else
           tenumsymtable(symtable).deref;
+{$ifdef jvm}
+        classdef:=tobjectdef(classdefderef.resolve);
+{$endif}
       end;
 
 
@@ -1854,6 +1879,9 @@ implementation
          ppufile.putaint(min);
          ppufile.putaint(max);
          ppufile.putaint(savesize);
+{$ifdef jvm}
+         ppufile.putderef(classdefderef);
+{$endif}
          if df_copied_def in defoptions then
            ppufile.putderef(basedefderef);
          ppufile.writeentry(ibenumdef);
@@ -4923,6 +4951,8 @@ implementation
                java_ansistring:=self
              else if (objname^='SHORTSTRINGCLASS') then
                java_shortstring:=self
+             else if (objname^='JLENUM') then
+               java_jlenum:=self
            end;
          writing_class_record_dbginfo:=false;
        end;

compiler/utils/ppudump.pp

@@ -2132,6 +2132,10 @@ begin
              writeln(space,' Smallest element : ',getaint);
              writeln(space,'  Largest element : ',getaint);
              writeln(space,'             Size : ',getaint);
+{$ifdef jvm}
+             write(space,'        Class def : ');
+             readderef('');
+{$endif}
              if df_copied_def in defoptions then
                begin
                  write(space,'Base enumeration type : ');

rtl/java/java_sys.inc

@@ -40,6 +40,10 @@
     function compareTo(para1: JLObject): jint; overload;
   end;
 
+  JLIterable = interface external 'java.lang' name 'Iterable' 
+    function iterator(): JUIterator; overload;
+  end;
+
   JLSystem = class sealed external 'java.lang' name 'System' (JLObject)
   public
     final class var
@@ -343,6 +347,36 @@
     function equals(para1: JLObject): jboolean; overload;
   end;
 
+  JUMap = interface external 'java.util' name 'Map' 
+    type
+      InnerEntry = interface;
+      Arr1InnerEntry = array of InnerEntry;
+      Arr2InnerEntry = array of Arr1InnerEntry;
+      Arr3InnerEntry = array of Arr2InnerEntry;
+      InnerEntry = interface external 'java.util' name 'Map$Entry' 
+        function getKey(): JLObject; overload;
+        function getValue(): JLObject; overload;
+        function setValue(para1: JLObject): JLObject; overload;
+        function equals(para1: JLObject): jboolean; overload;
+        function hashCode(): jint; overload;
+      end;
+
+    function size(): jint; overload;
+    function isEmpty(): jboolean; overload;
+    function containsKey(para1: JLObject): jboolean; overload;
+    function containsValue(para1: JLObject): jboolean; overload;
+    function get(para1: JLObject): JLObject; overload;
+    function put(para1: JLObject; para2: JLObject): JLObject; overload;
+    function remove(para1: JLObject): JLObject; overload;
+    procedure putAll(para1: JUMap); overload;
+    procedure clear(); overload;
+    function keySet(): JUSet; overload;
+    function values(): JUCollection; overload;
+    function entrySet(): JUSet; overload;
+    function equals(para1: JLObject): jboolean; overload;
+    function hashCode(): jint; overload;
+  end;
+
   JLNumber = class abstract external 'java.lang' name 'Number' (JLObject, JISerializable)
   public
     constructor create(); overload;
@@ -436,6 +470,28 @@
     function append(para1: JLCharSequence): JLAppendable; overload; virtual;  // throws java.io.IOException
   end;
 
+  JLBoolean = class sealed external 'java.lang' name 'Boolean' (JLObject, JISerializable, JLComparable)
+  public
+    final class var
+      fTRUE: JLBoolean; external name 'TRUE';
+      fFALSE: JLBoolean; external name 'FALSE';
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    constructor create(para1: jboolean); overload;
+    constructor create(para1: JLString); overload;
+    class function parseBoolean(para1: JLString): jboolean; static; overload;
+    function booleanValue(): jboolean; overload; virtual;
+    class function valueOf(para1: jboolean): JLBoolean; static; overload;
+    class function valueOf(para1: JLString): JLBoolean; static; overload;
+    class function toString(para1: jboolean): JLString; static; overload;
+    function toString(): JLString; overload; virtual;
+    function hashCode(): jint; overload; virtual;
+    function equals(para1: JLObject): jboolean; overload; virtual;
+    class function getBoolean(para1: JLString): jboolean; static; overload;
+    function compareTo(para1: JLBoolean): jint; overload; virtual;
+    function compareTo(para1: JLObject): jint; overload; virtual;
+  end;
+
   JLCharacter = class sealed external 'java.lang' name 'Character' (JLObject, JISerializable, JLComparable)
   public
     type
@@ -760,6 +816,28 @@
     function compareTo(para1: JLObject): jint; overload; virtual;
   end;
 
+  JLEnum = class abstract external 'java.lang' name 'Enum' (JLObject, JLComparable, JISerializable)
+  public
+    function name(): JLString; overload; virtual; final;
+    function ordinal(): jint; overload; virtual; final;
+  strict protected
+    constructor create(para1: JLString; para2: jint); overload;
+  public
+    function toString(): JLString; overload; virtual;
+    function equals(para1: JLObject): jboolean; overload; virtual; final;
+    function hashCode(): jint; overload; virtual; final;
+  strict protected
+    function clone(): JLObject; overload; virtual; final;  // throws java.lang.CloneNotSupportedException
+  public
+    function compareTo(para1: JLEnum): jint; overload; virtual; final;
+    function getDeclaringClass(): JLClass; overload; virtual; final;
+    class function valueOf(para1: JLClass; para2: JLString): JLEnum; static; overload;
+  strict protected
+    procedure finalize(); overload; virtual; final;
+  public
+    function compareTo(para1: JLObject): jint; overload; virtual;
+  end;
+
   JLString = class sealed external 'java.lang' name 'String' (JLObject, JISerializable, JLComparable, JLCharSequence)
   public
     type
@@ -876,21 +954,40 @@
     function compareTo(para1: JLObject): jint; overload; virtual;
   end;
 
+  JUCollection = interface external 'java.util' name 'Collection' (JLIterable)
+    function size(): jint; overload;
+    function isEmpty(): jboolean; overload;
+    function contains(para1: JLObject): jboolean; overload;
+    function iterator(): JUIterator; overload;
+    function toArray(): Arr1JLObject; overload;
+    function toArray(para1: Arr1JLObject): Arr1JLObject; overload;
+    function toArray(var para1: array of JLObject): Arr1JLObject; overload;
+    function add(para1: JLObject): jboolean; overload;
+    function remove(para1: JLObject): jboolean; overload;
+    function containsAll(para1: JUCollection): jboolean; overload;
+    function addAll(para1: JUCollection): jboolean; overload;
+    function removeAll(para1: JUCollection): jboolean; overload;
+    function retainAll(para1: JUCollection): jboolean; overload;
+    procedure clear(); overload;
+    function equals(para1: JLObject): jboolean; overload;
+    function hashCode(): jint; overload;
+  end;
+
   JLClass = class sealed external 'java.lang' name 'Class' (JLObject, JISerializable, JLRGenericDeclaration, JLRType, JLRAnnotatedElement)
   public
     type
-      InnerEnclosingMethodInfo = class;
-      Arr1InnerEnclosingMethodInfo = array of InnerEnclosingMethodInfo;
-      Arr2InnerEnclosingMethodInfo = array of Arr1InnerEnclosingMethodInfo;
-      Arr3InnerEnclosingMethodInfo = array of Arr2InnerEnclosingMethodInfo;
       InnerMethodArray = class;
       Arr1InnerMethodArray = array of InnerMethodArray;
       Arr2InnerMethodArray = array of Arr1InnerMethodArray;
       Arr3InnerMethodArray = array of Arr2InnerMethodArray;
-      InnerEnclosingMethodInfo = class sealed external 'java.lang' name 'Class$EnclosingMethodInfo' 
+      InnerEnclosingMethodInfo = class;
+      Arr1InnerEnclosingMethodInfo = array of InnerEnclosingMethodInfo;
+      Arr2InnerEnclosingMethodInfo = array of Arr1InnerEnclosingMethodInfo;
+      Arr3InnerEnclosingMethodInfo = array of Arr2InnerEnclosingMethodInfo;
+      InnerMethodArray = class external 'java.lang' name 'Class$MethodArray' 
       end;
 
-      InnerMethodArray = class external 'java.lang' name 'Class$MethodArray' 
+      InnerEnclosingMethodInfo = class sealed external 'java.lang' name 'Class$EnclosingMethodInfo' 
       end;
 
   public
@@ -995,6 +1092,106 @@
     constructor create(); overload;
   end;
 
+  JUAbstractMap = class abstract external 'java.util' name 'AbstractMap' (JLObject, JUMap)
+  public
+    type
+      InnerSimpleImmutableEntry = class;
+      Arr1InnerSimpleImmutableEntry = array of InnerSimpleImmutableEntry;
+      Arr2InnerSimpleImmutableEntry = array of Arr1InnerSimpleImmutableEntry;
+      Arr3InnerSimpleImmutableEntry = array of Arr2InnerSimpleImmutableEntry;
+      InnerSimpleEntry = class;
+      Arr1InnerSimpleEntry = array of InnerSimpleEntry;
+      Arr2InnerSimpleEntry = array of Arr1InnerSimpleEntry;
+      Arr3InnerSimpleEntry = array of Arr2InnerSimpleEntry;
+      InnerSimpleImmutableEntry = class external 'java.util' name 'AbstractMap$SimpleImmutableEntry' (JLObject, JUMap.InnerEntry, JISerializable)
+      public
+        constructor create(para1: JLObject; para2: JLObject); overload;
+        constructor create(para1: JUMap.InnerEntry); overload;
+        function getKey(): JLObject; overload; virtual;
+        function getValue(): JLObject; overload; virtual;
+        function setValue(para1: JLObject): JLObject; overload; virtual;
+        function equals(para1: JLObject): jboolean; overload; virtual;
+        function hashCode(): jint; overload; virtual;
+        function toString(): JLString; overload; virtual;
+      end;
+
+      InnerSimpleEntry = class external 'java.util' name 'AbstractMap$SimpleEntry' (JLObject, JUMap.InnerEntry, JISerializable)
+      public
+        constructor create(para1: JLObject; para2: JLObject); overload;
+        constructor create(para1: JUMap.InnerEntry); overload;
+        function getKey(): JLObject; overload; virtual;
+        function getValue(): JLObject; overload; virtual;
+        function setValue(para1: JLObject): JLObject; overload; virtual;
+        function equals(para1: JLObject): jboolean; overload; virtual;
+        function hashCode(): jint; overload; virtual;
+        function toString(): JLString; overload; virtual;
+      end;
+
+  strict protected
+    constructor create(); overload;
+  public
+    function size(): jint; overload; virtual;
+    function isEmpty(): jboolean; overload; virtual;
+    function containsValue(para1: JLObject): jboolean; overload; virtual;
+    function containsKey(para1: JLObject): jboolean; overload; virtual;
+    function get(para1: JLObject): JLObject; overload; virtual;
+    function put(para1: JLObject; para2: JLObject): JLObject; overload; virtual;
+    function remove(para1: JLObject): JLObject; overload; virtual;
+    procedure putAll(para1: JUMap); overload; virtual;
+    procedure clear(); overload; virtual;
+    function keySet(): JUSet; overload; virtual;
+    function values(): JUCollection; overload; virtual;
+    function entrySet(): JUSet; overload; virtual; abstract;
+    function equals(para1: JLObject): jboolean; overload; virtual;
+    function hashCode(): jint; overload; virtual;
+    function toString(): JLString; overload; virtual;
+  strict protected
+    function clone(): JLObject; overload; virtual;  // throws java.lang.CloneNotSupportedException
+  end;
+
+  JLByte = class sealed external 'java.lang' name 'Byte' (JLNumber, JLComparable)
+  public
+    type
+      InnerByteCache = class;
+      Arr1InnerByteCache = array of InnerByteCache;
+      Arr2InnerByteCache = array of Arr1InnerByteCache;
+      Arr3InnerByteCache = array of Arr2InnerByteCache;
+      InnerByteCache = class external 'java.lang' name 'Byte$ByteCache' 
+      end;
+
+  public
+    const
+      MIN_VALUE = -128;
+      MAX_VALUE = 127;
+  public
+    final class var
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    const
+      SIZE = 8;
+  public
+    class function toString(para1: jbyte): JLString; static; overload;
+    class function valueOf(para1: jbyte): JLByte; static; overload;
+    class function parseByte(para1: JLString): jbyte; static; overload;  // throws java.lang.NumberFormatException
+    class function parseByte(para1: JLString; para2: jint): jbyte; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString; para2: jint): JLByte; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString): JLByte; static; overload;  // throws java.lang.NumberFormatException
+    class function decode(para1: JLString): JLByte; static; overload;  // throws java.lang.NumberFormatException
+    constructor create(para1: jbyte); overload;
+    constructor create(para1: JLString); overload;  // throws java.lang.NumberFormatException
+    function byteValue(): jbyte; overload; virtual;
+    function shortValue(): jshort; overload; virtual;
+    function intValue(): jint; overload; virtual;
+    function longValue(): jlong; overload; virtual;
+    function floatValue(): jfloat; overload; virtual;
+    function doubleValue(): jdouble; overload; virtual;
+    function toString(): JLString; overload; virtual;
+    function hashCode(): jint; overload; virtual;
+    function equals(para1: JLObject): jboolean; overload; virtual;
+    function compareTo(para1: JLByte): jint; overload; virtual;
+    function compareTo(para1: JLObject): jint; overload; virtual;
+  end;
+
   JLDouble = class sealed external 'java.lang' name 'Double' (JLNumber, JLComparable)
   public
     const
@@ -1084,6 +1281,170 @@
     function compareTo(para1: JLObject): jint; overload; virtual;
   end;
 
+  JLInteger = class sealed external 'java.lang' name 'Integer' (JLNumber, JLComparable)
+  public
+    type
+      InnerIntegerCache = class;
+      Arr1InnerIntegerCache = array of InnerIntegerCache;
+      Arr2InnerIntegerCache = array of Arr1InnerIntegerCache;
+      Arr3InnerIntegerCache = array of Arr2InnerIntegerCache;
+      InnerIntegerCache = class external 'java.lang' name 'Integer$IntegerCache' 
+      end;
+
+  public
+    const
+      MIN_VALUE = -2147483648;
+      MAX_VALUE = 2147483647;
+  public
+    final class var
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    const
+      SIZE = 32;
+  public
+    class function toString(para1: jint; para2: jint): JLString; static; overload;
+    class function toHexString(para1: jint): JLString; static; overload;
+    class function toOctalString(para1: jint): JLString; static; overload;
+    class function toBinaryString(para1: jint): JLString; static; overload;
+    class function toString(para1: jint): JLString; static; overload;
+    class function parseInt(para1: JLString; para2: jint): jint; static; overload;  // throws java.lang.NumberFormatException
+    class function parseInt(para1: JLString): jint; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString; para2: jint): JLInteger; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString): JLInteger; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: jint): JLInteger; static; overload;
+    constructor create(para1: jint); overload;
+    constructor create(para1: JLString); overload;  // throws java.lang.NumberFormatException
+    function byteValue(): jbyte; overload; virtual;
+    function shortValue(): jshort; overload; virtual;
+    function intValue(): jint; overload; virtual;
+    function longValue(): jlong; overload; virtual;
+    function floatValue(): jfloat; overload; virtual;
+    function doubleValue(): jdouble; overload; virtual;
+    function toString(): JLString; overload; virtual;
+    function hashCode(): jint; overload; virtual;
+    function equals(para1: JLObject): jboolean; overload; virtual;
+    class function getInteger(para1: JLString): JLInteger; static; overload;
+    class function getInteger(para1: JLString; para2: jint): JLInteger; static; overload;
+    class function getInteger(para1: JLString; para2: JLInteger): JLInteger; static; overload;
+    class function decode(para1: JLString): JLInteger; static; overload;  // throws java.lang.NumberFormatException
+    function compareTo(para1: JLInteger): jint; overload; virtual;
+    class function highestOneBit(para1: jint): jint; static; overload;
+    class function lowestOneBit(para1: jint): jint; static; overload;
+    class function numberOfLeadingZeros(para1: jint): jint; static; overload;
+    class function numberOfTrailingZeros(para1: jint): jint; static; overload;
+    class function bitCount(para1: jint): jint; static; overload;
+    class function rotateLeft(para1: jint; para2: jint): jint; static; overload;
+    class function rotateRight(para1: jint; para2: jint): jint; static; overload;
+    class function reverse(para1: jint): jint; static; overload;
+    class function signum(para1: jint): jint; static; overload;
+    class function reverseBytes(para1: jint): jint; static; overload;
+    function compareTo(para1: JLObject): jint; overload; virtual;
+  end;
+
+  JLLong = class sealed external 'java.lang' name 'Long' (JLNumber, JLComparable)
+  public
+    type
+      InnerLongCache = class;
+      Arr1InnerLongCache = array of InnerLongCache;
+      Arr2InnerLongCache = array of Arr1InnerLongCache;
+      Arr3InnerLongCache = array of Arr2InnerLongCache;
+      InnerLongCache = class external 'java.lang' name 'Long$LongCache' 
+      end;
+
+  public
+    const
+      MIN_VALUE = jlong(-9223372036854775808);
+      MAX_VALUE = jlong(9223372036854775807);
+  public
+    final class var
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    const
+      SIZE = 64;
+  public
+    class function toString(para1: jlong; para2: jint): JLString; static; overload;
+    class function toHexString(para1: jlong): JLString; static; overload;
+    class function toOctalString(para1: jlong): JLString; static; overload;
+    class function toBinaryString(para1: jlong): JLString; static; overload;
+    class function toString(para1: jlong): JLString; static; overload;
+    class function parseLong(para1: JLString; para2: jint): jlong; static; overload;  // throws java.lang.NumberFormatException
+    class function parseLong(para1: JLString): jlong; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString; para2: jint): JLLong; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString): JLLong; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: jlong): JLLong; static; overload;
+    class function decode(para1: JLString): JLLong; static; overload;  // throws java.lang.NumberFormatException
+    constructor create(para1: jlong); overload;
+    constructor create(para1: JLString); overload;  // throws java.lang.NumberFormatException
+    function byteValue(): jbyte; overload; virtual;
+    function shortValue(): jshort; overload; virtual;
+    function intValue(): jint; overload; virtual;
+    function longValue(): jlong; overload; virtual;
+    function floatValue(): jfloat; overload; virtual;
+    function doubleValue(): jdouble; overload; virtual;
+    function toString(): JLString; overload; virtual;
+    function hashCode(): jint; overload; virtual;
+    function equals(para1: JLObject): jboolean; overload; virtual;
+    class function getLong(para1: JLString): JLLong; static; overload;
+    class function getLong(para1: JLString; para2: jlong): JLLong; static; overload;
+    class function getLong(para1: JLString; para2: JLLong): JLLong; static; overload;
+    function compareTo(para1: JLLong): jint; overload; virtual;
+    class function highestOneBit(para1: jlong): jlong; static; overload;
+    class function lowestOneBit(para1: jlong): jlong; static; overload;
+    class function numberOfLeadingZeros(para1: jlong): jint; static; overload;
+    class function numberOfTrailingZeros(para1: jlong): jint; static; overload;
+    class function bitCount(para1: jlong): jint; static; overload;
+    class function rotateLeft(para1: jlong; para2: jint): jlong; static; overload;
+    class function rotateRight(para1: jlong; para2: jint): jlong; static; overload;
+    class function reverse(para1: jlong): jlong; static; overload;
+    class function signum(para1: jlong): jint; static; overload;
+    class function reverseBytes(para1: jlong): jlong; static; overload;
+    function compareTo(para1: JLObject): jint; overload; virtual;
+  end;
+
+  JLShort = class sealed external 'java.lang' name 'Short' (JLNumber, JLComparable)
+  public
+    type
+      InnerShortCache = class;
+      Arr1InnerShortCache = array of InnerShortCache;
+      Arr2InnerShortCache = array of Arr1InnerShortCache;
+      Arr3InnerShortCache = array of Arr2InnerShortCache;
+      InnerShortCache = class external 'java.lang' name 'Short$ShortCache' 
+      end;
+
+  public
+    const
+      MIN_VALUE = -32768;
+      MAX_VALUE = 32767;
+  public
+    final class var
+      fTYPE: JLClass; external name 'TYPE';
+  public
+    const
+      SIZE = 16;
+  public
+    class function toString(para1: jshort): JLString; static; overload;
+    class function parseShort(para1: JLString): jshort; static; overload;  // throws java.lang.NumberFormatException
+    class function parseShort(para1: JLString; para2: jint): jshort; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString; para2: jint): JLShort; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: JLString): JLShort; static; overload;  // throws java.lang.NumberFormatException
+    class function valueOf(para1: jshort): JLShort; static; overload;
+    class function decode(para1: JLString): JLShort; static; overload;  // throws java.lang.NumberFormatException
+    constructor create(para1: jshort); overload;
+    constructor create(para1: JLString); overload;  // throws java.lang.NumberFormatException
+    function byteValue(): jbyte; overload; virtual;
+    function shortValue(): jshort; overload; virtual;
+    function intValue(): jint; overload; virtual;
+    function longValue(): jlong; overload; virtual;
+    function floatValue(): jfloat; overload; virtual;
+    function doubleValue(): jdouble; overload; virtual;
+    function toString(): JLString; overload; virtual;
+    function hashCode(): jint; overload; virtual;
+    function equals(para1: JLObject): jboolean; overload; virtual;
+    function compareTo(para1: JLShort): jint; overload; virtual;
+    class function reverseBytes(para1: jshort): jshort; static; overload;
+    function compareTo(para1: JLObject): jint; overload; virtual;
+  end;
+
   JLError = class external 'java.lang' name 'Error' (JLThrowable)
   public
     constructor create(); overload;
@@ -1300,6 +1661,104 @@
     function append(para1: JLCharSequence): JLAppendable; overload; virtual;  // throws java.io.IOException
   end;
 
+  JUSet = interface external 'java.util' name 'Set' (JUCollection)
+    function size(): jint; overload;
+    function isEmpty(): jboolean; overload;
+    function contains(para1: JLObject): jboolean; overload;
+    function iterator(): JUIterator; overload;
+    function toArray(): Arr1JLObject; overload;
+    function toArray(para1: Arr1JLObject): Arr1JLObject; overload;
+    function toArray(var para1: array of JLObject): Arr1JLObject; overload;
+    function add(para1: JLObject): jboolean; overload;
+    function remove(para1: JLObject): jboolean; overload;
+    function containsAll(para1: JUCollection): jboolean; overload;
+    function addAll(para1: JUCollection): jboolean; overload;
+    function retainAll(para1: JUCollection): jboolean; overload;
+    function removeAll(para1: JUCollection): jboolean; overload;
+    procedure clear(); overload;
+    function equals(para1: JLObject): jboolean; overload;
+    function hashCode(): jint; overload;
+  end;
+
+  JUHashMap = class external 'java.util' name 'HashMap' (JUAbstractMap, JUMap, JLCloneable, JISerializable)
+  public
+    type
+      InnerEntrySet = class;
+      Arr1InnerEntrySet = array of InnerEntrySet;
+      Arr2InnerEntrySet = array of Arr1InnerEntrySet;
+      Arr3InnerEntrySet = array of Arr2InnerEntrySet;
+      InnerKeySet = class;
+      Arr1InnerKeySet = array of InnerKeySet;
+      Arr2InnerKeySet = array of Arr1InnerKeySet;
+      Arr3InnerKeySet = array of Arr2InnerKeySet;
+      InnerValues = class;
+      Arr1InnerValues = array of InnerValues;
+      Arr2InnerValues = array of Arr1InnerValues;
+      Arr3InnerValues = array of Arr2InnerValues;
+      InnerKeyIterator = class;
+      Arr1InnerKeyIterator = array of InnerKeyIterator;
+      Arr2InnerKeyIterator = array of Arr1InnerKeyIterator;
+      Arr3InnerKeyIterator = array of Arr2InnerKeyIterator;
+      InnerValueIterator = class;
+      Arr1InnerValueIterator = array of InnerValueIterator;
+      Arr2InnerValueIterator = array of Arr1InnerValueIterator;
+      Arr3InnerValueIterator = array of Arr2InnerValueIterator;
+      InnerEntryIterator = class;
+      Arr1InnerEntryIterator = array of InnerEntryIterator;
+      Arr2InnerEntryIterator = array of Arr1InnerEntryIterator;
+      Arr3InnerEntryIterator = array of Arr2InnerEntryIterator;
+      InnerEntry = class;
+      Arr1InnerEntry = array of InnerEntry;
+      Arr2InnerEntry = array of Arr1InnerEntry;
+      Arr3InnerEntry = array of Arr2InnerEntry;
+      InnerHashIterator = class;
+      Arr1InnerHashIterator = array of InnerHashIterator;
+      Arr2InnerHashIterator = array of Arr1InnerHashIterator;
+      Arr3InnerHashIterator = array of Arr2InnerHashIterator;
+      InnerEntrySet = class sealed external 'java.util' name 'HashMap$EntrySet' 
+      end;
+
+      InnerKeySet = class sealed external 'java.util' name 'HashMap$KeySet' 
+      end;
+
+      InnerValues = class sealed external 'java.util' name 'HashMap$Values' 
+      end;
+
+      InnerKeyIterator = class sealed external 'java.util' name 'HashMap$KeyIterator' 
+      end;
+
+      InnerValueIterator = class sealed external 'java.util' name 'HashMap$ValueIterator' 
+      end;
+
+      InnerEntryIterator = class sealed external 'java.util' name 'HashMap$EntryIterator' 
+      end;
+
+      InnerEntry = class external 'java.util' name 'HashMap$Entry' 
+      end;
+
+      InnerHashIterator = class abstract external 'java.util' name 'HashMap$HashIterator' 
+      end;
+
+  public
+    constructor create(para1: jint; para2: jfloat); overload;
+    constructor create(para1: jint); overload;
+    constructor create(); overload;
+    constructor create(para1: JUMap); overload;
+    function size(): jint; overload; virtual;
+    function isEmpty(): jboolean; overload; virtual;
+    function get(para1: JLObject): JLObject; overload; virtual;
+    function containsKey(para1: JLObject): jboolean; overload; virtual;
+    function put(para1: JLObject; para2: JLObject): JLObject; overload; virtual;
+    procedure putAll(para1: JUMap); overload; virtual;
+    function remove(para1: JLObject): JLObject; overload; virtual;
+    procedure clear(); overload; virtual;
+    function containsValue(para1: JLObject): jboolean; overload; virtual;
+    function clone(): JLObject; overload; virtual;
+    function keySet(): JUSet; overload; virtual;
+    function values(): JUCollection; overload; virtual;
+    function entrySet(): JUSet; overload; virtual;
+  end;
+
   JLLinkageError = class external 'java.lang' name 'LinkageError' (JLError)
   public
     constructor create(); overload;

rtl/java/java_sysh.inc

@@ -1,4 +1,4 @@
-{ Imports for Java packages/classes: java.io.Serializable, java.lang.AbstractStringBuilder, java.lang.Appendable, java.lang.CharSequence, java.lang.Character, java.lang.Class, 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.lang.reflect.AnnotatedElement, java.lang.reflect.Array, java.lang.reflect.GenericDeclaration, java.lang.reflect.Type, java.text.Collator, java.util.Arrays, java.util.Comparator }
+{ Imports for Java packages/classes: java.io.Serializable, java.lang.AbstractStringBuilder, java.lang.Appendable, java.lang.Boolean, java.lang.Byte, java.lang.CharSequence, java.lang.Character, java.lang.Class, java.lang.Cloneable, java.lang.Comparable, java.lang.Double, java.lang.Enum, java.lang.Error, java.lang.Exception, java.lang.Float, java.lang.IllegalArgumentException, java.lang.IndexOutOfBoundsException, java.lang.Integer, java.lang.Iterable, java.lang.LinkageError, java.lang.Long, java.lang.Number, java.lang.Object, java.lang.RuntimeException, java.lang.Short, java.lang.String, java.lang.StringBuffer, java.lang.StringBuilder, java.lang.System, java.lang.Throwable, java.lang.reflect.AnnotatedElement, java.lang.reflect.Array, java.lang.reflect.GenericDeclaration, java.lang.reflect.Type, java.text.Collator, java.util.AbstractMap, java.util.Arrays, java.util.Collection, java.util.Comparator, java.util.HashMap, java.util.Map, java.util.Set }
 type
   JLStringBuffer = class;
   Arr1JLStringBuffer = array of JLStringBuffer;
@@ -10,11 +10,6 @@ type
   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;
@@ -25,15 +20,10 @@ type
   Arr2JLAbstractStringBuilder = array of Arr1JLAbstractStringBuilder;
   Arr3JLAbstractStringBuilder = array of Arr2JLAbstractStringBuilder;
 
-  JLLinkageError = class;
-  Arr1JLLinkageError = array of JLLinkageError;
-  Arr2JLLinkageError = array of Arr1JLLinkageError;
-  Arr3JLLinkageError = array of Arr2JLLinkageError;
-
-  JLRArray = class;
-  Arr1JLRArray = array of JLRArray;
-  Arr2JLRArray = array of Arr1JLRArray;
-  Arr3JLRArray = array of Arr2JLRArray;
+  JLEnum = class;
+  Arr1JLEnum = array of JLEnum;
+  Arr2JLEnum = array of Arr1JLEnum;
+  Arr3JLEnum = array of Arr2JLEnum;
 
   JLError = class;
   Arr1JLError = array of JLError;
@@ -45,6 +35,61 @@ type
   Arr2JLNumber = array of Arr1JLNumber;
   Arr3JLNumber = array of Arr2JLNumber;
 
+  JLCharacter = class;
+  Arr1JLCharacter = array of JLCharacter;
+  Arr2JLCharacter = array of Arr1JLCharacter;
+  Arr3JLCharacter = array of Arr2JLCharacter;
+
+  JUArrays = class;
+  Arr1JUArrays = array of JUArrays;
+  Arr2JUArrays = array of Arr1JUArrays;
+  Arr3JUArrays = array of Arr2JUArrays;
+
+  JLBoolean = class;
+  Arr1JLBoolean = array of JLBoolean;
+  Arr2JLBoolean = array of Arr1JLBoolean;
+  Arr3JLBoolean = array of Arr2JLBoolean;
+
+  JLLong = class;
+  Arr1JLLong = array of JLLong;
+  Arr2JLLong = array of Arr1JLLong;
+  Arr3JLLong = array of Arr2JLLong;
+
+  JLShort = class;
+  Arr1JLShort = array of JLShort;
+  Arr2JLShort = array of Arr1JLShort;
+  Arr3JLShort = array of Arr2JLShort;
+
+  JLThrowable = class;
+  Arr1JLThrowable = array of JLThrowable;
+  Arr2JLThrowable = array of Arr1JLThrowable;
+  Arr3JLThrowable = array of Arr2JLThrowable;
+
+  JLInteger = class;
+  Arr1JLInteger = array of JLInteger;
+  Arr2JLInteger = array of Arr1JLInteger;
+  Arr3JLInteger = array of Arr2JLInteger;
+
+  JLLinkageError = class;
+  Arr1JLLinkageError = array of JLLinkageError;
+  Arr2JLLinkageError = array of Arr1JLLinkageError;
+  Arr3JLLinkageError = array of Arr2JLLinkageError;
+
+  JLByte = class;
+  Arr1JLByte = array of JLByte;
+  Arr2JLByte = array of Arr1JLByte;
+  Arr3JLByte = array of Arr2JLByte;
+
+  JLRArray = class;
+  Arr1JLRArray = array of JLRArray;
+  Arr2JLRArray = array of Arr1JLRArray;
+  Arr3JLRArray = array of Arr2JLRArray;
+
+  JUAbstractMap = class;
+  Arr1JUAbstractMap = array of JUAbstractMap;
+  Arr2JUAbstractMap = array of Arr1JUAbstractMap;
+  Arr3JUAbstractMap = array of Arr2JUAbstractMap;
+
   JLException = class;
   Arr1JLException = array of JLException;
   Arr2JLException = array of Arr1JLException;
@@ -55,10 +100,10 @@ type
   Arr2JLIndexOutOfBoundsException = array of Arr1JLIndexOutOfBoundsException;
   Arr3JLIndexOutOfBoundsException = array of Arr2JLIndexOutOfBoundsException;
 
-  JLCharacter = class;
-  Arr1JLCharacter = array of JLCharacter;
-  Arr2JLCharacter = array of Arr1JLCharacter;
-  Arr3JLCharacter = array of Arr2JLCharacter;
+  JUHashMap = class;
+  Arr1JUHashMap = array of JUHashMap;
+  Arr2JUHashMap = array of Arr1JUHashMap;
+  Arr3JUHashMap = array of Arr2JUHashMap;
 
   JLDouble = class;
   Arr1JLDouble = array of JLDouble;
@@ -70,26 +115,21 @@ type
   Arr2JTCollator = array of Arr1JTCollator;
   Arr3JTCollator = array of Arr2JTCollator;
 
-  JUArrays = class;
-  Arr1JUArrays = array of JUArrays;
-  Arr2JUArrays = array of Arr1JUArrays;
-  Arr3JUArrays = array of Arr2JUArrays;
-
   JLIllegalArgumentException = class;
   Arr1JLIllegalArgumentException = array of JLIllegalArgumentException;
   Arr2JLIllegalArgumentException = array of Arr1JLIllegalArgumentException;
   Arr3JLIllegalArgumentException = array of Arr2JLIllegalArgumentException;
 
-  JLClass = class;
-  Arr1JLClass = array of JLClass;
-  Arr2JLClass = array of Arr1JLClass;
-  Arr3JLClass = array of Arr2JLClass;
-
   JLString = class;
   Arr1JLString = array of JLString;
   Arr2JLString = array of Arr1JLString;
   Arr3JLString = array of Arr2JLString;
 
+  JLClass = class;
+  Arr1JLClass = array of JLClass;
+  Arr2JLClass = array of Arr1JLClass;
+  Arr3JLClass = array of Arr2JLClass;
+
   JLFloat = class;
   Arr1JLFloat = array of JLFloat;
   Arr2JLFloat = array of Arr1JLFloat;
@@ -105,6 +145,46 @@ type
   Arr2JLRuntimeException = array of Arr1JLRuntimeException;
   Arr3JLRuntimeException = array of Arr2JLRuntimeException;
 
+  JLIterable = interface;
+  Arr1JLIterable = array of JLIterable;
+  Arr2JLIterable = array of Arr1JLIterable;
+  Arr3JLIterable = array of Arr2JLIterable;
+
+  JLCloneable = interface;
+  Arr1JLCloneable = array of JLCloneable;
+  Arr2JLCloneable = array of Arr1JLCloneable;
+  Arr3JLCloneable = array of Arr2JLCloneable;
+
+  JLAppendable = interface;
+  Arr1JLAppendable = array of JLAppendable;
+  Arr2JLAppendable = array of Arr1JLAppendable;
+  Arr3JLAppendable = array of Arr2JLAppendable;
+
+  JUCollection = interface;
+  Arr1JUCollection = array of JUCollection;
+  Arr2JUCollection = array of Arr1JUCollection;
+  Arr3JUCollection = array of Arr2JUCollection;
+
+  JUMap = interface;
+  Arr1JUMap = array of JUMap;
+  Arr2JUMap = array of Arr1JUMap;
+  Arr3JUMap = array of Arr2JUMap;
+
+  JUSet = interface;
+  Arr1JUSet = array of JUSet;
+  Arr2JUSet = array of Arr1JUSet;
+  Arr3JUSet = array of Arr2JUSet;
+
+  JLRType = interface;
+  Arr1JLRType = array of JLRType;
+  Arr2JLRType = array of Arr1JLRType;
+  Arr3JLRType = array of Arr2JLRType;
+
+  JLComparable = interface;
+  Arr1JLComparable = array of JLComparable;
+  Arr2JLComparable = array of Arr1JLComparable;
+  Arr3JLComparable = array of Arr2JLComparable;
+
   JLCharSequence = interface;
   Arr1JLCharSequence = array of JLCharSequence;
   Arr2JLCharSequence = array of Arr1JLCharSequence;
@@ -120,36 +200,16 @@ type
   Arr2JLRAnnotatedElement = array of Arr1JLRAnnotatedElement;
   Arr3JLRAnnotatedElement = array of Arr2JLRAnnotatedElement;
 
-  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;
-
-  JLRType = interface;
-  Arr1JLRType = array of JLRType;
-  Arr2JLRType = array of Arr1JLRType;
-  Arr3JLRType = array of Arr2JLRType;
-
   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;
@@ -245,6 +305,11 @@ type
   Arr2JLAAnnotation = array of Arr1JLAAnnotation;
   Arr3JLAAnnotation = array of Arr2JLAAnnotation;
 
+  JUIterator = interface external 'java.util' name 'Iterator';
+  Arr1JUIterator = array of JUIterator;
+  Arr2JUIterator = array of Arr1JUIterator;
+  Arr3JUIterator = array of Arr2JUIterator;
+
   JNCChannel = interface external 'java.nio.channels' name 'Channel';
   Arr1JNCChannel = array of JNCChannel;
   Arr2JNCChannel = array of Arr1JNCChannel;
@@ -255,9 +320,4 @@ type
   Arr2JLRTypeVariable = array of Arr1JLRTypeVariable;
   Arr3JLRTypeVariable = array of Arr2JLRTypeVariable;
 
-  JUMap = interface external 'java.util' name 'Map';
-  Arr1JUMap = array of JUMap;
-  Arr2JUMap = array of Arr1JUMap;
-  Arr3JUMap = array of Arr2JUMap;
-
 

rtl/java/jdk15.pas

@@ -180,11 +180,6 @@ type
   Arr2JUCAAtomicLongArray = array of Arr1JUCAAtomicLongArray;
   Arr3JUCAAtomicLongArray = array of Arr2JUCAAtomicLongArray;
 
-  JUHashMap = class;
-  Arr1JUHashMap = array of JUHashMap;
-  Arr2JUHashMap = array of Arr1JUHashMap;
-  Arr3JUHashMap = array of Arr2JUHashMap;
-
   JNCacheResponse = class;
   Arr1JNCacheResponse = array of JNCacheResponse;
   Arr2JNCacheResponse = array of Arr1JNCacheResponse;
@@ -285,16 +280,16 @@ type
   Arr2JSRSSyncProviderException = array of Arr1JSRSSyncProviderException;
   Arr3JSRSSyncProviderException = array of Arr2JSRSSyncProviderException;
 
-  JSPBBasicSplitPaneUI = class;
-  Arr1JSPBBasicSplitPaneUI = array of JSPBBasicSplitPaneUI;
-  Arr2JSPBBasicSplitPaneUI = array of Arr1JSPBBasicSplitPaneUI;
-  Arr3JSPBBasicSplitPaneUI = array of Arr2JSPBBasicSplitPaneUI;
-
   JTMergeCollation = class;
   Arr1JTMergeCollation = array of JTMergeCollation;
   Arr2JTMergeCollation = array of Arr1JTMergeCollation;
   Arr3JTMergeCollation = array of Arr2JTMergeCollation;
 
+  JSPBBasicSplitPaneUI = class;
+  Arr1JSPBBasicSplitPaneUI = array of JSPBBasicSplitPaneUI;
+  Arr2JSPBBasicSplitPaneUI = array of Arr1JSPBBasicSplitPaneUI;
+  Arr3JSPBBasicSplitPaneUI = array of Arr2JSPBBasicSplitPaneUI;
+
   OOD_DynUnionStub = class;
   Arr1OOD_DynUnionStub = array of OOD_DynUnionStub;
   Arr2OOD_DynUnionStub = array of Arr1OOD_DynUnionStub;
@@ -1020,16 +1015,16 @@ type
   Arr2JSecurityTimestamp = array of Arr1JSecurityTimestamp;
   Arr3JSecurityTimestamp = array of Arr2JSecurityTimestamp;
 
-  JSJSplitPane = class;
-  Arr1JSJSplitPane = array of JSJSplitPane;
-  Arr2JSJSplitPane = array of Arr1JSJSplitPane;
-  Arr3JSJSplitPane = array of Arr2JSJSplitPane;
-
   JNDirectFloatBufferRS = class;
   Arr1JNDirectFloatBufferRS = array of JNDirectFloatBufferRS;
   Arr2JNDirectFloatBufferRS = array of Arr1JNDirectFloatBufferRS;
   Arr3JNDirectFloatBufferRS = array of Arr2JNDirectFloatBufferRS;
 
+  JSJSplitPane = class;
+  Arr1JSJSplitPane = array of JSJSplitPane;
+  Arr2JSJSplitPane = array of Arr1JSJSplitPane;
+  Arr3JSJSplitPane = array of Arr2JSJSplitPane;
+
   JLMath = class;
   Arr1JLMath = array of JLMath;
   Arr2JLMath = array of Arr1JLMath;
@@ -1185,11 +1180,6 @@ type
   Arr2JPASColorSupported = array of Arr1JPASColorSupported;
   Arr3JPASColorSupported = array of Arr2JPASColorSupported;
 
-  JLEnum = class;
-  Arr1JLEnum = array of JLEnum;
-  Arr2JLEnum = array of Arr1JLEnum;
-  Arr3JLEnum = array of Arr2JLEnum;
-
   JNDInvalidAttributesException = class;
   Arr1JNDInvalidAttributesException = array of JNDInvalidAttributesException;
   Arr2JNDInvalidAttributesException = array of Arr1JNDInvalidAttributesException;
@@ -2295,16 +2285,16 @@ type
   Arr2JLInterruptedException = array of Arr1JLInterruptedException;
   Arr3JLInterruptedException = array of Arr2JLInterruptedException;
 
-  JLMEModifier = class;
-  Arr1JLMEModifier = array of JLMEModifier;
-  Arr2JLMEModifier = array of Arr1JLMEModifier;
-  Arr3JLMEModifier = array of Arr2JLMEModifier;
-
   JSFocusManager = class;
   Arr1JSFocusManager = array of JSFocusManager;
   Arr2JSFocusManager = array of Arr1JSFocusManager;
   Arr3JSFocusManager = array of Arr2JSFocusManager;
 
+  JLMEModifier = class;
+  Arr1JLMEModifier = array of JLMEModifier;
+  Arr2JLMEModifier = array of Arr1JLMEModifier;
+  Arr3JLMEModifier = array of Arr2JLMEModifier;
+
   JBjava_util_List_PersistenceDelegate = class;
   Arr1JBjava_util_List_PersistenceDelegate = array of JBjava_util_List_PersistenceDelegate;
   Arr2JBjava_util_List_PersistenceDelegate = array of Arr1JBjava_util_List_PersistenceDelegate;
@@ -4090,11 +4080,6 @@ type
   Arr2JSPSSynthSplitPaneDivider = array of Arr1JSPSSynthSplitPaneDivider;
   Arr3JSPSSynthSplitPaneDivider = array of Arr2JSPSSynthSplitPaneDivider;
 
-  JLInteger = class;
-  Arr1JLInteger = array of JLInteger;
-  Arr2JLInteger = array of Arr1JLInteger;
-  Arr3JLInteger = array of Arr2JLInteger;
-
   JMInvalidApplicationException = class;
   Arr1JMInvalidApplicationException = array of JMInvalidApplicationException;
   Arr2JMInvalidApplicationException = array of Arr1JMInvalidApplicationException;
@@ -4320,16 +4305,16 @@ type
   Arr2JCKeyGeneratorSpi = array of Arr1JCKeyGeneratorSpi;
   Arr3JCKeyGeneratorSpi = array of Arr2JCKeyGeneratorSpi;
 
-  JUGregorianCalendar = class;
-  Arr1JUGregorianCalendar = array of JUGregorianCalendar;
-  Arr2JUGregorianCalendar = array of Arr1JUGregorianCalendar;
-  Arr3JUGregorianCalendar = array of Arr2JUGregorianCalendar;
-
   JSCX509CertSelector = class;
   Arr1JSCX509CertSelector = array of JSCX509CertSelector;
   Arr2JSCX509CertSelector = array of Arr1JSCX509CertSelector;
   Arr3JSCX509CertSelector = array of Arr2JSCX509CertSelector;
 
+  JUGregorianCalendar = class;
+  Arr1JUGregorianCalendar = array of JUGregorianCalendar;
+  Arr2JUGregorianCalendar = array of Arr1JUGregorianCalendar;
+  Arr3JUGregorianCalendar = array of Arr2JUGregorianCalendar;
+
   JSSECFieldFp = class;
   Arr1JSSECFieldFp = array of JSSECFieldFp;
   Arr2JSSECFieldFp = array of Arr1JSSECFieldFp;
@@ -4435,11 +4420,6 @@ type
   Arr2JISFileImageInputStream = array of Arr1JISFileImageInputStream;
   Arr3JISFileImageInputStream = array of Arr2JISFileImageInputStream;
 
-  JLAElementType = class;
-  Arr1JLAElementType = array of JLAElementType;
-  Arr2JLAElementType = array of Arr1JLAElementType;
-  Arr3JLAElementType = array of Arr2JLAElementType;
-
   JSTime = class;
   Arr1JSTime = array of JSTime;
   Arr2JSTime = array of Arr1JSTime;
@@ -4450,6 +4430,11 @@ type
   Arr2JIFileDescriptor = array of Arr1JIFileDescriptor;
   Arr3JIFileDescriptor = array of Arr2JIFileDescriptor;
 
+  JLAElementType = class;
+  Arr1JLAElementType = array of JLAElementType;
+  Arr2JLAElementType = array of Arr1JLAElementType;
+  Arr3JLAElementType = array of Arr2JLAElementType;
+
   JSTHPTagStack = class;
   Arr1JSTHPTagStack = array of JSTHPTagStack;
   Arr2JSTHPTagStack = array of Arr1JSTHPTagStack;
@@ -4715,11 +4700,6 @@ type
   Arr2JSDigestInputStream = array of Arr1JSDigestInputStream;
   Arr3JSDigestInputStream = array of Arr2JSDigestInputStream;
 
-  JLLong = class;
-  Arr1JLLong = array of JLLong;
-  Arr2JLLong = array of Arr1JLLong;
-  Arr3JLLong = array of Arr2JLLong;
-
   JMRRRMIConnectorServer = class;
   Arr1JMRRRMIConnectorServer = array of JMRRRMIConnectorServer;
   Arr2JMRRRMIConnectorServer = array of Arr1JMRRRMIConnectorServer;
@@ -6970,16 +6950,16 @@ type
   Arr2JNByteBufferAsIntBufferRL = array of Arr1JNByteBufferAsIntBufferRL;
   Arr3JNByteBufferAsIntBufferRL = array of Arr2JNByteBufferAsIntBufferRL;
 
-  JXVSchemaFactoryLoader = class;
-  Arr1JXVSchemaFactoryLoader = array of JXVSchemaFactoryLoader;
-  Arr2JXVSchemaFactoryLoader = array of Arr1JXVSchemaFactoryLoader;
-  Arr3JXVSchemaFactoryLoader = array of Arr2JXVSchemaFactoryLoader;
-
   JTRuleBasedCollator = class;
   Arr1JTRuleBasedCollator = array of JTRuleBasedCollator;
   Arr2JTRuleBasedCollator = array of Arr1JTRuleBasedCollator;
   Arr3JTRuleBasedCollator = array of Arr2JTRuleBasedCollator;
 
+  JXVSchemaFactoryLoader = class;
+  Arr1JXVSchemaFactoryLoader = array of JXVSchemaFactoryLoader;
+  Arr2JXVSchemaFactoryLoader = array of Arr1JXVSchemaFactoryLoader;
+  Arr3JXVSchemaFactoryLoader = array of Arr2JXVSchemaFactoryLoader;
+
   JSPBBasicTextPaneUI = class;
   Arr1JSPBBasicTextPaneUI = array of JSPBBasicTextPaneUI;
   Arr2JSPBBasicTextPaneUI = array of Arr1JSPBBasicTextPaneUI;
@@ -7305,11 +7285,6 @@ type
   Arr2JSCCertificateNotYetValidException = array of Arr1JSCCertificateNotYetValidException;
   Arr3JSCCertificateNotYetValidException = array of Arr2JSCCertificateNotYetValidException;
 
-  JLBoolean = class;
-  Arr1JLBoolean = array of JLBoolean;
-  Arr2JLBoolean = array of Arr1JLBoolean;
-  Arr3JLBoolean = array of Arr2JLBoolean;
-
   JASystemTray = class;
   Arr1JASystemTray = array of JASystemTray;
   Arr2JASystemTray = array of Arr1JASystemTray;
@@ -8930,11 +8905,6 @@ type
   Arr2JIUTFDataFormatException = array of Arr1JIUTFDataFormatException;
   Arr3JIUTFDataFormatException = array of Arr2JIUTFDataFormatException;
 
-  JXBAXmlNsForm = class;
-  Arr1JXBAXmlNsForm = array of JXBAXmlNsForm;
-  Arr2JXBAXmlNsForm = array of Arr1JXBAXmlNsForm;
-  Arr3JXBAXmlNsForm = array of Arr2JXBAXmlNsForm;
-
   JLThread = class;
   Arr1JLThread = array of JLThread;
   Arr2JLThread = array of Arr1JLThread;
@@ -8945,6 +8915,11 @@ type
   Arr2JRSObjID = array of Arr1JRSObjID;
   Arr3JRSObjID = array of Arr2JRSObjID;
 
+  JXBAXmlNsForm = class;
+  Arr1JXBAXmlNsForm = array of JXBAXmlNsForm;
+  Arr2JXBAXmlNsForm = array of Arr1JXBAXmlNsForm;
+  Arr3JXBAXmlNsForm = array of Arr2JXBAXmlNsForm;
+
   JMRoundingMode = class;
   Arr1JMRoundingMode = array of JMRoundingMode;
   Arr2JMRoundingMode = array of Arr1JMRoundingMode;
@@ -9230,16 +9205,16 @@ type
   Arr2JIUnsupportedEncodingException = array of Arr1JIUnsupportedEncodingException;
   Arr3JIUnsupportedEncodingException = array of Arr2JIUnsupportedEncodingException;
 
-  JSKeyRep = class;
-  Arr1JSKeyRep = array of JSKeyRep;
-  Arr2JSKeyRep = array of Arr1JSKeyRep;
-  Arr3JSKeyRep = array of Arr2JSKeyRep;
-
   JSDriverInfo = class;
   Arr1JSDriverInfo = array of JSDriverInfo;
   Arr2JSDriverInfo = array of Arr1JSDriverInfo;
   Arr3JSDriverInfo = array of Arr2JSDriverInfo;
 
+  JSKeyRep = class;
+  Arr1JSKeyRep = array of JSKeyRep;
+  Arr2JSKeyRep = array of Arr1JSKeyRep;
+  Arr3JSKeyRep = array of Arr2JSKeyRep;
+
   JAMenuShortcut = class;
   Arr1JAMenuShortcut = array of JAMenuShortcut;
   Arr2JAMenuShortcut = array of Arr1JAMenuShortcut;
@@ -11185,16 +11160,16 @@ type
   Arr2JPAAttributeSetUtilities = array of Arr1JPAAttributeSetUtilities;
   Arr3JPAAttributeSetUtilities = array of Arr2JPAAttributeSetUtilities;
 
-  JUCConcurrentHashMap = class;
-  Arr1JUCConcurrentHashMap = array of JUCConcurrentHashMap;
-  Arr2JUCConcurrentHashMap = array of Arr1JUCConcurrentHashMap;
-  Arr3JUCConcurrentHashMap = array of Arr2JUCConcurrentHashMap;
-
   OOCPUnknownException = class;
   Arr1OOCPUnknownException = array of OOCPUnknownException;
   Arr2OOCPUnknownException = array of Arr1OOCPUnknownException;
   Arr3OOCPUnknownException = array of Arr2OOCPUnknownException;
 
+  JUCConcurrentHashMap = class;
+  Arr1JUCConcurrentHashMap = array of JUCConcurrentHashMap;
+  Arr2JUCConcurrentHashMap = array of Arr1JUCConcurrentHashMap;
+  Arr3JUCConcurrentHashMap = array of Arr2JUCConcurrentHashMap;
+
   JUHashSet = class;
   Arr1JUHashSet = array of JUHashSet;
   Arr2JUHashSet = array of Arr1JUHashSet;
@@ -11370,16 +11345,16 @@ type
   Arr2JUPPreferenceChangeEvent = array of Arr1JUPPreferenceChangeEvent;
   Arr3JUPPreferenceChangeEvent = array of Arr2JUPPreferenceChangeEvent;
 
-  JUPriorityQueue = class;
-  Arr1JUPriorityQueue = array of JUPriorityQueue;
-  Arr2JUPriorityQueue = array of Arr1JUPriorityQueue;
-  Arr3JUPriorityQueue = array of Arr2JUPriorityQueue;
-
   JNDirectIntBufferRU = class;
   Arr1JNDirectIntBufferRU = array of JNDirectIntBufferRU;
   Arr2JNDirectIntBufferRU = array of Arr1JNDirectIntBufferRU;
   Arr3JNDirectIntBufferRU = array of Arr2JNDirectIntBufferRU;
 
+  JUPriorityQueue = class;
+  Arr1JUPriorityQueue = array of JUPriorityQueue;
+  Arr2JUPriorityQueue = array of Arr1JUPriorityQueue;
+  Arr3JUPriorityQueue = array of Arr2JUPriorityQueue;
+
   JNSecureCacheResponse = class;
   Arr1JNSecureCacheResponse = array of JNSecureCacheResponse;
   Arr2JNSecureCacheResponse = array of Arr1JNSecureCacheResponse;
@@ -12340,11 +12315,6 @@ type
   Arr2OOPObjectReferenceTemplateSeqHolder = array of Arr1OOPObjectReferenceTemplateSeqHolder;
   Arr3OOPObjectReferenceTemplateSeqHolder = array of Arr2OOPObjectReferenceTemplateSeqHolder;
 
-  JLByte = class;
-  Arr1JLByte = array of JLByte;
-  Arr2JLByte = array of Arr1JLByte;
-  Arr3JLByte = array of Arr2JLByte;
-
   OOPObjectReferenceFactoryHolder = class;
   Arr1OOPObjectReferenceFactoryHolder = array of OOPObjectReferenceFactoryHolder;
   Arr2OOPObjectReferenceFactoryHolder = array of Arr1OOPObjectReferenceFactoryHolder;
@@ -12390,6 +12360,11 @@ type
   Arr2JURegularEnumSet = array of Arr1JURegularEnumSet;
   Arr3JURegularEnumSet = array of Arr2JURegularEnumSet;
 
+  JTCollationElementIterator = class;
+  Arr1JTCollationElementIterator = array of JTCollationElementIterator;
+  Arr2JTCollationElementIterator = array of Arr1JTCollationElementIterator;
+  Arr3JTCollationElementIterator = array of Arr2JTCollationElementIterator;
+
   JSCCertPathBuilder = class;
   Arr1JSCCertPathBuilder = array of JSCCertPathBuilder;
   Arr2JSCCertPathBuilder = array of Arr1JSCCertPathBuilder;
@@ -12400,11 +12375,6 @@ type
   Arr2JAKeyboardFocusManager = array of Arr1JAKeyboardFocusManager;
   Arr3JAKeyboardFocusManager = array of Arr2JAKeyboardFocusManager;
 
-  JTCollationElementIterator = class;
-  Arr1JTCollationElementIterator = array of JTCollationElementIterator;
-  Arr2JTCollationElementIterator = array of Arr1JTCollationElementIterator;
-  Arr3JTCollationElementIterator = array of Arr2JTCollationElementIterator;
-
   JAGraphics = class;
   Arr1JAGraphics = array of JAGraphics;
   Arr2JAGraphics = array of Arr1JAGraphics;
@@ -12580,11 +12550,6 @@ type
   Arr2JLVerifyError = array of Arr1JLVerifyError;
   Arr3JLVerifyError = array of Arr2JLVerifyError;
 
-  JUAbstractMap = class;
-  Arr1JUAbstractMap = array of JUAbstractMap;
-  Arr2JUAbstractMap = array of Arr1JUAbstractMap;
-  Arr3JUAbstractMap = array of Arr2JUAbstractMap;
-
   OODDInvalidValueHelper = class;
   Arr1OODDInvalidValueHelper = array of OODDInvalidValueHelper;
   Arr2OODDInvalidValueHelper = array of Arr1OODDInvalidValueHelper;
@@ -12735,11 +12700,6 @@ type
   Arr2JARobot = array of Arr1JARobot;
   Arr3JARobot = array of Arr2JARobot;
 
-  JLShort = class;
-  Arr1JLShort = array of JLShort;
-  Arr2JLShort = array of Arr1JLShort;
-  Arr3JLShort = array of Arr2JLShort;
-
   JAIInputContext = class;
   Arr1JAIInputContext = array of JAIInputContext;
   Arr2JAIInputContext = array of Arr1JAIInputContext;
@@ -13065,16 +13025,16 @@ type
   Arr2JSPBorderUIResource = array of Arr1JSPBorderUIResource;
   Arr3JSPBorderUIResource = array of Arr2JSPBorderUIResource;
 
-  JNLSortKey = class;
-  Arr1JNLSortKey = array of JNLSortKey;
-  Arr2JNLSortKey = array of Arr1JNLSortKey;
-  Arr3JNLSortKey = array of Arr2JNLSortKey;
-
   JSCX509CRLSelector = class;
   Arr1JSCX509CRLSelector = array of JSCX509CRLSelector;
   Arr2JSCX509CRLSelector = array of Arr1JSCX509CRLSelector;
   Arr3JSCX509CRLSelector = array of Arr2JSCX509CRLSelector;
 
+  JNLSortKey = class;
+  Arr1JNLSortKey = array of JNLSortKey;
+  Arr2JNLSortKey = array of Arr1JNLSortKey;
+  Arr3JNLSortKey = array of Arr2JNLSortKey;
+
   OOCINVALID_TRANSACTION = class;
   Arr1OOCINVALID_TRANSACTION = array of OOCINVALID_TRANSACTION;
   Arr2OOCINVALID_TRANSACTION = array of Arr1OOCINVALID_TRANSACTION;
@@ -13315,11 +13275,6 @@ type
   Arr2JPASNumberUpSupported = array of Arr1JPASNumberUpSupported;
   Arr3JPASNumberUpSupported = array of Arr2JPASNumberUpSupported;
 
-  JSLayoutStyle = class;
-  Arr1JSLayoutStyle = array of JSLayoutStyle;
-  Arr2JSLayoutStyle = array of Arr1JSLayoutStyle;
-  Arr3JSLayoutStyle = array of Arr2JSLayoutStyle;
-
   JSIdentityScope = class;
   Arr1JSIdentityScope = array of JSIdentityScope;
   Arr2JSIdentityScope = array of Arr1JSIdentityScope;
@@ -13330,6 +13285,11 @@ type
   Arr2JMOperationsException = array of Arr1JMOperationsException;
   Arr3JMOperationsException = array of Arr2JMOperationsException;
 
+  JSLayoutStyle = class;
+  Arr1JSLayoutStyle = array of JSLayoutStyle;
+  Arr2JSLayoutStyle = array of Arr1JSLayoutStyle;
+  Arr3JSLayoutStyle = array of Arr2JSLayoutStyle;
+
   JPASetOfIntegerSyntax = class;
   Arr1JPASetOfIntegerSyntax = array of JPASetOfIntegerSyntax;
   Arr2JPASetOfIntegerSyntax = array of Arr1JPASetOfIntegerSyntax;
@@ -13440,16 +13400,16 @@ type
   Arr2JMAttributeNotFoundException = array of Arr1JMAttributeNotFoundException;
   Arr3JMAttributeNotFoundException = array of Arr2JMAttributeNotFoundException;
 
-  JTAttributeEntry = class;
-  Arr1JTAttributeEntry = array of JTAttributeEntry;
-  Arr2JTAttributeEntry = array of Arr1JTAttributeEntry;
-  Arr3JTAttributeEntry = array of Arr2JTAttributeEntry;
-
   JNCClosedChannelException = class;
   Arr1JNCClosedChannelException = array of JNCClosedChannelException;
   Arr2JNCClosedChannelException = array of Arr1JNCClosedChannelException;
   Arr3JNCClosedChannelException = array of Arr2JNCClosedChannelException;
 
+  JTAttributeEntry = class;
+  Arr1JTAttributeEntry = array of JTAttributeEntry;
+  Arr2JTAttributeEntry = array of Arr1JTAttributeEntry;
+  Arr3JTAttributeEntry = array of Arr2JTAttributeEntry;
+
   JBDefaultPersistenceDelegate = class;
   Arr1JBDefaultPersistenceDelegate = array of JBDefaultPersistenceDelegate;
   Arr2JBDefaultPersistenceDelegate = array of Arr1JBDefaultPersistenceDelegate;
@@ -15610,16 +15570,16 @@ type
   Arr2OWDHHTMLDListElement = array of Arr1OWDHHTMLDListElement;
   Arr3OWDHHTMLDListElement = array of Arr2OWDHHTMLDListElement;
 
-  OOCDynEnum = interface;
-  Arr1OOCDynEnum = array of OOCDynEnum;
-  Arr2OOCDynEnum = array of Arr1OOCDynEnum;
-  Arr3OOCDynEnum = array of Arr2OOCDynEnum;
-
   JSSQLOutput = interface;
   Arr1JSSQLOutput = array of JSSQLOutput;
   Arr2JSSQLOutput = array of Arr1JSSQLOutput;
   Arr3JSSQLOutput = array of Arr2JSSQLOutput;
 
+  OOCDynEnum = interface;
+  Arr1OOCDynEnum = array of OOCDynEnum;
+  Arr2OOCDynEnum = array of Arr1OOCDynEnum;
+  Arr3OOCDynEnum = array of Arr2OOCDynEnum;
+
   OODDynAnyFactoryOperations = interface;
   Arr1OODDynAnyFactoryOperations = array of OODDynAnyFactoryOperations;
   Arr2OODDynAnyFactoryOperations = array of Arr1OODDynAnyFactoryOperations;
@@ -15665,11 +15625,6 @@ type
   Arr2JJWebParam = array of Arr1JJWebParam;
   Arr3JJWebParam = array of Arr2JJWebParam;
 
-  JUCollection = interface;
-  Arr1JUCollection = array of JUCollection;
-  Arr2JUCollection = array of Arr1JUCollection;
-  Arr3JUCollection = array of Arr2JUCollection;
-
   JXCDXMLObject = interface;
   Arr1JXCDXMLObject = array of JXCDXMLObject;
   Arr2JXCDXMLObject = array of Arr1JXCDXMLObject;
@@ -15935,16 +15890,16 @@ type
   Arr2JXSNode = array of Arr1JXSNode;
   Arr3JXSNode = array of Arr2JXSNode;
 
-  OOCPUBLIC_MEMBER = interface;
-  Arr1OOCPUBLIC_MEMBER = array of OOCPUBLIC_MEMBER;
-  Arr2OOCPUBLIC_MEMBER = array of Arr1OOCPUBLIC_MEMBER;
-  Arr3OOCPUBLIC_MEMBER = array of Arr2OOCPUBLIC_MEMBER;
-
   JIDataInput = interface;
   Arr1JIDataInput = array of JIDataInput;
   Arr2JIDataInput = array of Arr1JIDataInput;
   Arr3JIDataInput = array of Arr2JIDataInput;
 
+  OOCPUBLIC_MEMBER = interface;
+  Arr1OOCPUBLIC_MEMBER = array of OOCPUBLIC_MEMBER;
+  Arr2OOCPUBLIC_MEMBER = array of Arr1OOCPUBLIC_MEMBER;
+  Arr3OOCPUBLIC_MEMBER = array of Arr2OOCPUBLIC_MEMBER;
+
   OOITAG_MULTIPLE_COMPONENTS = interface;
   Arr1OOITAG_MULTIPLE_COMPONENTS = array of OOITAG_MULTIPLE_COMPONENTS;
   Arr2OOITAG_MULTIPLE_COMPONENTS = array of Arr1OOITAG_MULTIPLE_COMPONENTS;
@@ -17920,11 +17875,6 @@ type
   Arr2JAPMenuPeer = array of Arr1JAPMenuPeer;
   Arr3JAPMenuPeer = array of Arr2JAPMenuPeer;
 
-  JUSet = interface;
-  Arr1JUSet = array of JUSet;
-  Arr2JUSet = array of Arr1JUSet;
-  Arr3JUSet = array of Arr2JUSet;
-
   JCSecretKey = interface;
   Arr1JCSecretKey = array of JCSecretKey;
   Arr2JCSecretKey = array of Arr1JCSecretKey;
@@ -18885,11 +18835,6 @@ type
   Arr2JLRTypeVariable = array of Arr1JLRTypeVariable;
   Arr3JLRTypeVariable = array of Arr2JLRTypeVariable;
 
-  JUMap = interface;
-  Arr1JUMap = array of JUMap;
-  Arr2JUMap = array of Arr1JUMap;
-  Arr3JUMap = array of Arr2JUMap;
-
   JNSKeyManager = interface;
   Arr1JNSKeyManager = array of JNSKeyManager;
   Arr2JNSKeyManager = array of Arr1JNSKeyManager;
@@ -19115,16 +19060,16 @@ type
   Arr2OOCVM_CUSTOM = array of Arr1OOCVM_CUSTOM;
   Arr3OOCVM_CUSTOM = array of Arr2OOCVM_CUSTOM;
 
-  JMNotificationFilter = interface;
-  Arr1JMNotificationFilter = array of JMNotificationFilter;
-  Arr2JMNotificationFilter = array of Arr1JMNotificationFilter;
-  Arr3JMNotificationFilter = array of Arr2JMNotificationFilter;
-
   JSIRSAPrivateKey = interface;
   Arr1JSIRSAPrivateKey = array of JSIRSAPrivateKey;
   Arr2JSIRSAPrivateKey = array of Arr1JSIRSAPrivateKey;
   Arr3JSIRSAPrivateKey = array of Arr2JSIRSAPrivateKey;
 
+  JMNotificationFilter = interface;
+  Arr1JMNotificationFilter = array of JMNotificationFilter;
+  Arr2JMNotificationFilter = array of Arr1JMNotificationFilter;
+  Arr3JMNotificationFilter = array of Arr2JMNotificationFilter;
+
   JXWBindingType = interface;
   Arr1JXWBindingType = array of JXWBindingType;
   Arr2JXWBindingType = array of Arr1JXWBindingType;
@@ -20480,11 +20425,6 @@ type
   Arr2JSIDSAPrivateKey = array of Arr1JSIDSAPrivateKey;
   Arr3JSIDSAPrivateKey = array of Arr2JSIDSAPrivateKey;
 
-  JLIterable = interface;
-  Arr1JLIterable = array of JLIterable;
-  Arr2JLIterable = array of Arr1JLIterable;
-  Arr3JLIterable = array of Arr2JLIterable;
-
   OOCDomainManagerOperations = interface;
   Arr1OOCDomainManagerOperations = array of OOCDomainManagerOperations;
   Arr2OOCDomainManagerOperations = array of Arr1OOCDomainManagerOperations;
@@ -20660,16 +20600,16 @@ type
   Arr2JSETreeModelListener = array of Arr1JSETreeModelListener;
   Arr3JSETreeModelListener = array of Arr2JSETreeModelListener;
 
-  JUListIterator = interface;
-  Arr1JUListIterator = array of JUListIterator;
-  Arr2JUListIterator = array of Arr1JUListIterator;
-  Arr3JUListIterator = array of Arr2JUListIterator;
-
   JAPostConstruct = interface;
   Arr1JAPostConstruct = array of JAPostConstruct;
   Arr2JAPostConstruct = array of Arr1JAPostConstruct;
   Arr3JAPostConstruct = array of Arr2JAPostConstruct;
 
+  JUListIterator = interface;
+  Arr1JUListIterator = array of JUListIterator;
+  Arr2JUListIterator = array of Arr1JUListIterator;
+  Arr3JUListIterator = array of Arr2JUListIterator;
+
   JRAActivationMonitor = interface;
   Arr1JRAActivationMonitor = array of JRAActivationMonitor;
   Arr2JRAActivationMonitor = array of Arr1JRAActivationMonitor;
@@ -20785,6 +20725,11 @@ type
   Arr2JLThrowable = array of Arr1JLThrowable;
   Arr3JLThrowable = array of Arr2JLThrowable;
 
+  JLInteger = class external 'java.lang' name 'Integer';
+  Arr1JLInteger = array of JLInteger;
+  Arr2JLInteger = array of Arr1JLInteger;
+  Arr3JLInteger = array of Arr2JLInteger;
+
   JLObject = class external 'java.lang' name 'Object';
   Arr1JLObject = array of JLObject;
   Arr2JLObject = array of Arr1JLObject;
@@ -20795,6 +20740,16 @@ type
   Arr2JLLinkageError = array of Arr1JLLinkageError;
   Arr3JLLinkageError = array of Arr2JLLinkageError;
 
+  JLEnum = class external 'java.lang' name 'Enum';
+  Arr1JLEnum = array of JLEnum;
+  Arr2JLEnum = array of Arr1JLEnum;
+  Arr3JLEnum = array of Arr2JLEnum;
+
+  JUAbstractMap = class external 'java.util' name 'AbstractMap';
+  Arr1JUAbstractMap = array of JUAbstractMap;
+  Arr2JUAbstractMap = array of Arr1JUAbstractMap;
+  Arr3JUAbstractMap = array of Arr2JUAbstractMap;
+
   JLError = class external 'java.lang' name 'Error';
   Arr1JLError = array of JLError;
   Arr2JLError = array of Arr1JLError;
@@ -20820,36 +20775,91 @@ type
   Arr2JLIndexOutOfBoundsException = array of Arr1JLIndexOutOfBoundsException;
   Arr3JLIndexOutOfBoundsException = array of Arr2JLIndexOutOfBoundsException;
 
+  JUHashMap = class external 'java.util' name 'HashMap';
+  Arr1JUHashMap = array of JUHashMap;
+  Arr2JUHashMap = array of Arr1JUHashMap;
+  Arr3JUHashMap = array of Arr2JUHashMap;
+
   JTCollator = class external 'java.text' name 'Collator';
   Arr1JTCollator = array of JTCollator;
   Arr2JTCollator = array of Arr1JTCollator;
   Arr3JTCollator = array of Arr2JTCollator;
 
-  JLIllegalArgumentException = class external 'java.lang' name 'IllegalArgumentException';
-  Arr1JLIllegalArgumentException = array of JLIllegalArgumentException;
-  Arr2JLIllegalArgumentException = array of Arr1JLIllegalArgumentException;
-  Arr3JLIllegalArgumentException = array of Arr2JLIllegalArgumentException;
+  JLBoolean = class external 'java.lang' name 'Boolean';
+  Arr1JLBoolean = array of JLBoolean;
+  Arr2JLBoolean = array of Arr1JLBoolean;
+  Arr3JLBoolean = array of Arr2JLBoolean;
+
+  JLClass = class external 'java.lang' name 'Class';
+  Arr1JLClass = array of JLClass;
+  Arr2JLClass = array of Arr1JLClass;
+  Arr3JLClass = array of Arr2JLClass;
 
   JLString = class external 'java.lang' name 'String';
   Arr1JLString = array of JLString;
   Arr2JLString = array of Arr1JLString;
   Arr3JLString = array of Arr2JLString;
 
-  JLClass = class external 'java.lang' name 'Class';
-  Arr1JLClass = array of JLClass;
-  Arr2JLClass = array of Arr1JLClass;
-  Arr3JLClass = array of Arr2JLClass;
+  JLIllegalArgumentException = class external 'java.lang' name 'IllegalArgumentException';
+  Arr1JLIllegalArgumentException = array of JLIllegalArgumentException;
+  Arr2JLIllegalArgumentException = array of Arr1JLIllegalArgumentException;
+  Arr3JLIllegalArgumentException = array of Arr2JLIllegalArgumentException;
 
   JLFloat = class external 'java.lang' name 'Float';
   Arr1JLFloat = array of JLFloat;
   Arr2JLFloat = array of Arr1JLFloat;
   Arr3JLFloat = array of Arr2JLFloat;
 
+  JLLong = class external 'java.lang' name 'Long';
+  Arr1JLLong = array of JLLong;
+  Arr2JLLong = array of Arr1JLLong;
+  Arr3JLLong = array of Arr2JLLong;
+
   JLRuntimeException = class external 'java.lang' name 'RuntimeException';
   Arr1JLRuntimeException = array of JLRuntimeException;
   Arr2JLRuntimeException = array of Arr1JLRuntimeException;
   Arr3JLRuntimeException = array of Arr2JLRuntimeException;
 
+  JLIterable = interface external 'java.lang' name 'Iterable';
+  Arr1JLIterable = array of JLIterable;
+  Arr2JLIterable = array of Arr1JLIterable;
+  Arr3JLIterable = array of Arr2JLIterable;
+
+  JLCloneable = interface external 'java.lang' name 'Cloneable';
+  Arr1JLCloneable = array of JLCloneable;
+  Arr2JLCloneable = array of Arr1JLCloneable;
+  Arr3JLCloneable = array of Arr2JLCloneable;
+
+  JUCollection = interface external 'java.util' name 'Collection';
+  Arr1JUCollection = array of JUCollection;
+  Arr2JUCollection = array of Arr1JUCollection;
+  Arr3JUCollection = array of Arr2JUCollection;
+
+  JLAppendable = interface external 'java.lang' name 'Appendable';
+  Arr1JLAppendable = array of JLAppendable;
+  Arr2JLAppendable = array of Arr1JLAppendable;
+  Arr3JLAppendable = array of Arr2JLAppendable;
+
+  JUMap = interface external 'java.util' name 'Map';
+  Arr1JUMap = array of JUMap;
+  Arr2JUMap = array of Arr1JUMap;
+  Arr3JUMap = array of Arr2JUMap;
+
+  JUSet = interface external 'java.util' name 'Set';
+  Arr1JUSet = array of JUSet;
+  Arr2JUSet = array of Arr1JUSet;
+  Arr3JUSet = array of Arr2JUSet;
+
+  JLRType = interface external 'java.lang.reflect' name 'Type';
+  Arr1JLRType = array of JLRType;
+  Arr2JLRType = array of Arr1JLRType;
+  Arr3JLRType = array of Arr2JLRType;
+
+  JLComparable = interface external 'java.lang' name 'Comparable';
+  Arr1JLComparable = array of JLComparable;
+  Arr2JLComparable = array of Arr1JLComparable;
+  Arr3JLComparable = array of Arr2JLComparable;
+
   JLCharSequence = interface external 'java.lang' name 'CharSequence';
   Arr1JLCharSequence = array of JLCharSequence;
   Arr2JLCharSequence = array of Arr1JLCharSequence;
@@ -20865,36 +20875,16 @@ type
   Arr2JLRAnnotatedElement = array of Arr1JLRAnnotatedElement;
   Arr3JLRAnnotatedElement = array of Arr2JLRAnnotatedElement;
 
-  JLCloneable = interface external 'java.lang' name 'Cloneable';
-  Arr1JLCloneable = array of JLCloneable;
-  Arr2JLCloneable = array of Arr1JLCloneable;
-  Arr3JLCloneable = array of Arr2JLCloneable;
-
   JUComparator = interface external 'java.util' name 'Comparator';
   Arr1JUComparator = array of JUComparator;
   Arr2JUComparator = array of Arr1JUComparator;
   Arr3JUComparator = array of Arr2JUComparator;
 
-  JLAppendable = interface external 'java.lang' name 'Appendable';
-  Arr1JLAppendable = array of JLAppendable;
-  Arr2JLAppendable = array of Arr1JLAppendable;
-  Arr3JLAppendable = array of Arr2JLAppendable;
-
-  JLRType = interface external 'java.lang.reflect' name 'Type';
-  Arr1JLRType = array of JLRType;
-  Arr2JLRType = array of Arr1JLRType;
-  Arr3JLRType = array of Arr2JLRType;
-
   JISerializable = interface external 'java.io' name 'Serializable';
   Arr1JISerializable = array of JISerializable;
   Arr2JISerializable = array of Arr1JISerializable;
   Arr3JISerializable = array of Arr2JISerializable;
 
-  JLComparable = interface external 'java.lang' name 'Comparable';
-  Arr1JLComparable = array of JLComparable;
-  Arr2JLComparable = array of Arr1JLComparable;
-  Arr3JLComparable = array of Arr2JLComparable;
-
 
   CSJSPWDesktopProperty = class external 'com.sun.java.swing.plaf.windows' name 'DesktopProperty'
   end;