tkSet,tkMethod,tkSString,tkLStringOld,tkLString,
    tkWString,tkVariant,tkArray,tkRecord,tkInterface,
    tkClass,tkObject,tkWChar,tkBool,tkInt64,tkQWord,
    tkDynArray,tkInterfaceRaw,tkProcVar,tkUString,tkUChar,
    tkHelper,tkFile,tkClassRef,tkPointer);

const
   // all potentially managed types
   tkManagedTypes = [tkLStringOld,tkLString,tkWstring,tkUstring,tkArray,
                     tkObject,tkRecord,tkDynArray,tkInterface,tkVariant];
   // maps record or object types
   tkRecordTypes = [tkObject,tkRecord];
   tkRecordTypeOrSet = [tkObject,tkRecord];

type
................................................................................
    TypeInfo: PTypeInfoStored;
    {$ifdef FPC}
    Offset: sizeint;
    {$else}
    Offset: PtrUInt;
    {$endif FPC}
  end;

  {$ifdef ISDELPHI2010}
  /// map the Delphi record field enhanced RTTI (available since Delphi 2010)
  TEnhancedFieldInfo = packed record
    TypeInfo: PTypeInfoStored;
    Offset: PtrUInt;
    Flags: Byte;
    NameLen: byte; // = Name[0] = length(Name)
................................................................................
  // - used to calc the beginning of memory allocation of a string
  STRRECSIZE = SizeOf(TStrRec);

function ToText(k: TTypeKind): PShortString; overload;
begin
  result := GetEnumName(TypeInfo(TTypeKind),ord(k));
end;






type
  TTypeInfoSaved = type TRawByteStringDynArray;

function TypeInfoFind(const rttitypes: TTypeInfoSaved;
  const typename: RawUTF8): pointer;
var i,len: integer;
................................................................................
{ ************ low-level RTTI types and conversion routines }


{$ifdef FPC}

function RTTIManagedSize(typeInfo: Pointer): SizeInt; inline;
begin
  case PTypeKind(typeInfo)^ of
    tkLString,tkLStringOld,tkWString,tkUString,
    tkInterface,tkDynarray:
      result := sizeof(Pointer);
    {$ifndef NOVARIANTS}
    tkVariant:
      result := sizeof(TVarData);
    {$endif}
    tkArray:
      with GetTypeInfo(typeInfo,tkArray)^ do
        result := arraySize;
        //result := (arraySize and $7FFFFFFF) * ElCount; // to be validated
    tkObject,tkRecord:
      result := GetTypeInfo(typeInfo,PTypeKind(typeInfo)^)^.recSize;
  else
    raise ESynException.CreateUTF8('RTTIManagedSize(%)',[PByte(typeInfo)^]);

  end;
end;












procedure RecordClear(var Dest; TypeInfo: pointer);
  [external name 'FPC_FINALIZE'];

procedure RecordAddRef(var Data; TypeInfo : pointer);
  [external name 'FPC_ADDREF'];

................................................................................
var i: integer;
    itemtype: PTypeInfo;
{$ifndef DELPHI5OROLDER} // do not know why Delphi 5 compiler does not like it
   DynA, DynB: TDynArray;
{$endif}
begin // info is expected to come from a DeRef() if retrieved from RTTI
  result := 0; // A^<>B^
  case info^.Kind of
  tkLString{$ifdef FPC},tkLStringOld{$endif}:
    if PAnsiString(A)^=PAnsiString(B)^ then
      result := sizeof(pointer);
  tkWString:
    if PWideString(A)^=PWideString(B)^ then
      result := sizeof(pointer);
  {$ifdef HASVARUSTRING}
................................................................................
    if PPointer(A)^=PPointer(B)^ then
      result := sizeof(pointer);
  tkArray: begin
    info := GetTypeInfo(info,tkArray);
    if (info=nil) or (info^.dimCount<>1) then
      result := -1 else begin
      itemtype := DeRef(info^.arrayType);
      if itemtype=nil then

        if CompareMem(A,B,info^.arraySize) then
          result := info^.arraySize else
          result := 0 else begin
        for i := 1 to info^.elCount do begin
          result := ManagedTypeCompare(A,B,itemtype);
          if result<=0 then
            exit;
          inc(A,result);
          inc(B,result);
        end;
        result := info^.arraySize;
      end;
    end;
  end;
  else
    result := -1;
  end;
end;

function ManagedTypeSaveLength(data: PAnsiChar; info: PTypeInfo;
  out len: integer): integer;

var DynArray: TDynArray;
    itemtype: PTypeInfo;
    itemsize,size,i: integer;
    P: PPtrUInt absolute data;
begin
  case info^.Kind of
  tkLString,tkWString{$ifdef FPC},tkLStringOld{$endif}: begin
    len := sizeof(pointer); // length stored within WideString is in bytes
    if P^=0 then
      result := 1 else
      result := ToVarUInt32LengthWithData(PStrRec(Pointer(P^-STRRECSIZE))^.length);
  end;
  {$ifdef HASVARUSTRING}
................................................................................
    result := RecordSaveLength(data^,info,@len);
  tkArray: begin
    info := GetTypeInfo(info,tkArray);
    if (info=nil) or (info^.dimCount<>1) then
      result := 0 else begin
      len := info^.arraySize;
      itemtype := DeRef(info^.arrayType);
      if itemtype=nil then

        result := len else begin
        size := 0;
        for i := 1 to info^.elCount do begin
          inc(size,ManagedTypeSaveLength(data,itemtype,itemsize));
          inc(data,itemsize);
        end;
        result := size;
................................................................................
  else
    result := 0; // invalid/unhandled record content
  end;
end;

function ManagedTypeSave(data, dest: PAnsiChar; info: PTypeInfo;
  out len: integer): PAnsiChar;

var DynArray: TDynArray;
    itemtype: PTypeInfo;
    itemsize,i: integer;
    P: PPtrUInt absolute data;
