Explorar o código

+ ansistring support. Items of note:
o support for ansistring constants. It's done via a detour because the
JVM only supports UTF-16 string constants (no array of byte or anything
like that): store every ansicharacter in the lower 8 bits of an
UTF-16 constant string, and at run time copy the characters to an
ansistring. The alternative is to generate code that stores every
character separately to an array.
o the base ansistring support is implemented in a class called
AnsistringClass, and an ansistring is simply an instance of this
class under the hood
o the compiler currently does generate nil pointers as empty
ansistrings unlike for unicodestrings, where we always
explicitly generate an empty string. The reason is that
unicodestrings are the same as JLString and hence common
for Java interoperation, while ansistrings are unlikely to
be used in interaction with external Java code

* fixed indentation

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

Jonas Maebe %!s(int64=14) %!d(string=hai) anos
pai
achega
446d91eaab

+ 1 - 0
.gitattributes

@@ -7349,6 +7349,7 @@ rtl/inc/wstrings.inc svneol=native#text/plain
 rtl/inc/wustrings.inc svneol=native#text/plain
 rtl/java/Makefile svneol=native#text/plain
 rtl/java/Makefile.fpc svneol=native#text/plain
+rtl/java/astringh.inc svneol=native#text/plain
 rtl/java/astrings.inc svneol=native#text/plain
 rtl/java/compproc.inc svneol=native#text/plain
 rtl/java/java_sys.inc svneol=native#text/plain

+ 5 - 4
compiler/agjasmin.pas

@@ -187,10 +187,11 @@ implementation
                  inc(runlen);
                end
              else
-               // since Jasmin expects an UTF-16 string, we can't safely
-               // have high ASCII characters since they'll be
-               // re-interpreted as utf-16 anyway
-               internalerror(2010122808);
+               begin
+                 { see comments in njvmcon }
+                 flush;
+                 result:=result+'\u'+hexstr(ord(p[i]),4)
+               end;
            end;
          end;
        flush;

+ 2 - 0
compiler/jvm/hlcgcpu.pas

@@ -1340,6 +1340,8 @@ implementation
       { highloc is invalid, the length is part of the array in Java }
       if is_wide_or_unicode_string(t) then
         g_call_system_proc(list,'fpc_initialize_array_unicodestring')
+      else if is_ansistring(t) then
+        g_call_system_proc(list,'fpc_initialize_array_ansistring')
       else if is_dynamic_array(t) then
         g_call_system_proc(list,'fpc_initialize_array_dynarr')
       else if is_record(t) then

+ 1 - 1
compiler/jvm/njvmadd.pas

@@ -87,7 +87,7 @@ interface
           addn:
             begin
 {$ifndef nounsupported}
-               if not is_wide_or_unicode_string(resultdef) then
+               if is_shortstring(resultdef) then
                  begin
                    result:=left;
                    left:=nil;

+ 28 - 7
compiler/jvm/njvmcnv.pas

@@ -751,18 +751,37 @@ implementation
       end;
 
     function isstringconv(fromdef, todef: tdef): boolean;
+
+      function unicodestrcompatible(def: tdef): boolean;
+        begin
+          result:=
+            (def=java_jlobject) or
+            (def=java_jlstring);
+        end;
+
+      function ansistrcompatible(def: tdef): boolean;
+        begin
+          result:=
+            (def=java_jlobject) or
+            (def=java_ansistring);
+        end;
+
       begin
         if is_wide_or_unicode_string(todef) then
           begin
-            result:=
-              (fromdef=java_jlobject) or
-              (fromdef=java_jlstring)
+            result:=unicodestrcompatible(fromdef)
           end
         else if is_wide_or_unicode_string(fromdef) then
           begin
-            result:=
-              (todef=java_jlobject) or
-              (todef=java_jlstring)
+            result:=unicodestrcompatible(todef);
+          end
+        else if is_ansistring(todef) then
+          begin
+            result:=ansistrcompatible(fromdef);
+          end
+        else if is_ansistring(fromdef) then
+          begin
+            result:=ansistrcompatible(todef);
           end
         else
           result:=false;
@@ -937,7 +956,9 @@ implementation
         checkdef:=java_jlobject
 {$endif}
       else if is_wide_or_unicode_string(checkdef) then
-        checkdef:=java_jlstring;
+        checkdef:=java_jlstring
+      else if is_ansistring(checkdef) then
+        checkdef:=java_ansistring;
       if checkdef.typ in [objectdef,recorddef] then
         current_asmdata.CurrAsmList.concat(taicpu.op_sym(opcode,current_asmdata.RefAsmSymbol(tabstractrecorddef(checkdef).jvm_full_typename(true))))
       else if checkdef.typ=classrefdef then

+ 45 - 3
compiler/jvm/njvmcon.pas

@@ -35,6 +35,7 @@ interface
        end;
 
        tjvmstringconstnode = class(tstringconstnode)
+          function pass_1: tnode; override;
           procedure pass_generate_code;override;
        end;
 
@@ -42,9 +43,10 @@ interface
 implementation
 
     uses
-      globtype,widestr,
-      symdef,symtable,symconst,
+      globtype,cutils,widestr,verbose,
+      symdef,symsym,symtable,symconst,
       aasmdata,aasmcpu,defutil,
+      ncal,
       cgbase,hlcgobj,hlcgcpu,cgutils,cpubase
       ;
 
@@ -64,12 +66,52 @@ implementation
 
     { tcgstringconstnode }
 
+    function tjvmstringconstnode.pass_1: tnode;
+      var
+        astrclass: tobjectdef;
+        psym: tsym;
+        pw: pcompilerwidestring;
+      begin
+        { all Java strings are utf-16. However, there is no way to
+          declare a constant array of bytes (or any other type), those
+          have to be constructed by declaring a final field and then
+          initialising them in the class constructor element per
+          element. We therefore put the straight ASCII values into
+          the UTF-16 string, and then at run time extract those and
+          store them in an Ansistring/AnsiChar array }
+        result:=inherited pass_1;
+        if assigned(result) or
+           (cst_type in [cst_unicodestring,cst_widestring]) then
+          exit;
+        { convert the constant into a widestring representation without any
+          code page conversion }
+        initwidestring(pw);
+        ascii2unicode(value_str,len,pw,false);
+        ansistringdispose(value_str,len);
+        pcompilerwidestring(value_str):=pw;
+        cst_type:=cst_unicodestring;
+        { and now add a node to convert the data into ansistring format at
+          run time }
+        astrclass:=tobjectdef(search_system_type('ANSISTRINGCLASS').typedef);
+        psym:=search_struct_member(astrclass,'CREATEFROMLITERALSTRINGBYTES');
+        if not assigned(psym) or
+           (psym.typ<>procsym) then
+          internalerror(2011052001);
+        { since self will be freed, have to make a copy }
+        result:=ccallnode.create(ccallparanode.create(self.getcopy,nil),
+          tprocsym(psym),psym.owner,nil,[]);
+      end;
+
+
     procedure tjvmstringconstnode.pass_generate_code;
       begin
         location_reset(location,LOC_REGISTER,def_cgsize(resultdef));
         location.register:=hlcg.getaddressregister(current_asmdata.CurrAsmList,resultdef);
         case cst_type of
-          cst_ansistring,
+          cst_ansistring:
+            begin
+              current_asmdata.CurrAsmList.concat(taicpu.op_string(a_ldc,len,value_str));
+            end;
           cst_shortstring,
           cst_conststring:
             current_asmdata.CurrAsmList.concat(taicpu.op_string(a_ldc,len,value_str));

+ 18 - 9
compiler/jvm/njvminl.pas

@@ -446,12 +446,15 @@ implementation
         newstatement: tstatementnode;
         lefttemp: ttempcreatenode;
         assignmenttarget: tnode;
+        stringtype: tstringdef;
       begin
-        if is_wide_or_unicode_string(left.resultdef) then
+        if is_wide_or_unicode_string(left.resultdef) or
+           is_ansistring(left.resultdef) then
           begin
+            stringtype:=tstringdef(left.resultdef);
             { store left into a temp in case it may contain a function call
               (which must not be evaluated twice) }
-            lefttemp:=maybereplacewithtempref(tcallparanode(left).left,tcallparanode(left).left.resultdef.size,false);
+            lefttemp:=maybereplacewithtempref(tcallparanode(left).left,stringtype.size,false);
             if assigned(lefttemp) then
               begin
                 newblock:=internalstatements(newstatement);
@@ -464,7 +467,7 @@ implementation
             { back to original order for the call }
             left:=reverseparameters(tcallparanode(left));
             result:=cassignmentnode.create(assignmenttarget,
-              ccallnode.createintern('fpc_unicodestr_setlength',left));
+              ccallnode.createintern('fpc_'+stringtype.stringtypname+'_setlength',left));
             if assigned(lefttemp) then
               begin
                 addstatement(newstatement,result);
@@ -518,30 +521,36 @@ implementation
         stringnonnull,
         stringnull: tnode;
         psym: tsym;
+        stringclass: tdef;
       begin
-        if is_wide_or_unicode_string(left.resultdef) then
+        if is_wide_or_unicode_string(left.resultdef) or
+           is_ansistring(left.resultdef) then
           begin
-            { if assigned(JLString(left)) then
-                lentemp:=JLString(left).length()
+            { if assigned(stringclass(left)) then
+                lentemp:=stringclass(left).length()
               else
                 lentemp:=0;
               --> return lentemp
             }
+            if is_ansistring(left.resultdef) then
+              stringclass:=java_ansistring
+            else
+              stringclass:=java_jlstring;
             newblock:=internalstatements(newstatement);
             lentemp:=ctempcreatenode.create(s32inttype,s32inttype.size,tt_persistent,true);
             addstatement(newstatement,lentemp);
             { if-condition }
             ifcond:=cinlinenode.create(in_assigned_x,false,
-              ccallparanode.create(ctypeconvnode.create_explicit(left.getcopy,java_jlstring),nil));
+              ccallparanode.create(ctypeconvnode.create_explicit(left.getcopy,stringclass),nil));
             { then-path (reuse left, since last use) }
-            psym:=search_struct_member(java_jlstring,'LENGTH');
+            psym:=search_struct_member(tabstractrecorddef(stringclass),'LENGTH');
             if not assigned(psym) or
                (psym.typ<>procsym) then
               internalerror(2011031403);
             stringnonnull:=cassignmentnode.create(
               ctemprefnode.create(lentemp),
               ccallnode.create(nil,tprocsym(psym),psym.owner,
-                ctypeconvnode.create_explicit(left,java_jlstring),[]));
+                ctypeconvnode.create_explicit(left,stringclass),[]));
             left:=nil;
             { else-path}
             stringnull:=cassignmentnode.create(

+ 2 - 5
compiler/jvm/njvmld.pas

@@ -68,11 +68,8 @@ function tjvmassignmentnode.pass_1: tnode;
     }
     target:=left.actualtargetnode;
     if (target.nodetype=vecn) and
-       (is_wide_or_unicode_string(tvecnode(target).left.resultdef)
-{$ifndef nounsupported}
-        or is_ansistring(tvecnode(target).left.resultdef)
-{$endif}
-       ) then
+       (is_wide_or_unicode_string(tvecnode(target).left.resultdef) or
+        is_ansistring(tvecnode(target).left.resultdef)) then
       begin
         { prevent errors in case of an expression such as
             word(str[x]):=1234;

+ 9 - 3
compiler/jvm/njvmmem.pas

@@ -163,17 +163,23 @@ implementation
     function tjvmvecnode.pass_1: tnode;
       var
         psym: tsym;
+        stringclass: tdef;
       begin
-        if is_wide_or_unicode_string(left.resultdef) then
+        if is_wide_or_unicode_string(left.resultdef) or
+           is_ansistring(left.resultdef) then
           begin
-            psym:=search_struct_member(java_jlstring,'CHARAT');
+            if is_ansistring(left.resultdef) then
+              stringclass:=java_ansistring
+            else
+              stringclass:=java_jlstring;
+            psym:=search_struct_member(tabstractrecorddef(stringclass),'CHARAT');
             if not assigned(psym) or
                (psym.typ<>procsym) then
               internalerror(2011031501);
             { Pascal strings are 1-based, Java strings 0-based }
             result:=ccallnode.create(ccallparanode.create(
               caddnode.create(subn,right,genintconstnode(1)),nil),tprocsym(psym),
-              psym.owner,ctypeconvnode.create_explicit(left,java_jlstring),[]);
+              psym.owner,ctypeconvnode.create_explicit(left,stringclass),[]);
             left:=nil;
             right:=nil;
             exit;

