result := fValidationServerRoot+fValidationMethodName+'/'+
    GetWithSalt(aLogonName,aEmail,fValidationSalt)+
    BinToBase64URI(pointer(result),length(result));
end;

procedure TDDDEmailValidationService.EmailValidate(
  Ctxt: TSQLRestServerURIContext);
var code: RawByteString;
    logon,email,signature: RawUTF8;
    EmailValidation: TSQLRecordEmailValidation;
begin
  signature := Copy(Ctxt.URIBlobFieldName,1,SHA256DIGESTSTRLEN);
  if length(signature)<>SHA256DIGESTSTRLEN then
    exit;
  code := Copy(Ctxt.URIBlobFieldName,SHA256DIGESTSTRLEN+1,200);

  result := fValidationServerRoot+fValidationMethodName+'/'+
    GetWithSalt(aLogonName,aEmail,fValidationSalt)+
    BinToBase64URI(pointer(result),length(result));
end;

procedure TDDDEmailValidationService.EmailValidate(
  Ctxt: TSQLRestServerURIContext);
var code: RawUTF8;
    logon,email,signature: RawUTF8;
    EmailValidation: TSQLRecordEmailValidation;
begin
  signature := Copy(Ctxt.URIBlobFieldName,1,SHA256DIGESTSTRLEN);
  if length(signature)<>SHA256DIGESTSTRLEN then
    exit;
  code := Copy(Ctxt.URIBlobFieldName,SHA256DIGESTSTRLEN+1,200);

begin
  if self=nil then
    exit;
  fOwner := aOwner;
  if fInitialJsonContent='' then
    exit;
  tmp := fInitialJsonContent;
  UniqueString(AnsiString(tmp));
  RemoveCommentsFromJSON(pointer(tmp));
  JSONToObject(fOwner,pointer(tmp),result);
  if not result then
    fInitialJsonContent := '';
end;

procedure TDDDAppSettingsStorageAbstract.Store(const aJSON: RawUTF8);
begin

begin
  if self=nil then
    exit;
  fOwner := aOwner;
  if fInitialJsonContent='' then
    exit;
  tmp := fInitialJsonContent;

  RemoveCommentsFromJSON(UniqueRawUTF8(tmp));
  JSONToObject(fOwner,pointer(tmp),result);
  if not result then
    fInitialJsonContent := '';
end;

procedure TDDDAppSettingsStorageAbstract.Store(const aJSON: RawUTF8);
begin

    {$ifdef UNICODE}, tkUString{$endif});
const
  // maps record or object types
  tkRecordTypes = [tkRecord];
{$endif}
  // maps long string types
  tkStringTypes =
    [tkLString,tkWString{$ifdef UNICODE},tkUString{$endif}{$ifdef FPC},tkAString{$endif}];
  // maps 1, 8, 16, 32 and 64 bit ordinal types
  tkOrdinalTypes =
    [tkInteger, tkChar, tkWChar, tkEnumeration, tkSet, tkInt64
     {$ifdef FPC},tkBool,tkQWord{$endif}];

type
  /// specify ordinal (tkInteger and tkEnumeration) storage size and sign
................................................................................
    function DynArrayItemSize: integer; {$ifdef HASINLINE}inline;{$endif}
    /// recognize most used string types, returning their code page
    // - will recognize TSQLRawBlob as the fake CP_SQLRAWBLOB code page
    // - will return the exact code page since Delphi 2009, from RTTI
    // - for non Unicode versions of Delphi, will recognize WinAnsiString as
    // CODEPAGE_US, RawUnicode as CP_UTF16, RawByteString as CP_RAWBYTESTRING,
    // AnsiString as 0, and any other type as RawUTF8
    function AnsiStringCodePage: integer; {$ifdef UNICODE}inline;{$endif}
    /// get the TGUID of a given interface type information
    // - returns nil if this type is not an interface
    function InterfaceGUID: PGUID;
    /// get the unit name of a given interface type information
    // - returns '' if this type is not an interface
    function InterfaceUnitName: PShortString;
    /// get the ancestor/parent of a given interface type information
................................................................................
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure CopyLongStrProp(Source,Dest: TObject);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure GetWideStrProp(Instance: TObject; var Value: WideString);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetWideStrProp(Instance: TObject; const Value: WideString);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    {$ifdef UNICODE}
    function GetUnicodeStrProp(Instance: TObject): UnicodeString;
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetUnicodeStrProp(Instance: TObject; const Value: UnicodeString);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    {$endif}
    function GetCurrencyProp(Instance: TObject): currency;
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetCurrencyProp(Instance: TObject; const Value: Currency);
     {$ifdef HASINLINE}inline;{$endif}
    function GetDoubleProp(Instance: TObject): double;
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetDoubleProp(Instance: TObject; Value: Double);
................................................................................
    procedure SetGenericStringValue(Instance: TObject; const Value: string);
    /// low-level getter of the long string property value of a given instance
    // - uses the generic string type: to be used within the VCL
    // - this method will check if the corresponding property is a Long String,
    // or an UnicodeString (for Delphi 2009+),and will return '' if it's
    // not the case
    function GetGenericStringValue(Instance: TObject): string;
{$ifdef UNICODE}
    /// low-level setter of the Unicode string property value of a given instance
    // - this method will check if the corresponding property is a Unicode String
    procedure SetUnicodeStrValue(Instance: TObject; const Value: UnicodeString);
    /// low-level getter of the Unicode string property value of a given instance
    // - this method will check if the corresponding property is a Unicode String
    function GetUnicodeStrValue(Instance: TObject): UnicodeString;
{$endif}
    /// low-level getter of a dynamic array wrapper
    // - this method will NOT check if the property is a dynamic array: caller
    // must have already checked that PropType^^.Kind=tkDynArray
    function GetDynArray(Instance: TObject): TDynArray; overload;
      {$ifdef HASINLINE}inline;{$endif}
    /// low-level getter of a dynamic array wrapper
    // - this method will NOT check if the property is a dynamic array: caller
................................................................................
    procedure GetBinary(Instance: TObject; W: TFileBufferWriter); override;
    function SetBinary(Instance: TObject; P: PAnsiChar): PAnsiChar; override;
    procedure GetJSONValues(Instance: TObject; W: TJSONSerializer); override;
    function CompareValue(Item1,Item2: TObject; CaseInsensitive: boolean): PtrInt; override;
    function GetHash(Instance: TObject; CaseInsensitive: boolean): cardinal; override;
  end;

{$ifdef UNICODE}
  /// information about a UnicodeString published property
  TSQLPropInfoRTTIUnicode = class(TSQLPropInfoRTTI)
  protected
    procedure CopySameClassProp(Source: TObject; DestInfo: TSQLPropInfo; Dest: TObject); override;
  public
    procedure SetValue(Instance: TObject; Value: PUTF8Char; wasString: boolean); override;
    procedure SetValueVar(Instance: TObject; const Value: RawUTF8; wasString: boolean); override;
................................................................................
    procedure GetJSONValues(Instance: TObject; W: TJSONSerializer); override;
    procedure GetFieldSQLVar(Instance: TObject; var aValue: TSQLVar;
      var temp: RawByteString); override;
    function SetFieldSQLVar(Instance: TObject; const aValue: TSQLVar): boolean; override;
    function CompareValue(Item1,Item2: TObject; CaseInsensitive: boolean): PtrInt; override;
    function GetHash(Instance: TObject; CaseInsensitive: boolean): cardinal; override;
  end;
{$endif}

  /// information about a dynamic array published property
  TSQLPropInfoRTTIDynArray = class(TSQLPropInfoRTTI)
  protected
    fObjArray: PClassInstance;
    function GetDynArray(Instance: TObject): TDynArray; overload;
      {$ifdef HASINLINE}inline;{$endif}
................................................................................
            C := TSQLPropInfoRTTIDouble;
        tkLString {$ifdef FPC},tkAString{$endif}:
          case aType^.AnsiStringCodePage of // recognize optimized UTF-8/UTF-16
            CP_UTF8:  C := TSQLPropInfoRTTIRawUTF8;
            CP_UTF16: C := TSQLPropInfoRTTIRawUnicode;
            else C := TSQLPropInfoRTTIAnsi; // will use the right TSynAnsiConvert
          end;
        {$ifdef UNICODE}
        tkUString:
          C := TSQLPropInfoRTTIUnicode;
        {$endif}
        tkWString:
          C := TSQLPropInfoRTTIWide;
      end;
    end;
................................................................................
begin
  if Value<>nil then
    UTF8ToWideString(Value,StrLen(Value),Wide);
  fPropInfo.SetWideStrProp(Instance,Wide);
end;


{$ifdef UNICODE}

{ TSQLPropInfoRTTIUnicode }

procedure TSQLPropInfoRTTIUnicode.CopySameClassProp(Source: TObject;
  DestInfo: TSQLPropInfo; Dest: TObject);
begin
  TSQLPropInfoRTTIUnicode(DestInfo).fPropInfo.SetUnicodeStrProp(Dest,
................................................................................
  var temp: RawByteString);
begin
  temp := UnicodeStringToUtf8(fPropInfo.GetUnicodeStrProp(Instance));
  aValue.VType := ftUTF8;
  aValue.VText := Pointer(temp);
end;

{$endif UNICODE}


{ TObjArraySerializer}

type
  TObjArraySerializer = class(TPointerClassHashed)
  public