begin
  case info^.Kind of
    tkDynArray: begin
      DynArray.Init(info,data^);
      result := DynArray.SaveTo(dest);
      len := sizeof(PtrUInt); // size of tkDynArray in record
    end;
    tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}: begin
      if P^=0 then
        itemsize := 0 else
        itemsize := PStrRec(Pointer(P^-STRRECSIZE))^.length;
      {$ifdef HASVARUSTRING} // WideString has length in bytes, UnicodeString in WideChars
      if info^.Kind=tkUString then
        itemsize := itemsize*2;
      {$endif}
      result := pointer(ToVarUInt32(itemsize,pointer(dest)));
      if itemsize>0 then begin
        MoveFast(pointer(P^)^,result^,itemsize);
        inc(result,itemsize);
      end;
      len := sizeof(PtrUInt); // size of tkLString+tkWString+tkUString in record
    end;
    tkRecord{$ifdef FPC},tkObject{$endif}:
      result := RecordSave(data^,dest,info,len);
    tkArray: begin
      info := GetTypeInfo(info,tkArray);
      if (info=nil) or (info^.dimCount<>1) then
        result := nil else begin // supports single dimension static array only
        len := info^.arraySize;
        itemtype := DeRef(info^.arrayType);
        if itemtype=nil then begin

          MoveFast(data^,dest^,len);
          result := dest+len;
        end else begin
          for i := 1 to info^.elCount do begin
            dest := ManagedTypeSave(data,dest,itemtype,itemsize);
            if dest=nil then
              break; // invalid/unhandled content
            {$ifdef FPC}
            if itemsize=-1 then begin
              result := nil;
              exit;
            end;
            {$endif}
            inc(data,itemsize)
          end;
          result := dest;
        end;
      end;
    end;
    {$ifndef NOVARIANTS}
    tkVariant: begin
      result := VariantSave(PVariant(data)^,dest);
      len := sizeof(Variant); // size of tkVariant in record
    end;
    {$endif}
    else begin
      {$ifdef FPC}
      len := -1; // FPC generates RTTI for such unmanaged fields

      result := dest;


      {$else}
      result := nil;
      {$endif}
    end;
    end;
end;

function ManagedTypeLoad(data: PAnsiChar; var source: PAnsiChar; info: PTypeInfo): integer;

var DynArray: TDynArray;
    itemtype: PTypeInfo;
    itemsize,i: integer;
begin
  case info^.Kind of
  tkDynArray: begin
    DynArray.Init(info,data^);
    source := DynArray.LoadFrom(source);
    result := sizeof(PtrUInt); // size of tkDynArray in record
  end;
  tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
................................................................................
    inc(source,itemsize);
    result := sizeof(PtrUInt); // size of tkLString+tkWString+tkUString in record
  end;
  tkRecord{$ifdef FPC},tkObject{$endif}:
    source := RecordLoad(data^,source,info,@result);
  tkArray: begin
    info := GetTypeInfo(info,tkArray);
    if (info=nil) or (info^.dimCount<>1) then
      result := 0 else begin // supports single dimension static array only


      result := info^.arraySize;
      itemtype := DeRef(info^.arrayType);
      if itemtype=nil then begin

        MoveFast(source^,data^,result);
        inc(source,result);
      end else
        for i := 1 to info^.elCount do begin
          itemsize := ManagedTypeLoad(data,source,itemtype);
          if itemsize<=0 then begin
            result := 0;
            exit;
          end else
            inc(data,itemsize);
        end;
    end;
  end;
  {$ifndef NOVARIANTS}
  tkVariant: begin
    source := VariantLoad(PVariant(data)^,source,@JSON_OPTIONS[true]);
    result := sizeof(Variant); // size of tkVariant in record
  end;
  {$endif}
  else

    result := -1;

  end;
end;

function RecordEquals(const RecA, RecB; TypeInfo: pointer;
  PRecSize: PInteger): boolean;
var info: PTypeInfo;
    F: integer;
    Field: ^TFieldInfo;
    Diff: cardinal;
    A, B: PAnsiChar;
begin
  A := @RecA;
  B := @RecB;
  result := false;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
................................................................................
  if A=B then begin // both nil or same pointer
    result := true;
    exit;
  end;
  Field := @info^.ManagedFields[0];
  Diff := 0;
  for F := 1 to info^.ManagedCount do begin







    Diff := Field^.Offset-Diff;
    if Diff<>0 then begin
      if not CompareMem(A,B,Diff) then
        exit; // binary block not equal
      inc(A,Diff);
      inc(B,Diff);
    end;
    Diff := ManagedTypeCompare(A,B,DeRef(Field^.TypeInfo));
    if integer(Diff)<=0 then
      if Diff=0 then // A^<>B^
        exit else    // Diff=-1 for unexpected type
      {$ifdef FPC} // FPC does include RTTI for unmanaged fields! :)
        if Field^.TypeInfo^.Kind in tkManagedTypes then
          raise ESynException.CreateUTF8('RecordEquals: % is managed',
            [ToText(Field^.TypeInfo^.Kind)^]) else begin
          if F=info^.ManagedCount then
            Diff := info^.recSize-Field^.Offset else
            Diff := info^.ManagedFields[F].Offset-Field^.Offset;
          if not CompareMem(A,B,Diff) then
            exit; // binary block not equal
        end;
      {$else}
      raise ESynException.CreateUTF8('RecordEquals: % not supported',
        [ToText(Field^.TypeInfo^.Kind)^]);
      {$endif}
    inc(A,Diff);
    inc(B,Diff);
    inc(Diff,Field^.Offset);
    inc(Field);
  end;
  if CompareMem(A,B,info^.recSize-Diff) then
    result := true;
end;

function RecordSaveLength(const Rec; TypeInfo: pointer; Len: PInteger): integer;
var info: PTypeInfo;
    F, recsize,saved: integer;
    Field: ^TFieldInfo;
    R: PAnsiChar;