+ 3 - 9
compiler/jvmdef.pas

@@ -182,7 +182,7 @@ implementation
       end;
 
 
-    function jvmaddencodedtypeintern(def: tdef; bpacked: boolean; var encodedstr: string; forcesignature: boolean; out founderror: tdef): boolean;
+    function jvmaddencodedtype(def: tdef; bpacked: boolean; var encodedstr: string; forcesignature: boolean; out founderror: tdef): boolean;
       var
         c: char;
       begin
@@ -195,9 +195,9 @@ implementation
                 st_widestring,
                 st_unicodestring:
                   encodedstr:=encodedstr+'Ljava/lang/String;';
-{$ifndef nounsupported}
                 st_ansistring:
-                  encodedstr:=encodedstr+'Lorg/freepascal/rtl/AnsiString;';
+                  result:=jvmaddencodedtype(java_ansistring,false,encodedstr,forcesignature,founderror);
+{$ifndef nounsupported}
                 st_shortstring:
                   encodedstr:=encodedstr+'Lorg/freepascal/rtl/ShortString;';
 {$else}
@@ -362,12 +362,6 @@ implementation
       end;
 
 
-    function jvmaddencodedtype(def: tdef; bpacked: boolean; var encodedstr: string; forcesignature: boolean; out founderror: tdef): boolean;
-      begin
-        result:=jvmaddencodedtypeintern(def,bpacked,encodedstr,forcesignature,founderror);
-      end;
-
-
     function jvmtryencodetype(def: tdef; out encodedtype: string; forcesignature: boolean; out founderror: tdef): boolean;
       begin
         encodedtype:='';

+ 9 - 3
compiler/ncnv.pas

@@ -3116,9 +3116,15 @@ implementation
         restemp  : ttempcreatenode;
       begin
 {$if defined(jvm) and not defined(nounsupported)}
-        convtype:=tc_equal;
-        result:=nil;
-        exit;
+        if (not is_ansistring(left.resultdef) and
+            not is_unicodestring(left.resultdef)) or
+           (not is_ansistring(resultdef) and
+            not is_unicodestring(resultdef)) then
+          begin
+            convtype:=tc_equal;
+            result:=nil;
+            exit;
+          end;
 {$endif}
         { get the correct procedure name }
         procname := 'fpc_'+tstringdef(left.resultdef).stringtypname+

+ 2 - 0
compiler/pdecobj.pas

@@ -1295,6 +1295,8 @@ implementation
                         java_fpcbaserecordtype:=current_objectdef;
                       if (current_objectdef.objname^='JLSTRING') then
                         java_jlstring:=current_objectdef;
+                      if (current_objectdef.objname^='ANSISTRINGCLASS') then
+                        java_ansistring:=current_objectdef;
                     end;
                 end;
               end;

+ 10 - 3
compiler/symdef.pas

@@ -798,6 +798,8 @@ interface
        java_fpcbaserecordtype    : tobjectdef;
        { java.lang.String }
        java_jlstring             : tobjectdef;
+       { FPC java implementation of ansistrings }
+       java_ansistring           : tobjectdef;
 
     const
 {$ifdef i386}
@@ -1607,9 +1609,12 @@ implementation
       begin
         result:=
           (target_info.system=system_jvm_java32) and
-          (stringtype in [st_unicodestring,st_widestring]) and
-          ((d=java_jlobject) or
-           (d=java_jlstring));
+          (((stringtype in [st_unicodestring,st_widestring]) and
+            ((d=java_jlobject) or
+             (d=java_jlstring))) or
+           ((stringtype=st_ansistring) and
+            (d=java_jlobject) or
+            (d=java_ansistring)));
       end;
 
 
@@ -4832,6 +4837,8 @@ implementation
                java_fpcbaserecordtype:=self;
              if (objname^='JLSTRING') then
                java_jlstring:=self;
+             if (objname^='ANSISTRINGCLASS') then
+               java_ansistring:=self;
            end;
          writing_class_record_dbginfo:=false;
        end;

+ 4 - 3
compiler/widestr.pas

@@ -52,7 +52,7 @@ unit widestr;
     procedure copywidestring(s,d : pcompilerwidestring);
     function asciichar2unicode(c : char) : tcompilerwidechar;
     function unicode2asciichar(c : tcompilerwidechar) : char;
-    procedure ascii2unicode(p : pchar;l : SizeInt;r : pcompilerwidestring);
+    procedure ascii2unicode(p : pchar;l : SizeInt;r : pcompilerwidestring;codepagetranslation : boolean = true);
     procedure unicode2ascii(r : pcompilerwidestring;p : pchar);
     function hasnonasciichars(const p: pcompilerwidestring): boolean;
     function getcharwidestring(r : pcompilerwidestring;l : SizeInt) : tcompilerwidechar;
@@ -180,7 +180,7 @@ unit widestr;
           unicode2asciichar:='?';
       end;
 
-    procedure ascii2unicode(p : pchar;l : SizeInt;r : pcompilerwidestring);
+    procedure ascii2unicode(p : pchar;l : SizeInt;r : pcompilerwidestring;codepagetranslation : boolean = true);
       var
          source : pchar;
          dest   : tcompilerwidecharptr;
@@ -191,7 +191,8 @@ unit widestr;
          setlengthwidestring(r,l);
          source:=p;
          dest:=tcompilerwidecharptr(r^.data);
-         if (current_settings.sourcecodepage <> 'utf8') then
+         if (current_settings.sourcecodepage <> 'utf8') and
+            codepagetranslation then
            begin
              for i:=1 to l do
                 begin

+ 89 - 0
rtl/java/astringh.inc

@@ -0,0 +1,89 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 1999-2005 by Florian Klaempfl,
+    member of the Free Pascal development team.
+
+    This file implements support routines for UnicodeStrings with FPC
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+type
+  TAnsiCharArray = array of ansichar;
+  AnsistringClass = class sealed
+   private
+    fdata: TAnsiCharArray;
+   public
+    constructor Create(const arr: array of ansichar);overload;
+    constructor Create(const arr: array of unicodechar);overload;
+    constructor Create(const u: unicodestring);overload;
+    constructor Create(const a: ansistring);overload;
+    constructor Create(ch: ansichar);overload;
+    constructor Create(ch: unicodechar);overload;
+    class function CreateFromLiteralStringBytes(const u: unicodestring): ansistring; static;
+    function charAt(index: jint): ansichar;
+    function toUnicodeString: unicodestring;
+    function toString: JLString; override;
+//    function concat(const a: ansistring): ansistring;
+//    function concatmultiple(const arr: array of ansistring): ansistring;
+    function length: jint;
+  end;
+
+Function Pos (Const Substr : Ansistring; Const Source : Ansistring) : SizeInt;
+Function Pos (c : AnsiChar; Const s : Ansistring) : SizeInt;
+//Function Pos (c : AnsiString; Const s : UnicodeString) : SizeInt;
+//Function Pos (c : UnicodeString; Const s : AnsiString) : SizeInt;
+//Function Pos (c : ShortString; Const s : UnicodeString) : SizeInt;
+
+Function UpCase(const s : Ansistring) : Ansistring;
+//Function UpCase(c:UnicodeChar):UnicodeChar;
+
+//Procedure Insert (Const Source : UnicodeString; Var S : UnicodeString; Index : SizeInt);
+//Procedure Delete (Var S : UnicodeString; Index,Size: SizeInt);
+//Procedure SetString (Out S : UnicodeString; Buf : PUnicodeChar; Len : SizeInt);
+//Procedure SetString (Out S : UnicodeString; Buf : PChar; Len : SizeInt);
+//
+//function WideCharToString(S : PWideChar) : AnsiString;
+//function StringToWideChar(const Src : AnsiString;Dest : PWideChar;DestSize : SizeInt) : PWideChar;
+//function WideCharLenToString(S : PWideChar;Len : SizeInt) : AnsiString;
+//procedure WideCharLenToStrVar(Src : PWideChar;Len : SizeInt;out Dest : AnsiString);
+//procedure WideCharToStrVar(S : PWideChar;out Dest : AnsiString);
+//
+//function UnicodeCharToString(S : PUnicodeChar) : AnsiString;
+//function StringToUnicodeChar(const Src : AnsiString;Dest : PUnicodeChar;DestSize : SizeInt) : PUnicodeChar;
+//function UnicodeCharLenToString(S : PUnicodeChar;Len : SizeInt) : AnsiString;
+//procedure UnicodeCharLenToStrVar(Src : PUnicodeChar;Len : SizeInt;out Dest : AnsiString);
+//procedure UnicodeCharToStrVar(S : PUnicodeChar;out Dest : AnsiString);
+//
+//procedure DefaultUnicode2AnsiMove(source:punicodechar;var dest:ansistring;len:SizeInt);
+//procedure DefaultAnsi2UnicodeMove(source:pchar;var dest:unicodestring;len:SizeInt);
+
+//function UnicodeToUtf8(Dest: PChar; Source: PUnicodeChar; MaxBytes: SizeInt): SizeInt;{$ifdef SYSTEMINLINE}inline;{$endif}
+//function UnicodeToUtf8(Dest: PChar; MaxDestBytes: SizeUInt; Source: PUnicodeChar; SourceChars: SizeUInt): SizeUInt;
+//function Utf8ToUnicode(Dest: PUnicodeChar; Source: PChar; MaxChars: SizeInt): SizeInt;{$ifdef SYSTEMINLINE}inline;{$endif}
+//function Utf8ToUnicode(Dest: PUnicodeChar; MaxDestChars: SizeUInt; Source: PChar; SourceBytes: SizeUInt): SizeUInt;
+//function UTF8Encode(const s : Ansistring) : UTF8String; inline;
+//function UTF8Encode(const s : UnicodeString) : UTF8String;
+//function UTF8Decode(const s : UTF8String): UnicodeString;
+//function AnsiToUtf8(const s : ansistring): UTF8String;{$ifdef SYSTEMINLINE}inline;{$endif}
+//function Utf8ToAnsi(const s : UTF8String) : ansistring;{$ifdef SYSTEMINLINE}inline;{$endif}
+//function UnicodeStringToUCS4String(const s : UnicodeString) : UCS4String;
+//function UCS4StringToUnicodeString(const s : UCS4String) : UnicodeString;
+//function WideStringToUCS4String(const s : WideString) : UCS4String;
+//function UCS4StringToWideString(const s : UCS4String) : WideString;
+
+//Procedure GetWideStringManager (Var Manager : TUnicodeStringManager);
+//Procedure SetWideStringManager (Const New : TUnicodeStringManager);
+//Procedure SetWideStringManager (Const New : TUnicodeStringManager; Var Old: TUnicodeStringManager);
+
+//Procedure GetUnicodeStringManager (Var Manager : TUnicodeStringManager);
+//Procedure SetUnicodeStringManager (Const New : TUnicodeStringManager);
+//Procedure SetUnicodeStringManager (Const New : TUnicodeStringManager; Var Old: TUnicodeStringManager);
+
+

+ 244 - 353
rtl/java/astrings.inc

@@ -17,194 +17,180 @@
 { This will release some functions for special shortstring support }
 { define EXTRAANSISHORT}
 
