* 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

@@ -151,7 +151,7 @@ type
     function AsDouble : Double;
     function AsInteger: Integer;
     function AsError: HRESULT;
-    function AsChar: Char; inline;
+    function AsChar: AnsiChar; inline;
     function AsAnsiChar: AnsiChar;
     function AsWideChar: WideChar;
     function AsInt64: Int64;
@@ -2026,6 +2026,7 @@ begin
 end;
 
 function TValue.AsUnicodeString: UnicodeString;
+
 begin
   if (Kind in [tkSString, tkAString, tkUString, tkWString]) and not Assigned(FData.FValueData) then
     Result := ''
@@ -2266,9 +2267,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;
@@ -4416,6 +4417,7 @@ var
   end;
   s: String;
   ss: ShortString;
+  u : UnicodeString;
   O: TObject;
   Int: IUnknown;
 begin
@@ -4430,6 +4432,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));
@@ -4517,6 +4529,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}

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

@@ -1199,7 +1199,394 @@ end;
 
 
 
+<<<<<<< HEAD
 procedure TTestRTTI.TestInterface;
+=======
+  test.value1 := 42;
+  test.value2 := 'Hello World';
+  TValue.Make(@test, TypeInfo(TTestRecord), value);
+  Check(value.GetReferenceToRawData <> @test, 'Reference to record is equal');
+  Check(PTestRecord(value.GetReferenceToRawData)^.value1 = PTestRecord(@test)^.value1, 'Reference to record data value1 differs');
+  Check(PTestRecord(value.GetReferenceToRawData)^.value2 = PTestRecord(@test)^.value2, 'Reference to record data value2 differs');
+
+  SetLength(arrdyn, 3);
+  arrdyn[0] := 42;
+  arrdyn[1] := 23;
+  arrdyn[2] := 49;
+  TValue.Make(@arrdyn, TypeInfo(TArrayOfLongintDyn), value);
+  Check(PPointer(value.GetReferenceToRawData)^ = Pointer(arrdyn), 'Reference to dynamic array data differs');
+
+  arrstat[0] := 42;
+  arrstat[1] := 23;
+  arrstat[2] := 49;
+  arrstat[3] := 59;
+  TValue.Make(@arrstat, TypeInfo(TArrayOfLongintStatic), value);
+  Check(value.GetReferenceToRawData <> @arrstat, 'Reference to static array is equal');
+  Check(PLongInt(value.GetReferenceToRawData)^ = PLongInt(@arrstat)^, 'Reference to static array data differs');
+end;
+
+procedure TTestCase1.TestReferenceRawDataEmpty;
+var
+  value: TValue;
+begin
+  TValue.Make(Nil, TypeInfo(String), value);
+  Check(Assigned(value.GetReferenceToRawData()), 'Reference to empty String is not assigned');
+  Check(not Assigned(PPointer(value.GetReferenceToRawData)^), 'Empty String data is assigned');
+
+  TValue.Make(Nil, TypeInfo(IInterface), value);
+  Check(Assigned(value.GetReferenceToRawData()), 'Reference to empty interface is not assigned');
+  Check(not Assigned(PPointer(value.GetReferenceToRawData)^), 'Empty interface data is assigned');
+
+  TValue.Make(Nil, TypeInfo(LongInt), value);
+  Check(Assigned(value.GetReferenceToRawData()), 'Reference to empty LongInt is not assigned');
+  Check(PLongInt(value.GetReferenceToRawData)^ = 0, 'Empty longint data is not 0');
+
+  TValue.Make(Nil, TypeInfo(TTestRecord), value);
+  Check(Assigned(value.GetReferenceToRawData()), 'Reference to empty record is not assigned');
+  Check(PTestRecord(value.GetReferenceToRawData)^.value1 = 0, 'Empty record data value1 is not 0');
+  Check(PTestRecord(value.GetReferenceToRawData)^.value2 = '', 'Empty record data value2 is not empty');
+
+  TValue.Make(Nil, TypeInfo(TArrayOfLongintDyn), value);
+  Check(Assigned(value.GetReferenceToRawData()), 'Reference to empty dynamic array is not assigned');
+  Check(not Assigned(PPointer(value.GetReferenceToRawData)^), 'Empty dynamic array data is assigned');
+
+  TValue.Make(Nil, TypeInfo(TArrayOfLongintStatic), value);
+  Check(Assigned(value.GetReferenceToRawData()), 'Reference to empty static array is not assigned');
+  Check(PLongInt(value.GetReferenceToRawData)^ = 0, 'Empty static array data is not 0');
+end;
+
+procedure TTestCase1.TestDataSize;
+var
+  u8: UInt8;
+  u16: UInt16;
+  u32: UInt32;
+  u64: UInt64;
+  s8: Int8;
+  s16: Int16;
+  s32: Int32;
+  s64: Int64;
+  f32: Single;
+  f64: Double;
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+  f80: Extended;
+{$endif}
+  fco: Comp;
+  fcu: Currency;
+  ss: ShortString;
+  sa: AnsiString;
+  su: UnicodeString;
+  sw: WideString;
+  o: TObject;
+  c: TClass;
+  i: IInterface;
+  ad: TArrayOfLongintDyn;
+  _as: TArrayOfLongintStatic;
+  b8: Boolean;
+{$ifdef fpc}
+  b16: Boolean16;
+  b32: Boolean32;
+  b64: Boolean64;
+{$endif}
+  bl8: ByteBool;
+  bl16: WordBool;
+  bl32: LongBool;
+{$ifdef fpc}
+  bl64: QWordBool;
+{$endif}
+  e: TTestEnum;
+  s: TTestSet;
+  t: TTestRecord;
+  p: Pointer;
+  proc: TTestProc;
+  method: TTestMethod;
+
+  value: TValue;
+begin
+  u8:=245;
+  TValue.Make(@u8, TypeInfo(UInt8), value);
+  CheckEquals(1, value.DataSize, 'Size of UInt8 differs');
+  u16:=789;
+  TValue.Make(@u16, TypeInfo(UInt16), value);
+  CheckEquals(2, value.DataSize, 'Size of UInt16 differs');
+  u32:=568789;
+  TValue.Make(@u32, TypeInfo(UInt32), value);
+  CheckEquals(4, value.DataSize, 'Size of UInt32 differs');
+  u64:=$abdcefadbcef;
+  TValue.Make(@u64, TypeInfo(UInt64), value);
+  CheckEquals(8, value.DataSize, 'Size of UInt64 differs');
+  s8:=-32;
+  TValue.Make(@s8, TypeInfo(Int8), value);
+  CheckEquals(1, value.DataSize, 'Size of Int8 differs');
+  s16:=-5345;
+  TValue.Make(@s16, TypeInfo(Int16), value);
+  CheckEquals(2, value.DataSize, 'Size of Int16 differs');
+  s32:=-234567;
+  TValue.Make(@s32, TypeInfo(Int32), value);
+  CheckEquals(4, value.DataSize, 'Size of Int32 differs');
+  s64:=23456789012;
+  TValue.Make(@s64, TypeInfo(Int64), value);
+  CheckEquals(8, value.DataSize, 'Size of Int64 differs');
+  b8:=false;
+  TValue.Make(@b8, TypeInfo(Boolean), value);
+  CheckEquals(1, value.DataSize, 'Size of Boolean differs');
+{$ifdef fpc}
+  b16:=true;
+  TValue.Make(@b16, TypeInfo(Boolean16), value);
+  CheckEquals(2, value.DataSize, 'Size of Boolean16 differs');
+  b32:=false;
+  TValue.Make(@b32, TypeInfo(Boolean32), value);
+  CheckEquals(4, value.DataSize, 'Size of Boolean32 differs');
+  b64:=true;
+  TValue.Make(@b64, TypeInfo(Boolean64), value);
+  CheckEquals(8, value.DataSize, 'Size of Boolean64 differs');
+{$endif}
+  bl8:=true;
+  TValue.Make(@bl8, TypeInfo(ByteBool), value);
+  CheckEquals(1, value.DataSize, 'Size of ByteBool differs');
+  bl16:=false;
+  TValue.Make(@bl16, TypeInfo(WordBool), value);
+  CheckEquals(2, value.DataSize, 'Size of WordBool differs');
+  bl32:=false;
+  TValue.Make(@bl32, TypeInfo(LongBool), value);
+  CheckEquals(4, value.DataSize, 'Size of LongBool differs');
+{$ifdef fpc}
+  bl64:=true;
+  TValue.Make(@bl64, TypeInfo(QWordBool), value);
+  CheckEquals(8, value.DataSize, 'Size of QWordBool differs');
+{$endif}
+  f32:=4.567;
+  TValue.Make(@f32, TypeInfo(Single), value);
+  CheckEquals(4, value.DataSize, 'Size of Single differs');
+  f64:=-3456.678;
+  TValue.Make(@f64, TypeInfo(Double), value);
+  CheckEquals(8, value.DataSize, 'Size of Double differs');
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+  f80:=-2345.678;
+  TValue.Make(@f80, TypeInfo(Extended), value);
+  CheckEquals(10, value.DataSize, 'Size of Extended differs');
+{$endif}
+  fcu:=56.78;
+  TValue.Make(@fcu, TypeInfo(Currency), value);
+  CheckEquals(SizeOf(Currency), value.DataSize, 'Size of Currency differs');
+  fco:=456;
+  TValue.Make(@fco, TypeInfo(Comp), value);
+  CheckEquals(SizeOf(Comp), value.DataSize, 'Size of Comp differs');
+  ss := '';
+  TValue.Make(@ss, TypeInfo(ShortString), value);
+  CheckEquals(254, value.DataSize, 'Size ofShortString differs');
+  sa:= '';
+  TValue.Make(@sa, TypeInfo(AnsiString), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of AnsiString differs');
+  sw := '';
+  TValue.Make(@sw, TypeInfo(WideString), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of WideString differs');
+  su:='';
+  TValue.Make(@su, TypeInfo(UnicodeString), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of UnicodeString differs');
+  o := TTestValueClass.Create;
+  TValue.Make(@o, TypeInfo(TObject), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of TObject differs');
+  o.Free;
+  c := TObject;
+  TValue.Make(@c, TypeInfo(TClass), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of TClass differs');
+  i := Nil;
+  TValue.Make(@i, TypeInfo(IInterface), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of IInterface differs');
+  TValue.Make(@t, TypeInfo(TTestRecord), value);
+  CheckEquals(SizeOf(TTestRecord), value.DataSize, 'Size of TTestRecord differs');
+  proc := Nil;
+  TValue.Make(@proc, TypeInfo(TTestProc), value);
+  CheckEquals(SizeOf(TTestProc), value.DataSize, 'Size of TTestProc differs');
+  method := Nil;
+  TValue.Make(@method, TypeInfo(TTestMethod), value);
+  CheckEquals(SizeOf(TTestMethod), value.DataSize, 'Size of TTestMethod differs');
+  TValue.Make(@_as, TypeInfo(TArrayOfLongintStatic), value);
+  CheckEquals(SizeOf(TArrayOfLongintStatic), value.DataSize, 'Size of TArrayOfLongintStatic differs');
+  TValue.Make(@ad, TypeInfo(TArrayOfLongintDyn), value);
+  CheckEquals(SizeOf(TArrayOfLongintDyn), value.DataSize, 'Size of TArrayOfLongintDyn differs');
+  e:=low(TTestEnum);
+  TValue.Make(@e, TypeInfo(TTestEnum), value);
+  CheckEquals(SizeOf(TTestEnum), value.DataSize, 'Size of TTestEnum differs');
+  s:=[low(TTestEnum),high(TTestEnum)];
+  TValue.Make(@s, TypeInfo(TTestSet), value);
+  CheckEquals(SizeOf(TTestSet), value.DataSize, 'Size of TTestSet differs');
+  p := Nil;
+  TValue.Make(@p, TypeInfo(Pointer), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of Pointer differs');
+end;
+
+procedure TTestCase1.TestDataSizeEmpty;
+var
+  value: TValue;
+begin
+  TValue.Make(Nil, TypeInfo(UInt8), value);
+  CheckEquals(1, value.DataSize, 'Size of UInt8 differs');
+  TValue.Make(Nil, TypeInfo(UInt16), value);
+  CheckEquals(2, value.DataSize, 'Size of UInt16 differs');
+  TValue.Make(Nil, TypeInfo(UInt32), value);
+  CheckEquals(4, value.DataSize, 'Size of UInt32 differs');
+  TValue.Make(Nil, TypeInfo(UInt64), value);
+  CheckEquals(8, value.DataSize, 'Size of UInt64 differs');
+  TValue.Make(Nil, TypeInfo(Int8), value);
+  CheckEquals(1, value.DataSize, 'Size of Int8 differs');
+  TValue.Make(Nil, TypeInfo(Int16), value);
+  CheckEquals(2, value.DataSize, 'Size of Int16 differs');
+  TValue.Make(Nil, TypeInfo(Int32), value);
+  CheckEquals(4, value.DataSize, 'Size of Int32 differs');
+  TValue.Make(Nil, TypeInfo(Int64), value);
+  CheckEquals(8, value.DataSize, 'Size of Int64 differs');
+  TValue.Make(Nil, TypeInfo(Boolean), value);
+  CheckEquals(1, value.DataSize, 'Size of Boolean differs');
+{$ifdef fpc}
+  TValue.Make(Nil, TypeInfo(Boolean16), value);
+  CheckEquals(2, value.DataSize, 'Size of Boolean16 differs');
+  TValue.Make(Nil, TypeInfo(Boolean32), value);
+  CheckEquals(4, value.DataSize, 'Size of Boolean32 differs');
+  TValue.Make(Nil, TypeInfo(Boolean64), value);
+  CheckEquals(8, value.DataSize, 'Size of Boolean64 differs');
+{$endif}
+  TValue.Make(Nil, TypeInfo(ByteBool), value);
+  CheckEquals(1, value.DataSize, 'Size of ByteBool differs');
+  TValue.Make(Nil, TypeInfo(WordBool), value);
+  CheckEquals(2, value.DataSize, 'Size of WordBool differs');
+  TValue.Make(Nil, TypeInfo(LongBool), value);
+  CheckEquals(4, value.DataSize, 'Size of LongBool differs');
+{$ifdef fpc}
+  TValue.Make(Nil, TypeInfo(QWordBool), value);
+  CheckEquals(8, value.DataSize, 'Size of QWordBool differs');
+{$endif}
+  TValue.Make(Nil, TypeInfo(Single), value);
+  CheckEquals(4, value.DataSize, 'Size of Single differs');
+  TValue.Make(Nil, TypeInfo(Double), value);
+  CheckEquals(8, value.DataSize, 'Size of Double differs');
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+  TValue.Make(Nil, TypeInfo(Extended), value);
+  CheckEquals(10, value.DataSize, 'Size of Extended differs');
+{$endif}
+  TValue.Make(Nil, TypeInfo(Currency), value);
+  CheckEquals(SizeOf(Currency), value.DataSize, 'Size of Currency differs');
+  TValue.Make(Nil, TypeInfo(Comp), value);
+  CheckEquals(SizeOf(Comp), value.DataSize, 'Size of Comp differs');
+  TValue.Make(Nil, TypeInfo(ShortString), value);
+  CheckEquals(254, value.DataSize, 'Size of ShortString differs');
+  TValue.Make(Nil, TypeInfo(AnsiString), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of Pointer differs');
+  TValue.Make(Nil, TypeInfo(WideString), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of WideString differs');
+  TValue.Make(Nil, TypeInfo(UnicodeString), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of UnicodeString differs');
+  TValue.Make(Nil, TypeInfo(TObject), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of TObject differs');
+  TValue.Make(Nil, TypeInfo(TClass), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of TClass differs');
+  TValue.Make(Nil, TypeInfo(IInterface), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of IInterface differs');
+  TValue.Make(Nil, TypeInfo(TTestRecord), value);
+  CheckEquals(SizeOf(TTestRecord), value.DataSize, 'Size of TTestRecord differs');
+  TValue.Make(Nil, TypeInfo(TTestProc), value);
+  CheckEquals(SizeOf(TTestProc), value.DataSize, 'Size of TTestProc differs');
+  TValue.Make(Nil, TypeInfo(TTestMethod), value);
+  CheckEquals(SizeOf(TTestMethod), value.DataSize, 'Size of TTestMethod differs');
+  TValue.Make(Nil, TypeInfo(TArrayOfLongintStatic), value);
+  CheckEquals(SizeOf(TArrayOfLongintStatic), value.DataSize, 'Size of TArrayOfLongintStatic differs');
+  TValue.Make(Nil, TypeInfo(TArrayOfLongintDyn), value);
+  CheckEquals(SizeOf(TArrayOfLongintDyn), value.DataSize, 'Size of TArrayOfLongintDyn differs');
+  TValue.Make(Nil, TypeInfo(TTestEnum), value);
+  CheckEquals(SizeOf(TTestEnum), value.DataSize, 'Size of TTestEnum differs');
+  TValue.Make(Nil, TypeInfo(TTestSet), value);
+  CheckEquals(SizeOf(TTestSet), value.DataSize, 'Size of TTestSet differs');
+  TValue.Make(Nil, TypeInfo(Pointer), value);
+  CheckEquals(SizeOf(Pointer), value.DataSize, 'Size of Pointer differs');
+end;
+
+procedure TTestCase1.TestIsManaged;
+begin
+  CheckEquals(true, IsManaged(TypeInfo(ansistring)), 'IsManaged for tkAString');
+  CheckEquals(true, IsManaged(TypeInfo(widestring)), 'IsManaged for tkWString');
+  CheckEquals(true, IsManaged(TypeInfo(Variant)), 'IsManaged for tkVariant');
+  CheckEquals(true, IsManaged(TypeInfo(TArrayOfManagedRec)),
+    'IsManaged for tkArray (with managed ElType)');
+  CheckEquals(true, IsManaged(TypeInfo(TArrayOfString)),
+    'IsManaged for tkArray (with managed ElType)');
+  CheckEquals(true, IsManaged(TypeInfo(TManagedRec)), 'IsManaged for tkRecord');
+  {$ifdef fpc}
+  CheckEquals(true, IsManaged(TypeInfo(TManagedRecOp)), 'IsManaged for tkRecord');
+  {$endif}
+  CheckEquals(true, IsManaged(TypeInfo(IInterface)), 'IsManaged for tkInterface');
+  CheckEquals(true, IsManaged(TypeInfo(TManagedObj)), 'IsManaged for tkObject');
+  {$ifdef fpc}
+  CheckEquals(true, IsManaged(TypeInfo(specialize TArray<byte>)), 'IsManaged for tkDynArray');
+  {$else}
+  CheckEquals(true, IsManaged(TypeInfo(TArray<byte>)), 'IsManaged for tkDynArray');
+  {$endif}
+  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(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');
+  {$ifdef fpc}
+  CheckEquals(false, IsManaged(TypeInfo(TTestMethod)), 'IsManaged for tkMethod');
+  {$else}
+  { Delphi bug (or sabotage). For some reason Delphi considers method pointers to be managed (only in newer versions, probably since XE7) :/ }
+  CheckEquals({$if RTLVersion>=28}true{$else}false{$endif}, IsManaged(TypeInfo(TTestMethod)), 'IsManaged for tkMethod');
+  {$endif}
+  CheckEquals(false, IsManaged(TypeInfo(TArrayOfByte)),
+    'IsManaged for tkArray (with non managed ElType)');
+  CheckEquals(false, IsManaged(TypeInfo(TArrayOfNonManagedRec)),
+    'IsManaged for tkArray (with non managed ElType)');
+  CheckEquals(false, IsManaged(TypeInfo(TNonManagedRec)), 'IsManaged for tkRecord');
+  CheckEquals(false, IsManaged(TypeInfo(TObject)), 'IsManaged for tkClass');
+  CheckEquals(false, IsManaged(TypeInfo(TNonManagedObj)), 'IsManaged for tkObject');
+  CheckEquals(false, IsManaged(TypeInfo(WideChar)), 'IsManaged for tkWChar');
+  CheckEquals(false, IsManaged(TypeInfo(Boolean)), 'IsManaged for tkBool');
+  CheckEquals(false, IsManaged(TypeInfo(Int64)), 'IsManaged for tkInt64');
+  CheckEquals(false, IsManaged(TypeInfo(UInt64)), 'IsManaged for tkQWord');
+  {$ifdef fpc}
+  CheckEquals(false, IsManaged(TypeInfo(ICORBATest)), 'IsManaged for tkInterfaceRaw');
+  {$endif}
+  CheckEquals(false, IsManaged(TypeInfo(TTestProc)), 'IsManaged for tkProcVar');
+  CheckEquals(false, IsManaged(TypeInfo(TTestHelper)), 'IsManaged for tkHelper');
+  {$ifdef fpc}
+  CheckEquals(false, IsManaged(TypeInfo(file)), 'IsManaged for tkFile');
+  {$endif}
+  CheckEquals(false, IsManaged(TypeInfo(TClass)), 'IsManaged for tkClassRef');
+  CheckEquals(false, IsManaged(TypeInfo(Pointer)), 'IsManaged for tkPointer');
+  CheckEquals(false, IsManaged(nil), 'IsManaged for nil');
+end;
+
+{$ifdef fpc}
+procedure TTestCase1.TestOpenArrayToDyn;
+
+  procedure OpenArrayProc(aArr: array of LongInt);
+  var
+    value: TValue;
+  begin
+{$ifndef InLazIDE}
+    value := specialize OpenArrayToDynArrayValue<LongInt>(aArr);
+{$endif}
+    CheckEquals(value.IsArray, True);
+    CheckEquals(value.IsOpenArray, False);
+    CheckEquals(value.IsObject, False);
+    CheckEquals(value.IsOrdinal, False);
+    CheckEquals(value.IsClass, False);
+    CheckEquals(value.GetArrayLength, 2);
+    CheckEquals(value.GetArrayElement(0).AsInteger, 42);
+    CheckEquals(value.GetArrayElement(1).AsInteger, 84);
+    value.SetArrayElement(0, 21);
+    { since this is a copy the original array is not modified! }
+    CheckEquals(aArr[0], 42);
+  end;
+
+begin
+  OpenArrayProc([42, 84]);
+end;
+{$endif}
+
+procedure TTestCase1.TestInterface;
+>>>>>>> a86fa16f98 (* PChar -> PAnsiChar)
 var
   context: TRttiContext;
   t: TRttiType;

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

@@ -22,7 +22,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;
@@ -95,7 +95,7 @@ begin
   Result := AnsiChar(Byte(AsOrdinal));
 end;
 
-function TValueHelper.AsChar: Char;
+function TValueHelper.AsChar: AnsiChar;
 begin
   Result := AsWideChar;
 end;