begin
  R := @Rec;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
  if (R=nil) or (info=nil) then begin
    result := 0; // should have been checked before
    exit;
  end;
  Field := @info^.ManagedFields[0];
  result := info^.recSize;
  if Len<>nil then
    Len^ := result;
  for F := 1 to info^.ManagedCount do begin
    saved := ManagedTypeSaveLength(R+Field^.Offset,Deref(Field^.TypeInfo),recsize);
    {$ifdef FPC}
    if saved>0 then // FPC has RTTI for unmanaged fields -> ignore
      inc(result,saved-recsize);


    {$else}

    if saved=0 then begin
      result := 0; // invalid type
      exit;
    end;
    inc(result,saved-recsize);
    {$endif}
    inc(Field);
  end;
end;

function RecordSave(const Rec; Dest: PAnsiChar; TypeInfo: pointer;
  out Len: integer): PAnsiChar; 
var info: PTypeInfo;
    F: integer;
    Diff: cardinal;
    Field: ^TFieldInfo;
    R: PAnsiChar;
begin
  R := @Rec;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
  if (R=nil) or (info=nil) then begin
    result := nil; // should have been checked before
    exit;
  end;
  Len := info^.recSize;
  Field := @info^.ManagedFields[0];
  Diff := 0;
  for F := 1 to info^.ManagedCount do begin







    Diff := Field^.Offset-Diff;
    if Diff<>0 then begin
      MoveFast(R^,Dest^,Diff);
      inc(R,Diff);
      inc(Dest,Diff);
    end;
    Dest := ManagedTypeSave(R,Dest,Deref(Field^.TypeInfo),integer(Diff));
    if Dest=nil then begin
      result := nil; // invalid/unhandled record content
      exit;
    end;
    {$ifdef FPC} // FPC does include RTTI for unmanaged fields! :)
    if integer(Diff)=-1 then begin
      if info^.Kind in tkManagedTypes then
        raise ESynException.CreateUTF8('ManagedTypeSave: % not supported',
          [ToText(info^.Kind)^]) else begin
        if F=info^.ManagedCount then
          Diff := info^.recSize-Field^.Offset else
          Diff := info^.ManagedFields[F].Offset-Field^.Offset;
        MoveFast(R^,Dest^,Diff);
        inc(Dest,Diff);
      end;
    end;
    {$endif}
    inc(R,Diff);
    inc(Diff,Field.Offset);
    inc(Field);
  end;
  Diff := info^.recSize-Diff;
  if integer(Diff)<0 then
    raise ESynException.Create('RecordSave diff<0') else
................................................................................
        jmp     System.@FinalizeArray
{$endif CPU64}
end;
{$endif FPC}

function RecordLoad(var Rec; Source: PAnsiChar; TypeInfo: pointer;
  Len: PInteger): PAnsiChar;
var info: PTypeInfo;
    F: integer;
    Diff: cardinal;
    Field: ^TFieldInfo;
    R: PAnsiChar;
begin
  result := nil; // indicates error
  R := @Rec;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
  if (R=nil) or (info=nil) then // should have been checked before
    exit;
................................................................................
      _Finalize(R+Field^.Offset,Deref(Field^.TypeInfo));
      inc(Field);
    end;
    exit;
  end;
  Diff := 0;
  for F := 1 to info^.ManagedCount do begin







    Diff := Field^.Offset-Diff;
    if Diff<>0 then begin
      MoveFast(Source^,R^,Diff);
      inc(Source,Diff);
      inc(R,Diff);
    end;
    Diff := ManagedTypeLoad(R,Source,DeRef(Field^.TypeInfo));
    {$ifdef FPC} // FPC does include RTTI for unmanaged fields! :)
    if integer(Diff)<0 then begin
      if Field^.TypeInfo^.Kind in tkManagedTypes then
        raise ESynException.CreateUTF8('RecordLoad: % is not supported',
          [ToText(Field^.TypeInfo^.Kind)^]) else begin
        if F=info^.ManagedCount then
          Diff := info^.recSize-Field^.Offset else
          Diff := info^.ManagedFields[F].Offset-Field^.Offset;
        MoveFast(Source^,R^,Diff);
        inc(Source,Diff);
      end;
    end else
    {$endif}
    if Diff=0 then
      exit; // error at loading
    inc(R,Diff);
    inc(Diff,Field^.Offset);
    inc(Field);
  end;
  Diff := info^.recSize-Diff;
  if integer(Diff)<0 then