-{
-  This file contains the implementation of the AnsiString type,
-  and all things that are needed for it.
-  AnsiString is defined as a 'silent' pchar :
-  a pchar that points to :
-
-  @-8  : SizeInt for reference count;
-  @-4  : SizeInt for size;
-  @    : String + Terminating #0;
-  Pchar(Ansistring) is a valid typecast.
-  So AS[i] is converted to the address @AS+i-1.
-
-  Constants should be assigned a reference count of -1
-  Meaning that they can't be disposed of.
-}
-(*
-Type
-  PAnsiRec = ^TAnsiRec;
-  TAnsiRec = Packed Record
-    Ref,
-    Len   : SizeInt;
-    First : Char;
-  end;
-
-Const
-  AnsiRecLen = SizeOf(TAnsiRec);
-  FirstOff   = SizeOf(TAnsiRec)-1;
-*)
-
-{****************************************************************************
-                    Internal functions, not in interface.
-****************************************************************************}
+constructor AnsistringClass.Create(const arr: array of ansichar);
+begin
+  { make explicit copy so that changing the array afterwards doesn't change
+    the string }
+  if high(arr)=-1 then
+    exit;
+  setlength(fdata,high(arr)+1);
+  JLSystem.ArrayCopy(JLObject(@arr),0,JLObject(fdata),0,high(arr)+1);
+end;
 
 
-(*
-Function NewAnsiString(Len : SizeInt) : Pointer;
-{
-  Allocate a new AnsiString on the heap.
-  initialize it to zero length and reference count 1.
-}
-Var
-  P : Pointer;
+constructor AnsistringClass.Create(const arr: array of unicodechar);
 begin
-  { request a multiple of 16 because the heap manager alloctes anyways chunks of 16 bytes }
-  GetMem(P,Len+AnsiRecLen);
-  If P<>Nil then
-   begin
-     PAnsiRec(P)^.Ref:=1;         { Set reference count }
-     PAnsiRec(P)^.Len:=0;         { Initial length }
-     PAnsiRec(P)^.First:=#0;      { Terminating #0 }
-     inc(p,firstoff);             { Points to string now }
-   end;
-  NewAnsiString:=P;
+  if high(arr)=-1 then
+    exit;
+  fdata:=TAnsiCharArray(JLString.Create(arr).getBytes);
 end;
 
 
-Procedure DisposeAnsiString(Var S : Pointer); {$IFNDEF VER2_0} Inline; {$ENDIF}
-{
-  Deallocates a AnsiString From the heap.
-}
+constructor AnsistringClass.Create(const u: unicodestring);
 begin
-  If S=Nil then
+  if system.length(u)=0 then
     exit;
-  Dec (S,FirstOff);
-  FreeMem (S);
-  S:=Nil;
+  fdata:=TAnsiCharArray(JLString(u).getBytes);
 end;
 
-{$ifndef FPC_SYSTEM_HAS_ANSISTR_DECR_REF}
-Procedure fpc_ansistr_decr_ref (Var S : Pointer); [Public,Alias:'FPC_ANSISTR_DECR_REF'];  compilerproc;
-{
-  Decreases the ReferenceCount of a non constant ansistring;
-  If the reference count is zero, deallocate the string;
-}
-Type
-  pSizeInt = ^SizeInt;
-Var
-  l : pSizeInt;
-Begin
-  { Zero string }
-  If S=Nil then exit;
-  { check for constant strings ...}
-  l:=@PAnsiRec(S-FirstOff)^.Ref;
-  If l^<0 then exit;
-  { declocked does a MT safe dec and returns true, if the counter is 0 }
-  If declocked(l^) then
-    { Ref count dropped to zero }
-    DisposeAnsiString (S);        { Remove...}
-end;
-
-{$endif FPC_SYSTEM_HAS_ANSISTR_DECR_REF}
-
-{ also define alias for internal use in the system unit }
-Procedure fpc_ansistr_decr_ref (Var S : Pointer); [external name 'FPC_ANSISTR_DECR_REF'];
-
-Procedure fpc_AnsiStr_Incr_Ref (S : Pointer); [Public,Alias:'FPC_ANSISTR_INCR_REF'];  compilerproc; {$IFNDEF VER2_0} Inline; {$ENDIF}
-Begin
-  If S=Nil then
-    exit;
-  { Let's be paranoid : Constant string ??}
-  If PAnsiRec(S-FirstOff)^.Ref<0 then exit;
-  inclocked(PAnsiRec(S-FirstOff)^.Ref);
+
+constructor AnsistringClass.Create(const a: ansistring);
+begin
+  Create(AnsistringClass(a).fdata);
 end;
 
 
-{ also define alias which can be used inside the system unit }
-Procedure fpc_AnsiStr_Incr_Ref (S : Pointer); [external name 'FPC_ANSISTR_INCR_REF'];
-*)
+constructor AnsistringClass.Create(ch: ansichar);
+begin
+  setlength(fdata,1);
+  fdata[0]:=ch;
+end;
 
-Procedure fpc_AnsiStr_Assign (Var DestS : jlobject;S2 : jlobject); compilerproc;
-{
-  Assigns S2 to S1 (S1:=S2), taking in account reference counts.
-}
+
+constructor AnsistringClass.Create(ch: unicodechar);
 begin
-(*
-  if DestS=S2 then
-    exit;
-  If S2<>nil then
-    If PAnsiRec(S2-FirstOff)^.Ref>0 then
-      inclocked(PAnsiRec(S2-FirstOff)^.ref);
-  { Decrease the reference count on the old S1 }
-  fpc_ansistr_decr_ref (DestS);
-  { And finally, have DestS pointing to S2 (or its copy) }
-  DestS:=S2;
-*)
+  fdata:=TAnsiCharArray(JLString.Create(ch).getBytes);
 end;
-(*
-{ alias for internal use }
-Procedure fpc_AnsiStr_Assign (Var S1 : Pointer;S2 : Pointer);[external name 'FPC_ANSISTR_ASSIGN'];
-*)
 
-function fpc_AnsiStr_Concat (const S1,S2 : AnsiString): ansistring; compilerproc;
-(*
-Var
-  Size,Location : SizeInt;
-  pc : pchar;
-*)
+
+class function AnsistringClass.CreateFromLiteralStringBytes(const u: unicodestring): ansistring;
+var
+  res: AnsistringClass;
+  i: longint;
 begin
-(*
-  { only assign if s1 or s2 is empty }
-  if (S1='') then
-    begin
-      result:=s2;
-      exit;
-    end;
-  if (S2='') then
-    begin
-      result:=s1;
-      exit;
-    end;
-  Location:=Length(S1);
-  Size:=length(S2);
-  SetLength(result,Size+Location);
-  pc:=pchar(result);
-  Move(S1[1],pc^,Location);
-  inc(pc,location);
-  Move(S2[1],pc^,Size+1);
-*)
+  { used to construct constant ansisitrings for Java string constants }
+  res:=AnsistringClass.Create;
+  setlength(res.fdata,system.length(u));
+  for i:=1 to system.length(u) do
+    res.fdata[i-1]:=ansichar(ord(u[i]));
+  result:=ansistring(res);
+end;
+
+
+function AnsistringClass.charAt(index: jint): ansichar;
+begin
+  { index is already decreased by one, because same calling code is used for
+    JLString.charAt() }
+  result:=fdata[index];
+end;
+
+
+function AnsistringClass.toUnicodeString: unicodestring;
+begin
+  result:=UnicodeString(JLString.Create(TJByteArray(fdata)));
+end;
+
+
+function AnsistringClass.toString: JLString;
+begin
+  result:=JLString.Create(TJByteArray(fdata));
 end;
 
 (*
-function fpc_AnsiStr_Concat_multi (const sarr:array of Ansistring): ansistring; compilerproc;
-Var
-  i  : Longint;
-  p  : pointer;
-  pc : pchar;
-  Size,NewLen : SizeInt;
-begin
-  { First calculate size of the result so we can do
-    a single call to SetLength() }
-  NewLen:=0;
-  for i:=low(sarr) to high(sarr) do
-    inc(NewLen,length(sarr[i]));
-  SetLength(result,NewLen);
-  pc:=pchar(result);
-  for i:=low(sarr) to high(sarr) do
-    begin
-      p:=pointer(sarr[i]);
-      if assigned(p) then
-        begin
-          Size:=length(ansistring(p));
-          Move(pchar(p)^,pc^,Size+1);
-          inc(pc,size);
-        end;
-    end;
+function AnsistringClass.concat(const a: ansistring): ansistring;
+var
+  newdata: array of ansichar;
+  addlen: sizeint;
+begin
+  addlen:=length(a);
+  thislen:=this.length;
+  setlength(newdata,addlen+thislen);
+  if thislen>0 then
+    JLSystem.ArrayCopy(JLObject(fdata),0,JLObject(newdata),0,thislen);
+  if addlen>0 then
+    JLSystem.ArrayCopy(JLObject(AnsistringClass(a).fdata),0,JLObject(newdata),thislen,addlen);
+end;
+
+
+procedure AnsistringClass.concatmultiple(const arr: array of ansistring): ansistring;
+  Var
+    i  : longint;
+    size, newsize : sizeint;
+    curlen, addlen : sizeint
+    newdata: array of ansichar;
+  begin
+    { First calculate size of the result so we can allocate an array of
+      the right size }
+    NewSize:=0;
+    for i:=low(arr) to high(arr) do
+      inc(newsize,length(arr[i]));
+    setlength(newdata,newsize);
+    curlen
+    for i:=low(arr) to high(arr) do
+      begin
+        if length(arr[i])>0 then
+          sb.append(arr[i]);
+      end;
+    DestS:=sb.toString;
 end;
 *)
 
+function AnsiStringClass.length: jint;
+begin
+  result:=system.length(fdata);
+end;
+
+{****************************************************************************
+                    Internal functions, not in interface.
+****************************************************************************}
+
+function fpc_AnsiStr_Concat (const S1,S2 : AnsiString): ansistring; compilerproc;
+var
+  newdata: array of ansichar;
+  thislen, addlen: sizeint;
+begin
+  thislen:=length(s1);
+  addlen:=length(s2);
+  setlength(newdata,thislen+addlen);
+  if thislen>0 then
+    JLSystem.ArrayCopy(JLObject(AnsistringClass(s1).fdata),0,JLObject(newdata),0,thislen);
+  if addlen>0 then
+    JLSystem.ArrayCopy(JLObject(AnsistringClass(s2).fdata),0,JLObject(newdata),thislen,addlen);
+  result:=Ansistring(AnsistringClass.Create);
+  AnsistringClass(result).fdata:=newdata;
+end;
+
+
+procedure fpc_AnsiStr_Concat_multi (var DestS:Ansistring;const sarr:array of Ansistring); compilerproc;
+  Var
+    i  : longint;
+    size, newsize : sizeint;
+    curlen, addlen, nextlen : sizeint;
+    newdata: array of ansichar;
+    res : AnsistringClass;
+  begin
+    { First calculate size of the result so we can allocate an array of
+      the right size }
+    NewSize:=0;
+    for i:=low(sarr) to high(sarr) do
+      inc(newsize,length(sarr[i]));
+    setlength(newdata,newsize);
+    curlen:=0;
+    for i:=low(sarr) to high(sarr) do
+      begin
+        nextlen:=length(sarr[i]);
+        if nextlen>0 then
+          begin
+            JLSystem.ArrayCopy(JLObject(AnsistringClass(sarr[i]).fdata),0,JLObject(newdata),curlen,nextlen);
+            inc(curlen,nextlen);
+          end;
+      end;
+    res:=AnsistringClass.Create;
+    res.fdata:=newdata;
+    dests:=Ansistring(res);
+end;
+
+
 (*
 {$ifndef FPC_STRTOSHORTSTRINGPROC}
 
@@ -269,17 +255,12 @@ begin
 end;
 *)
 
-Function fpc_Char_To_AnsiStr(const c : Char): AnsiString; compilerproc;
+Function fpc_Char_To_AnsiStr(const c : AnsiChar): AnsiString; compilerproc;
 {
   Converts a Char to a AnsiString;
 }
 begin
-(*
-  Setlength (fpc_Char_To_AnsiStr,1);
-  PByte(Pointer(fpc_Char_To_AnsiStr))^:=byte(c);
-  { Terminating Zero }
-  PByte(Pointer(fpc_Char_To_AnsiStr)+1)^:=0;
-*)
+  result:=ansistring(AnsistringClass.Create(c));
 end;
 
 (*
@@ -298,57 +279,66 @@ end;
 *)
 
 
-Function fpc_CharArray_To_AnsiStr(const arr: array of char; zerobased: boolean = true): ansistring; compilerproc;
-(*
+Function fpc_CharArray_To_AnsiStr(const arr: array of ansichar; zerobased: boolean = true): ansistring; compilerproc;
 var
-  i  : SizeInt;
-*)
+  i,j  : SizeInt;
+  localarr: array of jbyte;
+  foundnull: boolean;
+  res: AnsistringClass;
 begin
-(*
   if (zerobased) then
     begin
       if (arr[0]=#0) Then
-        i := 0
-      else
       begin
-        i:=IndexChar(arr,high(arr)+1,#0);
-        if i = -1 then
-          i := high(arr)+1;
+        fpc_CharArray_To_AnsiStr := '';
+        exit;
       end;
+      foundnull:=false;
+      for i:=low(arr) to high(arr) do
+        if arr[i]=#0 then
+          begin
+            foundnull:=true;
+            break;
+          end;
+      if not foundnull then
+        begin
+          res:=AnsistringClass.Create(arr);
+          exit;
+        end
     end
   else
-    i := high(arr)+1;
-  SetLength(fpc_CharArray_To_AnsiStr,i);
-  if i > 0 then
-    Move (arr[0],Pointer(fpc_CharArray_To_AnsiStr)^,i);
-*)
+    begin
+      res:=AnsistringClass.Create(arr);
+      exit;
+    end;
+  res:=AnsistringClass.Create;
+  setlength(res.fdata,i);
+  JLSystem.ArrayCopy(JLObject(@arr),0,JLObject(res.fdata),0,i);
+  result:=Ansistring(res);
 end;
 
-procedure  fpc_ansistr_to_chararray(out res: array of char; const src: ansistring); compilerproc;
-(*
+procedure  fpc_ansistr_to_chararray(out res: array of ansichar; const src: ansistring); compilerproc;
 var
-  len: SizeInt;
-*)
+  i, len: SizeInt;
 begin
-(*
   len := length(src);
   if len > length(res) then
     len := length(res);
-{$r-}
   { make sure we don't try to access element 1 of the ansistring if it's nil }
   if len > 0 then
-    move(src[1],res[0],len);
-  { fpc_big_chararray is defined as array[0..0], see compproc.inc why }
-  fillchar(res[len],length(res)-len,0);
-{$ifdef RangeCheckWasOn}
-{$r+}
-{$endif}
-*)
+    JLSystem.ArrayCopy(JLObject(AnsistringClass(src).fdata),0,JLObject(@res),0,len);
+  for i:=len to length(res) do
+    res[i]:=#0;
 end;
 
 
 function fpc_ansistr_setchar(const s: AnsiString; const index: longint; const ch: ansichar): AnsiString; compilerproc;
+var
+  res: AnsistringClass;
 begin
+  res:=AnsistringClass.Create(s);
+  res.fdata[index-1]:=ch;
+  result:=Ansistring(res);
 end;
 
 
@@ -360,13 +350,10 @@ Function fpc_AnsiStr_Compare(const S1,S2 : AnsiString): SizeInt;  compilerproc;
    0 if S1=S2
    >0 if S1>S2
 }
-(*
 Var
-  MaxI,Temp : SizeInt;
-*)
+  MaxI,Temp, i : SizeInt;
 begin
-(*
-  if pointer(S1)=pointer(S2) then
+  if JLObject(S1)=JLObject(S2) then
     begin
       result:=0;
       exit;
@@ -377,13 +364,16 @@ begin
     MaxI:=Temp;
   if MaxI>0 then
     begin
-      result:=CompareByte(S1[1],S2[1],MaxI);
-      if result=0 then
-        result:=Length(S1)-Length(S2);
+      for i:=0 to MaxI-1 do
+        begin
+          result:=ord(AnsistringClass(S1).fdata[i])-ord(AnsistringClass(S2).fdata[i]);
+          if result<>0 then
+            exit;
+        end;
+      result:=Length(S1)-Length(S2);
     end
   else
     result:=Length(S1)-Length(S2);
-*)
 end;
 
 Function fpc_AnsiStr_Compare_equal(const S1,S2 : AnsiString): SizeInt; compilerproc;
@@ -393,89 +383,30 @@ Function fpc_AnsiStr_Compare_equal(const S1,S2 : AnsiString): SizeInt; compilerp
    0 if S1=S2
    <>0 if S1<>S2
 }
-(*
 Var
   MaxI,Temp : SizeInt;
-*)
 begin
-(*
-  if pointer(S1)=pointer(S2) then
+  if JLObject(S1)=JLObject(S2) then
     begin
       result:=0;
       exit;
     end;
-  Maxi:=Length(S1);
-  temp:=Length(S2);
-  Result := Maxi - temp;
-  if Result = 0 then
-    if MaxI>0 then
-      result:=CompareByte(S1[1],S2[1],MaxI);
-*)
+  result:=ord(not JUArrays.equals(TJByteArray(AnsistringClass(S1).fdata),TJByteArray(AnsistringClass(S2).fdata)));
 end;
 
 
 
-Procedure fpc_AnsiStr_SetLength (Var S : AnsiString; l : SizeInt); compilerproc;
+function fpc_AnsiStr_SetLength (S : AnsiString; l : SizeInt): Ansistring; compilerproc;
 {
   Sets The length of string S to L.
   Makes sure S is unique, and contains enough room.
 }
-(*
 Var
-  Temp : Pointer;
   lens, lena,
   movelen : SizeInt;
-*)
 begin
-(*
-  if (l>0) then
-    begin
-      if Pointer(S)=nil then
-       begin
-         GetMem(Pointer(S),AnsiRecLen+L);
-         PAnsiRec(S)^.Ref:=1;
-         inc(Pointer(S),firstoff);
-       end
-      else if PAnsiRec(Pointer(S)-FirstOff)^.Ref=1 then
-        begin
-          Dec(Pointer(S),FirstOff);
-          lens:=MemSize(Pointer(s));
-          lena:=AnsiRecLen+L;
-          { allow shrinking string if that saves at least half of current size }
-          if (lena>lens) or ((lens>32) and (lena<=(lens div 2))) then
-            reallocmem(pointer(S),AnsiRecLen+L);
-          Inc(Pointer(S),FirstOff);
-        end
-      else
-        begin
-          { Reallocation is needed... }
-          Temp:=Pointer(NewAnsiString(L));
-
-          { also move terminating null }
-          lens:=succ(length(s));
-          if l < lens then
-            movelen := l
-          else
-            movelen := lens;
-          Move(Pointer(S)^,Temp^,movelen);
-          { ref count dropped to zero in the mean time? }
-          If (PAnsiRec(Pointer(S)-FirstOff)^.Ref > 0) and
-             declocked(PAnsiRec(Pointer(S)-FirstOff)^.Ref) then
-            freemem(PAnsiRec(Pointer(s)-FirstOff));
-          Pointer(S):=Temp;
-       end;
-      { Force nil termination in case it gets shorter }
-      PByte(Pointer(S)+l)^:=0;
-      PAnsiRec(Pointer(S)-FirstOff)^.Len:=l;
-    end
-  else
-    begin
-      { Length=0 }
-      if Pointer(S)<>nil then
-       fpc_ansistr_decr_ref (Pointer(S));
-      Pointer(S):=Nil;
-    end;
-*)
+  setlength(AnsistringClass(s).fdata,l);
+  result:=s;
 end;
 
 {*****************************************************************************
@@ -497,6 +428,7 @@ begin
 end;
 *)
 
+(*
 {$ifndef FPC_SYSTEM_HAS_ANSISTR_UNIQUE}
 // MV: inline the basic checks for case that S is already unique.
 // Rest is too complex to inline, so factor that out as a call.
@@ -506,25 +438,22 @@ Function fpc_ansistr_Unique(Var S : jlobject): jlobject; compilerproc;
   using copy-on-write semantics.
 }
 begin
-(*
   pointer(result) := pointer(s);
   If Pointer(S)=Nil then
     exit;
   if PAnsiRec(Pointer(S)-Firstoff)^.Ref<>1 then
     result:=fpc_truely_ansistr_unique(s);
-*)
 end;
 {$endif FPC_SYSTEM_HAS_ANSISTR_UNIQUE}
+*)
 