................................................................................
        {$ifdef FPC}tkBool,{$endif}
        tkEnumeration, tkInteger, tkSet: begin
          V := P^.GetOrdProp(Value);
          if V<>P^.Default then
            Add('%%=%'#13,[SubCompName,P^.Name,V]);
        end;
        {$ifdef FPC}tkAString,{$endif} tkLString, tkWString
        {$ifdef UNICODE},tkUString{$endif}: begin
          P^.GetLongStrValue(Value,tmp);
          Add('%%=%'#13,[SubCompName,P^.Name,tmp]);
        end;
        tkFloat: begin
          VT[0] := AnsiChar(ExtendedToString(VT,P^.GetFloatProp(Value),DOUBLE_PRECISION));
          Add('%%=%'#13,[SubCompName,P^.Name,VT]);
        end;
................................................................................
      case cp of
        CP_UTF8:       result := tmp;
        CP_SQLRAWBLOB: result := TSQLRawBlobToBlob(TSQLRawBlob(tmp));
        else           result := TSynAnsiConvert.Engine(cp).AnsiToUTF8(tmp);
      end;
    end;
  end;
  {$ifdef UNICODE}
  tkUString:
    StringToUTF8(GetUnicodeStrProp(Instance),result);
  {$endif}
  tkWString: begin
    GetWideStrProp(Instance,tmpWS);
    RawUnicodeToUtf8(pointer(tmpWS),length(tmpWS),result);
  end;
  else result := '';
  end
................................................................................
  var tmp: RawByteString;
  begin
    if cp=CP_SQLRAWBLOB then
      tmp := BlobToTSQLRawBlob(Value) else
      tmp := TSynAnsiConvert.Engine(cp).UTF8ToAnsi(Value);
    SetLongStrProp(Instance,tmp);
  end;
  {$ifdef UNICODE}
  procedure HandleUnicode(Instance: TObject; const Value: RawUTF8);
  begin
    SetUnicodeStrProp(Instance,UTF8ToString(Value));
  end;
  {$endif}
  procedure HandleWideString(Instance: TObject; const Value: RawUTF8);
  begin
    SetWideStrProp(Instance,UTF8ToWideString(Value));
  end;
var cp: integer;
................................................................................
      cp := PropType^.AnsiStringCodePage;
      if cp=CP_UTF8 then
        SetLongStrProp(Instance,Value) else
        HandleAnsiString(Instance,Value,cp);
    end else
      SetLongStrProp(Instance,'');
  end;
  {$ifdef UNICODE}
  tkUString:
    HandleUnicode(Instance,Value);
  {$endif}
  tkWString:
    HandleWideString(Instance,Value);
  end;
end;
................................................................................
      i := PropType^.EnumBaseType^.GetEnumNameValue(pointer(u),length(u));
      if i>=0 then
        SetOrdProp(Instance,i)
    end;
  tkInt64{$ifdef FPC},tkQWord{$endif}:
    if VariantToInt64(Value,i64) then
      SetInt64Prop(Instance,i64);

  {$ifdef UNICODE}tkUString,{$endif}tkLString,tkWString{$ifdef FPC},tkAString{$endif}:
    if VariantToUTF8(Value,u) then
      SetLongStrValue(Instance,u);
  tkFloat:
    if VariantToDouble(Value,d) then
      SetFloatProp(Instance,d);
  tkVariant:
    SetVariantProp(Instance,Value);
................................................................................
  case PropType^.Kind of
  tkInteger,tkEnumeration,tkSet,tkChar,tkWChar{$ifdef FPC},tkBool{$endif}:
    SetOrdProp(Instance,0);
  tkInt64{$ifdef FPC},tkQWord{$endif}:
    SetInt64Prop(Instance,0);
  tkLString{$ifdef FPC},tkAString{$endif}:
    SetLongStrProp(Instance,'');
  {$ifdef UNICODE}
  tkUString:
    SetUnicodeStrProp(Instance,'');
  {$endif}
  tkWString:
    SetWideStrProp(Instance,'');
  tkFloat:
    SetFloatProp(Instance,0);
................................................................................
  if (Instance=nil) or (@self=nil) then
    result := '' else
    case PropType^.Kind of
      {$ifdef FPC}tkAString,{$endif} tkLString, tkWString: begin
        GetLongStrValue(Instance,tmp);
        result := UTF8ToString(tmp);
      end;
{$ifdef UNICODE}
      tkUString:
        result := GetUnicodeStrProp(Instance);
{$endif}else result := '';
     end;
end;

procedure TPropInfo.SetGenericStringValue(Instance: TObject; const Value: string);
begin
  if (Instance<>nil) and (@self<>nil) then
    case PropType^.Kind of
      {$ifdef FPC}tkAString,{$endif}tkLString, tkWString:
         SetLongStrValue(Instance,StringToUtf8(Value));
{$ifdef UNICODE}
       tkUString:
         SetUnicodeStrProp(Instance,Value);
{$endif}end;
end;


{$ifdef UNICODE}

function TPropInfo.GetUnicodeStrValue(Instance: TObject): UnicodeString;
begin
  if (Instance<>nil) and (@self<>nil) and
     (PropType^^.Kind=tkUString) then
    result := GetUnicodeStrProp(Instance);
end;

procedure TPropInfo.SetUnicodeStrValue(Instance: TObject; const Value: UnicodeString);
begin
  if (Instance<>nil) and (@self<>nil) and
     (PropType^^.Kind=tkUString) then
    SetUnicodeStrProp(Instance,Value);
end;
{$endif}

procedure TPropInfo.SetOrdValue(Instance: TObject; Value: PtrInt);
begin
  if (Instance<>nil) and (@self<>nil) and
     (PropType^.Kind in [
       tkInteger,tkEnumeration,tkSet,{$ifdef FPC}tkBool,{$endif}tkClass]) then
    SetOrdProp(Instance,Value);
................................................................................
        GetLongStrProp(Source,Value);
        DestInfo.SetLongStrProp(Dest,Value);
      end else
str:  if kD in tkStringTypes then begin
        GetLongStrValue(Source,RawUTF8(Value));
        DestInfo.SetLongStrValue(Dest,RawUTF8(Value));
      end;
    {$ifdef UNICODE}
    tkUString:
      if kD=tkUString then
        DestInfo.SetUnicodeStrProp(Dest,GetUnicodeStrProp(Source)) else
        goto str;
    {$endif}
    tkWString:
      if kD=tkWString then begin
................................................................................
end;

procedure TPropInfo.SetWideStrProp(Instance: TObject; const Value: WideString);
begin
  TypInfo.SetWideStrProp(Instance,@self,Value);
end;

{$ifdef UNICODE}
function TPropInfo.GetUnicodeStrProp(Instance: TObject): UnicodeString;
begin
  Value := TypInfo.GetUnicodeStrProp(Instance,@self);
end;

procedure TPropInfo.SetUnicodeStrProp(Instance: TObject; const Value: UnicodeString);
begin
  TypInfo.SetUnicodeStrProp(Instance,@self,Value);
end;
{$endif}

function TPropInfo.GetCurrencyProp(Instance: TObject): currency;
begin
  if GetterIsField then
    result := PCurrency(GetterAddr(Instance))^ else
    result := TypInfo.GetFloatProp(Instance,@self);
end;
................................................................................
    M.Data := Instance;
    if Index=NO_INDEX then  // no index
      TUStringSetProc(M)(Value) else
      TUStringIndexedSetProc(M)(Index, Value);
  end;
end;

{$ifdef UNICODE}
function TPropInfo.GetUnicodeStrProp(Instance: TObject): UnicodeString;
type
  TUStringGetProc = function: UnicodeString of object;
  TUStringIndexedGetProc = function(Index: Integer): UnicodeString of object;
var M: TMethod;
begin // caller must check that PropType^.Kind = tkUString
  if PropWrap(GetProc).Kind=$FF then
................................................................................
      M.Code := Pointer(SetProc);
    M.Data := Instance;
    if Index=NO_INDEX then // no index
      TUStringSetProc(M)(Value) else
      TUStringIndexedSetProc(M)(Index, Value);
  end;
end;
{$endif}

function TPropInfo.GetCurrencyProp(Instance: TObject): currency;
type // function(Instance: TObject) trick does not work with CPU64 :(
  TGetProc = function: currency of object;
  TIndexedGetProc = function(Index: Integer): currency of object;
var P: Pointer;
    Call: TMethod;
................................................................................
      if @self=TypeInfo(WinAnsiString) then begin
        result := sftAnsiText;
        exit;
      end else begin
        result := sftUTF8Text; // CP_UTF8,CP_UTF16 and any other to UTF-8 text
        exit; 
      end;
    {$ifdef UNICODE}tkUString,{$endif} tkChar, tkWChar, tkWString: begin
      result := sftUTF8Text;
      exit;
    end;
    tkDynArray: begin
      result := sftBlobDynArray;
      exit;
    end;
................................................................................
  if @self=nil then
    result := 0 else
    DynArrayTypeInfoToRecordInfo(@self,@result);
end;

function TTypeInfo.AnsiStringCodePage: integer;
begin
  {$ifdef UNICODE}
  if @self=TypeInfo(TSQLRawBlob) then
    result := CP_SQLRAWBLOB else
    if Kind in [{$ifdef FPC}tkAString,{$endif} tkLString] then
      result := PWord(AlignToPtr(@Name[ord(Name[0])+1]))^ else // from RTTI
  {$else}
  if @self=TypeInfo(RawUTF8) then
    result := CP_UTF8 else
................................................................................
          Int64ToUtf8(P^.GetInt64Prop(Value)));
      {$ifdef FPC}tkBool,{$endif} tkEnumeration, tkSet, tkInteger: begin
        V := P^.GetOrdProp(Value);
        //if V<>P^.Default then NO DEFAULT: update INI -> must override previous
        UpdateIniEntry(IniContent,Section,SubCompName+ToUTF8(P^.Name),
          Int32ToUtf8(V));
      end;
      {$ifdef UNICODE}tkUString,{$endif} {$ifdef FPC}tkAString,{$endif}
      tkLString, tkWString: begin
        P^.GetLongStrValue(Value,tmp);
        UpdateIniEntry(IniContent,Section,SubCompName+ToUTF8(P^.Name),tmp);
        end;
      tkClass:
      if Section='' then begin // recursive call works only as plain object
        Obj := P^.GetObjProp(Value);
        if (Obj<>nil) and Obj.InheritsFrom(TPersistent) then
          WriteObject(Value,IniContent,Section,SubCompName+ToUTF8(P^.Name)+'.');
      end;
      // tkString (shortstring) and tkInterface are not handled
................................................................................
        end;
      {$ifdef FPC}tkAString,{$endif} tkLString: 
        if wasString or (j2oIgnoreStringType in Options) then begin
          SetString(U,PAnsiChar(PropValue),StrLen(PropValue));
          P^.SetLongStrValue(Value,U);
        end else
          exit;
      {$ifdef UNICODE}
      tkUString:
        if wasString or (j2oIgnoreStringType in Options) then
          P^.SetUnicodeStrProp(Value,
            UTF8DecodeToUnicodeString(PropValue,StrLen(PropValue))) else
          exit;
      {$endif}
      tkWString:
................................................................................
          if err=0 then
            P^.SetFloatProp(Value,E);
        end;
      {$ifdef FPC}tkAString,{$endif} tkLString:
        P^.SetLongStrValue(Value,U);
      tkWString:
         P^.SetWideStrProp(Value,UTF8ToWideString(U));
      {$ifdef UNICODE}
      tkUString:
         P^.SetUnicodeStrProp(Value,UTF8ToString(U));
      {$endif}
      tkDynArray:
        P^.GetDynArray(Value).LoadFrom(pointer(BlobToTSQLRawBlob(U)));
{$ifdef PUBLISHRECORD}
      tkRecord{$ifdef FPC},tkObject{$endif}:
................................................................................
    Table: TSQLTable absolute Value;
    aClassType: TClass;
    Kind: TTypeKind;
    UtfP: PPUtf8CharArray;
    IsObj: TJSONObject;
    IsObjCustomIndex: integer;
    WS: WideString;
    {$ifdef UNICODE}
    US: UnicodeString;
    {$endif}
    tmp: RawByteString;
    dyn: TDynArray;
    dynObjArray: PClassInstance;
    {$ifndef NOVARIANTS}
    VVariant: variant;
................................................................................
            AddDateTime(P^.GetDoubleProp(Value));
            if woDateTimeWithZSuffix in Options then
              Add('Z');
            Add('"');
          end else
            Add(P^.GetFloatProp(Value),DOUBLE_PRECISION);
        end;
        {$ifdef UNICODE}
        tkUString: begin // write converted to UTF-8
          US := P^.GetUnicodeStrProp(Value);
          if (US<>'') or not (woDontStoreEmptyString in Options) then begin
            HR(P);
            Add('"');
            AddJSONEscapeW(pointer(US));
            Add('"');
................................................................................
      result := smvRawJSON else
    if P=TypeInfo(RawByteString) then
      result := smvRawByteString else
  {$ifndef UNICODE}
    if P=TypeInfo(AnsiString) then
      result := smvString else
      result := smvRawUTF8; // UTF-8 by default




  {$else UNICODE}
      result := smvRawUTF8;
  tkUString:
    result := smvString;
  {$endif}
  tkWString:
    result := smvWideString;
  tkClass:
    with P^.ClassType^ do
    if ClassHasPublishedFields(ClassType) or
       (JSONObject(ClassType,IsObjCustomIndex,[cpRead,cpWrite]) in
         [{$ifndef LVCL}oCollection,{$endif}oObjectList,oUtfs,oStrings,

    {$ifdef UNICODE}, tkUString{$endif});
const
  // maps record or object types
  tkRecordTypes = [tkRecord];
{$endif}
  // maps long string types
  tkStringTypes =
    [tkLString,tkWString{$ifdef HASVARUSTRING},tkUString{$endif}{$ifdef FPC},tkAString{$endif}];
  // maps 1, 8, 16, 32 and 64 bit ordinal types
  tkOrdinalTypes =
    [tkInteger, tkChar, tkWChar, tkEnumeration, tkSet, tkInt64
     {$ifdef FPC},tkBool,tkQWord{$endif}];

type
  /// specify ordinal (tkInteger and tkEnumeration) storage size and sign
................................................................................
    function DynArrayItemSize: integer; {$ifdef HASINLINE}inline;{$endif}
    /// recognize most used string types, returning their code page
    // - will recognize TSQLRawBlob as the fake CP_SQLRAWBLOB code page
    // - will return the exact code page since Delphi 2009, from RTTI
    // - for non Unicode versions of Delphi, will recognize WinAnsiString as
    // CODEPAGE_US, RawUnicode as CP_UTF16, RawByteString as CP_RAWBYTESTRING,
    // AnsiString as 0, and any other type as RawUTF8
    function AnsiStringCodePage: integer; {$ifdef HASCODEPAGE}inline;{$endif}
    /// get the TGUID of a given interface type information
    // - returns nil if this type is not an interface
    function InterfaceGUID: PGUID;
    /// get the unit name of a given interface type information
    // - returns '' if this type is not an interface
    function InterfaceUnitName: PShortString;
    /// get the ancestor/parent of a given interface type information
................................................................................
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure CopyLongStrProp(Source,Dest: TObject);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure GetWideStrProp(Instance: TObject; var Value: WideString);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetWideStrProp(Instance: TObject; const Value: WideString);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    {$ifdef HASVARUSTRING}
    function GetUnicodeStrProp(Instance: TObject): UnicodeString;
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetUnicodeStrProp(Instance: TObject; const Value: UnicodeString);
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    {$endif HASVARUSTRING}
    function GetCurrencyProp(Instance: TObject): currency;
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetCurrencyProp(Instance: TObject; const Value: Currency);
     {$ifdef HASINLINE}inline;{$endif}
    function GetDoubleProp(Instance: TObject): double;
     {$ifdef USETYPEINFO}{$ifdef HASINLINE}inline;{$endif}{$endif}
    procedure SetDoubleProp(Instance: TObject; Value: Double);
................................................................................
    procedure SetGenericStringValue(Instance: TObject; const Value: string);
    /// low-level getter of the long string property value of a given instance
    // - uses the generic string type: to be used within the VCL
    // - this method will check if the corresponding property is a Long String,
    // or an UnicodeString (for Delphi 2009+),and will return '' if it's
    // not the case
    function GetGenericStringValue(Instance: TObject): string;
    {$ifdef HASVARUSTRING}
    /// low-level setter of the Unicode string property value of a given instance
    // - this method will check if the corresponding property is a Unicode String
    procedure SetUnicodeStrValue(Instance: TObject; const Value: UnicodeString);
    /// low-level getter of the Unicode string property value of a given instance
    // - this method will check if the corresponding property is a Unicode String
    function GetUnicodeStrValue(Instance: TObject): UnicodeString;
    {$endif}
    /// low-level getter of a dynamic array wrapper
    // - this method will NOT check if the property is a dynamic array: caller
    // must have already checked that PropType^^.Kind=tkDynArray
    function GetDynArray(Instance: TObject): TDynArray; overload;
      {$ifdef HASINLINE}inline;{$endif}
    /// low-level getter of a dynamic array wrapper
    // - this method will NOT check if the property is a dynamic array: caller
................................................................................
    procedure GetBinary(Instance: TObject; W: TFileBufferWriter); override;
    function SetBinary(Instance: TObject; P: PAnsiChar): PAnsiChar; override;
    procedure GetJSONValues(Instance: TObject; W: TJSONSerializer); override;
    function CompareValue(Item1,Item2: TObject; CaseInsensitive: boolean): PtrInt; override;
    function GetHash(Instance: TObject; CaseInsensitive: boolean): cardinal; override;
  end;

  {$ifdef HASVARUSTRING}
  /// information about a UnicodeString published property
  TSQLPropInfoRTTIUnicode = class(TSQLPropInfoRTTI)
  protected
    procedure CopySameClassProp(Source: TObject; DestInfo: TSQLPropInfo; Dest: TObject); override;
  public
    procedure SetValue(Instance: TObject; Value: PUTF8Char; wasString: boolean); override;
    procedure SetValueVar(Instance: TObject; const Value: RawUTF8; wasString: boolean); override;
................................................................................
    procedure GetJSONValues(Instance: TObject; W: TJSONSerializer); override;
    procedure GetFieldSQLVar(Instance: TObject; var aValue: TSQLVar;
      var temp: RawByteString); override;
    function SetFieldSQLVar(Instance: TObject; const aValue: TSQLVar): boolean; override;
    function CompareValue(Item1,Item2: TObject; CaseInsensitive: boolean): PtrInt; override;
    function GetHash(Instance: TObject; CaseInsensitive: boolean): cardinal; override;
  end;
  {$endif HASVARUSTRING}

  /// information about a dynamic array published property
  TSQLPropInfoRTTIDynArray = class(TSQLPropInfoRTTI)
  protected
    fObjArray: PClassInstance;
    function GetDynArray(Instance: TObject): TDynArray; overload;
      {$ifdef HASINLINE}inline;{$endif}
................................................................................
            C := TSQLPropInfoRTTIDouble;
        tkLString {$ifdef FPC},tkAString{$endif}:
          case aType^.AnsiStringCodePage of // recognize optimized UTF-8/UTF-16
            CP_UTF8:  C := TSQLPropInfoRTTIRawUTF8;
            CP_UTF16: C := TSQLPropInfoRTTIRawUnicode;
            else C := TSQLPropInfoRTTIAnsi; // will use the right TSynAnsiConvert
          end;
        {$ifdef HASVARUSTRING}
        tkUString:
          C := TSQLPropInfoRTTIUnicode;
        {$endif}
        tkWString:
          C := TSQLPropInfoRTTIWide;
      end;
    end;
................................................................................
begin
  if Value<>nil then
    UTF8ToWideString(Value,StrLen(Value),Wide);
  fPropInfo.SetWideStrProp(Instance,Wide);
end;


{$ifdef HASVARUSTRING}

{ TSQLPropInfoRTTIUnicode }

procedure TSQLPropInfoRTTIUnicode.CopySameClassProp(Source: TObject;
  DestInfo: TSQLPropInfo; Dest: TObject);
begin
  TSQLPropInfoRTTIUnicode(DestInfo).fPropInfo.SetUnicodeStrProp(Dest,
................................................................................
  var temp: RawByteString);
begin
  temp := UnicodeStringToUtf8(fPropInfo.GetUnicodeStrProp(Instance));
  aValue.VType := ftUTF8;
  aValue.VText := Pointer(temp);
end;

{$endif HASVARUSTRING}


{ TObjArraySerializer}

type
  TObjArraySerializer = class(TPointerClassHashed)
  public
................................................................................
        {$ifdef FPC}tkBool,{$endif}
        tkEnumeration, tkInteger, tkSet: begin
          V := P^.GetOrdProp(Value);
          if V<>P^.Default then
            Add('%%=%'#13,[SubCompName,P^.Name,V]);
        end;
        {$ifdef FPC}tkAString,{$endif} tkLString, tkWString
        {$ifdef HASVARUSTRING},tkUString{$endif}: begin
          P^.GetLongStrValue(Value,tmp);
          Add('%%=%'#13,[SubCompName,P^.Name,tmp]);
        end;
        tkFloat: begin
          VT[0] := AnsiChar(ExtendedToString(VT,P^.GetFloatProp(Value),DOUBLE_PRECISION));
          Add('%%=%'#13,[SubCompName,P^.Name,VT]);
        end;
................................................................................
      case cp of
        CP_UTF8:       result := tmp;
        CP_SQLRAWBLOB: result := TSQLRawBlobToBlob(TSQLRawBlob(tmp));
        else           result := TSynAnsiConvert.Engine(cp).AnsiToUTF8(tmp);
      end;
    end;
  end;
  {$ifdef HASVARUSTRING}
  tkUString:
    result := UnicodeStringToUTF8(GetUnicodeStrProp(Instance));
  {$endif}
  tkWString: begin
    GetWideStrProp(Instance,tmpWS);
    RawUnicodeToUtf8(pointer(tmpWS),length(tmpWS),result);
  end;
  else result := '';
  end
................................................................................
  var tmp: RawByteString;
  begin
    if cp=CP_SQLRAWBLOB then
      tmp := BlobToTSQLRawBlob(Value) else
      tmp := TSynAnsiConvert.Engine(cp).UTF8ToAnsi(Value);
    SetLongStrProp(Instance,tmp);
  end;
  {$ifdef HASVARUSTRING}
  procedure HandleUnicode(Instance: TObject; const Value: RawUTF8);
  begin
    SetUnicodeStrProp(Instance,UTF8DecodeToUnicodeString(Value));
  end;
  {$endif}
  procedure HandleWideString(Instance: TObject; const Value: RawUTF8);
  begin
    SetWideStrProp(Instance,UTF8ToWideString(Value));
  end;
var cp: integer;
................................................................................
      cp := PropType^.AnsiStringCodePage;
      if cp=CP_UTF8 then
        SetLongStrProp(Instance,Value) else
        HandleAnsiString(Instance,Value,cp);
    end else
      SetLongStrProp(Instance,'');
  end;
  {$ifdef HASVARUSTRING}
  tkUString:
    HandleUnicode(Instance,Value);
  {$endif}
  tkWString:
    HandleWideString(Instance,Value);
  end;
end;
................................................................................
      i := PropType^.EnumBaseType^.GetEnumNameValue(pointer(u),length(u));
      if i>=0 then
        SetOrdProp(Instance,i)
    end;
  tkInt64{$ifdef FPC},tkQWord{$endif}:
    if VariantToInt64(Value,i64) then
      SetInt64Prop(Instance,i64);
  {$ifdef HASVARUSTRING}tkUString,{$endif}
  tkLString, tkWString {$ifdef FPC},tkAString{$endif}:
    if VariantToUTF8(Value,u) then
      SetLongStrValue(Instance,u);
  tkFloat:
    if VariantToDouble(Value,d) then
      SetFloatProp(Instance,d);
  tkVariant:
    SetVariantProp(Instance,Value);
................................................................................
  case PropType^.Kind of
  tkInteger,tkEnumeration,tkSet,tkChar,tkWChar{$ifdef FPC},tkBool{$endif}:
    SetOrdProp(Instance,0);
  tkInt64{$ifdef FPC},tkQWord{$endif}:
    SetInt64Prop(Instance,0);
  tkLString{$ifdef FPC},tkAString{$endif}:
    SetLongStrProp(Instance,'');
  {$ifdef HASVARUSTRING}
  tkUString:
    SetUnicodeStrProp(Instance,'');
  {$endif}
  tkWString:
    SetWideStrProp(Instance,'');
  tkFloat:
    SetFloatProp(Instance,0);
................................................................................
  if (Instance=nil) or (@self=nil) then
    result := '' else
    case PropType^.Kind of
      {$ifdef FPC}tkAString,{$endif} tkLString, tkWString: begin
        GetLongStrValue(Instance,tmp);
        result := UTF8ToString(tmp);
      end;
      {$ifdef HASVARUSTRING}
      tkUString:
        result := string(GetUnicodeStrProp(Instance));
      {$endif}else result := '';
     end;
end;

procedure TPropInfo.SetGenericStringValue(Instance: TObject; const Value: string);
begin
  if (Instance<>nil) and (@self<>nil) then
    case PropType^.Kind of
      {$ifdef FPC}tkAString,{$endif}tkLString, tkWString:
         SetLongStrValue(Instance,StringToUtf8(Value));
      {$ifdef HASVARUSTRING}
       tkUString:
         SetUnicodeStrProp(Instance,UnicodeString(Value));
      {$endif}
    end;
end;

{$ifdef HASVARUSTRING}

function TPropInfo.GetUnicodeStrValue(Instance: TObject): UnicodeString;
begin
  if (Instance<>nil) and (@self<>nil) and
     (PropType^.Kind=tkUString) then
    result := GetUnicodeStrProp(Instance);
end;

procedure TPropInfo.SetUnicodeStrValue(Instance: TObject; const Value: UnicodeString);
begin
  if (Instance<>nil) and (@self<>nil) and
     (PropType^.Kind=tkUString) then
    SetUnicodeStrProp(Instance,Value);
end;
{$endif HASVARUSTRING}

procedure TPropInfo.SetOrdValue(Instance: TObject; Value: PtrInt);
begin
  if (Instance<>nil) and (@self<>nil) and
     (PropType^.Kind in [
       tkInteger,tkEnumeration,tkSet,{$ifdef FPC}tkBool,{$endif}tkClass]) then
    SetOrdProp(Instance,Value);
................................................................................
        GetLongStrProp(Source,Value);
        DestInfo.SetLongStrProp(Dest,Value);
      end else
str:  if kD in tkStringTypes then begin
        GetLongStrValue(Source,RawUTF8(Value));
        DestInfo.SetLongStrValue(Dest,RawUTF8(Value));
      end;
    {$ifdef HASVARUSTRING}
    tkUString:
      if kD=tkUString then
        DestInfo.SetUnicodeStrProp(Dest,GetUnicodeStrProp(Source)) else
        goto str;
    {$endif}
    tkWString:
      if kD=tkWString then begin
................................................................................
end;

procedure TPropInfo.SetWideStrProp(Instance: TObject; const Value: WideString);
begin
  TypInfo.SetWideStrProp(Instance,@self,Value);
end;

{$ifdef HASVARUSTRING}
function TPropInfo.GetUnicodeStrProp(Instance: TObject): UnicodeString;
begin
  result := TypInfo.GetUnicodeStrProp(Instance,@self);
end;

procedure TPropInfo.SetUnicodeStrProp(Instance: TObject; const Value: UnicodeString);
begin
  TypInfo.SetUnicodeStrProp(Instance,@self,Value);
end;
{$endif HASVARUSTRING}

function TPropInfo.GetCurrencyProp(Instance: TObject): currency;
begin
  if GetterIsField then
    result := PCurrency(GetterAddr(Instance))^ else
    result := TypInfo.GetFloatProp(Instance,@self);
end;
................................................................................
    M.Data := Instance;
    if Index=NO_INDEX then  // no index
      TUStringSetProc(M)(Value) else
      TUStringIndexedSetProc(M)(Index, Value);
  end;
end;

{$ifdef HASVARUSTRING}
function TPropInfo.GetUnicodeStrProp(Instance: TObject): UnicodeString;
type
  TUStringGetProc = function: UnicodeString of object;
  TUStringIndexedGetProc = function(Index: Integer): UnicodeString of object;
var M: TMethod;
begin // caller must check that PropType^.Kind = tkUString
  if PropWrap(GetProc).Kind=$FF then
................................................................................
      M.Code := Pointer(SetProc);
    M.Data := Instance;
    if Index=NO_INDEX then // no index
      TUStringSetProc(M)(Value) else
      TUStringIndexedSetProc(M)(Index, Value);
  end;
end;
{$endif HASVARUSTRING}

function TPropInfo.GetCurrencyProp(Instance: TObject): currency;
type // function(Instance: TObject) trick does not work with CPU64 :(
  TGetProc = function: currency of object;
  TIndexedGetProc = function(Index: Integer): currency of object;
var P: Pointer;
    Call: TMethod;
................................................................................
      if @self=TypeInfo(WinAnsiString) then begin
        result := sftAnsiText;
        exit;
      end else begin
        result := sftUTF8Text; // CP_UTF8,CP_UTF16 and any other to UTF-8 text
        exit; 
      end;
    {$ifdef HASVARUSTRING}tkUString,{$endif} tkChar, tkWChar, tkWString: begin
      result := sftUTF8Text;
      exit;
    end;
    tkDynArray: begin
      result := sftBlobDynArray;
      exit;
    end;
................................................................................
  if @self=nil then
    result := 0 else
    DynArrayTypeInfoToRecordInfo(@self,@result);
end;

function TTypeInfo.AnsiStringCodePage: integer;
begin
  {$ifdef HASCODEPAGE}
  if @self=TypeInfo(TSQLRawBlob) then
    result := CP_SQLRAWBLOB else
    if Kind in [{$ifdef FPC}tkAString,{$endif} tkLString] then
      result := PWord(AlignToPtr(@Name[ord(Name[0])+1]))^ else // from RTTI
  {$else}
  if @self=TypeInfo(RawUTF8) then
    result := CP_UTF8 else
................................................................................
          Int64ToUtf8(P^.GetInt64Prop(Value)));
      {$ifdef FPC}tkBool,{$endif} tkEnumeration, tkSet, tkInteger: begin
        V := P^.GetOrdProp(Value);
        //if V<>P^.Default then NO DEFAULT: update INI -> must override previous
        UpdateIniEntry(IniContent,Section,SubCompName+ToUTF8(P^.Name),
          Int32ToUtf8(V));
      end;
      {$ifdef HASVARUSTRING}tkUString,{$endif} {$ifdef FPC}tkAString,{$endif}
      tkLString, tkWString: begin
        P^.GetLongStrValue(Value,tmp);
        UpdateIniEntry(IniContent,Section,SubCompName+ToUTF8(P^.Name),tmp);
      end;
      tkClass:
      if Section='' then begin // recursive call works only as plain object
        Obj := P^.GetObjProp(Value);
        if (Obj<>nil) and Obj.InheritsFrom(TPersistent) then
          WriteObject(Value,IniContent,Section,SubCompName+ToUTF8(P^.Name)+'.');
      end;
      // tkString (shortstring) and tkInterface are not handled
................................................................................
        end;
      {$ifdef FPC}tkAString,{$endif} tkLString: 
        if wasString or (j2oIgnoreStringType in Options) then begin
          SetString(U,PAnsiChar(PropValue),StrLen(PropValue));
          P^.SetLongStrValue(Value,U);
        end else
          exit;
      {$ifdef HASVARUSTRING}
      tkUString:
        if wasString or (j2oIgnoreStringType in Options) then
          P^.SetUnicodeStrProp(Value,
            UTF8DecodeToUnicodeString(PropValue,StrLen(PropValue))) else
          exit;
      {$endif}
      tkWString:
................................................................................
          if err=0 then
            P^.SetFloatProp(Value,E);
        end;
      {$ifdef FPC}tkAString,{$endif} tkLString:
        P^.SetLongStrValue(Value,U);
      tkWString:
         P^.SetWideStrProp(Value,UTF8ToWideString(U));
      {$ifdef HASVARUSTRING}
      tkUString:
         P^.SetUnicodeStrProp(Value,UTF8ToString(U));
      {$endif}
      tkDynArray:
        P^.GetDynArray(Value).LoadFrom(pointer(BlobToTSQLRawBlob(U)));
{$ifdef PUBLISHRECORD}
      tkRecord{$ifdef FPC},tkObject{$endif}:
................................................................................
    Table: TSQLTable absolute Value;
    aClassType: TClass;
    Kind: TTypeKind;
    UtfP: PPUtf8CharArray;
    IsObj: TJSONObject;
    IsObjCustomIndex: integer;
    WS: WideString;
    {$ifdef HASVARUSTRING}
    US: UnicodeString;
    {$endif}
    tmp: RawByteString;
    dyn: TDynArray;
    dynObjArray: PClassInstance;
    {$ifndef NOVARIANTS}
    VVariant: variant;
................................................................................
            AddDateTime(P^.GetDoubleProp(Value));
            if woDateTimeWithZSuffix in Options then
              Add('Z');
            Add('"');
          end else
            Add(P^.GetFloatProp(Value),DOUBLE_PRECISION);
        end;
        {$ifdef HASVARUSTRING}
        tkUString: begin // write converted to UTF-8
          US := P^.GetUnicodeStrProp(Value);
          if (US<>'') or not (woDontStoreEmptyString in Options) then begin
            HR(P);
            Add('"');
            AddJSONEscapeW(pointer(US));
            Add('"');
................................................................................
      result := smvRawJSON else
    if P=TypeInfo(RawByteString) then
      result := smvRawByteString else
  {$ifndef UNICODE}
    if P=TypeInfo(AnsiString) then
      result := smvString else
      result := smvRawUTF8; // UTF-8 by default
  {$ifdef HASVARUSTRING}
  tkUString:
    result := smvRawUTF8;
  {$endif}
  {$else UNICODE}
      result := smvRawUTF8;
  tkUString:
    result := smvString;
  {$endif UNICODE}
  tkWString:
    result := smvWideString;
  tkClass:
    with P^.ClassType^ do
    if ClassHasPublishedFields(ClassType) or
       (JSONObject(ClassType,IsObjCustomIndex,[cpRead,cpWrite]) in
         [{$ifndef LVCL}oCollection,{$endif}oObjectList,oUtfs,oStrings,

          end;
        tkLString: begin
            CLE := TLabeledEdit.Create(Scroll);
            if P^.PropType^=TypeInfo(RawUTF8) then
              CLE.Text := U2S(P^.GetLongStrValue(Obj)) else
              CLE.Text := P^.GetGenericStringValue(Obj);
          end;
        {$ifdef UNICODE}
        tkUString: begin
            CLE := TLabeledEdit.Create(Scroll);
            CLE.Text := P^.GetUnicodeStrValue(Obj);
          end;
        {$endif}
        tkClass: begin
          O := pointer(P^.GetOrdValue(Obj));
................................................................................
          Application.ProcessMessages;
          CNE.SetFocus;                   // focus corresponding field
          ShowMessage(CNE.EditLabel.Caption+':'#13+E.Message,true);
          exit;
        end;
      end else
      if C.InheritsFrom(TLabeledEdit) then
        {$ifdef UNICODE}
        if P^.PropType^^.Kind=tkUString then
          P^.SetUnicodeStrValue(Obj,CLE.Text) else
        {$endif}
          if P^.PropType^=TypeInfo(RawUTF8) then
            P^.SetLongStrValue(Obj,S2U(CLE.Text)) else
            P^.SetGenericStringValue(Obj,CLE.Text) else
      if C.InheritsFrom(TCheckBox) then

          end;
        tkLString: begin
            CLE := TLabeledEdit.Create(Scroll);
            if P^.PropType^=TypeInfo(RawUTF8) then
              CLE.Text := U2S(P^.GetLongStrValue(Obj)) else
              CLE.Text := P^.GetGenericStringValue(Obj);
          end;
        {$ifdef HASVARUSTRING}
        tkUString: begin
            CLE := TLabeledEdit.Create(Scroll);
            CLE.Text := P^.GetUnicodeStrValue(Obj);
          end;
        {$endif}
        tkClass: begin
          O := pointer(P^.GetOrdValue(Obj));
................................................................................
          Application.ProcessMessages;
          CNE.SetFocus;                   // focus corresponding field
          ShowMessage(CNE.EditLabel.Caption+':'#13+E.Message,true);
          exit;
        end;
      end else
      if C.InheritsFrom(TLabeledEdit) then
        {$ifdef HASVARUSTRING}
        if P^.PropType^^.Kind=tkUString then
          P^.SetUnicodeStrValue(Obj,CLE.Text) else
        {$endif}
          if P^.PropType^=TypeInfo(RawUTF8) then
            P^.SetLongStrValue(Obj,S2U(CLE.Text)) else
            P^.SetGenericStringValue(Obj,CLE.Text) else
      if C.InheritsFrom(TCheckBox) then

          raise ESynBidirSocket.CreateUTF8('%.GetFrame: received %, expected %',
            [self,OpcodeText(opcode)^,OpcodeText(Frame.opcode)^]);
      GetData(data);
      Frame.payload := Frame.payload+data;
    end;
    if (fProtocol<>nil) and (Frame.payload<>'') then
      fProtocol.AfterGetFrame(Frame);
    {$ifdef UNICODE}
    if opcode=focText then
      SetCodePage(Frame.payload,CP_UTF8,false); // identify text value as UTF-8
    {$endif}
    Log(frame,'GetFrame');
    SetLastPingTicks;
    result := true;
  finally

          raise ESynBidirSocket.CreateUTF8('%.GetFrame: received %, expected %',
            [self,OpcodeText(opcode)^,OpcodeText(Frame.opcode)^]);
      GetData(data);
      Frame.payload := Frame.payload+data;
    end;
    if (fProtocol<>nil) and (Frame.payload<>'') then
      fProtocol.AfterGetFrame(Frame);
    {$ifdef HASCODEPAGE}
    if opcode=focText then
      SetCodePage(Frame.payload,CP_UTF8,false); // identify text value as UTF-8
    {$endif}
    Log(frame,'GetFrame');
    SetLastPingTicks;
    result := true;
  finally

  /// a pointer to a variant array
  PVariantArray = ^TVariantArray;

  /// a dynamic array of variant values
  TVariantDynArray = array of variant;
{$endif}

/// RawUnicode is an Unicode String stored in an AnsiString
// - faster than WideString, which are allocated in Global heap (for COM)
// - an AnsiChar(#0) is added at the end, for having a true WideChar(#0) at ending
// - length(RawUnicode) returns memory bytes count: use (length(RawUnicode) shr 1)
// for WideChar count (that's why the definition of this type since Delphi 2009
// is AnsiString(1200) and not UnicodeString)
// - pointer(RawUnicode) is compatible with Win32 'Wide' API call
// - mimic Delphi 2009 UnicodeString, without the WideString or Ansi conversion overhead
// - all conversion to/from AnsiString or RawUTF8 must be explicit

  {$ifdef UNICODE}
  RawUnicode = type AnsiString(CP_UTF16); // Codepage for an UnicodeString
  {$else}
  RawUnicode = type AnsiString;
  {$endif}

  /// RawUTF8 is an UTF-8 String stored in an AnsiString
  // - use this type instead of System.UTF8String, which behavior changed
  // between Delphi 2009 compiler and previous versions: our implementation
  // is consistent and compatible with all versions of Delphi compiler
  // - mimic Delphi 2009 UTF8String, without the charset conversion overhead
  // - all conversion to/from AnsiString or RawUnicode must be explicit
  {$ifdef UNICODE}
  RawUTF8 = type AnsiString(CP_UTF8); // Codepage for an UTF8 string
  {$else}
  RawUTF8 = type AnsiString;
  {$endif}

  /// WinAnsiString is a WinAnsi-encoded AnsiString (code page 1252)
  // - use this type instead of System.String, which behavior changed
  // between Delphi 2009 compiler and previous versions: our implementation
  // is consistent and compatible with all versions of Delphi compiler
  // - all conversion to/from RawUTF8 or RawUnicode must be explicit
  {$ifdef UNICODE}
  WinAnsiString = type AnsiString(1252); // WinAnsi Codepage
  {$else}
  WinAnsiString = type AnsiString;
  {$endif}

{$ifndef UNICODE}





  /// define RawByteString, as it does exist in Delphi 2009+
  // - to be used for byte storage into an AnsiString
  // - use this type if you don't want the Delphi compiler not to do any
  // code page conversions when you assign a typed AnsiString to a RawByteString,
  // i.e. a RawUTF8 or a WinAnsiString
  RawByteString = type AnsiString;
  /// pointer to a RawByteString
  PRawByteString = ^RawByteString;
{$endif}

  /// RawJSON will indicate that this variable content would stay in raw JSON
  // - i.e. won't be serialized into values
  // - could be any JSON content: number, string, object or array
  // - e.g. interface-based service will use it for efficient and AJAX-ready
  // transmission of TSQLTableJSON result
  RawJSON = type RawUTF8;
................................................................................
function UTF8DecodeToUnicodeString(const S: RawUTF8): UnicodeString; overload; inline;

/// convert our UTF-8 encoded buffer into a Delphi 2009+ Unicode string
// - this function is the same as direct assignment, since RawUTF8=AnsiString(CP_UTF8),
// but is faster, since use no Win32 API call
procedure UTF8DecodeToUnicodeString(P: PUTF8Char; L: integer; var result: UnicodeString); overload;

{$endif HASVARUSTRING}

{$ifdef UNICODE}

/// convert a Delphi 2009+ Unicode string into a WinAnsi (code page 1252) string
function UnicodeStringToWinAnsi(const S: string): WinAnsiString; inline;

/// convert our UTF-8 encoded buffer into a Delphi 2009+ Unicode string
// - this function is the same as direct assignment, since RawUTF8=AnsiString(CP_UTF8),
// but is faster, since use no Win32 API call
function UTF8DecodeToUnicodeString(P: PUTF8Char; L: integer): UnicodeString; overload; inline;
................................................................................
// - this function is faster than default RTL, since use no Win32 API call
function WinAnsiToUnicodeString(WinAnsi: PAnsiChar; WinAnsiLen: integer): UnicodeString; overload;

/// convert a Win-Ansi string into a Delphi 2009+ Unicode string
// - this function is faster than default RTL, since use no Win32 API call
function WinAnsiToUnicodeString(const WinAnsi: WinAnsiString): UnicodeString; inline; overload;

{$endif UNICODE}

/// convert any generic VCL Text into an UTF-8 encoded String
// - it's prefered to use TLanguageFile.StringToUTF8() method in mORMoti18n,
// which will handle full i18n of your application
// - it will work as is with Delphi 2009+ (direct unicode conversion)
// - under older version of Delphi (no unicode), it will use the
// current RTL codepage, as with WideString conversion (but without slow
................................................................................
  {$ifdef UNICODE}inline;{$endif}

/// convert any UTF-8 encoded buffer into a generic VCL Text
procedure UTF8DecodeToString(P: PUTF8Char; L: integer; var result: string); overload;

/// convert any UTF-8 encoded String into a generic WideString Text
function UTF8ToWideString(const Text: RawUTF8): WideString; overload;
  {$ifdef UNICODE}inline;{$endif}

/// convert any UTF-8 encoded String into a generic WideString Text
procedure UTF8ToWideString(const Text: RawUTF8; var result: WideString); overload;
  {$ifdef UNICODE}inline;{$endif}

/// convert any UTF-8 encoded String into a generic WideString Text
procedure UTF8ToWideString(Text: PUTF8Char; Len: integer; var result: WideString); overload;

/// convert any UTF-8 encoded String into a generic SynUnicode Text
function UTF8ToSynUnicode(const Text: RawUTF8): SynUnicode; overload;

................................................................................
// - just a wrapper around PosEx(substr,str,1)
function Pos(const substr, str: RawUTF8): Integer; overload; inline;
{$endif UNICODE}

/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - only useful if our Enhanced Runtime (or LVCL) library is not installed
function Int64ToUtf8(Value: Int64): RawByteString; overload;
  {$ifdef PUREPASCAL}{$ifdef HASINLINE}inline;{$endif}{$endif}

/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - only useful if our Enhanced Runtime (or LVCL) library is not installed
function Int32ToUtf8(Value: integer): RawByteString; overload;
  {$ifdef PUREPASCAL}{$ifdef HASINLINE}inline;{$endif}{$endif}

/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - result as var parameter saves a local assignment and a try..finally
procedure Int32ToUTF8(Value: integer; var result: RawUTF8); overload;
  {$ifdef HASINLINE}inline;{$endif}
................................................................................
/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - result as var parameter saves a local assignment and a try..finally
procedure Int64ToUtf8(Value: Int64; var result: RawUTF8); overload;
  {$ifdef HASINLINE}inline;{$endif}

/// use our fast RawUTF8 version of IntToStr()
function ToUTF8(Value: PtrInt): RawByteString; overload;
  {$ifdef HASINLINE}inline;{$endif}

{$ifndef CPU64}
/// use our fast RawUTF8 version of IntToStr()
function ToUTF8(Value: Int64): RawByteString; overload;
  {$ifdef PUREPASCAL}{$ifdef HASINLINE}inline;{$endif}{$endif}
{$endif}

/// optimized conversion of a cardinal into RawUTF8
function UInt32ToUtf8(Value: cardinal): RawByteString; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// optimized conversion of a cardinal into RawUTF8
procedure UInt32ToUtf8(Value: cardinal; var result: RawUTF8); overload;
  {$ifdef HASINLINE}inline;{$endif}

/// faster version than default SysUtils.IntToStr implementation
................................................................................
// - warning: will encode generic string fields as AnsiString (one byte per char)
// prior to Delphi 2009, and as UnicodeString (two bytes per char) since Delphi
// 2009: if you want to use this function between UNICODE and NOT UNICODE
// versions of Delphi, you should use some explicit types like RawUTF8,
// WinAnsiString, SynUnicode or even RawUnicode/WideString
function RecordSave(const Rec; Dest: PAnsiChar; TypeInfo: pointer): PAnsiChar; overload;

/// save a record content into a Base-64 encoded RawByteString content
// - will use RecordSave() format, with a left-sided binary CRC
function RecordSaveBase64(const Rec; TypeInfo: pointer; UriCompatible: boolean=false): RawByteString;

/// compute the number of bytes needed to save a record content
// using the RecordSave() function
// - will return 0 in case of an invalid (not handled) record type (e.g. if
// it contains an unknown variant)
function RecordSaveLength(const Rec; TypeInfo: pointer): integer;

................................................................................
function HexDisplayToBin(Hex: PAnsiChar; Bin: PByte; BinBytes: integer): boolean;

/// fast conversion from hexa chars into a cardinal
function HexDisplayToCardinal(Hex: PAnsiChar; out aValue: cardinal): boolean;
    {$ifndef FPC}{$ifdef HASINLINE}inline;{$endif}{$endif}
    // inline gives an error under release conditions with FPC

/// fast conversion from binary data into Base64 encoded text
function BinToBase64(const s: RawByteString): RawByteString; overload;

/// fast conversion from binary data into Base64 encoded text
function BinToBase64(Bin: PAnsiChar; BinBytes: integer): RawByteString; overload;

/// fast conversion from binary data into Base64-like URI-compatible encoded text
// - will trim any right-sided '=' unsignificant characters, and replace
// '+' or '/' by '_' or '-'
function BinToBase64URI(Bin: PAnsiChar; BinBytes: integer): RawByteString;

/// conversion from any Base64 encoded value into URI-compatible encoded text
// - will trim any right-sided '=' unsignificant characters, and replace
// '+' or '/' by '_' or '-'
procedure Base64ToURI(var base64: RawByteString);

/// conversion from URI-compatible encoded text into its original Base64 value
// - will add any right-sided '=' unsignificant characters, and replace back
// '_' or '-' by '+' or '/'
procedure Base64FromURI(var base64: RawByteString);

/// fast conversion from binary data into Base64 encoded text
// with JSON_BASE64_MAGIC prefix (UTF-8 encoded \uFFF0 special code)
function BinToBase64WithMagic(const s: RawByteString): RawByteString; overload;

/// fast conversion from binary data into Base64 encoded text
// with JSON_BASE64_MAGIC prefix (UTF-8 encoded \uFFF0 special code)
function BinToBase64WithMagic(Data: pointer; DataLen: integer): RawByteString; overload;

/// fast conversion from Base64 encoded text into binary data
function Base64ToBin(const s: RawByteString): RawByteString; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// fast conversion from Base64 encoded text into binary data
function Base64ToBin(sp: PAnsiChar; len: PtrInt): RawByteString; overload;
................................................................................
    result := '' else begin
    if SourceChars<SizeOf(tmpA)shr fAnsiCharShift then
      SetString(result,tmpA,Utf8BufferToAnsi(tmpA,Source,SourceChars)-tmpA) else begin
      Getmem(A,(SourceChars+1) shl fAnsiCharShift);
      SetString(result,A,Utf8BufferToAnsi(A,Source,SourceChars)-A);
      FreeMem(A);
    end;
    {$ifdef UNICODE}
    SetCodePage(result,fCodePage,false);
    {$endif}
  end;
end;

function TSynAnsiConvert.UTF8ToAnsi(const UTF8: RawUTF8): RawByteString;
begin
................................................................................
    result := '' else begin
    if SourceChars<SizeOf(tmpA)shr fAnsiCharShift then
      SetString(result,tmpA,UnicodeBufferToAnsi(tmpA,Source,SourceChars)-tmpA) else begin
      Getmem(A,(SourceChars+1) shl fAnsiCharShift);
      SetString(result,A,UnicodeBufferToAnsi(A,Source,SourceChars)-A);
      FreeMem(A);
    end;
    {$ifdef UNICODE}
    SetCodePage(result,fCodePage,false);
    {$endif}
  end;
end;

function TSynAnsiConvert.RawUnicodeToAnsi(const Source: RawUnicode): RawByteString;
begin
................................................................................
  if SourceChars<sizeof(tmpU) shr 1 then
    result := UnicodeBufferToAnsi(tmpU,
      (PtrUInt(From.AnsiBufferToUnicode(tmpU,Source,SourceChars))-PtrUInt(@tmpU))shr 1) else begin
    GetMem(U,SourceChars*2+2);
    result := UnicodeBufferToAnsi(U,From.AnsiBufferToUnicode(U,Source,SourceChars)-U);
    FreeMem(U);
  end;



end;


{ TSynAnsiFixedWidth }

function TSynAnsiFixedWidth.AnsiBufferToUnicode(Dest: PWideChar;
  Source: PAnsiChar; SourceChars: Cardinal): PWideChar;
................................................................................
begin
  SetString(Result,Source,SourceChars);
end;

function TSynAnsiUTF8.UTF8ToAnsi(const UTF8: RawUTF8): RawByteString;
begin
  result := UTF8;



end;

function TSynAnsiUTF8.AnsiToUTF8(const AnsiText: RawByteString): RawUTF8;
begin
  result := AnsiText;



end;

function TSynAnsiUTF8.AnsiBufferToRawUTF8(Source: PAnsiChar; SourceChars: Cardinal): RawUTF8;
begin
  SetString(Result,Source,SourceChars);
end;

................................................................................
    Dest[j] := AnsiChar((ucs4 and $3f)+$80);
    ucs4 := ucs4 shr 6;
  end;
  Dest^ := AnsiChar(ToByte(ucs4) or UTF8_FIRSTBYTE[result]);
end;

procedure AnyAnsiToUTF8(const s: RawByteString; var result: RawUTF8);
{$ifdef UNICODE}var CodePage: Cardinal;{$endif}
begin
  if s='' then
    result := '' else begin
    {$ifdef UNICODE}
    CodePage := StringCodePage(s);
    if (CodePage=CP_UTF8) or (CodePage=CP_RAWBYTESTRING) then
      result := s else
      result := TSynAnsiConvert.Engine(CodePage).
    {$else}
    result := CurrentAnsiConvert.
    {$endif}
................................................................................
  if L<sizeof(short)div 3 then
    SetString(result,short,UTF8ToWideChar(short,P,L) shr 1) else begin
    GetMem(U,L*3+2); // maximum posible unicode size (if all <#128)
    SetString(result,U,UTF8ToWideChar(U,P,L) shr 1);
    FreeMem(U);
  end;
end;
{$endif}

{$ifdef UNICODE}
function UnicodeStringToWinAnsi(const S: string): WinAnsiString;
begin
  result := RawUnicodeToWinAnsi(pointer(S),length(S));
end;

function UTF8DecodeToUnicodeString(P: PUTF8Char; L: integer): UnicodeString;
begin
................................................................................
end;

function WinAnsiToUnicodeString(const WinAnsi: WinAnsiString): UnicodeString;
begin
  result := WinAnsiToUnicodeString(pointer(WinAnsi),length(WinAnsi));
end;

{$endif}

{$ifdef UNICODE}
function Ansi7ToString(const Text: RawByteString): string;
var i: integer;
begin
  SetString(result,nil,length(Text));
  for i := 0 to length(Text)-1 do
................................................................................
    end;
    vtAnsiString: begin // expect UTF-8 content
      Res.Text := pointer(V.VAnsiString);
      Res.Len := length(RawUTF8(V.VAnsiString));
      result := Res.Len;
      exit;
    end;
    {$ifdef UNICODE}
    vtUnicodeString:
      RawUnicodeToUtf8(V.VPWideChar,length(UnicodeString(V.VUnicodeString)),tmpStr);
    {$endif}
    vtWideString:
      RawUnicodeToUtf8(V.VPWideChar,length(WideString(V.VWideString)),tmpStr);
    vtPChar: begin
      Res.Text := V.VPointer;
................................................................................
  isString := not (V.VType in [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended]);
  with V do
  case V.VType of
    vtString:
      SetRawUTF8(result,@VString^[1],ord(VString^[0]));
    vtAnsiString:
      result := RawUTF8(VAnsiString); // expect UTF-8 content
    {$ifdef UNICODE}
    vtUnicodeString:
      result := UnicodeStringToUtf8(string(VUnicodeString));
    {$endif}
    vtWideString:
      RawUnicodeToUtf8(VWideString,length(WideString(VWideString)),result);
    vtPChar:
      SetRawUTF8(result,VPChar,StrLen(VPChar));
    vtChar:
      SetRawUTF8(result,PAnsiChar(@VChar),1);
................................................................................
    Curr64ToStr(VInt64,result);
  varDate: begin
    wasString := true;
    DateTimeToIso8601TextVar(VDate,'T',result);
  end;
  varString: begin
    wasString := true;
  {$ifdef UNICODE}
    AnyAnsiToUTF8(RawByteString(VString),result);
  {$else}
    result := RawUTF8(VString);
  {$endif}
  end;
  {$ifdef HASVARUSTRING}
  varUString: begin
................................................................................
  else
  if SetVariantUnRefSimpleValue(V,tmp) then
    VariantToUTF8(Variant(tmp),result,wasString) else
  if VType=varVariant or varByRef then // complex varByRef
    VariantToUTF8(PVariant(VPointer)^,result,wasString) else
  if VType=varByRef or varString then begin
    wasString := true;
    {$ifdef UNICODE}
      AnyAnsiToUTF8(PRawByteString(VString)^,result);
    {$else}
      result := PRawUTF8(VString)^;
    {$endif}
  end else
  if VType=varByRef or varOleStr then begin
    wasString := true;
................................................................................

{$ifndef PUREPASCAL} { these functions are implemented in asm }
{$ifndef LVCL} { don't define these functions twice }
{$ifndef FPC}  { these asm function use some low-level system.pas calls }

{$define OWNI2S}

function Int32ToUTF8(Value : integer): RawByteString; // 3x faster than SysUtils.IntToStr
// from IntToStr32_JOH_IA32_6_a, adapted for Delphi 2009+
asm // eax=Value, edx=@result
  push   ebx
  push   edi
  push   esi
  mov    ebx,eax                {Value}
  sar    ebx,31                 {0 for +ve Value or -1 for -ve Value}
................................................................................
  mov    [ecx],ax                {Save Final 2 Digits}
  ret
@@LastDigit:
  or     al,'0'                  {Ascii Adjustment}
  mov    [ecx],al                {Save Final Digit}
end;

function Int64ToUTF8(Value: Int64): RawByteString;
// from IntToStr64_JOH_IA32_6_b, adapted for Delphi 2009+
asm
  push   ebx
  mov    ecx, [ebp+8]            {Low Integer of Value}
  mov    edx, [ebp+12]           {High Integer of Value}
  xor    ebp, ebp                {Clear Sign Flag (EBP Already Pushed)}
  mov    ebx, ecx                {Low Integer of Value}
................................................................................
  SetLength(result,Gen-pointer(result));
  inc(maxParam);
end;


{$ifndef OWNI2S}

function Int32ToUTF8(Value : integer): RawByteString; // faster than SysUtils.IntToStr
var tmp: array[0..15] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt32(@tmp[15],Value);
  SetString(result,P,@tmp[15]-P);
end;

function Int64ToUtf8(Value: Int64): RawByteString; // faster than SysUtils.IntToStr
var tmp: array[0..23] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt64(@tmp[23],Value);
  SetString(result,P,@tmp[23]-P);
end;

{$endif}

{$ifndef CPU64} // already implemented by ToUTF8(Value: PtrInt) below
function ToUTF8(Value: Int64): RawByteString;
var tmp: array[0..23] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt64(@tmp[23],Value);
  SetString(result,P,@tmp[23]-P);
end;
{$endif}

function ToUTF8(Value: PtrInt): RawByteString;
var tmp: array[0..15] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt32(@tmp[15],Value);
  SetString(result,P,@tmp[15]-P);
end;

function UInt32ToUTF8(Value: Cardinal): RawByteString;
var tmp: array[0..15] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrUInt32(@tmp[15],Value);
  SetString(result,P,@tmp[15]-P);
end;

................................................................................
end;

function BinToBase64Length(len: PtrUInt): PtrUInt;
begin
  result := ((len+2)div 3)*4;
end;

function BinToBase64(const s: RawByteString): RawByteString;
var len: integer;
begin
  result := '';
  len := length(s);
  if len=0 then
    exit;
  SetLength(result,BinToBase64Length(len));
  Base64Encode(pointer(result),pointer(s),len);
end;

function BinToBase64(Bin: PAnsiChar; BinBytes: integer): RawByteString;
begin
  result := '';
  if BinBytes=0 then
    exit;
  SetLength(result,BinToBase64Length(BinBytes));
  Base64Encode(pointer(result),Bin,BinBytes);
end;

procedure Base64ToURI(var base64: RawByteString);
var P: PUTF8Char;
begin
  {$ifdef FPC}
  UniqueString(base64); // @base64[1] won't call UniqueString() under FPC :(
  {$endif}
  P := @base64[1];
  if P<>nil then
................................................................................
        break;
      end;
      end;
      inc(P);
    until false;
end;

procedure Base64FromURI(var base64: RawByteString);
var P: PUTF8Char;
    len,i,append: integer;
begin
  len := length(base64);
  if len=0 then
    exit;
  {$ifdef FPC}
................................................................................
  if append<>4 then begin // add unsignificant trailing '=' characters
    SetLength(base64,len+append);
    for i := len+1 to len+append do
      base64[i] := '=';
  end;
end;

function BinToBase64URI(Bin: PAnsiChar; BinBytes: integer): RawByteString;
begin
  result := BinToBase64(Bin,BinBytes);
  Base64ToURI(result);
end;

function BinToBase64WithMagic(const s: RawByteString): RawByteString;
var len: integer;
begin
  result:='';
  len := length(s);
  if len=0 then
    exit;
  SetLength(result,((len+2) div 3)*4+3);
  PInteger(pointer(result))^ := JSON_BASE64_MAGIC;
  Base64Encode(PAnsiChar(pointer(result))+3,pointer(s),len);
end;

function BinToBase64WithMagic(Data: pointer; DataLen: integer): RawByteString; overload;
begin
  result:='';
  if DataLen<=0 then
    exit;
  SetLength(result,((DataLen+2) div 3)*4+3);
  PInteger(pointer(result))^ := JSON_BASE64_MAGIC;
  Base64Encode(PAnsiChar(pointer(result))+3,Data,DataLen);
................................................................................
    while S[L]<=' ' do dec(L);
    result := Copy(S,I,L-I+1);
  end;
end;
{$endif}

{$IFDEF PUREPASCAL}
{$IFDEF UNICODE}
function Trim(const S: RawUTF8): RawUTF8;
var I,L: Integer;
begin
  L := Length(S);
  I := 1;
  while (I<=L) and (S[I]<=' ') do inc(I);
  if I>L then
................................................................................
     j := PosEx(endboundary,Body,i); // try last boundary
     if j=0 then
      exit;
    end;
    part.Content := copy(Body,i,j-i-2); // -2 to ignore latest #13#10
    if (part.ContentType='') or (PosEx('-8',part.ContentType)>0) then begin
      part.ContentType := TEXT_CONTENT_TYPE;
      {$ifdef UNICODE}
      SetCodePage(part.Content,CP_UTF8,false); // ensure raw field value is UTF-8
      {$endif}
    end else
    if IdemPropNameU(part.Encoding,'base64') then
      part.Content := Base64ToBin(part.Content);
    // note: "quoted-printable" not yet handled here
    SetLength(MultiPart,length(MultiPart)+1);
................................................................................
procedure FromVarString(var Source: PByte; var Value: RawByteString; CodePage: integer);
var Len: PtrUInt;
begin
  Len := FromVarUInt32(Source);
  if Len=0 then
    exit;
  SetString(Value,PAnsiChar(Source),Len);
  {$ifdef UNICODE}
  SetCodePage(Value,CodePage,false);
  {$endif}
  inc(Source,Len);
end;

function FromVarBlob(Data: PByte): TValueResult;
begin
................................................................................
        if PAnsiString(A)^=PAnsiString(B)^ then
          Diff := sizeof(pointer) else
          exit;
      tkWString:
        if PWideString(A)^=PWideString(B)^ then
          Diff := sizeof(pointer) else
          exit;
      {$ifdef UNICODE}
      tkUString:
        if PUnicodeString(A)^=PUnicodeString(B)^ then
          Diff := sizeof(pointer) else
          exit;
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}:
        if RecordEquals(A^,B^,Field^.TypeInfo{$ifndef FPC}^{$endif}) then
................................................................................
        inc(result,DynArray.SaveToLength-sizeof(PtrUInt));
      end;
      tkLString,tkWString{$ifdef FPC},tkLStringOld{$endif}:
        // length stored within WideString is in bytes
        if P^=0 then
          dec(result,sizeof(PtrUInt)-1) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(P^-STRRECSIZE))^.length)-sizeof(PtrUInt));
      {$ifdef UNICODE}
      tkUString:
        if P^=0 then
          dec(result,sizeof(PtrUInt)-1) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(P^-STRRECSIZE))^.length*2)-sizeof(PtrUInt));
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}: begin
        Len := RecordSaveLength(P^,Field.TypeInfo{$ifndef FPC}^{$endif});
................................................................................
    Kind := Field.TypeInfo^.Kind;
    case Kind of
    tkDynArray: begin
      DynArray.Init(Field.TypeInfo{$ifndef FPC}^{$endif},R^);
      Dest := DynArray.SaveTo(Dest);
      Diff := sizeof(PtrUInt); // size of tkDynArray in record
    end;
    tkLString, tkWString {$ifdef UNICODE}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}: begin
      if PPtrUInt(R)^=0 then
        LenBytes := 0 else
        LenBytes := PStrRec(Pointer(PPtrUInt(R)^-STRRECSIZE))^.length;
      {$ifdef UNICODE} // WideString has length in bytes, UnicodeString in WideChars
      if Kind=tkUString then
        LenBytes := LenBytes*2;
      {$endif}
      Dest := pointer(ToVarUInt32(LenBytes,pointer(Dest)));
      if LenBytes>0 then begin
        MoveFast(pointer(PPtrUInt(R)^)^,Dest^,LenBytes);
        inc(Dest,LenBytes);
................................................................................
begin
  Len := RecordSaveLength(Rec,TypeInfo);
  SetString(result,nil,Len);
  if Len<>0 then
    RecordSave(Rec,pointer(result),TypeInfo);
end;

function RecordSaveBase64(const Rec; TypeInfo: pointer; UriCompatible: boolean): RawByteString;
var len: integer;
    data: RawByteString;
    dat: PAnsiChar;
begin
  result := '';
  len := RecordSaveLength(Rec,TypeInfo);
  if len=0 then
................................................................................
  if UriCompatible then
    Base64ToURI(result);
end;

function RecordLoadBase64(Source: PAnsiChar; Len: integer; var Rec;
  TypeInfo: pointer; UriCompatible: boolean): boolean;
var data: RawByteString;

begin
  result := false;
  if Len<=6 then
    exit;
  if UriCompatible then begin
    SetString(data,Source,Len);
    Base64FromURI(data);
    data := Base64ToBin(data);
  end else
    data := Base64ToBin(Source,Len);
  Len := length(data);
  if Len<=4 then
    exit;
  Source := PAnsiChar(pointer(data))+4;
  if crc32c(0,Source,Len-4)=PCardinal(data)^ then
................................................................................
    Kind := Field.TypeInfo^.Kind;
    case Kind of
    tkDynArray: begin
      DynArray.Init(Field.TypeInfo{$ifndef FPC}^{$endif},R^);
      Source := DynArray.LoadFrom(Source);
      Diff := sizeof(PtrUInt); // size of tkDynArray in record
    end;
    tkLString, tkWString {$ifdef UNICODE}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}: begin
      LenBytes := FromVarUInt32(PByte(Source));
      case Kind of
        tkLString{$ifdef FPC},tkLStringOld{$endif}: begin
          SetString(PRawByteString(R)^,Source,LenBytes);
          {$ifdef UNICODE}
          { Delphi 2009+: set Code page for this AnsiString }
          if LenBytes<>0 then
            SetCodePage(PRawByteString(R)^,PWord(PtrUInt(Field.TypeInfo^)+
              Field.TypeInfo^^.NameLen+2)^,false);
          {$endif}
        end;
        tkWString:
          SetString(PWideString(R)^,PWideChar(Source),LenBytes shr 1);
        {$ifdef UNICODE}
        tkUString:
          SetString(PString(R)^,PWideChar(Source),LenBytes shr 1);
        {$endif}
      end;
      inc(Source,LenBytes);
      Diff := sizeof(PtrUInt); // size of tkLString+tkWString+tkUString in record
    end;