................................................................................
    result := Dest;
    exit;
  end;
  inc(Dest,sizeof(Cardinal)); // leave space for Hash32 checksum
  result := Dest;
  // store dynamic array elements content
  P := fValue^;
  if ElemType=nil then
    if GetIsObjArray then
      raise ESynException.CreateUTF8('TDynArray.SaveTo(%) is a T*ObjArray',
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
      // binary types: store as once
      n := n*integer(ElemSize);
      MoveFast(P^,Dest^,n);
      inc(Dest,n);
    end else
    for i := 1 to n do begin
      Dest := ManagedTypeSave(P,Dest,ElemType,LenBytes);
      if Dest=nil then
        break;
      {$ifdef FPC}
      if LenBytes=-1 then begin
        result := nil;
        exit;
      end;
      {$endif}
      inc(P,LenBytes);
    end;
  // store Hash32 checksum
  if Dest<>nil then  // may be nil if RecordSave() failed
    PCardinal(result-sizeof(Cardinal))^ := Hash32(result,Dest-result);
  result := Dest;
end;
................................................................................
    result := 0;
    exit; // avoid GPF if void
  end;
  n := Count;
  result := ToVarUInt32Length(ElemSize)+ToVarUInt32Length(n)+1;
  if n=0 then
    exit;
  if ElemType=nil then
    if GetIsObjArray then
      raise ESynException.CreateUTF8('TDynArray.SaveToLength(%) is a T*ObjArray',
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else
      inc(result,integer(ElemSize)*n) else begin
    P := fValue^;
    for i := 1 to n do begin
      L := ManagedTypeSaveLength(P,ElemType,size);
      assert(size=integer(ElemSize));
      if L=0 then
        break; // invalid record type (wrong field type)

      inc(result,L);
      inc(P,size);
    end;
  end;
  inc(result,sizeof(Cardinal)); // Hash32 checksum
end;

................................................................................
        djRawByteString:
          if not Base64MagicCheckAndDecode(Val,ValLen,PRawByteStringArray(fValue^)^[i]) then
            SetString(RawUTF8(PPointerArray(fValue^)^[i]),Val,ValLen);
        djWinAnsi:  WinAnsiConvert.UTF8BufferToAnsi(Val,ValLen,PRawByteStringArray(fValue^)^[i]);
        djString:   UTF8DecodeToString(Val,ValLen,string(PPointerArray(fValue^)^[i]));
        djWideString: UTF8ToWideString(Val,ValLen,WideString(PPointerArray(fValue^)^[i]));
        djSynUnicode: UTF8ToSynUnicode(Val,ValLen,SynUnicode(PPointerArray(fValue^)^[i]));
        djInterface: raise ESynException.Create('djInterface not readable');
        end;
      end;
    end;
    end;
  end;
  if aEndOfObject<>nil then
    aEndOfObject^ := EndOfObject;
................................................................................
    exit;
  end;
  // retrieve security checksum
  Hash := pointer(Source);
  inc(Source,sizeof(cardinal));
  // retrieve dynamic array elements content
  P := fValue^;
  if ElemType=nil then
    if GetIsObjArray then
      raise ESynException.CreateUTF8('TDynArray.LoadFrom(%) is a T*ObjArray',
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
      // binary type was stored directly
      n := n*integer(ElemSize);
      MoveFast(Source^,P^,n);
      inc(Source,n);
................................................................................
    result := fCompare(A,B)=0 else
    if ElemType=nil then
      case ElemSize of // optimized versions for arrays of common types
        1: result := byte(A)=byte(B);
        2: result := word(A)=word(B);
        4: result := cardinal(A)=cardinal(B);
        8: result := Int64(A)=Int64(B);
      else result := CompareMem(@A,@B,ElemSize); // generic comparison
      end else
    case PTypeKind(ElemType)^ of
    tkRecord{$ifdef FPC},tkObject{$endif}:
      result := RecordEquals(A,B,ElemType);
    tkLString{$ifdef FPC},tkLStringOld{$endif}:
      result := AnsiString(A)=AnsiString(B);
    tkWString:
      result := WideString(A)=WideString(B);
    {$ifdef HASVARUSTRING}
    tkUString:
      result := UnicodeString(A)=UnicodeString(B);
    {$endif}
    tkInterface:
      result := pointer(A)=pointer(B);
    {$ifndef NOVARIANTS}
    tkVariant:
      result := Variant(A)=Variant(B);
    {$endif}
    else result := false;
    end;

end;

{$ifndef DELPHI5OROLDER} // do not know why Delphi 5 compiler does not like it
function TDynArray.Equals(const B: TDynArray): boolean;
var i, n: integer;
    P1,P2: PAnsiChar;
    A1: PPointerArray absolute P1;
................................................................................
  fElemType := PTypeInfo(aTypeInfo)^.elType;
  if fElemType<>nil then begin
    {$ifndef HASDIRECTTYPEINFO}
    // FPC compatibility: if you have a GPF here at startup, your 3.1 trunk
    // revision seems older than June 2016
    // -> enable HASDIRECTTYPEINFO conditional below $ifdef VER3_1 in Synopse.inc
    // or in your project's options
    fElemType := PPointer(fElemType)^;
    {$endif}
    {$ifdef FPC}
    if not (PTypeKind(fElemType)^ in tkManagedTypes) then
      fElemType := nil; // as with Delphi
    {$endif}
  end;
  fCountP := aCountPointer;
................................................................................
  aCountPointer: PInteger=nil; aCaseInsensitive: boolean=false);
var Comp: TDynArraySortCompare;
begin
  Init(aTypeInfo,aValue,aCountPointer);
  Comp := DYNARRAY_SORTFIRSTFIELD[aCaseInsensitive,aKind];
  if @Comp=nil then
    raise ESynException.CreateUTF8('TDynArray.InitSpecific(%) wrong aKind=%',
      [PShortString(@PTypeInfo(aTypeInfo)^.NameLen)^,ord(aKind)]);
  fCompare := Comp;
  fKnownType := aKind;
  fKnownSize := KNOWNTYPE_SIZE[aKind];
end;

procedure TDynArray.UseExternalCount(var aCountPointer: Integer);
begin
................................................................................
  aKind: TDynArrayKind; aCountPointer: PInteger=nil; aCaseInsensitive: boolean=false);
var Comp: TDynArraySortCompare;
    Hasher: TDynArrayHashOne;
begin
  Comp := DYNARRAY_SORTFIRSTFIELD[aCaseInsensitive,aKind];
  Hasher := DYNARRAY_HASHFIRSTFIELD[aCaseInsensitive,aKind];
  if (@Hasher=nil) or (@Comp=nil) then
    raise ESynException.Create('TDynArrayHashed.InitSpecific wrong aKind');

  Init(aTypeInfo,aValue,Hasher,Comp,nil,aCountPointer,aCaseInsensitive);
  {$ifdef UNDIRECTDYNARRAY}with InternalDynArray do{$endif} begin
    fKnownType := aKind;
    fKnownSize := KNOWNTYPE_SIZE[aKind];
  end;
end;

................................................................................
      djWord:     AddU(PWordArray(P)^[i]);
      djInteger:  Add(PIntegerArray(P)^[i]);
      djCardinal: AddU(PCardinalArray(P)^[i]);
      djSingle:   AddSingle(PSingleArray(P)^[i]);
      djInt64:    Add(PInt64Array(P)^[i]);
      djDouble:   AddDouble(PDoubleArray(P)^[i]);
      djCurrency: AddCurr64(PInt64Array(P)^[i]);

      end;
      Add(',');
    end;
    end;
  CancelLastComma;
  Add(']');
end;

    tkSet,tkMethod,tkSString,tkLStringOld,tkLString,
    tkWString,tkVariant,tkArray,tkRecord,tkInterface,
    tkClass,tkObject,tkWChar,tkBool,tkInt64,tkQWord,
    tkDynArray,tkInterfaceRaw,tkProcVar,tkUString,tkUChar,
    tkHelper,tkFile,tkClassRef,tkPointer);