-
-Procedure fpc_ansistr_append_char(Var S : AnsiString;c : char); compilerproc;
+Procedure fpc_ansistr_append_char(Var S : AnsiString;c : ansichar); compilerproc;
+var
+  curlen: sizeint;
 begin
-(*
-  SetLength(S,length(S)+1);
-  // avoid unique call
-  PChar(Pointer(S)+length(S)-1)^:=c;
-  PByte(Pointer(S)+length(S))^:=0; { Terminating Zero }
-*)
+  curlen:=length(s);
+  SetLength(s,curlen+1);
+  AnsistringClass(s).fdata[curlen]:=c;
 end;
 
 Procedure fpc_ansistr_append_shortstring(Var S : AnsiString;const Str : ShortString); compilerproc;
@@ -545,37 +474,23 @@ begin
 end;
 
 Procedure fpc_ansistr_append_ansistring(Var S : AnsiString;const Str : AnsiString); compilerproc;
-(*
 var
-   ofs, strlength: SizeInt;
-   samestring: boolean;
-*)
+  ofs, strlength: longint;
 begin
-(*
    if Str='' then
      exit;
-   samestring := pointer(s) = pointer(str);
-   { needed in case s and str are the same string }
-   strlength := length(str);
+   strlength:=length(str);
    ofs:=Length(S);
+   { no problem if s and str are the same string, because "var" parameters are
+     copy-in/out for ansistring }
    SetLength(S,ofs+strlength);
-   { the pbyte cast avoids an unique call which isn't necessary because SetLength was just called }
-   if not(samestring) then
-     move(Str[1],(pointer(S)+ofs)^,strlength+1)
-   else
-     { the setlength may have relocated the string, so str may no longer be valid }
-     move(S[1],(pointer(S)+ofs)^,strlength+1)
-*)
+   JLSystem.ArrayCopy(JLObject(AnsistringClass(Str).fdata),0,JLObject(AnsistringClass(S).fdata),ofs,strlength);
 end;
 
 Function Fpc_Ansistr_Copy (Const S : AnsiString; Index,Size : SizeInt) : AnsiString;compilerproc;
-(*
 var
-  ResultAddress : Pointer;
-*)
+  res: AnsistringClass;
 begin
-(*
-  ResultAddress:=Nil;
   dec(index);
   if Index < 0 then
     Index := 0;
@@ -583,32 +498,23 @@ begin
     Size can be maxint and will get <0 when adding index }
   if (Size>Length(S)) or
      (Index+Size>Length(S)) then
-   Size:=Length(S)-Index;
+    Size:=Length(S)-Index;
   If Size>0 then
    begin
-     If Index<0 Then
-      Index:=0;
-     ResultAddress:=Pointer(NewAnsiString (Size));
-     if ResultAddress<>Nil then
-      begin
-        Move (Pointer(Pointer(S)+index)^,ResultAddress^,Size);
-        PAnsiRec(ResultAddress-FirstOff)^.Len:=Size;
-        PByte(ResultAddress+Size)^:=0;
-      end;
+     res:=AnsistringClass.Create;
+     setlength(res.fdata,size);
+     JLSystem.ArrayCopy(JLObject(AnsistringClass(S).fdata),index,JLObject(res.fdata),0,size);
+     result:=ansistring(res);
    end;
-   fpc_ansistr_decr_ref(Pointer(fpc_ansistr_copy));
-  Pointer(fpc_ansistr_Copy):=ResultAddress;
-*)
+  { default function result is empty string }
 end;
 
-Function Pos (Const Substr : ShortString; Const Source : AnsiString) : SizeInt;
 (*
+Function Pos (Const Substr : ShortString; Const Source : AnsiString) : SizeInt;
 var
   i,MaxLen : SizeInt;
   pc : pchar;
-*)
 begin
-(*
   Pos:=0;
   if Length(SubStr)>0 then
    begin
@@ -627,37 +533,37 @@ begin
         inc(pc);
       end;
    end;
-*)
 end;
-
+*)
 
 Function Pos (Const Substr : AnsiString; Const Source : AnsiString) : SizeInt;
-(*
 var
-  i,MaxLen : SizeInt;
-  pc : pchar;
-*)
+  i,j,k,MaxLen, SubstrLen : SizeInt;
 begin
-(*
   Pos:=0;
-  if Length(SubStr)>0 then
+  SubstrLen:=Length(SubStr);
+  if SubstrLen>0 then
    begin
      MaxLen:=Length(source)-Length(SubStr);
      i:=0;
-     pc:=@source[1];
      while (i<=MaxLen) do
       begin
         inc(i);
-        if (SubStr[1]=pc^) and
-           (CompareByte(Substr[1],pc^,Length(SubStr))=0) then
+        j:=0;
+        k:=i-1;
+        while (j<SubstrLen) and
+              (AnsistringClass(SubStr).fdata[j]=AnsistringClass(Source).fdata[k]) do
+          begin
+            inc(j);
+            inc(k);
+          end;
+        if (j=SubstrLen) then
          begin
            Pos:=i;
            exit;
          end;
-        inc(pc);
       end;
    end;
-*)
 end;
 
 
@@ -666,25 +572,18 @@ end;
 { using pos(char,pchar) will always call the shortstring version }
 { (exact match for first argument), also with $h+ (JM)           }
 Function Pos (c : Char; Const s : AnsiString) : SizeInt;
-(*
 var
   i: SizeInt;
-  pc : pchar;
-*)
 begin
-(*
-  pc:=@s[1];
   for i:=1 to length(s) do
    begin
-     if pc^=c then
+     if AnsistringClass(s).fdata[i-1]=c then
       begin
         pos:=i;
         exit;
       end;
-     inc(pc);
    end;
   pos:=0;
-*)
 end;
 
 (*
@@ -936,29 +835,21 @@ end;
 *)
 
 function upcase(const s : ansistring) : ansistring;