................................................................................
      if VType and VTYPE_STATIC<>0 then
        VarClear(Value);
      VType := varString;
      VAny := nil; // avoid GPF below when assigning a string variable to VAny
      if Txt='' then
        exit;
    end;
    {$ifdef UNICODE}
    if (PByte(Txt)<>nil) and (PWord(PByte(Txt)-12)^=CP_RAWBYTESTRING) then
      PWord(PByte(Txt)-12)^ := CP_UTF8; // force explicit UTF-8
    {$endif}
    RawByteString(VAny) := Txt;
  end;
end;

function RawUTF8ToVariant(const Txt: RawUTF8): variant;
begin
  RawUTF8ToVariant(Txt,result);
end;
................................................................................
  if Value.VType and VTYPE_STATIC<>0 then
    VarClear(variant(Value));
  Value.VType := ExpectedValueType;
  Value.VAny := nil; // avoid GPF below
  if Txt<>'' then
  case ExpectedValueType of
    varString: begin
      {$ifdef UNICODE}
      if PWord(PByte(Txt)-12)^=CP_RAWBYTESTRING then
        PWord(PByte(Txt)-12)^ := CP_UTF8; // force explicit UTF-8
      {$endif}
      RawByteString(Value.VAny) := Txt;
    end;
    varOleStr:
      UTF8ToWideString(Txt,WideString(Value.VAny));
    {$ifdef HASVARUSTRING}
    varUString:
      UTF8DecodeToUnicodeString(pointer(Txt),length(Txt),UnicodeString(Value.VAny));
    {$endif}