const
   // all potentially managed types - should match ManagedType*() functions
   tkManagedTypes = [tkLStringOld,tkLString,tkWstring,tkUstring,tkArray,
                     tkObject,tkRecord,tkDynArray,tkInterface,tkVariant];
   // maps record or object types
   tkRecordTypes = [tkObject,tkRecord];
   tkRecordTypeOrSet = [tkObject,tkRecord];

type
................................................................................
    TypeInfo: PTypeInfoStored;
    {$ifdef FPC}
    Offset: sizeint;
    {$else}
    Offset: PtrUInt;
    {$endif FPC}
  end;
  PFieldInfo = ^TFieldInfo;
  {$ifdef ISDELPHI2010}
  /// map the Delphi record field enhanced RTTI (available since Delphi 2010)
  TEnhancedFieldInfo = packed record
    TypeInfo: PTypeInfoStored;
    Offset: PtrUInt;
    Flags: Byte;
    NameLen: byte; // = Name[0] = length(Name)
................................................................................
  // - used to calc the beginning of memory allocation of a string
  STRRECSIZE = SizeOf(TStrRec);

function ToText(k: TTypeKind): PShortString; overload;
begin
  result := GetEnumName(TypeInfo(TTypeKind),ord(k));
end;

function ToText(k: TDynArrayKind): PShortString; overload; 
begin
  result := GetEnumName(TypeInfo(TDynArrayKind),ord(k));
end;

type
  TTypeInfoSaved = type TRawByteStringDynArray;

function TypeInfoFind(const rttitypes: TTypeInfoSaved;
  const typename: RawUTF8): pointer;
var i,len: integer;
................................................................................
{ ************ low-level RTTI types and conversion routines }


{$ifdef FPC}

function RTTIManagedSize(typeInfo: Pointer): SizeInt; inline;
begin
  case PTypeKind(typeInfo)^ of // match tkManagedTypes
    tkLString,tkLStringOld,tkWString,tkUString,
    tkInterface,tkDynarray:
      result := sizeof(Pointer);
    {$ifndef NOVARIANTS}
    tkVariant:
      result := sizeof(TVarData);
    {$endif}
    tkArray:
      result := GetTypeInfo(typeInfo,tkArray)^.arraySize and $7fffffff;


    tkObject,tkRecord:
      result := GetTypeInfo(typeInfo,PTypeKind(typeInfo)^)^.recSize;
  else
    raise ESynException.CreateUTF8('RTTIManagedSize unhandled % (%)',
      [ToText(PTypeKind(typeInfo)^)^,PByte(typeInfo)^]);
  end;
end;

function RTTIUnmanagedFieldSize(Index: integer; Field: PFieldInfo;
  Info: PTypeInfo): integer; inline;
begin
  if Info^.Kind in tkManagedTypes then
    raise ESynException.CreateUTF8('RTTIUnmanagedFieldSize: % not supported',
      [ToText(Info^.Kind)^]);
  if Index=Info^.ManagedCount then
    result := Info^.recSize-Field^.Offset else
    result := Info^.ManagedFields[Index].Offset-Field^.Offset;
end;

procedure RecordClear(var Dest; TypeInfo: pointer);
  [external name 'FPC_FINALIZE'];

procedure RecordAddRef(var Data; TypeInfo : pointer);
  [external name 'FPC_ADDREF'];

................................................................................
var i: integer;
    itemtype: PTypeInfo;
{$ifndef DELPHI5OROLDER} // do not know why Delphi 5 compiler does not like it
   DynA, DynB: TDynArray;
{$endif}
begin // info is expected to come from a DeRef() if retrieved from RTTI
  result := 0; // A^<>B^
  case info^.Kind of // should match tkManagedTypes
  tkLString{$ifdef FPC},tkLStringOld{$endif}:
    if PAnsiString(A)^=PAnsiString(B)^ then
      result := sizeof(pointer);
  tkWString:
    if PWideString(A)^=PWideString(B)^ then
      result := sizeof(pointer);
  {$ifdef HASVARUSTRING}
................................................................................
    if PPointer(A)^=PPointer(B)^ then
      result := sizeof(pointer);
  tkArray: begin
    info := GetTypeInfo(info,tkArray);
    if (info=nil) or (info^.dimCount<>1) then
      result := -1 else begin
      itemtype := DeRef(info^.arrayType);
      if (itemtype=nil)
        {$ifdef FPC}or not(itemtype^.Kind in tkManagedTypes){$endif} then
        if CompareMem(A,B,info^.arraySize) then
          result := info^.arraySize else
          result := 0 else begin
        for i := 1 to info^.elCount do begin
          result := ManagedTypeCompare(A,B,itemtype);
          if result<=0 then
            exit; // invalid (-1) or not equals (0)
          inc(A,result);
          inc(B,result);
        end;
        result := info^.arraySize;
      end;
    end;
  end;
  else
    result := -1; // Unhandled field
  end;
end;

function ManagedTypeSaveLength(data: PAnsiChar; info: PTypeInfo;
  out len: integer): integer;
// returns 0 on error, or saved bytes + len=data^ length
var DynArray: TDynArray;
    itemtype: PTypeInfo;
    itemsize,size,i: integer;
    P: PPtrUInt absolute data;
begin // info is expected to come from a DeRef() if retrieved from RTTI
  case info^.Kind of // should match tkManagedTypes
  tkLString,tkWString{$ifdef FPC},tkLStringOld{$endif}: begin
    len := sizeof(pointer); // length stored within WideString is in bytes
    if P^=0 then
      result := 1 else
      result := ToVarUInt32LengthWithData(PStrRec(Pointer(P^-STRRECSIZE))^.length);
  end;
  {$ifdef HASVARUSTRING}
