* PChar -> PAnsiChar

packages/rtl-objpas/examples/syshelpersdemo.pas

@@ -1,7 +1,8 @@
 program syshelpersconsoledemo; // syshelpers demonstration of customizable boolean, binary and hexadecimal data localized string representation
-
+{$codepage utf8}
 uses
   {$IFDEF WINDOWS}windows,{$ENDIF}
+  {$IFDEF UNIX}cwstring,{$ENDIF}
   sysutils, syshelpers;
 
 procedure Print(aValue: boolean);

packages/rtl-objpas/src/inc/dateutil.inc

@@ -450,9 +450,11 @@ Function LocalTimeToUniversal(LT: TDateTime; TZOffset: Integer): TDateTime;
 
 
 { ScanDateTime is a limited inverse of formatdatetime }
-function ScanDateTime(const Pattern:string;const s:string;const fmt:TFormatSettings;startpos:integer=1) : tdatetime; overload;
+function ScanDateTime(const Pattern:String;const s:string;const fmt:TFormatSettings;startpos:integer=1) : tdatetime; overload;
 function ScanDateTime(const Pattern:string;const s:string;startpos:integer=1) : tdatetime; overload;
 
+
+
 // ISO date/time
 // YYYYMMDD or YYYY-MM-DD
 function TryISOStrToDate(const aString: string; out outDate: TDateTime): Boolean;
@@ -2397,8 +2399,8 @@ end;
   Extensions
   - #9 eats whitespace.
   - whitespace at the end of a pattern is optional.