................................................................................
    vtVariant:
      result := V.VVariant^;
    vtAnsiString: begin
      VType := varString;
      VAny := nil;
      RawByteString(VAny) := RawByteString(V.VAnsiString);
    end;
    vtString, {$ifdef UNICODE}vtUnicodeString,{$endif}
    vtPChar, vtChar, vtWideChar, vtWideString, vtClass: begin
      VType := varString;
      VAny := nil; // avoid GPF on next line
      VarRecToUTF8(V,RawUTF8(VAny));
    end;
    vtObject: // class instance will be serialized as a TDocVariant
      ObjectToVariant(V.VObject,result);
................................................................................
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
      // binary types: store as once
      n := n*integer(ElemSize);
      MoveFast(P^,Dest^,n);
      inc(Dest,n);
    end else
    case PTypeKind(ElemType)^ of
    tkLString, tkWString {$ifdef UNICODE}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}: begin
      for i := 1 to n do begin
        if PPtrUInt(P)^=0 then
          LenBytes := 0 else begin
          LenBytes := PStrRec(Pointer(PPtrUInt(P)^-STRRECSIZE))^.length;
          {$ifdef UNICODE} // WideString length in bytes, UnicodeString in WideChars
          if PTypeKind(ElemType)^=tkUString then
            LenBytes := LenBytes*2;
          {$endif}
        end;
        Dest := pointer(ToVarUInt32(LenBytes,pointer(Dest)));
        if LenBytes>0 then begin
          MoveFast(pointer(PPtrUInt(P)^)^,Dest^,LenBytes);
................................................................................
    tkLString, tkWString{$ifdef FPC}, tkLStringOld{$endif}:
      for i := 1 to n do begin
        if PPtrUInt(P)^=0 then
          inc(result) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(PPtrUInt(P)^-STRRECSIZE))^.length));
        inc(P,sizeof(PtrUInt));
      end;
    {$ifdef UNICODE}
    tkUString: // WideString has length in bytes, UnicodeString in WideChars
      for i := 1 to n do begin
        if PPtrUInt(P)^=0 then
          inc(result) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(PPtrUInt(P)^-STRRECSIZE))^.length*2));
        inc(P,sizeof(PtrUInt));
      end;
................................................................................
      [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
    // binary type was stored as once
    n := n*integer(ElemSize);
    MoveFast(Source^,P^,n);
    inc(Source,n);
  end else
  case PTypeKind(ElemType)^ of
    tkLString, tkWString {$ifdef UNICODE}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}:
    for i := 1 to n do begin
      LenBytes := FromVarUInt32(PByte(Source));
      case PTypeKind(ElemType)^ of
      tkLString{$ifdef FPC},tkLStringOld{$endif}: begin
        SetString(PRawByteString(P)^,Source,LenBytes);
        {$ifdef UNICODE}
        { Delphi 2009+: set Code page for this AnsiString }
        if LenBytes<>0 then
          SetCodePage(PRawByteString(P)^,PWord(PtrUInt(ElemType)+
            PTypeInfo(ElemType)^.NameLen+2)^,false);
        {$endif}
      end;
      tkWString:
        SetString(PWideString(P)^,PWideChar(Source),LenBytes shr 1);
      {$ifdef UNICODE}
      tkUString:
        SetString(PString(P)^,PWideChar(Source),LenBytes shr 1);
      {$endif}
      end;
      inc(Source,LenBytes);
      inc(P,sizeof(PtrUInt));
    end;
................................................................................
    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 UNICODE}
    tkUString:
      result := UnicodeString(A)=UnicodeString(B);
    {$endif}
    tkInterface:
      result := pointer(A)=pointer(B);
    {$ifndef NOVARIANTS}
    tkVariant:
................................................................................
    for i := 0 to n-1 do
      if AnsiString(A1^[i])<>AnsiString(A2^[i]) then
        exit;
  tkWString:
    for i := 0 to n-1 do
      if WideString(A1^[i])<>WideString(A2^[i]) then
        exit;
  {$ifdef UNICODE}
  tkUString:
    for i := 0 to n-1 do
      if UnicodeString(A1^[i])<>UnicodeString(A2^[i]) then
        exit;
  {$endif}
  tkInterface:
    if not CompareMem(P1,P2,SizeOf(pointer)*cardinal(n)) then
................................................................................
  case PTypeKind(ElemType)^ of
  tkLString{$ifdef FPC},tkLStringOld{$endif}:
    for result := 0 to max do
      if AnsiString(PPtrIntArray(P)^[result])=AnsiString(Elem) then exit;
  tkWString:
    for result := 0 to max do
      if WideString(PPtrIntArray(P)^[result])=WideString(Elem) then exit;
  {$ifdef UNICODE}
  tkUString:
    for result := 0 to max do
      if UnicodeString(PPtrIntArray(P)^[result])=UnicodeString(Elem) then exit;
  {$endif}
  {$ifndef NOVARIANTS}
  tkVariant:
    for result := 0 to max do
................................................................................
    case PTypeKind(ElemType)^ of // release reference counted
      tkLString{$ifdef FPC},tkLStringOld{$endif}:
        RawByteString(Elem) := '';
      tkWString:
        WideString(Elem) := '';
      tkInterface:
        IUnknown(Elem) := nil;
      {$ifdef UNICODE}
      tkUString:
        UnicodeString(Elem) := '';
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}:
        RecordClear(Elem,ElemType);
      tkDynArray:
        _DynArrayClear(pointer(Elem),ElemType);
................................................................................
        WideString(B) := WideString(A);
        exit;
      end;
      tkInterface: begin
        IUnknown(B) := IUnknown(A);
        exit;
      end;
      {$ifdef UNICODE}
      tkUString: begin
        UnicodeString(B) := UnicodeString(A);
        exit;
      end;
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}: begin
        RecordCopy(B,A,ElemType);
................................................................................
  if Source=nil then
    exit; // avoid GPF
  if ElemType=nil then
    MoveFast(Source^,Elem,ElemSize) else
    case PTypeKind(ElemType)^ of
    tkLString{$ifdef FPC},tkLStringOld{$endif}: begin
      SetString(RawByteString(Elem),Source+4,PInteger(Source)^);
      {$ifdef UNICODE}
      { Delphi 2009+: set Code page for this AnsiString }
      if PPtrUInt(@Elem)^<>0 then
        SetCodePage(RawByteString(Elem),PWord(PtrUInt(ElemType)+
          PTypeInfo(ElemType)^.NameLen+2)^,false);
      {$endif}
    end;
    tkWString: // WideString internal length is in bytes
      SetString(WideString(Elem),PWideChar(Source+4),PInteger(Source)^ shr 1);
    {$ifdef UNICODE}
    tkUString:
      SetString(UnicodeString(Elem),PWideChar(Source+4),PInteger(Source)^);
    {$endif}
    {$ifndef NOVARIANTS}
    tkVariant:
      VariantLoad(variant(Elem),Source,@JSON_OPTIONS[true]);
    {$endif}
................................................................................
begin
  if (ElemType<>nil) and (length(ElemLoaded)=integer(ElemSize)) then
  case PTypeKind(ElemType)^ of
    tkLString{$ifdef FPC},tkLStringOld{$endif}:
      PRawByteString(pointer(ElemLoaded))^ := '';
    tkWString:
      PWideString(pointer(ElemLoaded))^ := '';
    {$ifdef UNICODE}
    tkUString:
      PUnicodeString(pointer(ElemLoaded))^ := '';
    {$endif}
    {$ifndef NOVARIANTS}
    tkVariant:
      VarClear(PVariant(pointer(ElemLoaded))^);
    {$endif}
................................................................................
      tkLString, tkWString, tkLStringOld:
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else begin
          LenBytes := PStrRec(Pointer(PPtrInt(@Elem)^-STRRECSIZE))^.length;
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),LenBytes+sizeof(integer));
          PInteger(result)^ := LenBytes;
        end;
      {$ifdef UNICODE}
      tkUString:
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else begin
          LenBytes := PStrRec(Pointer(PPtrInt(@Elem)^-STRRECSIZE))^.length;
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),LenBytes*2+sizeof(integer));
          PInteger(result)^ := LenBytes;
        end;
      end;
      {$endif}
      {$else FPC}
      tkLString, tkWString: // WideString internal length is in bytes
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),
            PInteger(PPtrInt(@Elem)^-sizeof(integer))^+sizeof(integer));
      {$ifdef UNICODE}
      tkUString:
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),
            PInteger(PPtrInt(@Elem)^-sizeof(integer))^*2+sizeof(integer));
      {$endif}
      {$endif FPC}
................................................................................

{$ifdef UNICODE}

function HashUnicodeString(const Elem; Hasher: THasher): cardinal;
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,Pointer(PtrUInt(Elem)),
      {$ifdef FPC}PStrRec(Pointer(PtrUInt(Elem)-STRRECSIZE))^.length
      {$else}PInteger(PtrUInt(Elem)-sizeof(integer))^{$endif}*2);
end;

function HashUnicodeStringI(const Elem; Hasher: THasher): cardinal;
var tmp: array[byte] of AnsiChar; // avoid slow heap allocation
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
................................................................................

{$endif UNICODE}

function HashSynUnicode(const Elem; Hasher: THasher): cardinal;
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,Pointer(PtrUInt(Elem)),
      {$ifdef FPC}PStrRec(Pointer(PtrUInt(Elem)-STRRECSIZE))^.length
      {$else}PInteger(PtrUInt(Elem)-sizeof(integer))^{$endif}
      {$ifdef UNICODE}*sizeof(WideChar){$endif});
      // WideString internal size is in bytes, UnicodeString is in WideChars
end;

function HashSynUnicodeI(const Elem; Hasher: THasher): cardinal;
var tmp: array[byte] of AnsiChar; // avoid slow heap allocation
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
................................................................................
    result := Hasher(0,tmp,UpperCopy255W(tmp,SynUnicode(Elem))-tmp);
end;

function HashWideString(const Elem; Hasher: THasher): cardinal;
begin // WideString internal size is in bytes, not WideChar
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,Pointer(PtrUInt(Elem)),
      {$ifdef FPC}PStrRec(Pointer(PtrUInt(Elem)-STRRECSIZE))^.length
      {$else}PInteger(PtrUInt(Elem)-sizeof(integer))^{$endif});
end;

function HashWideStringI(const Elem; Hasher: THasher): cardinal;
var tmp: array[byte] of AnsiChar; // avoid slow heap allocation
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,tmp,UpperCopy255W(tmp,pointer(Elem),Length(WideString(Elem)))-tmp);
end;

function HashPtrUInt(const Elem; Hasher: THasher): cardinal;
begin
{$ifdef CPU64}
  result := Hasher(0,@Elem,sizeof(PtrUInt));
{$else}
  result := (PtrUInt(Elem) shr 4)+1; // naive but optimal for TDynArrayHashed
{$endif}
end;

function HashPointer(const Elem; Hasher: THasher): cardinal;
begin
  result := Hasher(0,@Elem,sizeof(pointer));
end;

................................................................................
  varDate:     AddDateTime(@VDate,'T','"');
  varCurrency: AddCurr64(VInt64);
  varBoolean:  Add(VBoolean);
  varVariant:  AddVariant(PVariant(VPointer)^,Escape,ForcedSerializeAsNonExtendedJson);
  varString: begin
    if Escape=twJSONEscape then
      Add('"');
    {$ifdef UNICODE}
    AddAnyAnsiString(RawByteString(VString),Escape);
    {$else}  // VString is expected to be a RawUTF8
    Add(VAny,length(RawUTF8(VAny)),Escape);
    {$endif}
    if Escape=twJSONEscape then
      Add('"');
  end;
................................................................................
  end;
  else
  if VType=varVariant or varByRef then
    AddVariant(PVariant(VPointer)^,Escape,ForcedSerializeAsNonExtendedJson) else
  if VType=varByRef or varString then begin
    if Escape=twJSONEscape then
      Add('"');
    {$ifdef UNICODE}
    AddAnyAnsiString(PRawByteString(VAny)^,Escape);
    {$else}  // VString is expected to be a RawUTF8
    Add(PPointer(VAny)^,length(PRawUTF8(VAny)^),Escape);
    {$endif}
    if Escape=twJSONEscape then
      Add('"');
  end else
................................................................................
  if L=0 then
    exit;
  if PInteger(s)^ and $ffffff=JSON_BASE64_MAGIC then begin
    AddNoJSONEscape(pointer(s),L); // identified as a BLOB content
    exit;
  end;
  if CodePage<0 then
    {$ifdef UNICODE}
    CodePage := StringCodePage(s);
    {$else}
    CodePage := 0; // TSynAnsiConvert.Engine(0)=CurrentAnsiConvert
    {$endif}
  AddAnyAnsiBuffer(pointer(s),L,Escape,CodePage);
end;

................................................................................
end;

procedure TTextWriter.AddJSONEscape(const V: TVarRec);
begin
  with V do
  case VType of
    vtPointer: AddShort('null');
    vtString, vtAnsiString,{$ifdef UNICODE}vtUnicodeString,{$endif}
    vtPChar, vtChar, vtWideChar, vtWideString, vtClass: begin
      Add('"');
      case VType of
        vtString:     AddJSONEscape(@VString^[1],ord(VString^[0]));
        vtAnsiString: AddJSONEscape(pointer(RawUTF8(VAnsiString)));
    {$ifdef UNICODE}
        vtUnicodeString: AddJSONEscapeW(
          pointer(string(VUnicodeString)),length(string(VUnicodeString)));
    {$endif}
        vtPChar:      AddJSONEscape(VPChar);
        vtChar:       AddJSONEscape(@VChar,1);
        vtWideChar:   AddJSONEscapeW(@VWideChar,1);
        vtWideString: AddJSONEscapeW(VWideString);
        vtClass:      AddClassName(VClass);
      end;
      Add('"');
................................................................................
      AddW(VWideString,length(WideString(VWideString)),Escape);
  vtInt64:
    Add(VInt64^);
  {$ifndef NOVARIANTS}
  vtVariant:
    AddVariant(VVariant^,Escape);
  {$endif}
  {$ifdef UNICODE}
  vtUnicodeString:
    if VUnicodeString<>nil then // convert to UTF-8
      AddW(VUnicodeString,length(UnicodeString(VUnicodeString)),Escape);
  {$endif} end;
end;

{$ifndef NOVARIANTS}
................................................................................
begin
  FlushFinal;
  Len := fTotalFileSize-fInitialStreamPosition;
  if Len=0 then
    result := '' else
  if fStream.InheritsFrom(TRawByteStringStream) then
    with TRawByteStringStream(fStream) do
    if fInitialStreamPosition=0 then



      result := DataString else

      SetRawUTF8(result,PAnsiChar(pointer(DataString))+fInitialStreamPosition,Len) else
  if fStream.InheritsFrom(TCustomMemoryStream) then
    with TCustomMemoryStream(fStream) do
    SetRawUTF8(result,PAnsiChar(Memory)+fInitialStreamPosition,Len) else begin
    FastNewRawUTF8(result,Len);
    fStream.Seek(fInitialStreamPosition,soBeginning);
    fStream.Read(pointer(result)^,Len);

  /// a pointer to a variant array
  PVariantArray = ^TVariantArray;

  /// a dynamic array of variant values
  TVariantDynArray = array of variant;
{$endif}

  /// RawUnicode is an Unicode String stored in an AnsiString
  // - faster than WideString, which are allocated in Global heap (for COM)
  // - an AnsiChar(#0) is added at the end, for having a true WideChar(#0) at ending
  // - length(RawUnicode) returns memory bytes count: use (length(RawUnicode) shr 1)
  // for WideChar count (that's why the definition of this type since Delphi 2009
  // is AnsiString(1200) and not UnicodeString)
  // - pointer(RawUnicode) is compatible with Win32 'Wide' API call
  // - mimic Delphi 2009 UnicodeString, without the WideString or Ansi conversion overhead
  // - all conversion to/from AnsiString or RawUTF8 must be explicit: the
  // compiler is not able to make valid implicit conversion on CP_UTF16
  {$ifdef HASCODEPAGE}
  RawUnicode = type AnsiString(CP_UTF16); // Codepage for an UnicodeString
  {$else}
  RawUnicode = type AnsiString;
  {$endif}

  /// RawUTF8 is an UTF-8 String stored in an AnsiString
  // - use this type instead of System.UTF8String, which behavior changed
  // between Delphi 2009 compiler and previous versions: our implementation
  // is consistent and compatible with all versions of Delphi compiler
  // - mimic Delphi 2009 UTF8String, without the charset conversion overhead
  // - all conversion to/from AnsiString or RawUnicode must be explicit
  {$ifdef HASCODEPAGE}
  RawUTF8 = type AnsiString(CP_UTF8); // Codepage for an UTF8 string
  {$else}
  RawUTF8 = type AnsiString;
  {$endif}

  /// WinAnsiString is a WinAnsi-encoded AnsiString (code page 1252)
  // - use this type instead of System.String, which behavior changed
  // between Delphi 2009 compiler and previous versions: our implementation
  // is consistent and compatible with all versions of Delphi compiler
  // - all conversion to/from RawUTF8 or RawUnicode must be explicit
  {$ifdef HASCODEPAGE}
  WinAnsiString = type AnsiString(CODEPAGE_US); // WinAnsi Codepage
  {$else}
  WinAnsiString = type AnsiString;
  {$endif}

  {$ifdef HASCODEPAGE}
  {$ifdef FPC}
  // missing declaration
  PRawByteString = ^RawByteString;
  {$endif}
  {$else}
  /// define RawByteString, as it does exist in Delphi 2009+
  // - to be used for byte storage into an AnsiString
  // - use this type if you don't want the Delphi compiler not to do any
  // code page conversions when you assign a typed AnsiString to a RawByteString,
  // i.e. a RawUTF8 or a WinAnsiString
  RawByteString = type AnsiString;
  /// pointer to a RawByteString
  PRawByteString = ^RawByteString;
  {$endif}

  /// RawJSON will indicate that this variable content would stay in raw JSON
  // - i.e. won't be serialized into values
  // - could be any JSON content: number, string, object or array
  // - e.g. interface-based service will use it for efficient and AJAX-ready
  // transmission of TSQLTableJSON result
  RawJSON = type RawUTF8;
................................................................................
function UTF8DecodeToUnicodeString(const S: RawUTF8): UnicodeString; overload; inline;

/// convert our UTF-8 encoded buffer into a Delphi 2009+ Unicode string
// - this function is the same as direct assignment, since RawUTF8=AnsiString(CP_UTF8),
// but is faster, since use no Win32 API call
procedure UTF8DecodeToUnicodeString(P: PUTF8Char; L: integer; var result: UnicodeString); overload;





/// convert a Delphi 2009+ Unicode string into a WinAnsi (code page 1252) string
function UnicodeStringToWinAnsi(const S: string): WinAnsiString; inline;