................................................................................
    result := RecordSaveLength(data^,info,@len);
  tkArray: begin
    info := GetTypeInfo(info,tkArray);
    if (info=nil) or (info^.dimCount<>1) then
      result := 0 else begin
      len := info^.arraySize;
      itemtype := DeRef(info^.arrayType);
      if (itemtype=nil)
        {$ifdef FPC}or not(itemtype^.Kind in tkManagedTypes){$endif} then
        result := len else begin
        size := 0;
        for i := 1 to info^.elCount do begin
          inc(size,ManagedTypeSaveLength(data,itemtype,itemsize));
          inc(data,itemsize);
        end;
        result := size;
................................................................................
  else
    result := 0; // invalid/unhandled record content
  end;
end;

function ManagedTypeSave(data, dest: PAnsiChar; info: PTypeInfo;
  out len: integer): PAnsiChar;
// returns nil on error, or final dest + len=data^ length
var DynArray: TDynArray;
    itemtype: PTypeInfo;
    itemsize,i: integer;
    P: PPtrUInt absolute data;
begin // info is expected to come from a DeRef() if retrieved from RTTI
  case info^.Kind of





  tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
  {$ifdef FPC}, tkLStringOld{$endif}: begin
    if P^=0 then
      itemsize := 0 else
      itemsize := PStrRec(Pointer(P^-STRRECSIZE))^.length;
    {$ifdef HASVARUSTRING} // WideString has length in bytes, UnicodeString in WideChars
    if info^.Kind=tkUString then
      itemsize := itemsize*2;
    {$endif}
    result := pointer(ToVarUInt32(itemsize,pointer(dest)));
    if itemsize>0 then begin
      MoveFast(pointer(P^)^,result^,itemsize);
      inc(result,itemsize);
    end;
    len := sizeof(PtrUInt); // size of tkLString+tkWString+tkUString in record
  end;
  tkRecord{$ifdef FPC},tkObject{$endif}:
    result := RecordSave(data^,dest,info,len);
  tkArray: begin
    info := GetTypeInfo(info,tkArray);
    if (info=nil) or (info^.dimCount<>1) then
      result := nil else begin // supports single dimension static array only
      len := info^.arraySize;
      itemtype := DeRef(info^.arrayType);
      if (itemtype=nil)
        {$ifdef FPC}or not(itemtype^.Kind in tkManagedTypes){$endif} then begin
        MoveFast(data^,dest^,len);
        result := dest+len;
      end else begin
        for i := 1 to info^.elCount do begin
          dest := ManagedTypeSave(data,dest,itemtype,itemsize);
          if dest=nil then
            break; // invalid/unhandled content






          inc(data,itemsize)
        end;
        result := dest;
      end;
    end;
  end;
  {$ifndef NOVARIANTS}
  tkVariant: begin
    result := VariantSave(PVariant(data)^,dest);
    len := sizeof(Variant); // size of tkVariant in record
  end;
  {$endif}
  tkDynArray: begin


    DynArray.Init(info,data^);
    result := DynArray.SaveTo(dest);
    len := sizeof(PtrUInt); // size of tkDynArray in record
  end;
  else
    result := nil; // invalid/unhandled record content

  end;
end;


function ManagedTypeLoad(data: PAnsiChar; var source: PAnsiChar; info: PTypeInfo): integer;
// returns source=nil on error, or final source + result=data^ length 
var DynArray: TDynArray;
    itemtype: PTypeInfo;
    itemsize,i: integer;
begin // info is expected to come from a DeRef() if retrieved from RTTI
  case info^.Kind of
  tkDynArray: begin
    DynArray.Init(info,data^);
    source := DynArray.LoadFrom(source);
    result := sizeof(PtrUInt); // size of tkDynArray in record
  end;
  tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
................................................................................
    inc(source,itemsize);
    result := sizeof(PtrUInt); // size of tkLString+tkWString+tkUString in record
  end;
  tkRecord{$ifdef FPC},tkObject{$endif}:
    source := RecordLoad(data^,source,info,@result);
  tkArray: begin
    info := GetTypeInfo(info,tkArray);
    if (info=nil) or (info^.dimCount<>1) then begin
      source := nil; // supports single dimension static array only
      result := 0;
    end else begin
      result := info^.arraySize;
      itemtype := DeRef(info^.arrayType);
      if (itemtype=nil)
        {$ifdef FPC}or not(itemtype^.Kind in tkManagedTypes){$endif} then begin
        MoveFast(source^,data^,result);
        inc(source,result);
      end else
        for i := 1 to info^.elCount do begin
          inc(data,ManagedTypeLoad(data,source,itemtype));
          if source=nil then

            exit;


        end;
    end;
  end;
  {$ifndef NOVARIANTS}
  tkVariant: begin
    source := VariantLoad(PVariant(data)^,source,@JSON_OPTIONS[true]);
    result := sizeof(Variant); // size of tkVariant in record
  end;
  {$endif}
  else begin
    source := nil;
    result := 0;
  end; 
  end;
end;

function RecordEquals(const RecA, RecB; TypeInfo: pointer;
  PRecSize: PInteger): boolean;
var info,fieldinfo: PTypeInfo;
    F: integer;
    Field: PFieldInfo;
    Diff: cardinal;
    A, B: PAnsiChar;
begin
  A := @RecA;
  B := @RecB;
  result := false;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
................................................................................
  if A=B then begin // both nil or same pointer
    result := true;
    exit;
  end;
  Field := @info^.ManagedFields[0];
  Diff := 0;
  for F := 1 to info^.ManagedCount do begin
    fieldinfo := DeRef(Field^.TypeInfo);
    {$ifdef FPC} // FPC does include RTTI for unmanaged fields! :)
    if not (fieldinfo^.Kind in tkManagedTypes) then begin
      inc(Field);
      continue;
    end;
    {$endif};
    Diff := Field^.Offset-Diff;
    if Diff<>0 then begin
      if not CompareMem(A,B,Diff) then
        exit; // binary block not equal
      inc(A,Diff);
      inc(B,Diff);
    end;
    Diff := ManagedTypeCompare(A,B,fieldinfo);
    if integer(Diff)<=0 then
      if Diff=0 then // A^<>B^
        exit else    // Diff=-1 for unexpected type


        raise ESynException.CreateUTF8('RecordEquals: unexpected %',









          [ToText(fieldinfo^.Kind)^]);

    inc(A,Diff);
    inc(B,Diff);
    inc(Diff,Field^.Offset);
    inc(Field);
  end;
  if CompareMem(A,B,info^.recSize-Diff) then
    result := true;