-(*
 var
   i : SizeInt;
-*)
+  u : unicodestring;
 begin
-(*
-  Setlength(result,length(s));
-  for i := 1 to length (s) do
-    result[i] := upcase(s[i]);
-*)
+  u:=s;
+  result:=upcase(u);
 end;
 
 
 function lowercase(const s : ansistring) : ansistring;
-(*
 var
   i : SizeInt;
-*)
+  u : unicodestring;
 begin
-(*
-  Setlength(result,length(s));
-  for i := 1 to length (s) do
-    result[i] := lowercase(s[i]);
-*)
+  u:=s;
+  result:=lowercase(u);
 end;
 

+ 3 - 3
rtl/java/compproc.inc

@@ -232,7 +232,7 @@ Procedure fpc_ansistr_decr_ref (Var S : Pointer); compilerproc;
 Procedure fpc_ansistr_incr_ref (S : Pointer); compilerproc;
 *)
 {$ifndef nounsupported}
-Procedure fpc_AnsiStr_Assign (Var DestS : jlobject;S2 : jlobject); compilerproc;
+//Procedure fpc_AnsiStr_Assign (Var DestS : jlobject;S2 : jlobject); compilerproc;
 {$endif}
 (*
 {$ifdef STR_CONCAT_PROCS}
@@ -277,7 +277,7 @@ Function fpc_AnsiStr_Compare(const S1,S2 : AnsiString): SizeInt; compilerproc;
 Function fpc_AnsiStr_Compare_equal(const S1,S2 : AnsiString): SizeInt; compilerproc;
 //Procedure fpc_AnsiStr_CheckZero(p : jlobject); compilerproc;
 //Procedure fpc_AnsiStr_CheckRange(len,index : SizeInt); compilerproc;
-Procedure fpc_AnsiStr_SetLength (Var S : AnsiString; l : SizeInt); compilerproc;
+function fpc_AnsiStr_SetLength (S : AnsiString; l : SizeInt): ansistring; compilerproc;
 Function  fpc_ansistr_Copy (Const S : AnsiString; Index,Size : SizeInt) : AnsiString;compilerproc;
 {$endif}
 {$ifdef EXTRAANSISHORT}
@@ -286,7 +286,7 @@ Function  fpc_ansistr_Copy (Const S : AnsiString; Index,Size : SizeInt) : AnsiSt
 { pointer argument because otherwise when calling this, we get
   an endless loop since a 'var s: ansistring' must be made
   unique as well                                               }
-Function fpc_ansistr_Unique(Var S : jlobject): jlobject; compilerproc;
+//Function fpc_ansistr_Unique(Var S : jlobject): jlobject; compilerproc;
 (*
 {$endif FPC_HAS_FEATURE_ANSISTRINGS}
 *)

+ 229 - 6
rtl/java/java_sys.inc

@@ -115,6 +115,229 @@
   JLRType = interface external 'java.lang.reflect' name 'Type' 
   end;
 
+  JUArrays = class external 'java.util' name 'Arrays' (JLObject)
+  public
+    type
+      InnerArrayList = class;
+      Arr1InnerArrayList = array of InnerArrayList;
+      Arr2InnerArrayList = array of Arr1InnerArrayList;
+      Arr3InnerArrayList = array of Arr2InnerArrayList;
+      InnerArrayList = class external 'java.util' name 'Arrays$ArrayList' 
+      end;
+
+  public
+    class procedure sort(para1: Arr1jlong); static; overload;
+    class procedure sort(var para1: array of jlong); static; overload;
+    class procedure sort(para1: Arr1jlong; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of jlong; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1jint); static; overload;
+    class procedure sort(var para1: array of jint); static; overload;
+    class procedure sort(para1: Arr1jint; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of jint; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1jshort); static; overload;
+    class procedure sort(var para1: array of jshort); static; overload;
+    class procedure sort(para1: Arr1jshort; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of jshort; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1jchar); static; overload;
+    class procedure sort(var para1: array of jchar); static; overload;
+    class procedure sort(para1: Arr1jchar; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of jchar; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1jbyte); static; overload;
+    class procedure sort(var para1: array of jbyte); static; overload;
+    class procedure sort(para1: Arr1jbyte; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of jbyte; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1jdouble); static; overload;
+    class procedure sort(var para1: array of jdouble); static; overload;
+    class procedure sort(para1: Arr1jdouble; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of jdouble; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1jfloat); static; overload;
+    class procedure sort(var para1: array of jfloat); static; overload;
+    class procedure sort(para1: Arr1jfloat; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of jfloat; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1JLObject); static; overload;
+    class procedure sort(var para1: array of JLObject); static; overload;
+    class procedure sort(para1: Arr1JLObject; para2: jint; para3: jint); static; overload;
+    class procedure sort(var para1: array of JLObject; para2: jint; para3: jint); static; overload;
+    class procedure sort(para1: Arr1JLObject; para2: JUComparator); static; overload;
+    class procedure sort(var para1: array of JLObject; para2: JUComparator); static; overload;
+    class procedure sort(para1: Arr1JLObject; para2: jint; para3: jint; para4: JUComparator); static; overload;
+    class procedure sort(var para1: array of JLObject; para2: jint; para3: jint; para4: JUComparator); static; overload;
+    class function binarySearch(para1: Arr1jlong; para2: jlong): jint; static; overload;
+    class function binarySearch(var para1: array of jlong; para2: jlong): jint; static; overload;
+    class function binarySearch(para1: Arr1jlong; para2: jint; para3: jint; para4: jlong): jint; static; overload;
+    class function binarySearch(var para1: array of jlong; para2: jint; para3: jint; para4: jlong): jint; static; overload;
+    class function binarySearch(para1: Arr1jint; para2: jint): jint; static; overload;
+    class function binarySearch(var para1: array of jint; para2: jint): jint; static; overload;
+    class function binarySearch(para1: Arr1jint; para2: jint; para3: jint; para4: jint): jint; static; overload;
+    class function binarySearch(var para1: array of jint; para2: jint; para3: jint; para4: jint): jint; static; overload;
+    class function binarySearch(para1: Arr1jshort; para2: jshort): jint; static; overload;
+    class function binarySearch(var para1: array of jshort; para2: jshort): jint; static; overload;
+    class function binarySearch(para1: Arr1jshort; para2: jint; para3: jint; para4: jshort): jint; static; overload;
+    class function binarySearch(var para1: array of jshort; para2: jint; para3: jint; para4: jshort): jint; static; overload;
+    class function binarySearch(para1: Arr1jchar; para2: jchar): jint; static; overload;
+    class function binarySearch(var para1: array of jchar; para2: jchar): jint; static; overload;
+    class function binarySearch(para1: Arr1jchar; para2: jint; para3: jint; para4: jchar): jint; static; overload;
+    class function binarySearch(var para1: array of jchar; para2: jint; para3: jint; para4: jchar): jint; static; overload;
+    class function binarySearch(para1: Arr1jbyte; para2: jbyte): jint; static; overload;
+    class function binarySearch(var para1: array of jbyte; para2: jbyte): jint; static; overload;
+    class function binarySearch(para1: Arr1jbyte; para2: jint; para3: jint; para4: jbyte): jint; static; overload;
+    class function binarySearch(var para1: array of jbyte; para2: jint; para3: jint; para4: jbyte): jint; static; overload;
+    class function binarySearch(para1: Arr1jdouble; para2: jdouble): jint; static; overload;
+    class function binarySearch(var para1: array of jdouble; para2: jdouble): jint; static; overload;
+    class function binarySearch(para1: Arr1jdouble; para2: jint; para3: jint; para4: jdouble): jint; static; overload;
+    class function binarySearch(var para1: array of jdouble; para2: jint; para3: jint; para4: jdouble): jint; static; overload;
+    class function binarySearch(para1: Arr1jfloat; para2: jfloat): jint; static; overload;
+    class function binarySearch(var para1: array of jfloat; para2: jfloat): jint; static; overload;
+    class function binarySearch(para1: Arr1jfloat; para2: jint; para3: jint; para4: jfloat): jint; static; overload;
+    class function binarySearch(var para1: array of jfloat; para2: jint; para3: jint; para4: jfloat): jint; static; overload;
+    class function binarySearch(para1: Arr1JLObject; para2: JLObject): jint; static; overload;
+    class function binarySearch(var para1: array of JLObject; para2: JLObject): jint; static; overload;
+    class function binarySearch(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLObject): jint; static; overload;
+    class function binarySearch(var para1: array of JLObject; para2: jint; para3: jint; para4: JLObject): jint; static; overload;
+    class function binarySearch(para1: Arr1JLObject; para2: JLObject; para3: JUComparator): jint; static; overload;
+    class function binarySearch(var para1: array of JLObject; para2: JLObject; para3: JUComparator): jint; static; overload;
+    class function binarySearch(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLObject; para5: JUComparator): jint; static; overload;
+    class function binarySearch(var para1: array of JLObject; para2: jint; para3: jint; para4: JLObject; para5: JUComparator): jint; static; overload;
+    class function equals(para1: Arr1jlong; para2: Arr1jlong): jboolean; static; overload;
+    class function equals(var para1: array of jlong; var para2: array of jlong): jboolean; static; overload;
+    class function equals(para1: Arr1jint; para2: Arr1jint): jboolean; static; overload;
+    class function equals(var para1: array of jint; var para2: array of jint): jboolean; static; overload;
+    class function equals(para1: Arr1jshort; para2: Arr1jshort): jboolean; static; overload;
+    class function equals(var para1: array of jshort; var para2: array of jshort): jboolean; static; overload;
+    class function equals(para1: Arr1jchar; para2: Arr1jchar): jboolean; static; overload;
+    class function equals(var para1: array of jchar; var para2: array of jchar): jboolean; static; overload;
+    class function equals(para1: Arr1jbyte; para2: Arr1jbyte): jboolean; static; overload;
+    class function equals(var para1: array of jbyte; var para2: array of jbyte): jboolean; static; overload;
+    class function equals(para1: Arr1jboolean; para2: Arr1jboolean): jboolean; static; overload;
+    class function equals(var para1: array of jboolean; var para2: array of jboolean): jboolean; static; overload;
+    class function equals(para1: Arr1jdouble; para2: Arr1jdouble): jboolean; static; overload;
+    class function equals(var para1: array of jdouble; var para2: array of jdouble): jboolean; static; overload;
+    class function equals(para1: Arr1jfloat; para2: Arr1jfloat): jboolean; static; overload;
+    class function equals(var para1: array of jfloat; var para2: array of jfloat): jboolean; static; overload;
+    class function equals(para1: Arr1JLObject; para2: Arr1JLObject): jboolean; static; overload;
+    class function equals(var para1: array of JLObject; var para2: array of JLObject): jboolean; static; overload;
+    class procedure fill(para1: Arr1jlong; para2: jlong); static; overload;
+    class procedure fill(var para1: array of jlong; para2: jlong); static; overload;
+    class procedure fill(para1: Arr1jlong; para2: jint; para3: jint; para4: jlong); static; overload;
+    class procedure fill(var para1: array of jlong; para2: jint; para3: jint; para4: jlong); static; overload;
+    class procedure fill(para1: Arr1jint; para2: jint); static; overload;
+    class procedure fill(var para1: array of jint; para2: jint); static; overload;
+    class procedure fill(para1: Arr1jint; para2: jint; para3: jint; para4: jint); static; overload;
+    class procedure fill(var para1: array of jint; para2: jint; para3: jint; para4: jint); static; overload;
+    class procedure fill(para1: Arr1jshort; para2: jshort); static; overload;
+    class procedure fill(var para1: array of jshort; para2: jshort); static; overload;
+    class procedure fill(para1: Arr1jshort; para2: jint; para3: jint; para4: jshort); static; overload;
+    class procedure fill(var para1: array of jshort; para2: jint; para3: jint; para4: jshort); static; overload;
+    class procedure fill(para1: Arr1jchar; para2: jchar); static; overload;
+    class procedure fill(var para1: array of jchar; para2: jchar); static; overload;
+    class procedure fill(para1: Arr1jchar; para2: jint; para3: jint; para4: jchar); static; overload;
+    class procedure fill(var para1: array of jchar; para2: jint; para3: jint; para4: jchar); static; overload;
+    class procedure fill(para1: Arr1jbyte; para2: jbyte); static; overload;
+    class procedure fill(var para1: array of jbyte; para2: jbyte); static; overload;
+    class procedure fill(para1: Arr1jbyte; para2: jint; para3: jint; para4: jbyte); static; overload;
+    class procedure fill(var para1: array of jbyte; para2: jint; para3: jint; para4: jbyte); static; overload;
+    class procedure fill(para1: Arr1jboolean; para2: jboolean); static; overload;
+    class procedure fill(var para1: array of jboolean; para2: jboolean); static; overload;
+    class procedure fill(para1: Arr1jboolean; para2: jint; para3: jint; para4: jboolean); static; overload;
+    class procedure fill(var para1: array of jboolean; para2: jint; para3: jint; para4: jboolean); static; overload;
+    class procedure fill(para1: Arr1jdouble; para2: jdouble); static; overload;
+    class procedure fill(var para1: array of jdouble; para2: jdouble); static; overload;
+    class procedure fill(para1: Arr1jdouble; para2: jint; para3: jint; para4: jdouble); static; overload;
+    class procedure fill(var para1: array of jdouble; para2: jint; para3: jint; para4: jdouble); static; overload;
+    class procedure fill(para1: Arr1jfloat; para2: jfloat); static; overload;
+    class procedure fill(var para1: array of jfloat; para2: jfloat); static; overload;
+    class procedure fill(para1: Arr1jfloat; para2: jint; para3: jint; para4: jfloat); static; overload;
+    class procedure fill(var para1: array of jfloat; para2: jint; para3: jint; para4: jfloat); static; overload;
+    class procedure fill(para1: Arr1JLObject; para2: JLObject); static; overload;
+    class procedure fill(var para1: array of JLObject; para2: JLObject); static; overload;
+    class procedure fill(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLObject); static; overload;
+    class procedure fill(var para1: array of JLObject; para2: jint; para3: jint; para4: JLObject); static; overload;
+    class function copyOf(para1: Arr1JLObject; para2: jint): Arr1JLObject; static; overload;
+    class function copyOf(var para1: array of JLObject; para2: jint): Arr1JLObject; static; overload;
+    class function copyOf(para1: Arr1JLObject; para2: jint; para3: JLClass): Arr1JLObject; static; overload;
+    class function copyOf(var para1: array of JLObject; para2: jint; para3: JLClass): Arr1JLObject; static; overload;
+    class function copyOf(para1: Arr1jbyte; para2: jint): Arr1jbyte; static; overload;
+    class function copyOf(var para1: array of jbyte; para2: jint): Arr1jbyte; static; overload;
+    class function copyOf(para1: Arr1jshort; para2: jint): Arr1jshort; static; overload;
+    class function copyOf(var para1: array of jshort; para2: jint): Arr1jshort; static; overload;
+    class function copyOf(para1: Arr1jint; para2: jint): Arr1jint; static; overload;
+    class function copyOf(var para1: array of jint; para2: jint): Arr1jint; static; overload;
+    class function copyOf(para1: Arr1jlong; para2: jint): Arr1jlong; static; overload;
+    class function copyOf(var para1: array of jlong; para2: jint): Arr1jlong; static; overload;
+    class function copyOf(para1: Arr1jchar; para2: jint): Arr1jchar; static; overload;
+    class function copyOf(var para1: array of jchar; para2: jint): Arr1jchar; static; overload;
+    class function copyOf(para1: Arr1jfloat; para2: jint): Arr1jfloat; static; overload;
+    class function copyOf(var para1: array of jfloat; para2: jint): Arr1jfloat; static; overload;
+    class function copyOf(para1: Arr1jdouble; para2: jint): Arr1jdouble; static; overload;
+    class function copyOf(var para1: array of jdouble; para2: jint): Arr1jdouble; static; overload;
+    class function copyOf(para1: Arr1jboolean; para2: jint): Arr1jboolean; static; overload;
+    class function copyOf(var para1: array of jboolean; para2: jint): Arr1jboolean; static; overload;
+    class function copyOfRange(para1: Arr1JLObject; para2: jint; para3: jint): Arr1JLObject; static; overload;
+    class function copyOfRange(var para1: array of JLObject; para2: jint; para3: jint): Arr1JLObject; static; overload;
+    class function copyOfRange(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLClass): Arr1JLObject; static; overload;
+    class function copyOfRange(var para1: array of JLObject; para2: jint; para3: jint; para4: JLClass): Arr1JLObject; static; overload;
+    class function copyOfRange(para1: Arr1jbyte; para2: jint; para3: jint): Arr1jbyte; static; overload;
+    class function copyOfRange(var para1: array of jbyte; para2: jint; para3: jint): Arr1jbyte; static; overload;
+    class function copyOfRange(para1: Arr1jshort; para2: jint; para3: jint): Arr1jshort; static; overload;
+    class function copyOfRange(var para1: array of jshort; para2: jint; para3: jint): Arr1jshort; static; overload;
+    class function copyOfRange(para1: Arr1jint; para2: jint; para3: jint): Arr1jint; static; overload;
+    class function copyOfRange(var para1: array of jint; para2: jint; para3: jint): Arr1jint; static; overload;
+    class function copyOfRange(para1: Arr1jlong; para2: jint; para3: jint): Arr1jlong; static; overload;
+    class function copyOfRange(var para1: array of jlong; para2: jint; para3: jint): Arr1jlong; static; overload;
+    class function copyOfRange(para1: Arr1jchar; para2: jint; para3: jint): Arr1jchar; static; overload;
+    class function copyOfRange(var para1: array of jchar; para2: jint; para3: jint): Arr1jchar; static; overload;
+    class function copyOfRange(para1: Arr1jfloat; para2: jint; para3: jint): Arr1jfloat; static; overload;
+    class function copyOfRange(var para1: array of jfloat; para2: jint; para3: jint): Arr1jfloat; static; overload;
+    class function copyOfRange(para1: Arr1jdouble; para2: jint; para3: jint): Arr1jdouble; static; overload;
+    class function copyOfRange(var para1: array of jdouble; para2: jint; para3: jint): Arr1jdouble; static; overload;
+    class function copyOfRange(para1: Arr1jboolean; para2: jint; para3: jint): Arr1jboolean; static; overload;
+    class function copyOfRange(var para1: array of jboolean; para2: jint; para3: jint): Arr1jboolean; static; overload;
+    class function asList(para1: Arr1JLObject): JUList; static; overload;
+    class function asList(var para1: array of JLObject): JUList; static; overload;
+    class function hashCode(para1: Arr1jlong): jint; static; overload;
+    class function hashCode(var para1: array of jlong): jint; static; overload;
+    class function hashCode(para1: Arr1jint): jint; static; overload;
+    class function hashCode(var para1: array of jint): jint; static; overload;
+    class function hashCode(para1: Arr1jshort): jint; static; overload;
+    class function hashCode(var para1: array of jshort): jint; static; overload;
+    class function hashCode(para1: Arr1jchar): jint; static; overload;
+    class function hashCode(var para1: array of jchar): jint; static; overload;
+    class function hashCode(para1: Arr1jbyte): jint; static; overload;
+    class function hashCode(var para1: array of jbyte): jint; static; overload;
+    class function hashCode(para1: Arr1jboolean): jint; static; overload;
+    class function hashCode(var para1: array of jboolean): jint; static; overload;
+    class function hashCode(para1: Arr1jfloat): jint; static; overload;
+    class function hashCode(var para1: array of jfloat): jint; static; overload;
+    class function hashCode(para1: Arr1jdouble): jint; static; overload;
+    class function hashCode(var para1: array of jdouble): jint; static; overload;
+    class function hashCode(para1: Arr1JLObject): jint; static; overload;
+    class function hashCode(var para1: array of JLObject): jint; static; overload;
+    class function deepHashCode(para1: Arr1JLObject): jint; static; overload;
+    class function deepHashCode(var para1: array of JLObject): jint; static; overload;
+    class function deepEquals(para1: Arr1JLObject; para2: Arr1JLObject): jboolean; static; overload;
+    class function deepEquals(var para1: array of JLObject; var para2: array of JLObject): jboolean; static; overload;
+    class function toString(para1: Arr1jlong): JLString; static; overload;
+    class function toString(var para1: array of jlong): JLString; static; overload;
+    class function toString(para1: Arr1jint): JLString; static; overload;
+    class function toString(var para1: array of jint): JLString; static; overload;
+    class function toString(para1: Arr1jshort): JLString; static; overload;
+    class function toString(var para1: array of jshort): JLString; static; overload;
+    class function toString(para1: Arr1jchar): JLString; static; overload;
+    class function toString(var para1: array of jchar): JLString; static; overload;
+    class function toString(para1: Arr1jbyte): JLString; static; overload;
+    class function toString(var para1: array of jbyte): JLString; static; overload;
+    class function toString(para1: Arr1jboolean): JLString; static; overload;
+    class function toString(var para1: array of jboolean): JLString; static; overload;
+    class function toString(para1: Arr1jfloat): JLString; static; overload;
+    class function toString(var para1: array of jfloat): JLString; static; overload;
+    class function toString(para1: Arr1jdouble): JLString; static; overload;
+    class function toString(var para1: array of jdouble): JLString; static; overload;
+    class function toString(para1: Arr1JLObject): JLString; static; overload;
+    class function toString(var para1: array of JLObject): JLString; static; overload;
+    class function deepToString(para1: Arr1JLObject): JLString; static; overload;
+    class function deepToString(var para1: array of JLObject): JLString; static; overload;
+  end;
+
   JUComparator = interface external 'java.util' name 'Comparator' 
     function compare(para1: JLObject; para2: JLObject): jint; overload;
     function equals(para1: JLObject): jboolean; overload;
@@ -656,18 +879,18 @@
   JLClass = class sealed external 'java.lang' name 'Class' (JLObject, JISerializable, JLRGenericDeclaration, JLRType, JLRAnnotatedElement)
   public
     type
-      InnerMethodArray = class;
-      Arr1InnerMethodArray = array of InnerMethodArray;
-      Arr2InnerMethodArray = array of Arr1InnerMethodArray;
-      Arr3InnerMethodArray = array of Arr2InnerMethodArray;
       InnerEnclosingMethodInfo = class;
       Arr1InnerEnclosingMethodInfo = array of InnerEnclosingMethodInfo;
       Arr2InnerEnclosingMethodInfo = array of Arr1InnerEnclosingMethodInfo;
       Arr3InnerEnclosingMethodInfo = array of Arr2InnerEnclosingMethodInfo;
-      InnerMethodArray = class external 'java.lang' name 'Class$MethodArray' 
+      InnerMethodArray = class;
+      Arr1InnerMethodArray = array of InnerMethodArray;
+      Arr2InnerMethodArray = array of Arr1InnerMethodArray;
+      Arr3InnerMethodArray = array of Arr2InnerMethodArray;
+      InnerEnclosingMethodInfo = class sealed external 'java.lang' name 'Class$EnclosingMethodInfo' 
       end;
 
-      InnerEnclosingMethodInfo = class sealed external 'java.lang' name 'Class$EnclosingMethodInfo' 
+      InnerMethodArray = class external 'java.lang' name 'Class$MethodArray' 
       end;
 
   public

+ 11 - 1
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.Comparator }
+{ 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 }
 type
   JLStringBuffer = class;
   Arr1JLStringBuffer = array of JLStringBuffer;