/// convert our UTF-8 encoded buffer into a Delphi 2009+ Unicode string
// - this function is the same as direct assignment, since RawUTF8=AnsiString(CP_UTF8),
// but is faster, since use no Win32 API call
function UTF8DecodeToUnicodeString(P: PUTF8Char; L: integer): UnicodeString; overload; inline;
................................................................................
// - this function is faster than default RTL, since use no Win32 API call
function WinAnsiToUnicodeString(WinAnsi: PAnsiChar; WinAnsiLen: integer): UnicodeString; overload;

/// convert a Win-Ansi string into a Delphi 2009+ Unicode string
// - this function is faster than default RTL, since use no Win32 API call
function WinAnsiToUnicodeString(const WinAnsi: WinAnsiString): UnicodeString; inline; overload;

{$endif HASVARUSTRING}

/// convert any generic VCL Text into an UTF-8 encoded String
// - it's prefered to use TLanguageFile.StringToUTF8() method in mORMoti18n,
// which will handle full i18n of your application
// - it will work as is with Delphi 2009+ (direct unicode conversion)
// - under older version of Delphi (no unicode), it will use the
// current RTL codepage, as with WideString conversion (but without slow
................................................................................
  {$ifdef UNICODE}inline;{$endif}

/// convert any UTF-8 encoded buffer into a generic VCL Text
procedure UTF8DecodeToString(P: PUTF8Char; L: integer; var result: string); overload;

/// convert any UTF-8 encoded String into a generic WideString Text
function UTF8ToWideString(const Text: RawUTF8): WideString; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// convert any UTF-8 encoded String into a generic WideString Text
procedure UTF8ToWideString(const Text: RawUTF8; var result: WideString); overload;
  {$ifdef HASINLINE}inline;{$endif}

/// convert any UTF-8 encoded String into a generic WideString Text
procedure UTF8ToWideString(Text: PUTF8Char; Len: integer; var result: WideString); overload;

/// convert any UTF-8 encoded String into a generic SynUnicode Text
function UTF8ToSynUnicode(const Text: RawUTF8): SynUnicode; overload;

................................................................................
// - just a wrapper around PosEx(substr,str,1)
function Pos(const substr, str: RawUTF8): Integer; overload; inline;
{$endif UNICODE}

/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - only useful if our Enhanced Runtime (or LVCL) library is not installed
function Int64ToUtf8(Value: Int64): RawUTF8; overload;
  {$ifdef PUREPASCAL}{$ifdef HASINLINE}inline;{$endif}{$endif}

/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - only useful if our Enhanced Runtime (or LVCL) library is not installed
function Int32ToUtf8(Value: integer): RawUTF8; overload;
  {$ifdef PUREPASCAL}{$ifdef HASINLINE}inline;{$endif}{$endif}

/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - result as var parameter saves a local assignment and a try..finally
procedure Int32ToUTF8(Value: integer; var result: RawUTF8); overload;
  {$ifdef HASINLINE}inline;{$endif}
................................................................................
/// use our fast RawUTF8 version of IntToStr()
// - without any slow UnicodeString=String->AnsiString conversion for Delphi 2009
// - result as var parameter saves a local assignment and a try..finally
procedure Int64ToUtf8(Value: Int64; var result: RawUTF8); overload;
  {$ifdef HASINLINE}inline;{$endif}

/// use our fast RawUTF8 version of IntToStr()
function ToUTF8(Value: PtrInt): RawUTF8; overload;
  {$ifdef HASINLINE}inline;{$endif}

{$ifndef CPU64}
/// use our fast RawUTF8 version of IntToStr()
function ToUTF8(Value: Int64): RawUTF8; overload;
  {$ifdef PUREPASCAL}{$ifdef HASINLINE}inline;{$endif}{$endif}
{$endif}

/// optimized conversion of a cardinal into RawUTF8
function UInt32ToUtf8(Value: cardinal): RawUTF8; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// optimized conversion of a cardinal into RawUTF8
procedure UInt32ToUtf8(Value: cardinal; var result: RawUTF8); overload;
  {$ifdef HASINLINE}inline;{$endif}

/// faster version than default SysUtils.IntToStr implementation
................................................................................
// - warning: will encode generic string fields as AnsiString (one byte per char)
// prior to Delphi 2009, and as UnicodeString (two bytes per char) since Delphi
// 2009: if you want to use this function between UNICODE and NOT UNICODE
// versions of Delphi, you should use some explicit types like RawUTF8,
// WinAnsiString, SynUnicode or even RawUnicode/WideString
function RecordSave(const Rec; Dest: PAnsiChar; TypeInfo: pointer): PAnsiChar; overload;

/// save a record content into a Base-64 encoded UTF-8 text content
// - will use RecordSave() format, with a left-sided binary CRC
function RecordSaveBase64(const Rec; TypeInfo: pointer; UriCompatible: boolean=false): RawUTF8;

/// compute the number of bytes needed to save a record content
// using the RecordSave() function
// - will return 0 in case of an invalid (not handled) record type (e.g. if
// it contains an unknown variant)
function RecordSaveLength(const Rec; TypeInfo: pointer): integer;

................................................................................
function HexDisplayToBin(Hex: PAnsiChar; Bin: PByte; BinBytes: integer): boolean;

/// fast conversion from hexa chars into a cardinal
function HexDisplayToCardinal(Hex: PAnsiChar; out aValue: cardinal): boolean;
    {$ifndef FPC}{$ifdef HASINLINE}inline;{$endif}{$endif}
    // inline gives an error under release conditions with FPC

/// fast conversion from binary data into Base64 encoded UTF-8 text
function BinToBase64(const s: RawByteString): RawUTF8; overload;

/// fast conversion from binary data into Base64 encoded UTF-8 text
function BinToBase64(Bin: PAnsiChar; BinBytes: integer): RawUTF8; overload;

/// fast conversion from binary data into Base64-like URI-compatible encoded text
// - will trim any right-sided '=' unsignificant characters, and replace
// '+' or '/' by '_' or '-'
function BinToBase64URI(Bin: PAnsiChar; BinBytes: integer): RawUTF8;

/// conversion from any Base64 encoded value into URI-compatible encoded text
// - will trim any right-sided '=' unsignificant characters, and replace
// '+' or '/' by '_' or '-'
procedure Base64ToURI(var base64: RawUTF8);

/// conversion from URI-compatible encoded text into its original Base64 value
// - will add any right-sided '=' unsignificant characters, and replace back
// '_' or '-' by '+' or '/'
procedure Base64FromURI(var base64: RawUTF8);

/// fast conversion from binary data into Base64 encoded UTF-8 text
// with JSON_BASE64_MAGIC prefix (UTF-8 encoded \uFFF0 special code)
function BinToBase64WithMagic(const s: RawByteString): RawUTF8; overload;

/// fast conversion from binary data into Base64 encoded UTF-8 text
// with JSON_BASE64_MAGIC prefix (UTF-8 encoded \uFFF0 special code)
function BinToBase64WithMagic(Data: pointer; DataLen: integer): RawUTF8; overload;

/// fast conversion from Base64 encoded text into binary data
function Base64ToBin(const s: RawByteString): RawByteString; overload;
  {$ifdef HASINLINE}inline;{$endif}

/// fast conversion from Base64 encoded text into binary data
function Base64ToBin(sp: PAnsiChar; len: PtrInt): RawByteString; overload;
................................................................................
    result := '' else begin
    if SourceChars<SizeOf(tmpA)shr fAnsiCharShift then
      SetString(result,tmpA,Utf8BufferToAnsi(tmpA,Source,SourceChars)-tmpA) else begin
      Getmem(A,(SourceChars+1) shl fAnsiCharShift);
      SetString(result,A,Utf8BufferToAnsi(A,Source,SourceChars)-A);
      FreeMem(A);
    end;
    {$ifdef HASCODEPAGE}
    SetCodePage(result,fCodePage,false);
    {$endif}
  end;
end;

function TSynAnsiConvert.UTF8ToAnsi(const UTF8: RawUTF8): RawByteString;
begin
................................................................................
    result := '' else begin
    if SourceChars<SizeOf(tmpA)shr fAnsiCharShift then
      SetString(result,tmpA,UnicodeBufferToAnsi(tmpA,Source,SourceChars)-tmpA) else begin
      Getmem(A,(SourceChars+1) shl fAnsiCharShift);
      SetString(result,A,UnicodeBufferToAnsi(A,Source,SourceChars)-A);
      FreeMem(A);
    end;
    {$ifdef HASCODEPAGE}
    SetCodePage(result,fCodePage,false);
    {$endif}
  end;
end;

function TSynAnsiConvert.RawUnicodeToAnsi(const Source: RawUnicode): RawByteString;
begin
................................................................................
  if SourceChars<sizeof(tmpU) shr 1 then
    result := UnicodeBufferToAnsi(tmpU,
      (PtrUInt(From.AnsiBufferToUnicode(tmpU,Source,SourceChars))-PtrUInt(@tmpU))shr 1) else begin
    GetMem(U,SourceChars*2+2);
    result := UnicodeBufferToAnsi(U,From.AnsiBufferToUnicode(U,Source,SourceChars)-U);
    FreeMem(U);
  end;
  {$ifdef HASCODEPAGE}
  SetCodePage(result,fCodePage,false);
  {$endif}
end;


{ TSynAnsiFixedWidth }

function TSynAnsiFixedWidth.AnsiBufferToUnicode(Dest: PWideChar;
  Source: PAnsiChar; SourceChars: Cardinal): PWideChar;
................................................................................
begin
  SetString(Result,Source,SourceChars);
end;

function TSynAnsiUTF8.UTF8ToAnsi(const UTF8: RawUTF8): RawByteString;
begin
  result := UTF8;
  {$ifdef HASCODEPAGE}
  SetCodePage(result,CP_UTF8,false);
  {$endif}
end;

function TSynAnsiUTF8.AnsiToUTF8(const AnsiText: RawByteString): RawUTF8;
begin
  result := AnsiText;
  {$ifdef HASCODEPAGE}
  SetCodePage(RawByteString(result),CP_UTF8,false);
  {$endif}
end;

function TSynAnsiUTF8.AnsiBufferToRawUTF8(Source: PAnsiChar; SourceChars: Cardinal): RawUTF8;
begin
  SetString(Result,Source,SourceChars);
end;

................................................................................
    Dest[j] := AnsiChar((ucs4 and $3f)+$80);
    ucs4 := ucs4 shr 6;
  end;
  Dest^ := AnsiChar(ToByte(ucs4) or UTF8_FIRSTBYTE[result]);
end;

procedure AnyAnsiToUTF8(const s: RawByteString; var result: RawUTF8);
{$ifdef HASCODEPAGE}var CodePage: Cardinal;{$endif}
begin
  if s='' then
    result := '' else begin
    {$ifdef HASCODEPAGE}
    CodePage := StringCodePage(s);
    if (CodePage=CP_UTF8) or (CodePage=CP_RAWBYTESTRING) then
      result := s else
      result := TSynAnsiConvert.Engine(CodePage).
    {$else}
    result := CurrentAnsiConvert.
    {$endif}
................................................................................
  if L<sizeof(short)div 3 then
    SetString(result,short,UTF8ToWideChar(short,P,L) shr 1) else begin
    GetMem(U,L*3+2); // maximum posible unicode size (if all <#128)
    SetString(result,U,UTF8ToWideChar(U,P,L) shr 1);
    FreeMem(U);
  end;
end;



function UnicodeStringToWinAnsi(const S: string): WinAnsiString;
begin
  result := RawUnicodeToWinAnsi(pointer(S),length(S));
end;

function UTF8DecodeToUnicodeString(P: PUTF8Char; L: integer): UnicodeString;
begin
................................................................................
end;

function WinAnsiToUnicodeString(const WinAnsi: WinAnsiString): UnicodeString;
begin
  result := WinAnsiToUnicodeString(pointer(WinAnsi),length(WinAnsi));
end;

{$endif HASVARUSTRING}

{$ifdef UNICODE}
function Ansi7ToString(const Text: RawByteString): string;
var i: integer;
begin
  SetString(result,nil,length(Text));
  for i := 0 to length(Text)-1 do
................................................................................
    end;
    vtAnsiString: begin // expect UTF-8 content
      Res.Text := pointer(V.VAnsiString);
      Res.Len := length(RawUTF8(V.VAnsiString));
      result := Res.Len;
      exit;
    end;
    {$ifdef HASVARUSTRING}
    vtUnicodeString:
      RawUnicodeToUtf8(V.VPWideChar,length(UnicodeString(V.VUnicodeString)),tmpStr);
    {$endif}
    vtWideString:
      RawUnicodeToUtf8(V.VPWideChar,length(WideString(V.VWideString)),tmpStr);
    vtPChar: begin
      Res.Text := V.VPointer;
................................................................................
  isString := not (V.VType in [vtBoolean,vtInteger,vtInt64,vtCurrency,vtExtended]);
  with V do
  case V.VType of
    vtString:
      SetRawUTF8(result,@VString^[1],ord(VString^[0]));
    vtAnsiString:
      result := RawUTF8(VAnsiString); // expect UTF-8 content
    {$ifdef HASVARUSTRING}
    vtUnicodeString:
      result := UnicodeStringToUtf8(UnicodeString(VUnicodeString));
    {$endif}
    vtWideString:
      RawUnicodeToUtf8(VWideString,length(WideString(VWideString)),result);
    vtPChar:
      SetRawUTF8(result,VPChar,StrLen(VPChar));
    vtChar:
      SetRawUTF8(result,PAnsiChar(@VChar),1);
................................................................................
    Curr64ToStr(VInt64,result);
  varDate: begin
    wasString := true;
    DateTimeToIso8601TextVar(VDate,'T',result);
  end;
  varString: begin
    wasString := true;
  {$ifdef HASCODEPAGE}
    AnyAnsiToUTF8(RawByteString(VString),result);
  {$else}
    result := RawUTF8(VString);
  {$endif}
  end;
  {$ifdef HASVARUSTRING}
  varUString: begin
................................................................................
  else
  if SetVariantUnRefSimpleValue(V,tmp) then
    VariantToUTF8(Variant(tmp),result,wasString) else
  if VType=varVariant or varByRef then // complex varByRef
    VariantToUTF8(PVariant(VPointer)^,result,wasString) else
  if VType=varByRef or varString then begin
    wasString := true;
    {$ifdef HASCODEPAGE}
      AnyAnsiToUTF8(PRawByteString(VString)^,result);
    {$else}
      result := PRawUTF8(VString)^;
    {$endif}
  end else
  if VType=varByRef or varOleStr then begin
    wasString := true;
................................................................................

{$ifndef PUREPASCAL} { these functions are implemented in asm }
{$ifndef LVCL} { don't define these functions twice }
{$ifndef FPC}  { these asm function use some low-level system.pas calls }

{$define OWNI2S}

function Int32ToUTF8(Value : integer): RawUtf8; // 3x faster than SysUtils.IntToStr
// from IntToStr32_JOH_IA32_6_a, adapted for Delphi 2009+
asm // eax=Value, edx=@result
  push   ebx
  push   edi
  push   esi
  mov    ebx,eax                {Value}
  sar    ebx,31                 {0 for +ve Value or -1 for -ve Value}
................................................................................
  mov    [ecx],ax                {Save Final 2 Digits}
  ret
@@LastDigit:
  or     al,'0'                  {Ascii Adjustment}
  mov    [ecx],al                {Save Final Digit}
end;

function Int64ToUTF8(Value: Int64): RawUtf8;
// from IntToStr64_JOH_IA32_6_b, adapted for Delphi 2009+
asm
  push   ebx
  mov    ecx, [ebp+8]            {Low Integer of Value}
  mov    edx, [ebp+12]           {High Integer of Value}
  xor    ebp, ebp                {Clear Sign Flag (EBP Already Pushed)}
  mov    ebx, ecx                {Low Integer of Value}
................................................................................
  SetLength(result,Gen-pointer(result));
  inc(maxParam);
end;


{$ifndef OWNI2S}

function Int32ToUTF8(Value : integer): RawUTF8; // faster than SysUtils.IntToStr
var tmp: array[0..15] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt32(@tmp[15],Value);
  SetString(result,P,@tmp[15]-P);
end;

function Int64ToUtf8(Value: Int64): RawUTF8; // faster than SysUtils.IntToStr
var tmp: array[0..23] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt64(@tmp[23],Value);
  SetString(result,P,@tmp[23]-P);
end;

{$endif}

{$ifndef CPU64} // already implemented by ToUTF8(Value: PtrInt) below
function ToUTF8(Value: Int64): RawUTF8;
var tmp: array[0..23] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt64(@tmp[23],Value);
  SetString(result,P,@tmp[23]-P);
end;
{$endif}

function ToUTF8(Value: PtrInt): RawUTF8;
var tmp: array[0..15] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrInt32(@tmp[15],Value);
  SetString(result,P,@tmp[15]-P);
end;

function UInt32ToUTF8(Value: Cardinal): RawUTF8;
var tmp: array[0..15] of AnsiChar;
    P: PAnsiChar;
begin
  P := StrUInt32(@tmp[15],Value);
  SetString(result,P,@tmp[15]-P);
end;

................................................................................
end;

function BinToBase64Length(len: PtrUInt): PtrUInt;
begin
  result := ((len+2)div 3)*4;
end;

function BinToBase64(const s: RawByteString): RawUTF8;
var len: integer;
begin
  result := '';
  len := length(s);
  if len=0 then
    exit;
  SetLength(result,BinToBase64Length(len));
  Base64Encode(pointer(result),pointer(s),len);
end;

function BinToBase64(Bin: PAnsiChar; BinBytes: integer): RawUTF8;
begin
  result := '';
  if BinBytes=0 then
    exit;
  SetLength(result,BinToBase64Length(BinBytes));
  Base64Encode(pointer(result),Bin,BinBytes);
end;

procedure Base64ToURI(var base64: RawUTF8);
var P: PUTF8Char;
begin
  {$ifdef FPC}
  UniqueString(base64); // @base64[1] won't call UniqueString() under FPC :(
  {$endif}
  P := @base64[1];
  if P<>nil then
................................................................................
        break;
      end;
      end;
      inc(P);
    until false;
end;

procedure Base64FromURI(var base64: RawUTF8);
var P: PUTF8Char;
    len,i,append: integer;
begin
  len := length(base64);
  if len=0 then
    exit;
  {$ifdef FPC}
................................................................................
  if append<>4 then begin // add unsignificant trailing '=' characters
    SetLength(base64,len+append);
    for i := len+1 to len+append do
      base64[i] := '=';
  end;
end;

function BinToBase64URI(Bin: PAnsiChar; BinBytes: integer): RawUTF8;
begin
  result := BinToBase64(Bin,BinBytes);
  Base64ToURI(result);
end;

function BinToBase64WithMagic(const s: RawByteString): RawUTF8;
var len: integer;
begin
  result:='';
  len := length(s);
  if len=0 then
    exit;
  SetLength(result,((len+2) div 3)*4+3);
  PInteger(pointer(result))^ := JSON_BASE64_MAGIC;
  Base64Encode(PAnsiChar(pointer(result))+3,pointer(s),len);
end;

function BinToBase64WithMagic(Data: pointer; DataLen: integer): RawUTF8; overload;
begin
  result:='';
  if DataLen<=0 then
    exit;
  SetLength(result,((DataLen+2) div 3)*4+3);
  PInteger(pointer(result))^ := JSON_BASE64_MAGIC;
  Base64Encode(PAnsiChar(pointer(result))+3,Data,DataLen);
................................................................................
    while S[L]<=' ' do dec(L);
    result := Copy(S,I,L-I+1);
  end;
end;
{$endif}

{$IFDEF PUREPASCAL}
{$IFDEF HASCODEPAGE}
function Trim(const S: RawUTF8): RawUTF8;
var I,L: Integer;
begin
  L := Length(S);
  I := 1;
  while (I<=L) and (S[I]<=' ') do inc(I);
  if I>L then
................................................................................
     j := PosEx(endboundary,Body,i); // try last boundary
     if j=0 then
      exit;
    end;
    part.Content := copy(Body,i,j-i-2); // -2 to ignore latest #13#10
    if (part.ContentType='') or (PosEx('-8',part.ContentType)>0) then begin
      part.ContentType := TEXT_CONTENT_TYPE;
      {$ifdef HASCODEPAGE}
      SetCodePage(part.Content,CP_UTF8,false); // ensure raw field value is UTF-8
      {$endif}
    end else
    if IdemPropNameU(part.Encoding,'base64') then
      part.Content := Base64ToBin(part.Content);
    // note: "quoted-printable" not yet handled here
    SetLength(MultiPart,length(MultiPart)+1);
................................................................................
procedure FromVarString(var Source: PByte; var Value: RawByteString; CodePage: integer);
var Len: PtrUInt;
begin
  Len := FromVarUInt32(Source);
  if Len=0 then
    exit;
  SetString(Value,PAnsiChar(Source),Len);
  {$ifdef HASCODEPAGE}
  SetCodePage(Value,CodePage,false);
  {$endif}
  inc(Source,Len);
end;

function FromVarBlob(Data: PByte): TValueResult;
begin
................................................................................
        if PAnsiString(A)^=PAnsiString(B)^ then
          Diff := sizeof(pointer) else
          exit;
      tkWString:
        if PWideString(A)^=PWideString(B)^ then
          Diff := sizeof(pointer) else
          exit;
      {$ifdef HASVARUSTRING}
      tkUString:
        if PUnicodeString(A)^=PUnicodeString(B)^ then
          Diff := sizeof(pointer) else
          exit;
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}:
        if RecordEquals(A^,B^,Field^.TypeInfo{$ifndef FPC}^{$endif}) then
................................................................................
        inc(result,DynArray.SaveToLength-sizeof(PtrUInt));
      end;
      tkLString,tkWString{$ifdef FPC},tkLStringOld{$endif}:
        // length stored within WideString is in bytes
        if P^=0 then
          dec(result,sizeof(PtrUInt)-1) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(P^-STRRECSIZE))^.length)-sizeof(PtrUInt));
      {$ifdef HASVARUSTRING}
      tkUString:
        if P^=0 then
          dec(result,sizeof(PtrUInt)-1) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(P^-STRRECSIZE))^.length*2)-sizeof(PtrUInt));
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}: begin
        Len := RecordSaveLength(P^,Field.TypeInfo{$ifndef FPC}^{$endif});
................................................................................
    Kind := Field.TypeInfo^.Kind;
    case Kind of
    tkDynArray: begin
      DynArray.Init(Field.TypeInfo{$ifndef FPC}^{$endif},R^);
      Dest := DynArray.SaveTo(Dest);
      Diff := sizeof(PtrUInt); // size of tkDynArray in record
    end;
    tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}: begin
      if PPtrUInt(R)^=0 then
        LenBytes := 0 else
        LenBytes := PStrRec(Pointer(PPtrUInt(R)^-STRRECSIZE))^.length;
      {$ifdef HASVARUSTRING} // WideString has length in bytes, UnicodeString in WideChars
      if Kind=tkUString then
        LenBytes := LenBytes*2;
      {$endif}
      Dest := pointer(ToVarUInt32(LenBytes,pointer(Dest)));
      if LenBytes>0 then begin
        MoveFast(pointer(PPtrUInt(R)^)^,Dest^,LenBytes);
        inc(Dest,LenBytes);
................................................................................
begin
  Len := RecordSaveLength(Rec,TypeInfo);
  SetString(result,nil,Len);
  if Len<>0 then
    RecordSave(Rec,pointer(result),TypeInfo);
end;

function RecordSaveBase64(const Rec; TypeInfo: pointer; UriCompatible: boolean): RawUTF8;
var len: integer;
    data: RawByteString;
    dat: PAnsiChar;
begin
  result := '';
  len := RecordSaveLength(Rec,TypeInfo);
  if len=0 then
................................................................................
  if UriCompatible then
    Base64ToURI(result);
end;

function RecordLoadBase64(Source: PAnsiChar; Len: integer; var Rec;
  TypeInfo: pointer; UriCompatible: boolean): boolean;
var data: RawByteString;
    uri: RawUTF8;
begin
  result := false;
  if Len<=6 then
    exit;
  if UriCompatible then begin
    SetString(uri,Source,Len);
    Base64FromURI(uri);
    data := Base64ToBin(uri);
  end else
    data := Base64ToBin(Source,Len);
  Len := length(data);
  if Len<=4 then
    exit;
  Source := PAnsiChar(pointer(data))+4;
  if crc32c(0,Source,Len-4)=PCardinal(data)^ then