end;

function RecordSaveLength(const Rec; TypeInfo: pointer; Len: PInteger): integer;
var info,fieldinfo: PTypeInfo;
    F, recsize,saved: integer;
    Field: PFieldInfo;
    R: PAnsiChar;
begin
  R := @Rec;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
  if (R=nil) or (info=nil) then begin
    result := 0; // should have been checked before
    exit;
  end;
  Field := @info^.ManagedFields[0];
  result := info^.recSize;
  if Len<>nil then
    Len^ := result;
  for F := 1 to info^.ManagedCount do begin
    fieldinfo := DeRef(Field^.TypeInfo);
    {$ifdef FPC} // FPC does include RTTI for unmanaged fields! :)
    if not (fieldinfo^.Kind in tkManagedTypes) then begin
      inc(Field);
      continue;
    end;
    {$endif};
    saved := ManagedTypeSaveLength(R+Field^.Offset,fieldinfo,recsize);
    if saved=0 then begin
      result := 0; // invalid type
      exit;
    end;
    inc(result,saved-recsize); // extract recsize from info^.recSize

    inc(Field);
  end;
end;

function RecordSave(const Rec; Dest: PAnsiChar; TypeInfo: pointer;
  out Len: integer): PAnsiChar; 
var info,fieldinfo: PTypeInfo;
    F: integer;
    Diff: cardinal;
    Field: PFieldInfo;
    R: PAnsiChar;
begin
  R := @Rec;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
  if (R=nil) or (info=nil) then begin
    result := nil; // should have been checked before
    exit;
  end;
  Len := info^.recSize;
  Field := @info^.ManagedFields[0];
  Diff := 0;
  for F := 1 to info^.ManagedCount do begin
    fieldinfo := DeRef(Field^.TypeInfo);
    {$ifdef FPC} // FPC does include RTTI for unmanaged fields! :)
    if not (fieldinfo^.Kind in tkManagedTypes) then begin
      inc(Field);
      continue;
    end;
    {$endif};
    Diff := Field^.Offset-Diff;
    if Diff<>0 then begin
      MoveFast(R^,Dest^,Diff);
      inc(R,Diff);
      inc(Dest,Diff);
    end;
    Dest := ManagedTypeSave(R,Dest,fieldinfo,integer(Diff));
    if Dest=nil then begin
      result := nil; // invalid/unhandled record content
      exit;
    end;













    inc(R,Diff);
    inc(Diff,Field.Offset);
    inc(Field);
  end;
  Diff := info^.recSize-Diff;
  if integer(Diff)<0 then
    raise ESynException.Create('RecordSave diff<0') else
................................................................................
        jmp     System.@FinalizeArray
{$endif CPU64}
end;
{$endif FPC}

function RecordLoad(var Rec; Source: PAnsiChar; TypeInfo: pointer;
  Len: PInteger): PAnsiChar;
var info,fieldinfo: PTypeInfo;
    F: integer;
    Diff: cardinal;
    Field: PFieldInfo;
    R: PAnsiChar;
begin
  result := nil; // indicates error
  R := @Rec;
  info := GetTypeInfo(TypeInfo,tkRecordTypeOrSet);
  if (R=nil) or (info=nil) then // should have been checked before
    exit;
................................................................................
      _Finalize(R+Field^.Offset,Deref(Field^.TypeInfo));
      inc(Field);
    end;
    exit;
  end;
  Diff := 0;
  for F := 1 to info^.ManagedCount do begin
    fieldinfo := DeRef(Field^.TypeInfo);
    {$ifdef FPC} // FPC does include RTTI for unmanaged fields! :)
    if not (fieldinfo^.Kind in tkManagedTypes) then begin
      inc(Field);
      continue;
    end;
    {$endif};
    Diff := Field^.Offset-Diff;
    if Diff<>0 then begin
      MoveFast(Source^,R^,Diff);
      inc(Source,Diff);
      inc(R,Diff);
    end;
    Diff := ManagedTypeLoad(R,Source,fieldinfo);
    if Source=nil then













      exit; // error at loading
    inc(R,Diff);
    inc(Diff,Field^.Offset);
    inc(Field);
  end;
  Diff := info^.recSize-Diff;
  if integer(Diff)<0 then