@@ -70,6 +70,11 @@ 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;
@@ -230,6 +235,11 @@ type
   Arr2JNCCharset = array of Arr1JNCCharset;
   Arr3JNCCharset = array of Arr2JNCCharset;
 
+  JUList = interface external 'java.util' name 'List';
+  Arr1JUList = array of JUList;
+  Arr2JUList = array of Arr1JUList;
+  Arr3JUList = array of Arr2JUList;
+
   JLAAnnotation = interface external 'java.lang.annotation' name 'Annotation';
   Arr1JLAAnnotation = array of JLAAnnotation;
   Arr2JLAAnnotation = array of Arr1JLAAnnotation;

+ 0 - 223
rtl/java/jdk15.inc

@@ -4268,229 +4268,6 @@
     function isSEAsianSwapping(): jboolean; overload; virtual;
   end;
 
-  JUArrays = class external 'java.util' name 'Arrays' (JLObject)
-  public
-    type
-      InnerArrayList = class;
-      Arr1InnerArrayList = array of InnerArrayList;
-      Arr2InnerArrayList = array of Arr1InnerArrayList;
-      Arr3InnerArrayList = array of Arr2InnerArrayList;
-      InnerArrayList = class external 'java.util' name 'Arrays$ArrayList' 
-      end;
-
-  public
-    class procedure sort(para1: Arr1jlong); static; overload;
-    class procedure sort(var para1: array of jlong); static; overload;
-    class procedure sort(para1: Arr1jlong; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of jlong; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1jint); static; overload;
-    class procedure sort(var para1: array of jint); static; overload;
-    class procedure sort(para1: Arr1jint; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of jint; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1jshort); static; overload;
-    class procedure sort(var para1: array of jshort); static; overload;
-    class procedure sort(para1: Arr1jshort; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of jshort; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1jchar); static; overload;
-    class procedure sort(var para1: array of jchar); static; overload;
-    class procedure sort(para1: Arr1jchar; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of jchar; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1jbyte); static; overload;
-    class procedure sort(var para1: array of jbyte); static; overload;
-    class procedure sort(para1: Arr1jbyte; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of jbyte; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1jdouble); static; overload;
-    class procedure sort(var para1: array of jdouble); static; overload;
-    class procedure sort(para1: Arr1jdouble; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of jdouble; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1jfloat); static; overload;
-    class procedure sort(var para1: array of jfloat); static; overload;
-    class procedure sort(para1: Arr1jfloat; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of jfloat; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1JLObject); static; overload;
-    class procedure sort(var para1: array of JLObject); static; overload;
-    class procedure sort(para1: Arr1JLObject; para2: jint; para3: jint); static; overload;
-    class procedure sort(var para1: array of JLObject; para2: jint; para3: jint); static; overload;
-    class procedure sort(para1: Arr1JLObject; para2: JUComparator); static; overload;
-    class procedure sort(var para1: array of JLObject; para2: JUComparator); static; overload;
-    class procedure sort(para1: Arr1JLObject; para2: jint; para3: jint; para4: JUComparator); static; overload;
-    class procedure sort(var para1: array of JLObject; para2: jint; para3: jint; para4: JUComparator); static; overload;
-    class function binarySearch(para1: Arr1jlong; para2: jlong): jint; static; overload;
-    class function binarySearch(var para1: array of jlong; para2: jlong): jint; static; overload;
-    class function binarySearch(para1: Arr1jlong; para2: jint; para3: jint; para4: jlong): jint; static; overload;
-    class function binarySearch(var para1: array of jlong; para2: jint; para3: jint; para4: jlong): jint; static; overload;
-    class function binarySearch(para1: Arr1jint; para2: jint): jint; static; overload;
-    class function binarySearch(var para1: array of jint; para2: jint): jint; static; overload;
-    class function binarySearch(para1: Arr1jint; para2: jint; para3: jint; para4: jint): jint; static; overload;
-    class function binarySearch(var para1: array of jint; para2: jint; para3: jint; para4: jint): jint; static; overload;
-    class function binarySearch(para1: Arr1jshort; para2: jshort): jint; static; overload;
-    class function binarySearch(var para1: array of jshort; para2: jshort): jint; static; overload;
-    class function binarySearch(para1: Arr1jshort; para2: jint; para3: jint; para4: jshort): jint; static; overload;
-    class function binarySearch(var para1: array of jshort; para2: jint; para3: jint; para4: jshort): jint; static; overload;
-    class function binarySearch(para1: Arr1jchar; para2: jchar): jint; static; overload;
-    class function binarySearch(var para1: array of jchar; para2: jchar): jint; static; overload;
-    class function binarySearch(para1: Arr1jchar; para2: jint; para3: jint; para4: jchar): jint; static; overload;
-    class function binarySearch(var para1: array of jchar; para2: jint; para3: jint; para4: jchar): jint; static; overload;
-    class function binarySearch(para1: Arr1jbyte; para2: jbyte): jint; static; overload;
-    class function binarySearch(var para1: array of jbyte; para2: jbyte): jint; static; overload;
-    class function binarySearch(para1: Arr1jbyte; para2: jint; para3: jint; para4: jbyte): jint; static; overload;
-    class function binarySearch(var para1: array of jbyte; para2: jint; para3: jint; para4: jbyte): jint; static; overload;
-    class function binarySearch(para1: Arr1jdouble; para2: jdouble): jint; static; overload;
-    class function binarySearch(var para1: array of jdouble; para2: jdouble): jint; static; overload;
-    class function binarySearch(para1: Arr1jdouble; para2: jint; para3: jint; para4: jdouble): jint; static; overload;
-    class function binarySearch(var para1: array of jdouble; para2: jint; para3: jint; para4: jdouble): jint; static; overload;
-    class function binarySearch(para1: Arr1jfloat; para2: jfloat): jint; static; overload;
-    class function binarySearch(var para1: array of jfloat; para2: jfloat): jint; static; overload;
-    class function binarySearch(para1: Arr1jfloat; para2: jint; para3: jint; para4: jfloat): jint; static; overload;
-    class function binarySearch(var para1: array of jfloat; para2: jint; para3: jint; para4: jfloat): jint; static; overload;
-    class function binarySearch(para1: Arr1JLObject; para2: JLObject): jint; static; overload;
-    class function binarySearch(var para1: array of JLObject; para2: JLObject): jint; static; overload;
-    class function binarySearch(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLObject): jint; static; overload;
-    class function binarySearch(var para1: array of JLObject; para2: jint; para3: jint; para4: JLObject): jint; static; overload;
-    class function binarySearch(para1: Arr1JLObject; para2: JLObject; para3: JUComparator): jint; static; overload;
-    class function binarySearch(var para1: array of JLObject; para2: JLObject; para3: JUComparator): jint; static; overload;
-    class function binarySearch(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLObject; para5: JUComparator): jint; static; overload;
-    class function binarySearch(var para1: array of JLObject; para2: jint; para3: jint; para4: JLObject; para5: JUComparator): jint; static; overload;
-    class function equals(para1: Arr1jlong; para2: Arr1jlong): jboolean; static; overload;
-    class function equals(var para1: array of jlong; var para2: array of jlong): jboolean; static; overload;
-    class function equals(para1: Arr1jint; para2: Arr1jint): jboolean; static; overload;
-    class function equals(var para1: array of jint; var para2: array of jint): jboolean; static; overload;
-    class function equals(para1: Arr1jshort; para2: Arr1jshort): jboolean; static; overload;
-    class function equals(var para1: array of jshort; var para2: array of jshort): jboolean; static; overload;
-    class function equals(para1: Arr1jchar; para2: Arr1jchar): jboolean; static; overload;
-    class function equals(var para1: array of jchar; var para2: array of jchar): jboolean; static; overload;
-    class function equals(para1: Arr1jbyte; para2: Arr1jbyte): jboolean; static; overload;
-    class function equals(var para1: array of jbyte; var para2: array of jbyte): jboolean; static; overload;
-    class function equals(para1: Arr1jboolean; para2: Arr1jboolean): jboolean; static; overload;
-    class function equals(var para1: array of jboolean; var para2: array of jboolean): jboolean; static; overload;
-    class function equals(para1: Arr1jdouble; para2: Arr1jdouble): jboolean; static; overload;
-    class function equals(var para1: array of jdouble; var para2: array of jdouble): jboolean; static; overload;
-    class function equals(para1: Arr1jfloat; para2: Arr1jfloat): jboolean; static; overload;
-    class function equals(var para1: array of jfloat; var para2: array of jfloat): jboolean; static; overload;
-    class function equals(para1: Arr1JLObject; para2: Arr1JLObject): jboolean; static; overload;
-    class function equals(var para1: array of JLObject; var para2: array of JLObject): jboolean; static; overload;
-    class procedure fill(para1: Arr1jlong; para2: jlong); static; overload;
-    class procedure fill(var para1: array of jlong; para2: jlong); static; overload;
-    class procedure fill(para1: Arr1jlong; para2: jint; para3: jint; para4: jlong); static; overload;
-    class procedure fill(var para1: array of jlong; para2: jint; para3: jint; para4: jlong); static; overload;
-    class procedure fill(para1: Arr1jint; para2: jint); static; overload;
-    class procedure fill(var para1: array of jint; para2: jint); static; overload;
-    class procedure fill(para1: Arr1jint; para2: jint; para3: jint; para4: jint); static; overload;
-    class procedure fill(var para1: array of jint; para2: jint; para3: jint; para4: jint); static; overload;
-    class procedure fill(para1: Arr1jshort; para2: jshort); static; overload;
-    class procedure fill(var para1: array of jshort; para2: jshort); static; overload;
-    class procedure fill(para1: Arr1jshort; para2: jint; para3: jint; para4: jshort); static; overload;
-    class procedure fill(var para1: array of jshort; para2: jint; para3: jint; para4: jshort); static; overload;
-    class procedure fill(para1: Arr1jchar; para2: jchar); static; overload;
-    class procedure fill(var para1: array of jchar; para2: jchar); static; overload;
-    class procedure fill(para1: Arr1jchar; para2: jint; para3: jint; para4: jchar); static; overload;
-    class procedure fill(var para1: array of jchar; para2: jint; para3: jint; para4: jchar); static; overload;
-    class procedure fill(para1: Arr1jbyte; para2: jbyte); static; overload;
-    class procedure fill(var para1: array of jbyte; para2: jbyte); static; overload;
-    class procedure fill(para1: Arr1jbyte; para2: jint; para3: jint; para4: jbyte); static; overload;
-    class procedure fill(var para1: array of jbyte; para2: jint; para3: jint; para4: jbyte); static; overload;
-    class procedure fill(para1: Arr1jboolean; para2: jboolean); static; overload;
-    class procedure fill(var para1: array of jboolean; para2: jboolean); static; overload;
-    class procedure fill(para1: Arr1jboolean; para2: jint; para3: jint; para4: jboolean); static; overload;
-    class procedure fill(var para1: array of jboolean; para2: jint; para3: jint; para4: jboolean); static; overload;
-    class procedure fill(para1: Arr1jdouble; para2: jdouble); static; overload;
-    class procedure fill(var para1: array of jdouble; para2: jdouble); static; overload;
-    class procedure fill(para1: Arr1jdouble; para2: jint; para3: jint; para4: jdouble); static; overload;
-    class procedure fill(var para1: array of jdouble; para2: jint; para3: jint; para4: jdouble); static; overload;
-    class procedure fill(para1: Arr1jfloat; para2: jfloat); static; overload;
-    class procedure fill(var para1: array of jfloat; para2: jfloat); static; overload;
-    class procedure fill(para1: Arr1jfloat; para2: jint; para3: jint; para4: jfloat); static; overload;
-    class procedure fill(var para1: array of jfloat; para2: jint; para3: jint; para4: jfloat); static; overload;
-    class procedure fill(para1: Arr1JLObject; para2: JLObject); static; overload;
-    class procedure fill(var para1: array of JLObject; para2: JLObject); static; overload;
-    class procedure fill(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLObject); static; overload;
-    class procedure fill(var para1: array of JLObject; para2: jint; para3: jint; para4: JLObject); static; overload;
-    class function copyOf(para1: Arr1JLObject; para2: jint): Arr1JLObject; static; overload;
-    class function copyOf(var para1: array of JLObject; para2: jint): Arr1JLObject; static; overload;
-    class function copyOf(para1: Arr1JLObject; para2: jint; para3: JLClass): Arr1JLObject; static; overload;
-    class function copyOf(var para1: array of JLObject; para2: jint; para3: JLClass): Arr1JLObject; static; overload;
-    class function copyOf(para1: Arr1jbyte; para2: jint): Arr1jbyte; static; overload;
-    class function copyOf(var para1: array of jbyte; para2: jint): Arr1jbyte; static; overload;
-    class function copyOf(para1: Arr1jshort; para2: jint): Arr1jshort; static; overload;
-    class function copyOf(var para1: array of jshort; para2: jint): Arr1jshort; static; overload;
-    class function copyOf(para1: Arr1jint; para2: jint): Arr1jint; static; overload;
-    class function copyOf(var para1: array of jint; para2: jint): Arr1jint; static; overload;
-    class function copyOf(para1: Arr1jlong; para2: jint): Arr1jlong; static; overload;
-    class function copyOf(var para1: array of jlong; para2: jint): Arr1jlong; static; overload;
-    class function copyOf(para1: Arr1jchar; para2: jint): Arr1jchar; static; overload;
-    class function copyOf(var para1: array of jchar; para2: jint): Arr1jchar; static; overload;
-    class function copyOf(para1: Arr1jfloat; para2: jint): Arr1jfloat; static; overload;
-    class function copyOf(var para1: array of jfloat; para2: jint): Arr1jfloat; static; overload;
-    class function copyOf(para1: Arr1jdouble; para2: jint): Arr1jdouble; static; overload;
-    class function copyOf(var para1: array of jdouble; para2: jint): Arr1jdouble; static; overload;
-    class function copyOf(para1: Arr1jboolean; para2: jint): Arr1jboolean; static; overload;
-    class function copyOf(var para1: array of jboolean; para2: jint): Arr1jboolean; static; overload;
-    class function copyOfRange(para1: Arr1JLObject; para2: jint; para3: jint): Arr1JLObject; static; overload;
-    class function copyOfRange(var para1: array of JLObject; para2: jint; para3: jint): Arr1JLObject; static; overload;
-    class function copyOfRange(para1: Arr1JLObject; para2: jint; para3: jint; para4: JLClass): Arr1JLObject; static; overload;
-    class function copyOfRange(var para1: array of JLObject; para2: jint; para3: jint; para4: JLClass): Arr1JLObject; static; overload;
-    class function copyOfRange(para1: Arr1jbyte; para2: jint; para3: jint): Arr1jbyte; static; overload;
-    class function copyOfRange(var para1: array of jbyte; para2: jint; para3: jint): Arr1jbyte; static; overload;
-    class function copyOfRange(para1: Arr1jshort; para2: jint; para3: jint): Arr1jshort; static; overload;
-    class function copyOfRange(var para1: array of jshort; para2: jint; para3: jint): Arr1jshort; static; overload;
-    class function copyOfRange(para1: Arr1jint; para2: jint; para3: jint): Arr1jint; static; overload;
-    class function copyOfRange(var para1: array of jint; para2: jint; para3: jint): Arr1jint; static; overload;
-    class function copyOfRange(para1: Arr1jlong; para2: jint; para3: jint): Arr1jlong; static; overload;
-    class function copyOfRange(var para1: array of jlong; para2: jint; para3: jint): Arr1jlong; static; overload;
-    class function copyOfRange(para1: Arr1jchar; para2: jint; para3: jint): Arr1jchar; static; overload;
-    class function copyOfRange(var para1: array of jchar; para2: jint; para3: jint): Arr1jchar; static; overload;
-    class function copyOfRange(para1: Arr1jfloat; para2: jint; para3: jint): Arr1jfloat; static; overload;
-    class function copyOfRange(var para1: array of jfloat; para2: jint; para3: jint): Arr1jfloat; static; overload;
-    class function copyOfRange(para1: Arr1jdouble; para2: jint; para3: jint): Arr1jdouble; static; overload;
-    class function copyOfRange(var para1: array of jdouble; para2: jint; para3: jint): Arr1jdouble; static; overload;
-    class function copyOfRange(para1: Arr1jboolean; para2: jint; para3: jint): Arr1jboolean; static; overload;
-    class function copyOfRange(var para1: array of jboolean; para2: jint; para3: jint): Arr1jboolean; static; overload;
-    class function asList(para1: Arr1JLObject): JUList; static; overload;
-    class function asList(var para1: array of JLObject): JUList; static; overload;
-    class function hashCode(para1: Arr1jlong): jint; static; overload;
-    class function hashCode(var para1: array of jlong): jint; static; overload;
-    class function hashCode(para1: Arr1jint): jint; static; overload;
-    class function hashCode(var para1: array of jint): jint; static; overload;
-    class function hashCode(para1: Arr1jshort): jint; static; overload;
-    class function hashCode(var para1: array of jshort): jint; static; overload;
-    class function hashCode(para1: Arr1jchar): jint; static; overload;
-    class function hashCode(var para1: array of jchar): jint; static; overload;
-    class function hashCode(para1: Arr1jbyte): jint; static; overload;
-    class function hashCode(var para1: array of jbyte): jint; static; overload;
-    class function hashCode(para1: Arr1jboolean): jint; static; overload;
-    class function hashCode(var para1: array of jboolean): jint; static; overload;
-    class function hashCode(para1: Arr1jfloat): jint; static; overload;
-    class function hashCode(var para1: array of jfloat): jint; static; overload;
-    class function hashCode(para1: Arr1jdouble): jint; static; overload;
-    class function hashCode(var para1: array of jdouble): jint; static; overload;
-    class function hashCode(para1: Arr1JLObject): jint; static; overload;
-    class function hashCode(var para1: array of JLObject): jint; static; overload;
-    class function deepHashCode(para1: Arr1JLObject): jint; static; overload;
-    class function deepHashCode(var para1: array of JLObject): jint; static; overload;
-    class function deepEquals(para1: Arr1JLObject; para2: Arr1JLObject): jboolean; static; overload;
-    class function deepEquals(var para1: array of JLObject; var para2: array of JLObject): jboolean; static; overload;
-    class function toString(para1: Arr1jlong): JLString; static; overload;
-    class function toString(var para1: array of jlong): JLString; static; overload;
-    class function toString(para1: Arr1jint): JLString; static; overload;
-    class function toString(var para1: array of jint): JLString; static; overload;
-    class function toString(para1: Arr1jshort): JLString; static; overload;
-    class function toString(var para1: array of jshort): JLString; static; overload;
-    class function toString(para1: Arr1jchar): JLString; static; overload;
-    class function toString(var para1: array of jchar): JLString; static; overload;
-    class function toString(para1: Arr1jbyte): JLString; static; overload;
-    class function toString(var para1: array of jbyte): JLString; static; overload;
-    class function toString(para1: Arr1jboolean): JLString; static; overload;
-    class function toString(var para1: array of jboolean): JLString; static; overload;
-    class function toString(para1: Arr1jfloat): JLString; static; overload;
-    class function toString(var para1: array of jfloat): JLString; static; overload;
-    class function toString(para1: Arr1jdouble): JLString; static; overload;
-    class function toString(var para1: array of jdouble): JLString; static; overload;
-    class function toString(para1: Arr1JLObject): JLString; static; overload;
-    class function toString(var para1: array of JLObject): JLString; static; overload;
-    class function deepToString(para1: Arr1JLObject): JLString; static; overload;
-    class function deepToString(var para1: array of JLObject): JLString; static; overload;
-  end;
-
   JUCollections = class external 'java.util' name 'Collections' (JLObject)
   public
     type