................................................................................
    Kind := Field.TypeInfo^.Kind;
    case Kind of
    tkDynArray: begin
      DynArray.Init(Field.TypeInfo{$ifndef FPC}^{$endif},R^);
      Source := DynArray.LoadFrom(Source);
      Diff := sizeof(PtrUInt); // size of tkDynArray in record
    end;
    tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}: begin
      LenBytes := FromVarUInt32(PByte(Source));
      case Kind of
        tkLString{$ifdef FPC},tkLStringOld{$endif}: begin
          SetString(PRawByteString(R)^,Source,LenBytes);
          {$ifdef HASCODEPAGE}
          { Delphi 2009+: set Code page for this AnsiString }
          if LenBytes<>0 then
            SetCodePage(PRawByteString(R)^,PWord(PtrUInt(Field.TypeInfo{$ifndef FPC}^{$endif})+
              Field.TypeInfo{$ifndef FPC}^{$endif}^.NameLen+2)^,false);
          {$endif}
        end;
        tkWString:
          SetString(PWideString(R)^,PWideChar(Source),LenBytes shr 1);
        {$ifdef HASVARUSTRING}
        tkUString:
          SetString(PString(R)^,PWideChar(Source),LenBytes shr 1);
        {$endif}
      end;
      inc(Source,LenBytes);
      Diff := sizeof(PtrUInt); // size of tkLString+tkWString+tkUString in record
    end;
................................................................................
      if VType and VTYPE_STATIC<>0 then
        VarClear(Value);
      VType := varString;
      VAny := nil; // avoid GPF below when assigning a string variable to VAny
      if Txt='' then
        exit;
    end;
    RawByteString(VAny) := Txt;
    {$ifdef HASCODEPAGE}
    if (Txt<>'') and  (StringCodePage(Txt)=CP_RAWBYTESTRING) then
      SetCodePage(RawByteString(VAny),CP_UTF8,false); // force explicit UTF-8
    {$endif}
  end;
end;

function RawUTF8ToVariant(const Txt: RawUTF8): variant;
begin
  RawUTF8ToVariant(Txt,result);
end;
................................................................................
  if Value.VType and VTYPE_STATIC<>0 then
    VarClear(variant(Value));
  Value.VType := ExpectedValueType;
  Value.VAny := nil; // avoid GPF below
  if Txt<>'' then
  case ExpectedValueType of
    varString: begin
      RawByteString(Value.VAny) := Txt;
      {$ifdef HASCODEPAGE}
      if (Txt<>'') and  (StringCodePage(Txt)=CP_RAWBYTESTRING) then
        SetCodePage(RawByteString(Value.VAny),CP_UTF8,false); // force explicit UTF-8
      {$endif}
    end;
    varOleStr:
      UTF8ToWideString(Txt,WideString(Value.VAny));
    {$ifdef HASVARUSTRING}
    varUString:
      UTF8DecodeToUnicodeString(pointer(Txt),length(Txt),UnicodeString(Value.VAny));
    {$endif}
................................................................................
    vtVariant:
      result := V.VVariant^;
    vtAnsiString: begin
      VType := varString;
      VAny := nil;
      RawByteString(VAny) := RawByteString(V.VAnsiString);
    end;
    vtString, {$ifdef HASVARUSTRING}vtUnicodeString,{$endif}
    vtPChar, vtChar, vtWideChar, vtWideString, vtClass: begin
      VType := varString;
      VAny := nil; // avoid GPF on next line
      VarRecToUTF8(V,RawUTF8(VAny));
    end;
    vtObject: // class instance will be serialized as a TDocVariant
      ObjectToVariant(V.VObject,result);
................................................................................
        [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
      // binary types: store as once
      n := n*integer(ElemSize);
      MoveFast(P^,Dest^,n);
      inc(Dest,n);
    end else
    case PTypeKind(ElemType)^ of
    tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}: begin
      for i := 1 to n do begin
        if PPtrUInt(P)^=0 then
          LenBytes := 0 else begin
          LenBytes := PStrRec(Pointer(PPtrUInt(P)^-STRRECSIZE))^.length;
          {$ifdef HASVARUSTRING} // WideString length in bytes, UnicodeString in WideChars
          if PTypeKind(ElemType)^=tkUString then
            LenBytes := LenBytes*2;
          {$endif}
        end;
        Dest := pointer(ToVarUInt32(LenBytes,pointer(Dest)));
        if LenBytes>0 then begin
          MoveFast(pointer(PPtrUInt(P)^)^,Dest^,LenBytes);
................................................................................
    tkLString, tkWString{$ifdef FPC}, tkLStringOld{$endif}:
      for i := 1 to n do begin
        if PPtrUInt(P)^=0 then
          inc(result) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(PPtrUInt(P)^-STRRECSIZE))^.length));
        inc(P,sizeof(PtrUInt));
      end;
    {$ifdef HASVARUSTRING}
    tkUString: // WideString has length in bytes, UnicodeString in WideChars
      for i := 1 to n do begin
        if PPtrUInt(P)^=0 then
          inc(result) else
          inc(result,ToVarUInt32LengthWithData(PStrRec(Pointer(PPtrUInt(P)^-STRRECSIZE))^.length*2));
        inc(P,sizeof(PtrUInt));
      end;
................................................................................
      [PShortString(@PTypeInfo(ArrayType).NameLen)^]) else begin
    // binary type was stored as once
    n := n*integer(ElemSize);
    MoveFast(Source^,P^,n);
    inc(Source,n);
  end else
  case PTypeKind(ElemType)^ of
    tkLString, tkWString {$ifdef HASVARUSTRING}, tkUString{$endif}
    {$ifdef FPC}, tkLStringOld{$endif}:
    for i := 1 to n do begin
      LenBytes := FromVarUInt32(PByte(Source));
      case PTypeKind(ElemType)^ of
      tkLString{$ifdef FPC},tkLStringOld{$endif}: begin
        SetString(PRawByteString(P)^,Source,LenBytes);
        {$ifdef HASCODEPAGE}
        { Delphi 2009+: set Code page for this AnsiString }
        if LenBytes<>0 then
          SetCodePage(PRawByteString(P)^,PWord(PtrUInt(ElemType)+
            PTypeInfo(ElemType)^.NameLen+2)^,false);
        {$endif}
      end;
      tkWString:
        SetString(PWideString(P)^,PWideChar(Source),LenBytes shr 1);
      {$ifdef HASVARUSTRING}
      tkUString:
        SetString(PString(P)^,PWideChar(Source),LenBytes shr 1);
      {$endif}
      end;
      inc(Source,LenBytes);
      inc(P,sizeof(PtrUInt));
    end;
................................................................................
    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:
................................................................................
    for i := 0 to n-1 do
      if AnsiString(A1^[i])<>AnsiString(A2^[i]) then
        exit;
  tkWString:
    for i := 0 to n-1 do
      if WideString(A1^[i])<>WideString(A2^[i]) then
        exit;
  {$ifdef HASVARUSTRING}
  tkUString:
    for i := 0 to n-1 do
      if UnicodeString(A1^[i])<>UnicodeString(A2^[i]) then
        exit;
  {$endif}
  tkInterface:
    if not CompareMem(P1,P2,SizeOf(pointer)*cardinal(n)) then
................................................................................
  case PTypeKind(ElemType)^ of
  tkLString{$ifdef FPC},tkLStringOld{$endif}:
    for result := 0 to max do
      if AnsiString(PPtrIntArray(P)^[result])=AnsiString(Elem) then exit;
  tkWString:
    for result := 0 to max do
      if WideString(PPtrIntArray(P)^[result])=WideString(Elem) then exit;
  {$ifdef HASVARUSTRING}
  tkUString:
    for result := 0 to max do
      if UnicodeString(PPtrIntArray(P)^[result])=UnicodeString(Elem) then exit;
  {$endif}
  {$ifndef NOVARIANTS}
  tkVariant:
    for result := 0 to max do
................................................................................
    case PTypeKind(ElemType)^ of // release reference counted
      tkLString{$ifdef FPC},tkLStringOld{$endif}:
        RawByteString(Elem) := '';
      tkWString:
        WideString(Elem) := '';
      tkInterface:
        IUnknown(Elem) := nil;
      {$ifdef HASVARUSTRING}
      tkUString:
        UnicodeString(Elem) := '';
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}:
        RecordClear(Elem,ElemType);
      tkDynArray:
        _DynArrayClear(pointer(Elem),ElemType);
................................................................................
        WideString(B) := WideString(A);
        exit;
      end;
      tkInterface: begin
        IUnknown(B) := IUnknown(A);
        exit;
      end;
      {$ifdef HASVARUSTRING}
      tkUString: begin
        UnicodeString(B) := UnicodeString(A);
        exit;
      end;
      {$endif}
      tkRecord{$ifdef FPC},tkObject{$endif}: begin
        RecordCopy(B,A,ElemType);
................................................................................
  if Source=nil then
    exit; // avoid GPF
  if ElemType=nil then
    MoveFast(Source^,Elem,ElemSize) else
    case PTypeKind(ElemType)^ of
    tkLString{$ifdef FPC},tkLStringOld{$endif}: begin
      SetString(RawByteString(Elem),Source+4,PInteger(Source)^);
      {$ifdef HASCODEPAGE}
      { Delphi 2009+: set Code page for this AnsiString }
      if PPtrUInt(@Elem)^<>0 then
        SetCodePage(RawByteString(Elem),PWord(PtrUInt(ElemType)+
          PTypeInfo(ElemType)^.NameLen+2)^,false);
      {$endif}
    end;
    tkWString: // WideString internal length is in bytes
      SetString(WideString(Elem),PWideChar(Source+4),PInteger(Source)^ shr 1);
    {$ifdef HASVARUSTRING}
    tkUString:
      SetString(UnicodeString(Elem),PWideChar(Source+4),PInteger(Source)^);
    {$endif}
    {$ifndef NOVARIANTS}
    tkVariant:
      VariantLoad(variant(Elem),Source,@JSON_OPTIONS[true]);
    {$endif}
................................................................................
begin
  if (ElemType<>nil) and (length(ElemLoaded)=integer(ElemSize)) then
  case PTypeKind(ElemType)^ of
    tkLString{$ifdef FPC},tkLStringOld{$endif}:
      PRawByteString(pointer(ElemLoaded))^ := '';
    tkWString:
      PWideString(pointer(ElemLoaded))^ := '';
    {$ifdef HASVARUSTRING}
    tkUString:
      PUnicodeString(pointer(ElemLoaded))^ := '';
    {$endif}
    {$ifndef NOVARIANTS}
    tkVariant:
      VarClear(PVariant(pointer(ElemLoaded))^);
    {$endif}
................................................................................
      tkLString, tkWString, tkLStringOld:
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else begin
          LenBytes := PStrRec(Pointer(PPtrInt(@Elem)^-STRRECSIZE))^.length;
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),LenBytes+sizeof(integer));
          PInteger(result)^ := LenBytes;
        end;
      {$ifdef HASVARUSTRING}
      tkUString:
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else begin
          LenBytes := PStrRec(Pointer(PPtrInt(@Elem)^-STRRECSIZE))^.length;
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),LenBytes*2+sizeof(integer));
          PInteger(result)^ := LenBytes;
        end;

      {$endif}
      {$else FPC}
      tkLString, tkWString: // WideString internal length is in bytes
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),
            PInteger(PPtrInt(@Elem)^-sizeof(integer))^+sizeof(integer));
      {$ifdef HASVARUSTRING}
      tkUString:
        if PPtrInt(@Elem)^=0 then
          SetString(result,PAnsiChar(@Elem),4) else
          SetString(result,PAnsiChar(PPtrInt(@Elem)^-sizeof(integer)),
            PInteger(PPtrInt(@Elem)^-sizeof(integer))^*2+sizeof(integer));
      {$endif}
      {$endif FPC}
................................................................................

{$ifdef UNICODE}

function HashUnicodeString(const Elem; Hasher: THasher): cardinal;
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,Pointer(Elem),length(UnicodeString(Elem))*2);


end;

function HashUnicodeStringI(const Elem; Hasher: THasher): cardinal;
var tmp: array[byte] of AnsiChar; // avoid slow heap allocation
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
................................................................................

{$endif UNICODE}

function HashSynUnicode(const Elem; Hasher: THasher): cardinal;
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,Pointer(Elem),length(SynUnicode(Elem))*2);




end;

function HashSynUnicodeI(const Elem; Hasher: THasher): cardinal;
var tmp: array[byte] of AnsiChar; // avoid slow heap allocation
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
................................................................................
    result := Hasher(0,tmp,UpperCopy255W(tmp,SynUnicode(Elem))-tmp);
end;

function HashWideString(const Elem; Hasher: THasher): cardinal;
begin // WideString internal size is in bytes, not WideChar
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,Pointer(Elem),Length(WideString(Elem))*2);


end;

function HashWideStringI(const Elem; Hasher: THasher): cardinal;
var tmp: array[byte] of AnsiChar; // avoid slow heap allocation
begin
  if PtrUInt(Elem)=0 then
    result := HASH_ONVOIDCOLISION else
    result := Hasher(0,tmp,UpperCopy255W(tmp,pointer(Elem),Length(WideString(Elem)))-tmp);
end;

function HashPtrUInt(const Elem; Hasher: THasher): cardinal;
begin
  {$ifdef CPU64}
  result := Hasher(0,@Elem,sizeof(PtrUInt));
  {$else}
  result := (PtrUInt(Elem) shr 4)+1; // naive but optimal for TDynArrayHashed
  {$endif}
end;

function HashPointer(const Elem; Hasher: THasher): cardinal;
begin
  result := Hasher(0,@Elem,sizeof(pointer));
end;

................................................................................
  varDate:     AddDateTime(@VDate,'T','"');
  varCurrency: AddCurr64(VInt64);
  varBoolean:  Add(VBoolean);
  varVariant:  AddVariant(PVariant(VPointer)^,Escape,ForcedSerializeAsNonExtendedJson);
  varString: begin
    if Escape=twJSONEscape then
      Add('"');
    {$ifdef HASCODEPAGE}
    AddAnyAnsiString(RawByteString(VString),Escape);
    {$else}  // VString is expected to be a RawUTF8
    Add(VAny,length(RawUTF8(VAny)),Escape);
    {$endif}
    if Escape=twJSONEscape then
      Add('"');
  end;
................................................................................
  end;
  else
  if VType=varVariant or varByRef then
    AddVariant(PVariant(VPointer)^,Escape,ForcedSerializeAsNonExtendedJson) else
  if VType=varByRef or varString then begin
    if Escape=twJSONEscape then
      Add('"');
    {$ifdef HASCODEPAGE}
    AddAnyAnsiString(PRawByteString(VAny)^,Escape);
    {$else}  // VString is expected to be a RawUTF8
    Add(PPointer(VAny)^,length(PRawUTF8(VAny)^),Escape);
    {$endif}
    if Escape=twJSONEscape then
      Add('"');
  end else
................................................................................
  if L=0 then
    exit;
  if PInteger(s)^ and $ffffff=JSON_BASE64_MAGIC then begin
    AddNoJSONEscape(pointer(s),L); // identified as a BLOB content
    exit;
  end;
  if CodePage<0 then
    {$ifdef HASCODEPAGE}
    CodePage := StringCodePage(s);
    {$else}
    CodePage := 0; // TSynAnsiConvert.Engine(0)=CurrentAnsiConvert
    {$endif}
  AddAnyAnsiBuffer(pointer(s),L,Escape,CodePage);
end;

................................................................................
end;

procedure TTextWriter.AddJSONEscape(const V: TVarRec);
begin
  with V do
  case VType of
    vtPointer: AddShort('null');
    vtString, vtAnsiString,{$ifdef HASVARUSTRING}vtUnicodeString,{$endif}
    vtPChar, vtChar, vtWideChar, vtWideString, vtClass: begin
      Add('"');
      case VType of
        vtString:     AddJSONEscape(@VString^[1],ord(VString^[0]));
        vtAnsiString: AddJSONEscape(pointer(RawUTF8(VAnsiString)));
        {$ifdef HASVARUSTRING}
        vtUnicodeString: AddJSONEscapeW(
          pointer(UnicodeString(VUnicodeString)),length(UnicodeString(VUnicodeString)));
        {$endif}
        vtPChar:      AddJSONEscape(VPChar);
        vtChar:       AddJSONEscape(@VChar,1);
        vtWideChar:   AddJSONEscapeW(@VWideChar,1);
        vtWideString: AddJSONEscapeW(VWideString);
        vtClass:      AddClassName(VClass);
      end;
      Add('"');
................................................................................
      AddW(VWideString,length(WideString(VWideString)),Escape);
  vtInt64:
    Add(VInt64^);
  {$ifndef NOVARIANTS}
  vtVariant:
    AddVariant(VVariant^,Escape);
  {$endif}
  {$ifdef HASVARUSTRING}
  vtUnicodeString:
    if VUnicodeString<>nil then // convert to UTF-8
      AddW(VUnicodeString,length(UnicodeString(VUnicodeString)),Escape);
  {$endif} end;
end;

{$ifndef NOVARIANTS}
................................................................................
begin
  FlushFinal;
  Len := fTotalFileSize-fInitialStreamPosition;
  if Len=0 then
    result := '' else
  if fStream.InheritsFrom(TRawByteStringStream) then
    with TRawByteStringStream(fStream) do
    if fInitialStreamPosition=0 then begin
      {$ifdef HASCODEPAGE} // FPC expects this
      SetCodePage(fDataString,CP_UTF8,false);
      {$endif}
      result := fDataString;
    end else
      SetRawUTF8(result,PAnsiChar(pointer(DataString))+fInitialStreamPosition,Len) else
  if fStream.InheritsFrom(TCustomMemoryStream) then
    with TCustomMemoryStream(fStream) do
    SetRawUTF8(result,PAnsiChar(Memory)+fInitialStreamPosition,Len) else begin
    FastNewRawUTF8(result,Len);
    fStream.Seek(fInitialStreamPosition,soBeginning);
    fStream.Read(pointer(result)^,Len);

  /// define the fastest Unicode string type of the compiler
  SynUnicode = UnicodeString;
  /// define a raw storage string type, used for data buffer management
  SockString = type RawByteString;
{$else}
  /// define the fastest Unicode string type of the compiler
  SynUnicode = WideString;



  /// define a raw storage string type, used for data buffer management
  SockString = type AnsiString;

{$endif}

{$ifndef CONDITIONALEXPRESSIONS}
  // not defined in Delphi 5 or older
  PPointer = ^Pointer;
  TTextLineBreakStyle = (tlbsLF, tlbsCRLF);
  UTF8String = AnsiString;
................................................................................
      result := nil;
      exit;
    end;
    Inc(result);
  end;
end;

{$ifdef UNICODE}
// rewrite some functions to avoid unattempted ansi<->unicode conversion

function Trim(const S: SockString): SockString;
{$ifdef PUREPASCAL}
var I, L: Integer;
begin
  L := Length(S);
  I := 1;
  while (I<=L) and (S[i]<=' ') do Inc(I);
  if I>L then
    Result := '' else
................................................................................

function UpperCase(const S: SockString): SockString;
procedure Upper(Source, Dest: PAnsiChar; L: cardinal);
var Ch: AnsiChar; // this sub-call is shorter and faster than 1 plain proc
begin
  repeat
    Ch := Source^;
    if (Ch >= 'a') and (Ch <= 'z') then
      dec(Ch, 32);
    Dest^ := Ch;
    dec(L);
    inc(Source);
    inc(Dest);
  until L=0;
end;
var L: cardinal;
................................................................................
  L := Length(S);
  if L=0 then
    exit;
  SetLength(result, L);
  Upper(pointer(S),pointer(result),L);
end;

{$endif}

function GetCardinal(P: PAnsiChar): cardinal; overload;
var c: cardinal;
begin
  if P=nil then begin
    result := 0;
    exit;
................................................................................

constructor TCrtSocket.Bind(const aPort: SockString; aLayer: TCrtSocketLayer=cslTCP);
var s,p: SockString;
    i: integer;
begin
  // on Linux, Accept() blocks even after Shutdown() -> use 0.5 second timeout
  Create({$ifdef LINUX}500{$else}5000{$endif});
  i := pos({$ifdef UNICODE}SockString{$endif}(':'),aPort);
  if i=0 then begin
    s := '0.0.0.0';
    p := aPort;
  end else begin
    s := Copy(aPort,1,i-1);
    p := Copy(aPort,i+1,10);
  end;
................................................................................
  for i := 0 to high(Values) do
  with Values[i] do
  case VType of
    vtString:
      SockSend(@VString^[1],pByte(VString)^);
    vtAnsiString:
      SockSend(VAnsiString,length(SockString(VAnsiString)));
{$ifdef UNICODE}
    vtUnicodeString: begin
      tmp := ShortString(UnicodeString(VUnicodeString)); // convert into ansi
      SockSend(@tmp[1],length(tmp));
    end;
{$endif}
    vtPChar:
      SockSend(VPChar,StrLen(VPChar));
    vtChar:
      SockSend(@VChar,1);
    vtWideChar:
      SockSend(@VWideChar,1); // only ansi part of the character
    vtInteger: begin