-  - ? matches any char.
-  - Quote the above chars to really match the char.
+  - ? matches any AnsiChar.
+  - Quote the above chars to really match the AnsiChar.
 }
 
 const whitespace  = [' ',#13,#10];
@@ -2415,22 +2417,23 @@ begin
   raise EConvertError.Create(s);
 end;
 
-function scandatetime(const pattern:string;const s:string;const fmt:TFormatSettings;startpos:integer=1) : tdatetime;
+function scandatetime(const pattern: string;const s:string;const fmt:TFormatSettings;startpos:integer=1) : tdatetime;
+
 const
   EPS = 1E-15;
 
 var len ,ind  : integer;
     yy,mm,dd  : integer;
     timeval   : TDateTime;
-    activequote: char;
+    activequote: Char;
 
-procedure intscandate(ptrn:pchar;plen:integer;poffs:integer);
+procedure intscandate(ptrn:PChar;plen:integer;poffs:integer);
 // poffs is the offset to
 
 var
     pind : integer;
 
-function findimatch(const mnts:array of string;p:pchar):integer;
+function findimatch(const mnts:array of string;p:PChar):integer;
 var i : integer;
     plen, findlen: integer;
 begin
@@ -2441,8 +2444,13 @@ begin
     begin
       findlen := length(mnts[i]);
       if (findlen > 0) and (findlen <= plen) then // protect against buffer over-read
+{$if SizeOf(Char)=2}
+        if StrLIComp(p,@(mnts[i][1]),findlen)=0 then
+          result:=i;
+{$else}
         if AnsiStrLIComp(p,@(mnts[i][1]),findlen)=0 then
           result:=i;
+{$endif}
       inc(i);
     end;
 end;
@@ -2453,7 +2461,7 @@ begin
   raiseexception(format(SNoArrayMatch,[pind+1,ind]))
 end;
 
-function scanmatch(const mnts : array of string;p:pchar; patlen: integer):integer;
+function scanmatch(const mnts : array of string;p:PChar; patlen: integer):integer;
 begin
   result:=findimatch(mnts,p);
   if result=-1 then
@@ -2471,7 +2479,7 @@ var
     i     : integer;
 
 function scanfixedint(maxv:integer):integer;
-var c : char;
+var c : Char;
     oi:integer;
 begin
   result:=0;
@@ -2488,7 +2496,7 @@ begin
     raiseexception(format(SPatternCharMismatch,[c,oi]));
 end;
 
-procedure matchchar(c:char);
+procedure matchchar(c:Char);
 
 begin
   if (ind>len) or (s[ind]<>c) then
@@ -2498,7 +2506,7 @@ begin
 end;
 
 function scanpatlen:integer;
-var c : char;
+var c : Char;
     lind : Integer;
 begin
   result:=pind;
@@ -2519,7 +2527,7 @@ begin
     intscandate(@lptr[1],len,pind+poffs);
 end;
 
-var lasttoken,lch : char;
+var lasttoken,lch : Char;
 
 begin
   pind:=0;     lasttoken:=' ';
@@ -2648,7 +2656,7 @@ begin
                                   end;
                                  inc(pind,length(AMPMformatting[2]));
                                end;
-                           else  // no AM/PM match. Assume 'a' is simply a char
+                           else  // no AM/PM match. Assume 'a' is simply a AnsiChar
                                matchchar(ptrn[pind]);
                              end;
                          end;
@@ -2709,6 +2717,12 @@ begin
      result:=result+encodedate(yy,mm,dd);
 end;
 
+function ScanDateTime(const Pattern: Ansistring; const s: string;
+  startpos: integer): tdatetime;
+begin
+
+end;
+
 
 function scandatetime(const pattern:string;const s:string;startpos:integer=1) : tdatetime; overload;
 
@@ -2751,7 +2765,7 @@ function DateToISO8601(const ADate: TDateTime; AInputIsUTC: Boolean = True): str
 
 const
   FmtOffset: string = '%.02d:%.02d';
-  Sign: array[Boolean] of Char = ('+', '-');
+  Sign: array[Boolean] of AnsiChar = ('+', '-');
 
 var
   Offset: Integer;

packages/rtl-objpas/src/inc/fmtbcd.pp

@@ -950,7 +950,7 @@ IMPLEMENTATION
       j : Integer;
 
     const
-      ft : ARRAY [ Boolean ] of Char = ( 'f', 't' );
+      ft : ARRAY [ Boolean ] of AnsiChar = ( 'f', 't' );
 
     begin
 {$ifndef bigger_BCD}
@@ -980,7 +980,7 @@ IMPLEMENTATION
       i : Integer;
 
     const
-      ft : ARRAY [ Boolean ] of Char = ( 'f', 't' );
+      ft : ARRAY [ Boolean ] of AnsiChar = ( 'f', 't' );
 
     begin
       Write ( 'Prec:', v.Prec, ' ',
@@ -1394,7 +1394,7 @@ IMPLEMENTATION
       lav : {$ifopt r+} longword {$else} longword {$endif};
       i   : {$ifopt r+} longword {$else} longword {$endif};
 {$endif}
-      ch : Char;
+      ch : AnsiChar;
 
     type
       ife = ( inint, infrac, inexp );
@@ -2501,7 +2501,7 @@ writeln ( '> ', i4, ' ', bh.Singles[i4], ' ', Add );
                              Digits : Integer ) : FmtBCDStringtype;
     var P, E: integer;
         Negative: boolean;
-        DS, TS: char;
+        DS, TS: AnsiChar;
 
     procedure RoundDecimalDigits(const d: integer);
     var i,j: integer;
@@ -2526,7 +2526,7 @@ writeln ( '> ', i4, ' ', bh.Singles[i4], ' ', Add );
             break;
           end;
         end;
-      if d = 0 then dec(j); // if decimal separator is last char then do not copy them
+      if d = 0 then dec(j); // if decimal separator is last AnsiChar then do not copy them
       Result := copy(Result, 1, j);
     end;
 
@@ -2654,25 +2654,25 @@ writeln ( '> ', i4, ' ', bh.Singles[i4], ' ', Add );
       TSection=record
         FmtStart, FmtEnd,      // positions in Format string,
         Fmt1Dig,               // position of 1st digit placeholder,
-        FmtDS: PChar;          // position of decimal point
+        FmtDS: PAnsiChar;          // position of decimal point
         Digits: integer;       // number of all digit placeholders
         DigDS: integer;        // number of digit placeholders after decimal separator
         HasTS, HasDS: boolean; // has thousand or decimal separator?
       end;
 
     var
-      PFmt: PChar;
+      PFmt: PAnsiChar;
       i, j, j1, je, ReqSec, Sec, Scale: integer;
       Section: TSection;
       FF: TFloatFormat;
       BCDStr: string;                   // BCDToStrF of given BCD parameter
-      Buf: array [0..85] of char;       // output buffer
+      Buf: array [0..85] of AnsiChar;       // output buffer
 
     // Parses Format parameter, their sections (positive;negative;zero) and
     //  builds Section information for requested section
     procedure ParseFormat;
-    var C,Q: Char;
-        PFmtEnd: PChar;
+    var C,Q: AnsiChar;
+        PFmtEnd: PAnsiChar;
         Section1: TSection;
     begin
       PFmt:=@Format[1];
@@ -2744,8 +2744,8 @@ writeln ( '> ', i4, ' ', bh.Singles[i4], ' ', Add );
       end;
     end;
 
-    procedure PutFmtDigit(var AFmt: PChar; var iBCDStr, iBuf: integer; MoveBy: integer);
-    var ADig, Q: Char;
+    procedure PutFmtDigit(var AFmt: PAnsiChar; var iBCDStr, iBuf: integer; MoveBy: integer);
+    var ADig, Q: AnsiChar;
     begin
       if (iBuf < low(Buf)) or (iBuf > high(Buf)) then
         raise eBCDOverflowException.Create ( 'in FormatBCD' );
@@ -4305,7 +4305,7 @@ end;
     {$ifdef BCDgr4 }
 
   const
-    myMinIntBCDValue : packed array [ 1..3 ] of Char = #$32#$76#$80;
+    myMinIntBCDValue : packed array [ 1..3 ] of AnsiChar = #$32#$76#$80;
 
     {$endif}
   {$else}
@@ -4314,7 +4314,7 @@ end;
       {$ifdef BCDgr9 }
 
   const
-    myMinIntBCDValue : packed array [ 1..10 ] of Char = #$21#$47#$48#$36#$48;
+    myMinIntBCDValue : packed array [ 1..10 ] of AnsiChar = #$21#$47#$48#$36#$48;
 
       {$endif}
 (*
@@ -4323,7 +4323,7 @@ end;
         {$ifdef BCDgr18 }
 
   const
-    myMinIntBCDValue : packed array [ 1..19 ] of Char = #$92#$23#$37#$20#$36#$85#$47#$75#$80#$80;
+    myMinIntBCDValue : packed array [ 1..19 ] of AnsiChar = #$92#$23#$37#$20#$36#$85#$47#$75#$80#$80;
 
         {$endif}
       {$else}

packages/rtl-objpas/src/inc/rtti.pp

@@ -140,7 +140,7 @@ type
     function AsBoolean: boolean;
     function AsCurrency: Currency;
     function AsInteger: Integer;
-    function AsChar: Char; inline;
+    function AsChar: AnsiChar; inline;
     function AsAnsiChar: AnsiChar;
     function AsWideChar: WideChar;
     function AsInt64: Int64;
@@ -1922,6 +1922,7 @@ begin
 end;
 
 function TValue.AsUnicodeString: UnicodeString;
+
 begin
   if (Kind in [tkSString, tkAString, tkUString, tkWString]) and not Assigned(FData.FValueData) then
     Result := ''
@@ -2101,9 +2102,9 @@ begin
     raise EInvalidCast.Create(SErrInvalidTypecast);
 end;
 
-function TValue.AsChar: Char;
+function TValue.AsChar: AnsiChar;
 begin
-{$if SizeOf(Char) = 1}
+{$if SizeOf(AnsiChar) = 1}
   Result := AsAnsiChar;
 {$else}
   Result := AsWideChar;
@@ -4131,6 +4132,7 @@ var
   end;
   s: String;
   ss: ShortString;
+  u : UnicodeString;
   O: TObject;
   Int: IUnknown;
 begin
@@ -4145,6 +4147,16 @@ begin
         s := GetStrProp(TObject(Instance), FPropInfo);
         TValue.Make(@s, FPropInfo^.PropType, result);
       end;
+    tkUString:
+      begin
+        U := GetUnicodeStrProp(TObject(Instance), FPropInfo);
+        TValue.Make(@U, FPropInfo^.PropType, result);
+      end;
+    tkWString:
+      begin
+        U := GetWideStrProp(TObject(Instance), FPropInfo);
+        TValue.Make(@U, FPropInfo^.PropType, result);
+      end;
     tkEnumeration:
       begin
         Values.Enum := Integer(GetOrdProp(TObject(Instance), FPropInfo));
@@ -4232,6 +4244,10 @@ begin
     tkSString,
     tkAString:
       SetStrProp(TObject(Instance), FPropInfo, AValue.AsString);
+    tkUString:
+      SetUnicodeStrProp(TObject(Instance), FPropInfo, AValue.AsUnicodeString);
+    tkWString:
+      SetWideStrProp(TObject(Instance), FPropInfo, AValue.AsUnicodeString);
     tkInteger,
     tkInt64,
     tkQWord,

packages/rtl-objpas/src/inc/variants.pp

@@ -83,8 +83,8 @@ function VarIsNumeric(const V: Variant): Boolean; inline;
 function VarIsStr(const V: Variant): Boolean;
 function VarIsBool(const V: Variant): Boolean; inline;
 
-function VarToStr(const V: Variant): string;
-function VarToStrDef(const V: Variant; const ADefault: string): string;
+function VarToStr(const V: Variant): AnsiString;
+function VarToStrDef(const V: Variant; const ADefault: AnsiString): AnsiString;
 function VarToWideStr(const V: Variant): WideString;
 function VarToWideStrDef(const V: Variant; const ADefault: WideString): WideString;
 function VarToUnicodeStr(const V: Variant): UnicodeString;
@@ -182,9 +182,9 @@ type
     procedure VarDataCastTo(var Dest: TVarData; const Source: TVarData; const aVarType: TVarType); overload;
     procedure VarDataCastTo(var Dest: TVarData; const aVarType: TVarType); overload;
     procedure VarDataCastToOleStr(var Dest: TVarData);
-    procedure VarDataFromStr(var V: TVarData; const Value: string);
+    procedure VarDataFromStr(var V: TVarData; const Value: AnsiString);
     procedure VarDataFromOleStr(var V: TVarData; const Value: WideString);
-    function VarDataToStr(const V: TVarData): string;
+    function VarDataToStr(const V: TVarData): AnsiString;
     function VarDataIsEmptyParam(const V: TVarData): Boolean;
     function VarDataIsByRef(const V: TVarData): Boolean;
     function VarDataIsArray(const V: TVarData): Boolean;
@@ -214,12 +214,12 @@ type
   IVarInvokeable = interface
     ['{1CB65C52-BBCB-41A6-9E58-7FB916BEEB2D}']
     function DoFunction(var Dest: TVarData; const V: TVarData;
-      const Name: string; const Arguments: TVarDataArray): Boolean;
-    function DoProcedure(const V: TVarData; const Name: string;
+      const Name: AnsiString; const Arguments: TVarDataArray): Boolean;
+    function DoProcedure(const V: TVarData; const Name: AnsiString;
       const Arguments: TVarDataArray): Boolean;
     function GetProperty(var Dest: TVarData; const V: TVarData;
-      const Name: string): Boolean;
-    function SetProperty(var V: TVarData; const Name: string;
+      const Name: AnsiString): Boolean;
+    function SetProperty(var V: TVarData; const Name: AnsiString;
       const Value: TVarData): Boolean;
   end;
 
@@ -230,12 +230,12 @@ type
   public
     { IVarInvokeable }
     function DoFunction(var Dest: TVarData; const V: TVarData;
-      const Name: string; const Arguments: TVarDataArray): Boolean; virtual;
-    function DoProcedure(const V: TVarData; const Name: string;
+      const Name: AnsiString; const Arguments: TVarDataArray): Boolean; virtual;
+    function DoProcedure(const V: TVarData; const Name: AnsiString;
       const Arguments: TVarDataArray): Boolean; virtual;
     function GetProperty(var Dest: TVarData; const V: TVarData;
-      const Name: string): Boolean; virtual;
-    function SetProperty(var V: TVarData; const Name: string;
+      const Name: AnsiString): Boolean; virtual;
+    function SetProperty(var V: TVarData; const Name: AnsiString;
       const Value: TVarData): Boolean; virtual;
   end;
 
@@ -250,14 +250,14 @@ type
     function GetInstance(const V: TVarData): TObject; virtual; abstract;
   public
     function GetProperty(var Dest: TVarData; const V: TVarData;
-      const Name: string): Boolean; override;
-    function SetProperty(var V: TVarData; const Name: string;
+      const Name: AnsiString): Boolean; override;
+    function SetProperty(var V: TVarData; const Name: AnsiString;
       const Value: TVarData): Boolean; override;
   end;
 
   function FindCustomVariantType(const aVarType: TVarType;
     out CustomVariantType: TCustomVariantType): Boolean; overload;
-  function FindCustomVariantType(const TypeName: string;
+  function FindCustomVariantType(const TypeName: AnsiString;
     out CustomVariantType: TCustomVariantType): Boolean; overload;
 
 type
@@ -276,7 +276,7 @@ var
   NullEqualityRule: TNullCompareRule = ncrLoose;
   NullMagnitudeRule: TNullCompareRule = ncrLoose;
   NullStrictConvert: Boolean = true;
-  NullAsStringValue: string = '';
+  NullAsStringValue: AnsiString = '';
   PackVarCreation: Boolean = True;
 {$ifndef FPUNONE}
   OleVariantInt64AsDouble: Boolean = False;
@@ -312,11 +312,11 @@ procedure VarArrayCreateError;
 procedure VarResultCheck(AResult: HRESULT);{$IFDEF VARIANTINLINE}inline;{$ENDIF VARIANTINLINE}
 procedure VarResultCheck(AResult: HRESULT; ASourceType, ADestType: TVarType);
 procedure HandleConversionException(const ASourceType, ADestType: TVarType);
-function VarTypeAsText(const AType: TVarType): string;
+function VarTypeAsText(const AType: TVarType): AnsiString;
 function FindVarData(const V: Variant): PVarData;
 
 const
-  VarOpAsText : array[TVarOp] of string = (
+  VarOpAsText : array[TVarOp] of AnsiString = (
     '+',   {opAdd}
     '-',   {opSubtract}
     '*',   {opMultiply}
@@ -345,8 +345,8 @@ const
 Function  GetPropValue(Instance: TObject; PropInfo: PPropInfo; PreferStrings: Boolean): Variant; overload;
 Procedure SetPropValue(Instance: TObject; PropInfo: PPropInfo; const Value: Variant); overload;
 Function  GetVariantProp(Instance: TObject; PropInfo : PPropInfo): Variant;
-Function  GetVariantProp(Instance: TObject; const PropName: string): Variant;
-Procedure SetVariantProp(Instance: TObject; const PropName: string; const Value: Variant);
+Function  GetVariantProp(Instance: TObject; const PropName: AnsiString): Variant;
+Procedure SetVariantProp(Instance: TObject; const PropName: AnsiString; const Value: Variant);
 Procedure SetVariantProp(Instance: TObject; PropInfo : PPropInfo; const Value: Variant);
 
 
@@ -390,7 +390,7 @@ begin
 end;
 
 { ---------------------------------------------------------------------
-    String Messages
+    AnsiString Messages
   ---------------------------------------------------------------------}
 
 ResourceString
@@ -401,12 +401,12 @@ ResourceString
     Auxiliary routines
   ---------------------------------------------------------------------}
 
-Procedure VariantError (Const Msg : String); inline;
+Procedure VariantError (Const Msg : AnsiString); inline;
 begin
   Raise EVariantError.Create(Msg);
 end;
 
-Procedure NotSupported(Meth: String);
+Procedure NotSupported(Meth: AnsiString);
 begin
   Raise EVariantError.CreateFmt('Method %s not yet supported.',[Meth]);
 end;
@@ -1235,7 +1235,7 @@ end;
 
 function DoVarCmpWStrDirect(const Left, Right: Pointer; const OpCode: TVarOp): ShortInt; inline;
 begin
-  { we can do this without ever copying the string }
+  { we can do this without ever copying the AnsiString }
   if OpCode in [opCmpEq, opCmpNe] then
     if Length(WideString(Left)) <> Length(WideString(Right)) then
       Exit(-1);
@@ -1256,7 +1256,7 @@ end;
 
 function DoVarCmpLStrDirect(const Left, Right: Pointer; const OpCode: TVarOp): ShortInt; inline;
 begin
-  { we can do this without ever copying the string }
+  { we can do this without ever copying the AnsiString }
   if OpCode in [opCmpEq, opCmpNe] then
     if Length(AnsiString(Left)) <> Length(AnsiString(Right)) then
       Exit(-1);
@@ -2763,7 +2763,7 @@ begin
       if arrayelementtype=varVariant then
         begin
           VarResultCheck(SafeArrayPtrOfIndex(p,PVarArrayCoorArray(indices),arraydest));
-          { we can't store ansistrings in Variant arrays so we convert the string to
+          { we can't store ansistrings in Variant arrays so we convert the AnsiString to
             an olestring }
           if valuevtype=varString then
             begin
@@ -3048,14 +3048,14 @@ begin
 end;
 
 
-function VarToStr(const V: Variant): string;
+function VarToStr(const V: Variant): AnsiString;
 
 begin
   Result:=VarToStrDef(V,'');
 end;
 
 
-function VarToStrDef(const V: Variant; const ADefault: string): string;
+function VarToStrDef(const V: Variant; const ADefault: AnsiString): AnsiString;
 
 begin
   If TVarData(V).vType<>varNull then
@@ -3675,7 +3675,7 @@ function FindCustomVariantType(const aVarType: TVarType; out CustomVariantType:
   end;
 
 
-function FindCustomVariantType(const TypeName: string;  out CustomVariantType: TCustomVariantType): Boolean; overload;
+function FindCustomVariantType(const TypeName: AnsiString;  out CustomVariantType: TCustomVariantType): Boolean; overload;
   var
     i: Integer;
     tmp: TCustomVariantType;
@@ -3869,7 +3869,7 @@ end;
 
 
 
-procedure TCustomVariantType.VarDataFromStr(var V: TVarData; const Value: string);
+procedure TCustomVariantType.VarDataFromStr(var V: TVarData; const Value: AnsiString);
 
 begin
   sysvarfromlstr(Variant(V),Value);
@@ -3883,7 +3883,7 @@ begin
 end;
 
 
-function TCustomVariantType.VarDataToStr(const V: TVarData): string;
+function TCustomVariantType.VarDataToStr(const V: TVarData): AnsiString;
 
 begin
   sysvartolstr(Result,Variant(V));
@@ -4094,7 +4094,7 @@ const
   argref_mask = $80;
 begin
   arg_count := CallDesc^.ArgCount;
-  method_name := ansistring(pchar(@CallDesc^.ArgTypes[arg_count]));
+  method_name := ansistring(PAnsiChar(@CallDesc^.ArgTypes[arg_count]));
   setLength(args, arg_count);
   if arg_count > 0 then
   begin
@@ -4214,25 +4214,25 @@ begin
   end;
 end;
 
-function TInvokeableVariantType.DoFunction(var Dest: TVarData; const V: TVarData; const Name: string; const Arguments: TVarDataArray): Boolean;
+function TInvokeableVariantType.DoFunction(var Dest: TVarData; const V: TVarData; const Name: AnsiString; const Arguments: TVarDataArray): Boolean;
 
 begin
   result := False;
 end;
 
-function TInvokeableVariantType.DoProcedure(const V: TVarData; const Name: string; const Arguments: TVarDataArray): Boolean;
+function TInvokeableVariantType.DoProcedure(const V: TVarData; const Name: AnsiString; const Arguments: TVarDataArray): Boolean;
 begin
   result := False
 end;
 
 
-function TInvokeableVariantType.GetProperty(var Dest: TVarData; const V: TVarData; const Name: string): Boolean;
+function TInvokeableVariantType.GetProperty(var Dest: TVarData; const V: TVarData; const Name: AnsiString): Boolean;
   begin
     result := False;
   end;
 
 
-function TInvokeableVariantType.SetProperty(var V: TVarData; const Name: string; const Value: TVarData): Boolean;
+function TInvokeableVariantType.SetProperty(var V: TVarData; const Name: AnsiString; const Value: TVarData): Boolean;
   begin
     result := False;
   end;
@@ -4242,14 +4242,14 @@ function TInvokeableVariantType.SetProperty(var V: TVarData; const Name: string;
     TPublishableVariantType implementation
   ---------------------------------------------------------------------}
 
-function TPublishableVariantType.GetProperty(var Dest: TVarData; const V: TVarData; const Name: string): Boolean;
+function TPublishableVariantType.GetProperty(var Dest: TVarData; const V: TVarData; const Name: AnsiString): Boolean;
   begin
     Result:=true;
     Variant(Dest):=TypInfo.GetPropValue(getinstance(v),name);
   end;
 
 
-function TPublishableVariantType.SetProperty(var V: TVarData; const Name: string; const Value: TVarData): Boolean;
+function TPublishableVariantType.SetProperty(var V: TVarData; const Name: AnsiString; const Value: TVarData): Boolean;
   begin
     Result:=true;
     TypInfo.SetPropValue(getinstance(v),name,Variant(value));
@@ -4458,11 +4458,11 @@ procedure HandleConversionException(const ASourceType, ADestType: TVarType);
   end;
 
 
-function VarTypeAsText(const AType: TVarType): string;
+function VarTypeAsText(const AType: TVarType): AnsiString;
   var
     customvarianttype : TCustomVariantType;
   const
-    names : array[varEmpty..varQWord] of string[8] = (
+    names : array[varEmpty..varQWord] of String[8] = (
     'Empty','Null','Smallint','Integer','Single','Double','Currency','Date','OleStr','Dispatch','Error','Boolean','Variant',
     'Unknown','Decimal','???','ShortInt','Byte','Word','DWord','Int64','QWord');
   begin
@@ -4471,7 +4471,7 @@ function VarTypeAsText(const AType: TVarType): string;
     else
       case AType and varTypeMask of
         varString:
-          Result:='String';
+          Result:='AnsiString';
         varAny:
           Result:='Any';
         else
@@ -4556,13 +4556,13 @@ begin
 end;
 
 
-Function GetVariantProp(Instance: TObject; const PropName: string): Variant;
+Function GetVariantProp(Instance: TObject; const PropName: AnsiString): Variant;
 begin
   Result:=GetVariantProp(Instance,FindPropInfo(Instance,PropName));
 end;
 
 
-Procedure SetVariantProp(Instance: TObject; const PropName: string;  const Value: Variant);
+Procedure SetVariantProp(Instance: TObject; const PropName: AnsiString;  const Value: Variant);
 begin
   SetVariantprop(instance,FindpropInfo(Instance,PropName),Value);
 end;
@@ -4571,7 +4571,7 @@ end;
   All properties through Variant.
   ---------------------------------------------------------------------}
 
-Function GetPropValue(Instance: TObject; const PropName: string): Variant;
+Function GetPropValue(Instance: TObject; const PropName: AnsiString): Variant;
 begin
   Result:=TypInfo.GetPropValue(Instance,PropName,True);
 end;
@@ -4627,7 +4627,7 @@ var
  O: Integer;
  I64: Int64;
  Qw: QWord;
- S: String;
+ S: AnsiString;
  B: Boolean;
  dynarr: Pointer;
 

packages/rtl-objpas/src/inc/varutils.inc

@@ -560,7 +560,7 @@ begin
         end;
       ReAllocMem(psa^.Data,(Count+D)*psa^.ElementSize);
       if D>0 then
-        fillchar((PChar(psa^.Data)+Count*psa^.ElementSize)^,D*psa^.ElementSize,0);
+        fillchar((PAnsiChar(psa^.Data)+Count*psa^.ElementSize)^,D*psa^.ElementSize,0);
       end;
     psa^.Bounds[0].ElementCount:=NewBound.ElementCount;
     psa^.Bounds[0].LowBound:=NewBound.LowBound;

packages/rtl-objpas/src/inc/widestrutils.pp

@@ -35,7 +35,7 @@ type
   TEncodeType = (etUSASCII, etUTF8, etANSI);
 
 const
-  sUTF8BOMString: array[1..3] of char = (#$EF, #$BB, #$BF);
+  sUTF8BOMString: array[1..3] of AnsiChar = (#$EF, #$BB, #$BF);
 
 function HasUTF8BOM(S: TStream): boolean; overload;
 function HasUTF8BOM(const S: RawByteString): boolean; overload;
@@ -147,7 +147,7 @@ end;
 function HasUTF8BOM(S: TStream): boolean;
 var
   OldPos: Int64;
-  Buf: array[1..3] of char;
+  Buf: array[1..3] of AnsiChar;
 begin
   Result := false;
   if S.Size<3 then exit;

packages/rtl-objpas/tests/testrunner.rtlobjpas.pp

@@ -20,6 +20,9 @@ program testrunner.rtlobjpas;
 {$endif}
 
 uses
+{$ifdef unix} 
+  cwstring,
+{$endif}
 {$ifdef useffi}
   ffi.manager,
 {$endif}
@@ -36,6 +39,8 @@ var
   Application: TTestRunner;
 
 begin
+  DefaultRunAllTests:=True;
+  DefaultFormat:=fPlain;
   Application := TTestRunner.Create(nil);
   Application.Initialize;
   Application.Title := 'RTL-ObjPas unit tests';

packages/rtl-objpas/tests/tests.rtti.pas

@@ -2496,7 +2496,7 @@ begin
   CheckEquals(true, IsManaged(TypeInfo(unicodestring)), 'IsManaged for tkUString');
   CheckEquals(false, IsManaged(TypeInfo(shortstring)), 'IsManaged for tkSString');
   CheckEquals(false, IsManaged(TypeInfo(Byte)), 'IsManaged for tkInteger');
-  CheckEquals(false, IsManaged(TypeInfo(Char)), 'IsManaged for tkChar');
+  CheckEquals(false, IsManaged(TypeInfo(AnsiChar)), 'IsManaged for tkChar');
   CheckEquals(false, IsManaged(TypeInfo(TTestEnum)), 'IsManaged for tkEnumeration');
   CheckEquals(false, IsManaged(TypeInfo(Single)), 'IsManaged for tkFloat');
   CheckEquals(false, IsManaged(TypeInfo(TTestSet)), 'IsManaged for tkSet');

packages/rtl-objpas/tests/tests.rtti.util.pas

@@ -20,7 +20,7 @@ type
     class procedure Make<T>(const aValue: T; var aResult: TValue); overload; static;
     function AsUnicodeString: UnicodeString;
     function AsAnsiString: AnsiString;
-    function AsChar: Char; inline;
+    function AsChar: AnsiChar; inline;
     function AsAnsiChar: AnsiChar;
     function AsWideChar: WideChar;
   end;
@@ -91,7 +91,7 @@ begin
   Result := AnsiChar(Byte(AsOrdinal));
 end;
 
-function TValueHelper.AsChar: Char;
+function TValueHelper.AsChar: AnsiChar;
 begin
   Result := AsWideChar;
 end;