+ 0 - 5
rtl/java/jdk15.pas

@@ -12480,11 +12480,6 @@ type
   Arr2JXTSSAXTransformerFactory = array of Arr1JXTSSAXTransformerFactory;
   Arr3JXTSSAXTransformerFactory = array of Arr2JXTSSAXTransformerFactory;
 
-  JUArrays = class;
-  Arr1JUArrays = array of JUArrays;
-  Arr2JUArrays = array of Arr1JUArrays;
-  Arr3JUArrays = array of Arr2JUArrays;
-
   JSPMMultiTabbedPaneUI = class;
   Arr1JSPMMultiTabbedPaneUI = array of JSPMMultiTabbedPaneUI;
   Arr2JSPMMultiTabbedPaneUI = array of Arr1JSPMMultiTabbedPaneUI;

+ 19 - 0
rtl/java/rtti.inc

@@ -31,6 +31,25 @@ procedure fpc_initialize_array_unicodestring(arr: TJObjectArray; normalarrdim: l
   end;
 
 
+procedure fpc_initialize_array_ansistring_intern(arr: TJObjectArray; normalarrdim: longint); external name 'fpc_initialize_array_ansistring';
+
+procedure fpc_initialize_array_ansistring(arr: TJObjectArray; normalarrdim: longint);compilerproc;
+  var
+    i: longint;
+  begin
+    if normalarrdim > 0 then
+      begin
+        for i:=low(arr) to high(arr) do
+          fpc_initialize_array_ansistring_intern(TJObjectArray(arr[i]),normalarrdim-1);
+      end
+    else
+      begin
+        for i:=low(arr) to high(arr) do
+          ansistring(arr[i]):='';
+      end;
+  end;
+
+
 procedure fpc_initialize_array_dynarr_intern(arr: TJObjectArray; normalarrdim: longint); external name 'fpc_initialize_array_dynarr';
 
 procedure fpc_initialize_array_dynarr(arr: TJObjectArray; normalarrdim: longint);compilerproc;

+ 2 - 1
rtl/java/system.pp

@@ -123,6 +123,7 @@ type
 {$i jmathh.inc}
 {$i jrech.inc}
 {$i jdynarrh.inc}
+{$i astringh.inc}
 
 {$ifndef nounsupported}
 type
@@ -173,7 +174,7 @@ type
        vtObject        : (VObject: TObject);
 //       vtClass         : (VClass: TClass);
 //       vtPWideChar     : (VPWideChar: PWideChar);
-       vtAnsiString    : (VAnsiString: JLString);
+       vtAnsiString    : (VAnsiString: JLObject);
        vtCurrency      : (VCurrency: Currency);
 //       vtVariant       : (VVariant: PVariant);
        vtInterface     : (VInterface: JLObject);

+ 19 - 33
rtl/java/ustrings.inc

@@ -78,17 +78,10 @@ Function fpc_UnicodeStr_To_AnsiStr (const S2 : UnicodeString): AnsiString; compi
 {
   Converts a UnicodeString to an AnsiString
 }
-{$ifdef nounsupported}
 Var
   Size : SizeInt;
-{$endif}
 begin
-{$ifdef nounsupported}
-  result:='';
-  Size:=Length(S2);
-  if Size>0 then
-    widestringmanager.Unicode2AnsiMoveProc(PUnicodeChar(Pointer(S2)),result,Size);
-{$endif}
+  result:=Ansistring(AnsistringClass.Create(s2));
 end;
 
 
@@ -96,17 +89,13 @@ Function fpc_AnsiStr_To_UnicodeStr (Const S2 : AnsiString): UnicodeString; compi
 {
   Converts an AnsiString to a UnicodeString;
 }
-{$ifdef nounsupported}
 Var
   Size : SizeInt;
-{$endif}
 begin
-{$ifdef nounsupported}
-  result:='';
-  Size:=Length(S2);
-  if Size>0 then
-    widestringmanager.Ansi2UnicodeMoveProc(PChar(S2),result,Size);
-{$endif}
+  if length(s2)=0 then
+    result:=''
+  else
+    result:=AnsistringClass(S2).toString;
 end;
 
 Function fpc_UnicodeStr_To_WideStr (const S2 : UnicodeString): WideString; compilerproc;
@@ -277,9 +266,8 @@ Function fpc_UChar_To_UnicodeStr(const c : UnicodeChar): UnicodeString; compiler
   Converts a UnicodeChar to a UnicodeString;
 }
 var