................................................................................
    end else
      Exec('HELO '+Server,'25');
    writeln(TCP.SockOut^,'MAIL FROM:<',From,'>'); Expect('250');
    ToList := 'To: ';
    repeat
      rec := trim(GetNextItem(P));
      if rec='' then continue;
      if pos({$ifdef UNICODE}SockString{$endif}('<'),rec)=0 then
        rec := '<'+rec+'>';
      Exec('RCPT TO:'+rec,'25');
      ToList := ToList+rec+', ';
    until P=nil;
    Exec('DATA','354');
    writeln(TCP.SockOut^,'Subject: ',Subject,#13#10,
      ToList,#13#10'Content-Type: text/plain; charset=',TextCharSet,

  /// define the fastest Unicode string type of the compiler
  SynUnicode = UnicodeString;
  /// define a raw storage string type, used for data buffer management
  SockString = type RawByteString;
{$else}
  /// define the fastest Unicode string type of the compiler
  SynUnicode = WideString;
  {$ifdef HASCODEPAGE} // FPC expects a CP, e.g. to compare to string constants
  SockString = type AnsiString(CP_UTF8);
  {$else}
  /// define a raw storage string type, used for data buffer management
  SockString = type AnsiString;
  {$endif}
{$endif}

{$ifndef CONDITIONALEXPRESSIONS}
  // not defined in Delphi 5 or older
  PPointer = ^Pointer;
  TTextLineBreakStyle = (tlbsLF, tlbsCRLF);
  UTF8String = AnsiString;
................................................................................
      result := nil;
      exit;
    end;
    Inc(result);
  end;
end;

{$ifdef HASCODEPAGE}
// rewrite some functions to avoid unattempted ansi<->unicode conversion

function Trim(const S: SockString): SockString;
{$ifdef FPC_OR_PUREPASCAL}
var I, L: Integer;
begin
  L := Length(S);
  I := 1;
  while (I<=L) and (S[i]<=' ') do Inc(I);
  if I>L then
    Result := '' else
................................................................................

function UpperCase(const S: SockString): SockString;
procedure Upper(Source, Dest: PAnsiChar; L: cardinal);
var Ch: AnsiChar; // this sub-call is shorter and faster than 1 plain proc
begin
  repeat
    Ch := Source^;
    if (Ch>='a') and (Ch<='z') then
      dec(Ch,32);
    Dest^ := Ch;
    dec(L);
    inc(Source);
    inc(Dest);
  until L=0;
end;
var L: cardinal;
................................................................................
  L := Length(S);
  if L=0 then
    exit;
  SetLength(result, L);
  Upper(pointer(S),pointer(result),L);
end;

{$endif HASCODEPAGE}

function GetCardinal(P: PAnsiChar): cardinal; overload;
var c: cardinal;
begin
  if P=nil then begin
    result := 0;
    exit;
................................................................................

constructor TCrtSocket.Bind(const aPort: SockString; aLayer: TCrtSocketLayer=cslTCP);
var s,p: SockString;
    i: integer;
begin
  // on Linux, Accept() blocks even after Shutdown() -> use 0.5 second timeout
  Create({$ifdef LINUX}500{$else}5000{$endif});
  i := pos({$ifdef HASCODEPAGE}SockString{$endif}(':'),aPort);
  if i=0 then begin
    s := '0.0.0.0';
    p := aPort;
  end else begin
    s := Copy(aPort,1,i-1);
    p := Copy(aPort,i+1,10);
  end;
................................................................................
  for i := 0 to high(Values) do
  with Values[i] do
  case VType of
    vtString:
      SockSend(@VString^[1],pByte(VString)^);
    vtAnsiString:
      SockSend(VAnsiString,length(SockString(VAnsiString)));
    {$ifdef HASVARUSTRING}
    vtUnicodeString: begin
      tmp := ShortString(UnicodeString(VUnicodeString)); // convert into ansi
      SockSend(@tmp[1],length(tmp));
    end;
    {$endif}
    vtPChar:
      SockSend(VPChar,StrLen(VPChar));
    vtChar:
      SockSend(@VChar,1);
    vtWideChar:
      SockSend(@VWideChar,1); // only ansi part of the character
    vtInteger: begin
................................................................................
    end else
      Exec('HELO '+Server,'25');
    writeln(TCP.SockOut^,'MAIL FROM:<',From,'>'); Expect('250');
    ToList := 'To: ';
    repeat
      rec := trim(GetNextItem(P));
      if rec='' then continue;
      if pos({$ifdef HASCODEPAGE}SockString{$endif}('<'),rec)=0 then
        rec := '<'+rec+'>';
      Exec('RCPT TO:'+rec,'25');
      ToList := ToList+rec+', ';
    until P=nil;
    Exec('DATA','354');
    writeln(TCP.SockOut^,'Subject: ',Subject,#13#10,
      ToList,#13#10'Content-Type: text/plain; charset=',TextCharSet,

        BindTextU(i,'',IO) else begin
        c := PInteger(VAnsiString)^ and $00ffffff;
        if c=JSON_BASE64_MAGIC then
          BindBlob(i,Base64ToBin(PAnsiChar(VAnsiString)+3,length(RawUTF8(VAnsiString))-3)) else
        if c=JSON_SQLDATE_MAGIC then
          BindDateTime(i,Iso8601ToDateTimePUTF8Char(PUTF8Char(VAnsiString)+3,length(RawUTF8(VAnsiString))-3)) else
          // expect UTF-8 content only for AnsiString, i.e. RawUTF8 variables



          BindTextU(i,RawUTF8(VAnsiString),IO);

      end;
    vtPChar:      BindTextP(i,PUTF8Char(VPChar),IO);
    vtChar:       BindTextU(i,RawUTF8(VChar),IO);
    vtWideChar:   BindTextU(i,RawUnicodeToUtf8(@VWideChar,1),IO);
    vtPWideChar:  BindTextU(i,RawUnicodeToUtf8(VPWideChar,StrLenW(VPWideChar)),IO);
    vtWideString: BindTextW(i,WideString(VWideString),IO);

{$ifdef UNICODE}
    vtUnicodeString: BindTextS(i,string(VUnicodeString),IO);


{$endif}

    vtBoolean:    Bind(i,integer(VBoolean),IO);
    vtInteger:    Bind(i,VInteger,IO);
    vtInt64:      Bind(i,VInt64^,IO);
    vtCurrency:   BindCurrency(i,VCurrency^,IO);
    vtExtended:   Bind(i,VExtended^,IO);
    vtPointer:
      if VPointer=nil then
................................................................................
      if DataIsBlob then
        if (VAny<>nil) and (PInteger(VAny)^ and $00ffffff=JSON_BASE64_MAGIC) then
          // recognized as Base64 encoded text
          BindBlob(Param,Base64ToBin(PAnsiChar(VAny)+3,length(RawByteString(VAny))-3)) else
          // no conversion if was set via TQuery.AsBlob property e.g.
          BindBlob(Param,RawByteString(VAny),IO) else
        // direct bind of AnsiString as UTF-8 value
        {$ifdef UNICODE}
        BindTextU(Param,AnyAnsiToUTF8(RawByteString(VAny)),IO);
        {$else} // on older Delphi, we assume AnsiString = RawUTF8
        BindTextU(Param,RawUTF8(VAny),IO);
        {$endif}
    else
    if VType=varByRef or varVariant then
      BindVariant(Param,PVariant(VPointer)^,DataIsBlob,IO) else
................................................................................
              dec(L); // avoid return of invalid UTF-8 buffer
            if L=0 then
              L := MaxCharCount;
            SetString(result,PAnsiChar(VAny),L);
          end else
            result := RawUTF8(VAny);
        end;
        {$ifdef UNICODE}
        varUString: begin
          L := length(string(VAny));
          if L>MaxCharCount then begin
            Truncated := true;
            L := MaxCharCount;
          end;
          RawUnicodeToUtf8(VAny,L,result);
        end;
        {$endif}

        BindTextU(i,'',IO) else begin
        c := PInteger(VAnsiString)^ and $00ffffff;
        if c=JSON_BASE64_MAGIC then
          BindBlob(i,Base64ToBin(PAnsiChar(VAnsiString)+3,length(RawUTF8(VAnsiString))-3)) else
        if c=JSON_SQLDATE_MAGIC then
          BindDateTime(i,Iso8601ToDateTimePUTF8Char(PUTF8Char(VAnsiString)+3,length(RawUTF8(VAnsiString))-3)) else
          // expect UTF-8 content only for AnsiString, i.e. RawUTF8 variables
          {$ifdef HASCODEPAGE}
          BindTextU(i,AnyAnsiToUTF8(RawByteString(VAnsiString)),IO);
          {$else}
          BindTextU(i,RawUTF8(VAnsiString),IO);
          {$endif}
      end;
    vtPChar:      BindTextP(i,PUTF8Char(VPChar),IO);
    vtChar:       BindTextU(i,RawUTF8(VChar),IO);
    vtWideChar:   BindTextU(i,RawUnicodeToUtf8(@VWideChar,1),IO);
    vtPWideChar:  BindTextU(i,RawUnicodeToUtf8(VPWideChar,StrLenW(VPWideChar)),IO);
    vtWideString: BindTextW(i,WideString(VWideString),IO);
    {$ifdef HASVARUSTRING}
    {$ifdef UNICODE}
    vtUnicodeString: BindTextS(i,string(VUnicodeString),IO);
    {$else}
    vtUnicodeString: BindTextU(i,UnicodeStringToUtf8(UnicodeString(VUnicodeString)),IO);
    {$endif}
    {$endif}
    vtBoolean:    Bind(i,integer(VBoolean),IO);
    vtInteger:    Bind(i,VInteger,IO);
    vtInt64:      Bind(i,VInt64^,IO);
    vtCurrency:   BindCurrency(i,VCurrency^,IO);
    vtExtended:   Bind(i,VExtended^,IO);
    vtPointer:
      if VPointer=nil then
................................................................................
      if DataIsBlob then
        if (VAny<>nil) and (PInteger(VAny)^ and $00ffffff=JSON_BASE64_MAGIC) then
          // recognized as Base64 encoded text
          BindBlob(Param,Base64ToBin(PAnsiChar(VAny)+3,length(RawByteString(VAny))-3)) else
          // no conversion if was set via TQuery.AsBlob property e.g.
          BindBlob(Param,RawByteString(VAny),IO) else
        // direct bind of AnsiString as UTF-8 value
        {$ifdef HASCODEPAGE}
        BindTextU(Param,AnyAnsiToUTF8(RawByteString(VAny)),IO);
        {$else} // on older Delphi, we assume AnsiString = RawUTF8
        BindTextU(Param,RawUTF8(VAny),IO);
        {$endif}
    else
    if VType=varByRef or varVariant then
      BindVariant(Param,PVariant(VPointer)^,DataIsBlob,IO) else
................................................................................
              dec(L); // avoid return of invalid UTF-8 buffer
            if L=0 then
              L := MaxCharCount;
            SetString(result,PAnsiChar(VAny),L);
          end else
            result := RawUTF8(VAny);
        end;
        {$ifdef HASVARUSTRING}
        varUString: begin
          L := length(UnicodeString(VAny));
          if L>MaxCharCount then begin
            Truncated := true;
            L := MaxCharCount;
          end;
          RawUnicodeToUtf8(VAny,L,result);
        end;
        {$endif}

    end;
  end;
  inc(len,startlen+finlen);//add { and }
  SetLength(result,len);
  P := pointer(result);

  if startlen>0 then begin
    Move(pointer(start)^,P^,startlen);
    inc(P,startlen);
  end;

  i := 0;
  repeat
    L := length(Values[i]);
    if L>0 then begin
................................................................................
          j := 0;
          while k+j<l do begin
            case Values[i][k+j] of
              '"': break;
              else inc(j);
            end;
          end;
          move(pointer(@Values[i][k])^,P^,j);
          inc(P,j);
          inc(k,j);
          case Values[i][k] of
            '"': begin
              move(pointer(dQuoteRepl)^,P^,dQuoteRepllen);
              inc(P,dQuoteRepllen);
              inc(k);
            end;
          end;
        end;
        P^ := '"';
        inc(p);
      end else begin
        move(pointer(Values[i])^,P^,L);
        inc(P,L);
      end;
    end;

    if i=high(Values) then
      Break;
    if seplen>0 then begin
      Move(pointer(Sep)^,P^,seplen);
      inc(P,seplen);
    end;
    inc(i);
  until false;

  if finlen>0 then begin
    Move(pointer(fin)^,P^,finlen);
    inc(P,finlen);
  end;
  Assert(P-pointer(result)=len);
end;

procedure TSQLDBZEOSStatement.ExecutePrepared;
var i,n: integer;

    end;
  end;
  inc(len,startlen+finlen);//add { and }
  SetLength(result,len);
  P := pointer(result);

  if startlen>0 then begin
    MoveFast(pointer(start)^,P^,startlen);
    inc(P,startlen);
  end;

  i := 0;
  repeat
    L := length(Values[i]);
    if L>0 then begin
................................................................................
          j := 0;
          while k+j<l do begin
            case Values[i][k+j] of
              '"': break;
              else inc(j);
            end;
          end;
          MoveFast(pointer(@Values[i][k])^,P^,j);
          inc(P,j);
          inc(k,j);
          case Values[i][k] of
            '"': begin
              MoveFast(pointer(dQuoteRepl)^,P^,dQuoteRepllen);
              inc(P,dQuoteRepllen);
              inc(k);
            end;
          end;
        end;
        P^ := '"';
        inc(p);
      end else begin
        MoveFast(pointer(Values[i])^,P^,L);
        inc(P,L);
      end;
    end;

    if i=high(Values) then
      Break;
    if seplen>0 then begin
      MoveFast(pointer(Sep)^,P^,seplen);
      inc(P,seplen);
    end;
    inc(i);
  until false;

  if finlen>0 then begin
    MoveFast(pointer(fin)^,P^,finlen);
    inc(P,finlen);
  end;
  Assert(P-pointer(result)=len);
end;

procedure TSQLDBZEOSStatement.ExecutePrepared;
var i,n: integer;

/// helper to save a specified graphic into GIF/PNG/JPG/TIFF format
// - CompressionQuality is only used for gptJPG format saving
// and is expected to be from 0 to 100
// - if MaxPixelsForBiggestSide is set to something else than 0, the resulting
// picture biggest side won't exceed this pixel number
procedure SaveAsRawByteString(Graphic: TPersistent;

  out DataRawByteString; Format: TGDIPPictureType; CompressionQuality: integer=80;
  MaxPixelsForBiggestSide: cardinal=0; BitmapSetResolution: single=0);

/// helper to load a specified graphic from GIF/PNG/JPG/TIFF format content
function LoadFromRawByteString(const Picture: {$ifdef UNICODE}RawByteString{$else}AnsiString{$endif}): TBitmap;

/// helper function to create a bitmap from any GIF/PNG/JPG/TIFF/EMF/WMF file
// - if file extension if .EMF, the file is drawn with a special antialiased
// GDI+ drawing method (if the global Gdip var is a TGDIPlusFull instance)
function LoadFrom(const FileName: TFileName): TBitmap; overload;

/// helper function to create a bitmap from any EMF content
................................................................................
    SaveAs(Graphic,Stream,Format,CompressionQuality,MaxPixelsForBiggestSide,
      BitmapSetResolution);
  finally
    Stream.Free;
  end;
end;

{$ifndef UNICODE}
type RawByteString = AnsiString;
{$endif}

procedure SaveAsRawByteString(Graphic: TPersistent;

  out DataRawByteString; Format: TGDIPPictureType; CompressionQuality: integer=80;
  MaxPixelsForBiggestSide: cardinal=0; BitmapSetResolution: single=0); overload;
var Stream: TMemoryStream;
begin
  Stream := TMemoryStream.Create;
  try
    SaveAs(Graphic,Stream,Format,CompressionQuality,MaxPixelsForBiggestSide,
      BitmapSetResolution);
    SetString(RawByteString(DataRawByteString),PAnsiChar(Stream.Memory),Stream.Seek(0,soFromCurrent));
  finally
    Stream.Free;
  end;
end;

function LoadFromRawByteString(const Picture: {$ifdef UNICODE}RawByteString{$else}AnsiString{$endif}): TBitmap;
var ST: TStringStream;
begin
  Result := nil;
  if Picture='' then
    exit;
  ST := TStringStream.Create(Picture);
  try

/// helper to save a specified graphic into GIF/PNG/JPG/TIFF format
// - CompressionQuality is only used for gptJPG format saving
// and is expected to be from 0 to 100
// - if MaxPixelsForBiggestSide is set to something else than 0, the resulting
// picture biggest side won't exceed this pixel number
procedure SaveAsRawByteString(Graphic: TPersistent;
  out DataRawByteString{$ifdef HASCODEPAGE}: RawByteString{$endif};
  Format: TGDIPPictureType; CompressionQuality: integer=80;
  MaxPixelsForBiggestSide: cardinal=0; BitmapSetResolution: single=0);

/// helper to load a specified graphic from GIF/PNG/JPG/TIFF format content
function LoadFromRawByteString(const Picture: {$ifdef HASCODEPAGE}RawByteString{$else}AnsiString{$endif}): TBitmap;

/// helper function to create a bitmap from any GIF/PNG/JPG/TIFF/EMF/WMF file
// - if file extension if .EMF, the file is drawn with a special antialiased
// GDI+ drawing method (if the global Gdip var is a TGDIPlusFull instance)
function LoadFrom(const FileName: TFileName): TBitmap; overload;

/// helper function to create a bitmap from any EMF content
................................................................................
    SaveAs(Graphic,Stream,Format,CompressionQuality,MaxPixelsForBiggestSide,
      BitmapSetResolution);
  finally
    Stream.Free;
  end;
end;

{$ifndef HASCODEPAGE}
type RawByteString = AnsiString;
{$endif}

procedure SaveAsRawByteString(Graphic: TPersistent;
  out DataRawByteString{$ifdef HASCODEPAGE}: RawByteString{$endif};
  Format: TGDIPPictureType; CompressionQuality: integer=80;
  MaxPixelsForBiggestSide: cardinal=0; BitmapSetResolution: single=0); overload;
var Stream: TMemoryStream;
begin
  Stream := TMemoryStream.Create;
  try
    SaveAs(Graphic,Stream,Format,CompressionQuality,MaxPixelsForBiggestSide,
      BitmapSetResolution);
    SetString(RawByteString(DataRawByteString),PAnsiChar(Stream.Memory),Stream.Seek(0,soFromCurrent));
  finally
    Stream.Free;
  end;
end;

function LoadFromRawByteString(const Picture: RawByteString): TBitmap;
var ST: TStringStream;
begin
  Result := nil;
  if Picture='' then
    exit;
  ST := TStringStream.Create(Picture);
  try

  case value.VType of
    vtBoolean:  BSONWrite(name,value.VBoolean);
    vtInteger:  BSONWrite(name,value.VInteger);
    vtInt64:    BSONWrite(name,value.VInt64^);
    vtCurrency: BSONWrite(name,value.VCurrency^);
    vtExtended: BSONWrite(name,value.VExtended^);
    vtVariant:  BSONWriteVariant(name,value.VVariant^);
    vtString, vtAnsiString, {$ifdef UNICODE}vtUnicodeString,{$endif}
    vtPChar, vtChar, vtWideChar, vtWideString: begin
      VarRecToUTF8(value,tmp);
      BSONWrite(name,tmp);
    end;
    else raise EBSONException.CreateUtf8(
      '%.BSONWrite(TVarRec.VType=%)',[self,value.VType]);
  end;

  case value.VType of
    vtBoolean:  BSONWrite(name,value.VBoolean);
    vtInteger:  BSONWrite(name,value.VInteger);
    vtInt64:    BSONWrite(name,value.VInt64^);
    vtCurrency: BSONWrite(name,value.VCurrency^);
    vtExtended: BSONWrite(name,value.VExtended^);
    vtVariant:  BSONWriteVariant(name,value.VVariant^);
    vtString, vtAnsiString, {$ifdef HASVARUSTRING}vtUnicodeString,{$endif}
    vtPChar, vtChar, vtWideChar, vtWideString: begin
      VarRecToUTF8(value,tmp);
      BSONWrite(name,tmp);
    end;
    else raise EBSONException.CreateUtf8(
      '%.BSONWrite(TVarRec.VType=%)',[self,value.VType]);
  end;

    fCodePage: integer;
    fAddGlyphFont: (fNone, fMain, fFallBack);
    fDoc: TPdfDocument;
    Tmp: array[0..511] of AnsiChar;
    /// internal Ansi->Unicode conversion, using the CodePage used in Create()
    // - caller must release the returned memory via FreeMem()
    function ToWideChar(const Ansi: PDFString; out DLen: Integer): PWideChar;
{$ifdef USE_UNISCRIBE}
    /// internal method using the Windows Uniscribe API
    // - return FALSE if PW was not appened to the PDF content, TRUE if OK
    function AddUnicodeHexTextUniScribe(PW: PWideChar; WinAnsiTTF: TPdfFontTrueType;
      NextLine: boolean; Canvas: TPdfCanvas): boolean;
{$endif}
    /// internal method NOT using the Windows Uniscribe API
    procedure AddUnicodeHexTextNoUniScribe(PW: PWideChar; TTF: TPdfFontTrueType;
      NextLine: boolean; Canvas: TPdfCanvas);
    /// internal methods handling font fall-back
    procedure AddGlyphFromChar(Char: WideChar; Canvas: TPdfCanvas;
      TTF: TPdfFontTrueType; NextLine: PBoolean);
    procedure AddGlyphFlush(Canvas: TPdfCanvas; TTF: TPdfFontTrueType; NextLine: PBoolean);
................................................................................
    // line by (tx ,ty)
    // - tx and ty are numbers expressed in unscaled text space units
    procedure MoveTextPoint(tx, ty: Single); {$ifdef HASINLINE}inline;{$endif} {  Td  }
    /// set the Text Matrix to a,b,c,d and the text line Matrix x,y
    procedure SetTextMatrix(a, b, c, d, x, y: Single);           {  Tm  }
    /// Move to the start of the next line
    procedure MoveToNextLine;                                    {  T*  }
{$ifdef UNICODE}
    /// Show a text string
    // - text is expected to be Unicode encoded
    // - if NextLine is TRUE, moves to the next line and show a text string;
    // in this case, method as the same effect as MoveToNextLine; ShowText(s);
    procedure ShowText(const text: UnicodeString; NextLine: boolean=false); overload; inline; {  Tj  or ' }

    /// Show a text string
    // - text is expected to be Ansi-Encoded, in the current CharSet; if
    // some Unicode or MBCS conversion is necessary, it will be notified to the
    // corresponding
    // - if NextLine is TRUE, moves to the next line and show a text string;
    // in this case, method as the same effect as MoveToNextLine; ShowText(s);
    procedure ShowText(const text: PDFString; NextLine: boolean=false); overload; {  Tj  or ' }
{$else}
    /// Show a text string
    // - text is expected to be Ansi-Encoded, in the current CharSet; if
    // some Unicode or MBCS conversion is necessary, it will be notified to the
    // corresponding
    // - if NextLine is TRUE, moves to the next line and show a text string;
    // in this case, method as the same effect as MoveToNextLine; ShowText(s);
    procedure ShowText(const text: PDFString; NextLine: boolean=false); overload; {  Tj  or ' }
{$endif}
    /// Show an Unicode Text string
    // - if NextLine is TRUE, moves to the next line and show a text string;
    // in this case, method as the same effect as MoveToNextLine; ShowText(s);
    procedure ShowText(PW: PWideChar; NextLine: boolean=false); overload;
      {$ifdef HASINLINE}inline;{$endif}
    /// Show an Unicode Text string, encoded as Glyphs or the current font
    // - PW must follow the ETO_GLYPH_INDEX layout, i.e. refers to an array as
................................................................................

procedure TPdfCanvas.MoveToNextLine;
begin
  if FContents<>nil then
    FContents.Writer.Add('T*'#10);
end;

{$ifdef UNICODE}

procedure TPdfCanvas.ShowText(const text: UnicodeString; NextLine: boolean);
begin // direct call of the unicode text drawing method below
  ShowText(pointer(text),NextLine);
end;

{$endif}

    fCodePage: integer;
    fAddGlyphFont: (fNone, fMain, fFallBack);
    fDoc: TPdfDocument;
    Tmp: array[0..511] of AnsiChar;
    /// internal Ansi->Unicode conversion, using the CodePage used in Create()
    // - caller must release the returned memory via FreeMem()
    function ToWideChar(const Ansi: PDFString; out DLen: Integer): PWideChar;
    {$ifdef USE_UNISCRIBE}
    /// internal method using the Windows Uniscribe API
    // - return FALSE if PW was not appened to the PDF content, TRUE if OK
    function AddUnicodeHexTextUniScribe(PW: PWideChar; WinAnsiTTF: TPdfFontTrueType;
      NextLine: boolean; Canvas: TPdfCanvas): boolean;
    {$endif}
    /// internal method NOT using the Windows Uniscribe API
    procedure AddUnicodeHexTextNoUniScribe(PW: PWideChar; TTF: TPdfFontTrueType;
      NextLine: boolean; Canvas: TPdfCanvas);
    /// internal methods handling font fall-back
    procedure AddGlyphFromChar(Char: WideChar; Canvas: TPdfCanvas;
      TTF: TPdfFontTrueType; NextLine: PBoolean);
    procedure AddGlyphFlush(Canvas: TPdfCanvas; TTF: TPdfFontTrueType; NextLine: PBoolean);
................................................................................
    // line by (tx ,ty)
    // - tx and ty are numbers expressed in unscaled text space units
    procedure MoveTextPoint(tx, ty: Single); {$ifdef HASINLINE}inline;{$endif} {  Td  }
    /// set the Text Matrix to a,b,c,d and the text line Matrix x,y
    procedure SetTextMatrix(a, b, c, d, x, y: Single);           {  Tm  }
    /// Move to the start of the next line
    procedure MoveToNextLine;                                    {  T*  }
    {$ifdef HASVARUSTRING}
    /// Show a text string
    // - text is expected to be Unicode encoded
    // - if NextLine is TRUE, moves to the next line and show a text string;
    // in this case, method as the same effect as MoveToNextLine; ShowText(s);
    procedure ShowText(const text: UnicodeString; NextLine: boolean=false); overload; inline; {  Tj  or ' }
    {$endif}
    /// Show a text string
    // - text is expected to be Ansi-Encoded, in the current CharSet; if
    // some Unicode or MBCS conversion is necessary, it will be notified to the
    // corresponding
    // - if NextLine is TRUE, moves to the next line and show a text string;
    // in this case, method as the same effect as MoveToNextLine; ShowText(s);
    procedure ShowText(const text: PDFString; NextLine: boolean=false); overload; {  Tj  or ' }









    /// Show an Unicode Text string
    // - if NextLine is TRUE, moves to the next line and show a text string;
    // in this case, method as the same effect as MoveToNextLine; ShowText(s);
    procedure ShowText(PW: PWideChar; NextLine: boolean=false); overload;
      {$ifdef HASINLINE}inline;{$endif}
    /// Show an Unicode Text string, encoded as Glyphs or the current font
    // - PW must follow the ETO_GLYPH_INDEX layout, i.e. refers to an array as
................................................................................

procedure TPdfCanvas.MoveToNextLine;
begin
  if FContents<>nil then
    FContents.Writer.Add('T*'#10);
end;

{$ifdef HASVARUSTRING}

procedure TPdfCanvas.ShowText(const text: UnicodeString; NextLine: boolean);
begin // direct call of the unicode text drawing method below
  ShowText(pointer(text),NextLine);
end;

{$endif}

      FValue := DOUBLE_TO_JSVAL(V.VExtended^);
    vtVariant:
      SetVariant(cx,V.VVariant^);
    vtWideString:
      SetWideString(cx,WideString(V.VPointer));
    vtAnsiString:
      SetAnsiChar(cx,V.VPointer,length(RawByteString(V.VAnsiString)),
{$ifndef UNICODE}     CP_UTF8);
{$else}               StringCodePage(RawByteString(V.VAnsiString)));
    vtUnicodeString:
      SetSynUnicode(cx,UnicodeString(V.VPointer));
{$endif}
    vtString:
      SetAnsiChar(cx,PAnsiChar(@V.VString^[1]),ord(V.VString^[0]),0);
    vtPChar:

      FValue := DOUBLE_TO_JSVAL(V.VExtended^);
    vtVariant:
      SetVariant(cx,V.VVariant^);
    vtWideString:
      SetWideString(cx,WideString(V.VPointer));
    vtAnsiString:
      SetAnsiChar(cx,V.VPointer,length(RawByteString(V.VAnsiString)),
{$ifndef HASCODEPAGE} CP_UTF8);
{$else}               StringCodePage(RawByteString(V.VAnsiString)));
    vtUnicodeString:
      SetSynUnicode(cx,UnicodeString(V.VPointer));
{$endif}
    vtString:
      SetAnsiChar(cx,PAnsiChar(@V.VString^[1]),ord(V.VString^[0]),0);
    vtPChar:

procedure TTestLowLevelCommon._TDynArray;
var AI, AI2: TIntegerDynArray;
    AU: TRawUTF8DynArray;
    AR: TRecs;
    AF: TFVs;
    AF2: TFV2s;
    i,j,k,Len, count,AIcount: integer;
    U: RawUTF8;
    P: PUTF8Char;
    PI: PIntegerArray;
    R: TRec;
    F, F1: TFV;
    F2: TFV2;
    City: TCity;
    Province: TProvince;
................................................................................
  end;
  W.CancelAll;
  W.AddDynArrayJSON(ARP);
  U := W.Text;
  Check(Hash32(U)={$ifdef CPU64}$9F98936D{$else}$54659D65{$endif});
  P := pointer(U);
  JSON_BASE64_MAGIC_UTF8 := RawUnicodeToUtf8(@MAGIC,2);
  Check(U='['+JSON_BASE64_MAGIC_UTF8+BinToBase64(ARP.SaveTo)+'"]');

  ARP.Clear;
  Check(ARP.LoadFromJSON(pointer(U))<>nil);
  if not CheckFailed(ARP.Count=1001) then
    for i := 0 to 1000 do
    with AR[i] do begin
      Check(A=i);
      Check(B=byte(i+1));
................................................................................
  {Check(A.Dyn[0]=0) bug in original VCL?}
  Check(C.Dyn[0]=10);
end;

procedure TTestLowLevelCommon.UrlEncoding;
var i: integer;
    s: RawByteString;
    name,value: RawUTF8;
    P: PUTF8Char;
    GUID2: TGUID;
    U: TURI;
const GUID: TGUID = '{c9a646d3-9c61-4cb7-bfcd-ee2522c8f633}';
procedure Test(const decoded,encoded: RawUTF8);
begin
  Check(UrlEncode(decoded)=encoded);
................................................................................
  Check(P^=#0);
  Check(name='name,complex');
  Check(value='value');
  for i := 0 to 100 do begin
    s := RandomString(i*5);
    Check(UrlDecode(UrlEncode(s))=s,string(s));
  end;
  s := BinToBase64URI(@GUID,sizeof(GUID));
  Check(s='00amyWGct0y_ze4lIsj2Mw');
  Base64FromURI(s);
  Check(Base64ToBinLength(pointer(s),length(s))=sizeof(GUID2));
  fillchar(GUID2,sizeof(GUID2),0);
  SynCommons.Base64Decode(Pointer(s),@GUID2,SizeOf(GUID2));
  Check(IsEqualGUID(GUID2,GUID));
  Check(U.From('toto.com'));
  Check(U.URI='http://toto.com/');
  Check(U.From('toto.com:123'));
  Check(U.URI='http://toto.com:123/');
  Check(U.From('https://toto.com:123/tata/titi'));
  Check(U.URI='https://toto.com:123/tata/titi');
................................................................................
  end;
end;

procedure TTestLowLevelCommon._UTF8;
procedure Test(CP: cardinal; const W: WinAnsiString);
var C: TSynAnsiConvert;
    L: integer;


    tmpA: array[0..127] of AnsiChar;
begin
  C := TSynAnsiConvert.Engine(CP);

  Check(C.UTF8ToAnsi(C.AnsiToUTF8(W))=W);

















  Check(C.RawUnicodeToAnsi(C.AnsiToRawUnicode(W))=W);

  FillChar(tmpA,SizeOf(tmpA),1);
  if CP=CP_UTF16 then
    exit;
  L := C.Utf8ToAnsiBuffer(RawByteString(W),tmpA,sizeof(tmpA));
  Check(L=StrLen(@tmpA));
  if L<sizeof(tmpA)-1 then
    Check(L=Length(W)) else
................................................................................
var i, CP, L: integer;
    W: WinAnsiString;
    WS: WideString;
    SU: SynUnicode;
    U, res, Up,Up2: RawUTF8;
    arr: TRawUTF8DynArray;
    PB: PByte;
{$ifndef DELPHI5OROLDER}
    q: RawUTF8;
{$endif}
    Unic: RawUnicode;
    WA: Boolean;
begin
  res := 'one,two,three';
  Check(StrLen(nil)=0);
  for i := length(res)+1 downto 1 do
    Check(StrLen(Pointer(@res[i]))=length(res)-i+1);
................................................................................
    Test(CP_UTF8,W);
    L := Length(W);
    if L and 1<>0 then
      SetLength(W,L-1); // force exact UTF-16 buffer length
    Test(CP_UTF16,W);
    W := WinAnsiString(RandomString(i*5));
    U := WinAnsiToUtf8(W);


    Check(Utf8ToWinAnsi(U)=W);
    Check(WinAnsiConvert.UTF8ToAnsi(WinAnsiConvert.AnsiToUTF8(W))=W);
    Check(WinAnsiConvert.RawUnicodeToAnsi(WinAnsiConvert.AnsiToRawUnicode(W))=W);
    if CurrentAnsiConvert.InheritsFrom(TSynAnsiFixedWidth) then begin
      Check(CurrentAnsiConvert.UTF8ToAnsi(CurrentAnsiConvert.AnsiToUTF8(W))=W);
      Check(CurrentAnsiConvert.RawUnicodeToAnsi(CurrentAnsiConvert.AnsiToRawUnicode(W))=W);
    end;
    Unic := Utf8DecodeToRawUnicode(U);
    res := RawUnicodeToUtf8(Unic);
    Check(res=U);
    Check(RawUnicodeToWinAnsi(Unic)=W);

    WS := UTF8ToWideString(U);
    Check(length(WS)=length(Unic)shr 1);
    if WS<>'' then
      Check(CompareMem(pointer(WS),pointer(Unic),length(WS)*sizeof(WideChar)));
    Check(integer(Utf8ToUnicodeLength(Pointer(U)))=length(WS));
    SU := UTF8ToSynUnicode(U);
    Check(length(SU)=length(Unic)shr 1);
................................................................................
    Trans: TTestCustomJSON2;
    Disco: TTestCustomDiscogs;
    Cache: TSQLRestCacheEntryValue;
{$ifndef DELPHI5OROLDER}
    peop: TSQLRecordPeople;
    K,U2: RawUTF8;
    Valid: boolean;

{$ifndef LVCL}
    Instance: TClassInstance;
    Coll, C2: TCollTst;
    MyItem: TCollTest;
    Comp: TComplexNumber;
    DA: TDynArray;
    F: TFV;
................................................................................
    Check(not IsString(V[2]));
    Check(not IsStringJSON(V[2]));
    Check(GetInteger(V[2])=a);
    Check(V[3]=nil);
    J := BinToBase64WithMagic(U);
    check(PInteger(J)^ and $00ffffff=JSON_BASE64_MAGIC);
{$ifndef DELPHI5OROLDER}
    check(BlobToTSQLRawBlob(pointer(J))=U);


    Base64MagicToBlob(@J[4],K);
    check(BlobToTSQLRawBlob(pointer(K))=U);


{    J := TSQLRestServer.JSONEncodeResult([r]);
    Check(SameValue(GetExtended(pointer(JSONDecode(J)),err),r)); }
    {$ifndef NOVARIANTS}
    with TTextWriter.CreateOwnedStream do
    try
      AddVariant(a);
      Add(',');
................................................................................
procedure TTestCryptographicRoutines._Adler32;
begin
  Check(Adler32SelfTest);
end;

procedure TTestCryptographicRoutines._Base64;
const
  Value64: RawByteString = 'SGVsbG8gL2Mn6XRhaXQg5+Ar';
var tmp, b64: RawByteString;

    Value: WinAnsiString;
    i, L: Integer;
begin
  Value := 'Hello /c''0tait 67+';
  Value[10] := #$E9;
  Value[16] := #$E7;
  Value[17] := #$E0;

procedure TTestLowLevelCommon._TDynArray;
var AI, AI2: TIntegerDynArray;
    AU: TRawUTF8DynArray;
    AR: TRecs;
    AF: TFVs;
    AF2: TFV2s;
    i,j,k,Len, count,AIcount: integer;
    U,U2: RawUTF8;
    P: PUTF8Char;
    PI: PIntegerArray;
    R: TRec;
    F, F1: TFV;
    F2: TFV2;
    City: TCity;
    Province: TProvince;
................................................................................
  end;
  W.CancelAll;
  W.AddDynArrayJSON(ARP);
  U := W.Text;
  Check(Hash32(U)={$ifdef CPU64}$9F98936D{$else}$54659D65{$endif});
  P := pointer(U);
  JSON_BASE64_MAGIC_UTF8 := RawUnicodeToUtf8(@MAGIC,2);
  U2 := RawUTF8('[')+JSON_BASE64_MAGIC_UTF8+RawUTF8(BinToBase64(ARP.SaveTo))+RawUTF8('"]');
  Check(U=U2);
  ARP.Clear;
  Check(ARP.LoadFromJSON(pointer(U))<>nil);
  if not CheckFailed(ARP.Count=1001) then
    for i := 0 to 1000 do
    with AR[i] do begin
      Check(A=i);
      Check(B=byte(i+1));
................................................................................
  {Check(A.Dyn[0]=0) bug in original VCL?}
  Check(C.Dyn[0]=10);
end;

procedure TTestLowLevelCommon.UrlEncoding;
var i: integer;
    s: RawByteString;
    name,value,utf: RawUTF8;
    P: PUTF8Char;
    GUID2: TGUID;
    U: TURI;
const GUID: TGUID = '{c9a646d3-9c61-4cb7-bfcd-ee2522c8f633}';
procedure Test(const decoded,encoded: RawUTF8);
begin
  Check(UrlEncode(decoded)=encoded);
................................................................................
  Check(P^=#0);
  Check(name='name,complex');
  Check(value='value');
  for i := 0 to 100 do begin
    s := RandomString(i*5);
    Check(UrlDecode(UrlEncode(s))=s,string(s));
  end;
  utf := BinToBase64URI(@GUID,sizeof(GUID));
  Check(utf='00amyWGct0y_ze4lIsj2Mw');
  Base64FromURI(utf);
  Check(Base64ToBinLength(pointer(utf),length(utf))=sizeof(GUID2));
  fillchar(GUID2,sizeof(GUID2),0);
  SynCommons.Base64Decode(Pointer(utf),@GUID2,SizeOf(GUID2));
  Check(IsEqualGUID(GUID2,GUID));
  Check(U.From('toto.com'));
  Check(U.URI='http://toto.com/');
  Check(U.From('toto.com:123'));
  Check(U.URI='http://toto.com:123/');
  Check(U.From('https://toto.com:123/tata/titi'));
  Check(U.URI='https://toto.com:123/tata/titi');
................................................................................
  end;
end;

procedure TTestLowLevelCommon._UTF8;
procedure Test(CP: cardinal; const W: WinAnsiString);
var C: TSynAnsiConvert;
    L: integer;
    A: RawByteString;
    U: RawUTF8;
    tmpA: array[0..127] of AnsiChar;
begin
  C := TSynAnsiConvert.Engine(CP);
  Check(C.CodePage=CP);
  U := C.AnsiToUTF8(W);
  A := C.UTF8ToAnsi(U);
  Check(length(W)=length(A));
  if W='' then
    exit;
  {$ifdef HASCODEPAGE}
  {$ifndef FPC}
  Check(StringCodePage(W)=1252);
  {$endif}
  CP := StringCodePage(A);
  Check(CP=C.CodePage);
  {$endif}
  {$ifdef FPC}
  if CP=CP_UTF16 then
    exit;
  Check(CompareMem(pointer(W),pointer(A),length(W)));
  {$else}
  Check(A=W);
  Check(C.RawUnicodeToAnsi(C.AnsiToRawUnicode(W))=W);
  {$endif}
  FillChar(tmpA,SizeOf(tmpA),1);
  if CP=CP_UTF16 then
    exit;
  L := C.Utf8ToAnsiBuffer(RawByteString(W),tmpA,sizeof(tmpA));
  Check(L=StrLen(@tmpA));
  if L<sizeof(tmpA)-1 then
    Check(L=Length(W)) else
................................................................................
var i, CP, L: integer;
    W: WinAnsiString;
    WS: WideString;
    SU: SynUnicode;
    U, res, Up,Up2: RawUTF8;
    arr: TRawUTF8DynArray;
    PB: PByte;
    {$ifndef DELPHI5OROLDER}
    q: RawUTF8;
    {$endif}
    Unic: RawUnicode;
    WA: Boolean;
begin
  res := 'one,two,three';
  Check(StrLen(nil)=0);
  for i := length(res)+1 downto 1 do
    Check(StrLen(Pointer(@res[i]))=length(res)-i+1);
................................................................................
    Test(CP_UTF8,W);
    L := Length(W);
    if L and 1<>0 then
      SetLength(W,L-1); // force exact UTF-16 buffer length
    Test(CP_UTF16,W);
    W := WinAnsiString(RandomString(i*5));
    U := WinAnsiToUtf8(W);
    Unic := Utf8DecodeToRawUnicode(U);
    {$ifndef FPC_HAS_CPSTRING} // buggy FPC
    Check(Utf8ToWinAnsi(U)=W);
    Check(WinAnsiConvert.UTF8ToAnsi(WinAnsiConvert.AnsiToUTF8(W))=W);
    Check(WinAnsiConvert.RawUnicodeToAnsi(WinAnsiConvert.AnsiToRawUnicode(W))=W);
    if CurrentAnsiConvert.InheritsFrom(TSynAnsiFixedWidth) then begin
      Check(CurrentAnsiConvert.UTF8ToAnsi(CurrentAnsiConvert.AnsiToUTF8(W))=W);
      Check(CurrentAnsiConvert.RawUnicodeToAnsi(CurrentAnsiConvert.AnsiToRawUnicode(W))=W);
    end;

    res := RawUnicodeToUtf8(Unic);
    Check(res=U);
    Check(RawUnicodeToWinAnsi(Unic)=W);
    {$endif FPC_HAS_CPSTRING}
    WS := UTF8ToWideString(U);
    Check(length(WS)=length(Unic)shr 1);
    if WS<>'' then
      Check(CompareMem(pointer(WS),pointer(Unic),length(WS)*sizeof(WideChar)));
    Check(integer(Utf8ToUnicodeLength(Pointer(U)))=length(WS));
    SU := UTF8ToSynUnicode(U);
    Check(length(SU)=length(Unic)shr 1);
................................................................................
    Trans: TTestCustomJSON2;
    Disco: TTestCustomDiscogs;
    Cache: TSQLRestCacheEntryValue;
{$ifndef DELPHI5OROLDER}
    peop: TSQLRecordPeople;
    K,U2: RawUTF8;
    Valid: boolean;
    RB: TSQLRawBlob;
{$ifndef LVCL}
    Instance: TClassInstance;
    Coll, C2: TCollTst;
    MyItem: TCollTest;
    Comp: TComplexNumber;
    DA: TDynArray;
    F: TFV;
................................................................................
    Check(not IsString(V[2]));
    Check(not IsStringJSON(V[2]));
    Check(GetInteger(V[2])=a);
    Check(V[3]=nil);
    J := BinToBase64WithMagic(U);
    check(PInteger(J)^ and $00ffffff=JSON_BASE64_MAGIC);
{$ifndef DELPHI5OROLDER}
    RB := BlobToTSQLRawBlob(pointer(J));
    check(length(RB)=length(U)); // RB=U is buggy under FPC :(
    check(CompareMem(pointer(RB),pointer(U),length(U)));
    Base64MagicToBlob(@J[4],K);
    RB := BlobToTSQLRawBlob(pointer(K));
    check(length(RB)=length(U)); // RB=U is buggy under FPC :(
    check(CompareMem(pointer(RB),pointer(U),length(U)));
{    J := TSQLRestServer.JSONEncodeResult([r]);
    Check(SameValue(GetExtended(pointer(JSONDecode(J)),err),r)); }
    {$ifndef NOVARIANTS}
    with TTextWriter.CreateOwnedStream do
    try
      AddVariant(a);
      Add(',');
................................................................................
procedure TTestCryptographicRoutines._Adler32;
begin
  Check(Adler32SelfTest);
end;

procedure TTestCryptographicRoutines._Base64;
const
  Value64: RawUTF8 = 'SGVsbG8gL2Mn6XRhaXQg5+Ar';
var tmp: RawByteString;
    b64: RawUTF8;
    Value: WinAnsiString;
    i, L: Integer;
begin
  Value := 'Hello /c''0tait 67+';
  Value[10] := #$E9;
  Value[16] := #$E7;
  Value[17] := #$E0;

// - by default, will use the deflate/.zip header-less format, but you may set
// ZlibFormat=true to add an header, as expected by zlib (and pdf)
function UnCompressStream(src: pointer; srcLen: integer; aStream: TStream;
  checkCRC: PCardinal; ZlibFormat: Boolean=false): cardinal;


type
{$ifdef UNICODE}
  /// define a raw storage string type, used for data buffer management
  ZipString = type RawByteString;
{$else}
  /// define a raw storage string type, used for data buffer management
  ZipString = type AnsiString;
  /// as available in newer Delphi versions
  NativeUInt = cardinal;

// - by default, will use the deflate/.zip header-less format, but you may set
// ZlibFormat=true to add an header, as expected by zlib (and pdf)
function UnCompressStream(src: pointer; srcLen: integer; aStream: TStream;
  checkCRC: PCardinal; ZlibFormat: Boolean=false): cardinal;


type
{$ifdef HASCODEPAGE}
  /// define a raw storage string type, used for data buffer management
  ZipString = type RawByteString;
{$else}
  /// define a raw storage string type, used for data buffer management
  ZipString = type AnsiString;
  /// as available in newer Delphi versions
  NativeUInt = cardinal;

  // LVCL does not support variants
  {$define NOVARIANTS}
{$endif}

{$ifdef UNICODE}
  {$undef ENHANCEDRTL} // Delphi 2009 and up don't have our Enhanced Runtime library
  {$define HASVARUSTRING}

  { due to a bug in Delphi 2009+, we need to fake inheritance of record,
    since TDynArrayHashed = object(TDynArray) fails to initialize
    http://blog.synopse.info/post/2011/01/29/record-and-object-issue-in-Delphi-2010 }
  {$define UNDIRECTDYNARRAY}
{$endif}


................................................................................
{$ifdef FPC}

  {$MODE DELPHI} // e.g. for asm syntax - disabled for FPC 2.6 compatibility
  {$INLINE ON}
  {$MINENUMSIZE 1}
  {$PACKSET 1}
  {$PACKENUM 1}


  {$undef ENHANCEDRTL}    // there is no version of our Enhanced RTL for FPC
  {$undef DOPATCHTRTL}
  {$define USETYPEINFO}  // will use SynFPCTypInfo.pas wrapper
  {$define HASINLINE}
  {$define NODELPHIASM}   // ignore low-level System.@LStrFromPCharLen calls
  {$define HASAESNI}
................................................................................
  {$endif}

  {$define FPC_OR_PUREPASCAL}
  {$define FPC_OR_KYLIX}
  // exceptions interception code in FPC differs from Delphi
  {$define NOEXCEPTIONINTERCEPT}


  {$ifdef VER2_7}
    {$define ISFPC27}
  {$endif}
  {$ifdef VER3_0}
    {$define ISFPC27}
  {$endif}
  {$ifdef VER3_1}
    {$define ISFPC27}
  {$endif}



  {$ifdef ISFPC27}
    {$define ISFPC271}
    {$define HASVARUSTRING}
    {$define HASVARUSTRARG}
    // defined if the http://mantis.freepascal.org/view.php?id=26773 bug is fixed
    // you should use 2.7.1/trunk branch in revision 28995 from 2014-11-05T22:17:54
    // => this will change the TInvokeableVariantType.SetProperty() signature

  // LVCL does not support variants
  {$define NOVARIANTS}
{$endif}

{$ifdef UNICODE}
  {$undef ENHANCEDRTL} // Delphi 2009 and up don't have our Enhanced Runtime library
  {$define HASVARUSTRING}
  {$define HASCODEPAGE}
  { due to a bug in Delphi 2009+, we need to fake inheritance of record,
    since TDynArrayHashed = object(TDynArray) fails to initialize
    http://blog.synopse.info/post/2011/01/29/record-and-object-issue-in-Delphi-2010 }
  {$define UNDIRECTDYNARRAY}
{$endif}


................................................................................
{$ifdef FPC}

  {$MODE DELPHI} // e.g. for asm syntax - disabled for FPC 2.6 compatibility
  {$INLINE ON}
  {$MINENUMSIZE 1}
  {$PACKSET 1}
  {$PACKENUM 1}
  {$CODEPAGE UTF8} // otherwise unexpected behavior occurs in most cases

  {$undef ENHANCEDRTL}    // there is no version of our Enhanced RTL for FPC
  {$undef DOPATCHTRTL}
  {$define USETYPEINFO}  // will use SynFPCTypInfo.pas wrapper
  {$define HASINLINE}
  {$define NODELPHIASM}   // ignore low-level System.@LStrFromPCharLen calls
  {$define HASAESNI}
................................................................................
  {$endif}

  {$define FPC_OR_PUREPASCAL}
  {$define FPC_OR_KYLIX}
  // exceptions interception code in FPC differs from Delphi
  {$define NOEXCEPTIONINTERCEPT}

  // {$if FPC_FULLVERSION>20700} does not compile under Delphi 6-7 :(
  {$ifdef VER2_7}
    {$define ISFPC27}
  {$endif}
  {$ifdef VER3_0}
    {$define ISFPC27}
  {$endif}
  {$ifdef VER3_1}
    {$define ISFPC27}
  {$endif}
  {$ifdef FPC_HAS_CPSTRING}
    {$define HASCODEPAGE} // UNICODE means {$mode delphiunicode}
  {$endif}
  {$ifdef ISFPC27}
    {$define ISFPC271}
    {$define HASVARUSTRING}
    {$define HASVARUSTRARG}
    // defined if the http://mantis.freepascal.org/view.php?id=26773 bug is fixed
    // you should use 2.7.1/trunk branch in revision 28995 from 2014-11-05T22:17:54
    // => this will change the TInvokeableVariantType.SetProperty() signature

'1.18.2255'

'1.18.2256'