................................................................................
    result := Dest;
    exit;
  end;
  inc(Dest,sizeof(Cardinal)); // leave space for Hash32 checksum
  result := Dest;
  // store dynamic array elements content
  P := fValue^;
  if ElemType=nil then // FPC: nil also if not Kind in tkManagedTypes
    if GetIsObjArray then
      raise ESynException.CreateUTF8('TDynArray.SaveTo(%) is a T*ObjArray',
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
      // binary types: store as once
      n := n*integer(ElemSize);
      MoveFast(P^,Dest^,n);
      inc(Dest,n);
    end else
    for i := 1 to n do begin
      Dest := ManagedTypeSave(P,Dest,ElemType,LenBytes);
      if Dest=nil then
        break;
      assert(LenBytes=integer(ElemSize));





      inc(P,LenBytes);
    end;
  // store Hash32 checksum
  if Dest<>nil then  // may be nil if RecordSave() failed
    PCardinal(result-sizeof(Cardinal))^ := Hash32(result,Dest-result);
  result := Dest;
end;
................................................................................
    result := 0;
    exit; // avoid GPF if void
  end;
  n := Count;
  result := ToVarUInt32Length(ElemSize)+ToVarUInt32Length(n)+1;
  if n=0 then
    exit;
  if ElemType=nil then // FPC: nil also if not Kind in tkManagedTypes
    if GetIsObjArray then
      raise ESynException.CreateUTF8('TDynArray.SaveToLength(%) is a T*ObjArray',
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else
      inc(result,integer(ElemSize)*n) else begin
    P := fValue^;
    for i := 1 to n do begin
      L := ManagedTypeSaveLength(P,ElemType,size);

      if L=0 then
        break; // invalid record type (wrong field type)
      assert(size=integer(ElemSize));
      inc(result,L);
      inc(P,size);
    end;
  end;
  inc(result,sizeof(Cardinal)); // Hash32 checksum
end;

................................................................................
        djRawByteString:
          if not Base64MagicCheckAndDecode(Val,ValLen,PRawByteStringArray(fValue^)^[i]) then
            SetString(RawUTF8(PPointerArray(fValue^)^[i]),Val,ValLen);
        djWinAnsi:  WinAnsiConvert.UTF8BufferToAnsi(Val,ValLen,PRawByteStringArray(fValue^)^[i]);
        djString:   UTF8DecodeToString(Val,ValLen,string(PPointerArray(fValue^)^[i]));
        djWideString: UTF8ToWideString(Val,ValLen,WideString(PPointerArray(fValue^)^[i]));
        djSynUnicode: UTF8ToSynUnicode(Val,ValLen,SynUnicode(PPointerArray(fValue^)^[i]));
        else raise ESynException.CreateUTF8('% not readable',[ToText(T)^]);
        end;
      end;
    end;
    end;
  end;
  if aEndOfObject<>nil then
    aEndOfObject^ := EndOfObject;
................................................................................
    exit;
  end;
  // retrieve security checksum
  Hash := pointer(Source);
  inc(Source,sizeof(cardinal));
  // retrieve dynamic array elements content
  P := fValue^;
  if ElemType=nil then // FPC: nil also if not Kind in tkManagedTypes
    if GetIsObjArray then
      raise ESynException.CreateUTF8('TDynArray.LoadFrom(%) is a T*ObjArray',
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
      // binary type was stored directly
      n := n*integer(ElemSize);
      MoveFast(Source^,P^,n);
      inc(Source,n);
................................................................................
    result := fCompare(A,B)=0 else
    if ElemType=nil then
      case ElemSize of // optimized versions for arrays of common types
        1: result := byte(A)=byte(B);
        2: result := word(A)=word(B);
        4: result := cardinal(A)=cardinal(B);
        8: result := Int64(A)=Int64(B);
      else result := CompareMem(@A,@B,ElemSize); // binary comparison
      end else
      if PTypeKind(ElemType)^ in tkRecordTypes then // most likely

        result := RecordEquals(A,B,ElemType) else
















        result := ManagedTypeCompare(@A,@B,ElemType)>0; // other complex types
end;

{$ifndef DELPHI5OROLDER} // do not know why Delphi 5 compiler does not like it
function TDynArray.Equals(const B: TDynArray): boolean;
var i, n: integer;
    P1,P2: PAnsiChar;
    A1: PPointerArray absolute P1;
................................................................................
  fElemType := PTypeInfo(aTypeInfo)^.elType;
  if fElemType<>nil then begin
    {$ifndef HASDIRECTTYPEINFO}
    // FPC compatibility: if you have a GPF here at startup, your 3.1 trunk
    // revision seems older than June 2016
    // -> enable HASDIRECTTYPEINFO conditional below $ifdef VER3_1 in Synopse.inc
    // or in your project's options
    fElemType := PPointer(fElemType)^; // inlined DeRef()
    {$endif}
    {$ifdef FPC}
    if not (PTypeKind(fElemType)^ in tkManagedTypes) then
      fElemType := nil; // as with Delphi
    {$endif}
  end;
  fCountP := aCountPointer;
................................................................................
  aCountPointer: PInteger=nil; aCaseInsensitive: boolean=false);
var Comp: TDynArraySortCompare;
begin
  Init(aTypeInfo,aValue,aCountPointer);
  Comp := DYNARRAY_SORTFIRSTFIELD[aCaseInsensitive,aKind];
  if @Comp=nil then
    raise ESynException.CreateUTF8('TDynArray.InitSpecific(%) wrong aKind=%',
      [PShortString(@PTypeInfo(aTypeInfo)^.NameLen)^,ToText(aKind)^]);
  fCompare := Comp;
  fKnownType := aKind;
  fKnownSize := KNOWNTYPE_SIZE[aKind];
end;

procedure TDynArray.UseExternalCount(var aCountPointer: Integer);
begin
................................................................................
  aKind: TDynArrayKind; aCountPointer: PInteger=nil; aCaseInsensitive: boolean=false);
var Comp: TDynArraySortCompare;
    Hasher: TDynArrayHashOne;
begin
  Comp := DYNARRAY_SORTFIRSTFIELD[aCaseInsensitive,aKind];
  Hasher := DYNARRAY_HASHFIRSTFIELD[aCaseInsensitive,aKind];
  if (@Hasher=nil) or (@Comp=nil) then
    raise ESynException.CreateUTF8('TDynArrayHashed.InitSpecific unsupported %',
      [ToText(aKind)^]);
  Init(aTypeInfo,aValue,Hasher,Comp,nil,aCountPointer,aCaseInsensitive);
  {$ifdef UNDIRECTDYNARRAY}with InternalDynArray do{$endif} begin
    fKnownType := aKind;
    fKnownSize := KNOWNTYPE_SIZE[aKind];
  end;
end;

................................................................................
      djWord:     AddU(PWordArray(P)^[i]);
      djInteger:  Add(PIntegerArray(P)^[i]);
      djCardinal: AddU(PCardinalArray(P)^[i]);
      djSingle:   AddSingle(PSingleArray(P)^[i]);
      djInt64:    Add(PInt64Array(P)^[i]);
      djDouble:   AddDouble(PDoubleArray(P)^[i]);
      djCurrency: AddCurr64(PInt64Array(P)^[i]);
      else raise ESynException.CreateUTF8('AddDynArrayJSON unsupported %',[ToText(T)^]);
      end;
      Add(',');
    end;
    end;
  CancelLastComma;
  Add(']');
end;

'1.18.3291'

'1.18.3292'