-  arr: array of UnicodeChar;
+  arr: array[0..0] of UnicodeChar;
 begin
-  setlength(arr,1);
   arr[0]:=c;
   result:=JLString.create(arr);
 end;
@@ -933,26 +921,28 @@ begin
   result:=Pos(wc,s);
 end;
 
-
 (*
 Procedure Delete (Var S : UnicodeString; Index,Size: SizeInt);
 Var
   LS : SizeInt;
+  sb: JLStringBuilder;
 begin
   LS:=Length(S);
   if (Index>LS) or (Index<=0) or (Size<=0) then
     exit;
 
-  UniqueString (S);
   { (Size+Index) will overflow if Size=MaxInt. }
   if Size>LS-Index then
     Size:=LS-Index+1;
   if Size<=LS-Index then
-  begin
-    Dec(Index);
-    Move(PUnicodeChar(S)[Index+Size],PUnicodeChar(S)[Index],(LS-Index-Size+1)*sizeof(UnicodeChar));
-  end;
-  Setlength(s,LS-Size);
+    begin
+      Dec(Index);
+      sb:=JLStringBuilder.Create(s);
+      sb.delete(index,size);
+      s:=sb.toString;
+    end
+  else
+    s:=JLString(s).substring(0,index-1);
 end;
 
 
@@ -960,6 +950,7 @@ Procedure Insert (Const Source : UnicodeString; Var S : UnicodeString; Index : S
 var
   Temp : UnicodeString;
   LS : SizeInt;
+  sb : JLStringBuilder;
 begin
   If Length(Source)=0 then
    exit;
@@ -969,14 +960,9 @@ begin
   if index > LS then
    index := LS+1;
   Dec(Index);
-  Pointer(Temp) := NewUnicodeString(Length(Source)+LS);
-  SetLength(Temp,Length(Source)+LS);
-  If Index>0 then
-    move (PUnicodeChar(S)^,PUnicodeChar(Temp)^,Index*sizeof(UnicodeChar));
-  Move (PUnicodeChar(Source)^,PUnicodeChar(Temp)[Index],Length(Source)*sizeof(UnicodeChar));
-  If (LS-Index)>0 then
-    Move(PUnicodeChar(S)[Index],PUnicodeChar(temp)[Length(Source)+index],(LS-Index)*sizeof(UnicodeChar));
-  S:=Temp;
+  sb:=JLStringBuilder.Create(S);
+  sb.insert(Index,Source);
+  S:=sb.toString;
 end;
 *)