unicode.pas
上传用户:raido2005
上传日期:2022-06-22
资源大小:5044k
文件大小:7k
源码类别:

Delphi控件源码

开发平台:

Delphi

  1. //*******************************************************//
  2. //                                                       //
  3. //                      DelphiFlash.com                  //
  4. //              Copyright (c) 2004 FeatherySoft, Inc.    //
  5. //                    info@delphiflash.com               //
  6. //                                                       //
  7. //*******************************************************//
  8. //  Description: This unit is a copy of an system.pas source
  9. //               from Delphi 7 and necessary only for
  10. //               compatibility with Delphi 5
  11. Unit Unicode;
  12. interface
  13. type
  14.   UTF8String = type string;
  15.   PUTF8String = ^UTF8String;
  16. { PChar/PWideChar Unicode <-> UTF8 conversion }
  17. // UnicodeToUTF8(3):
  18. // UTF8ToUnicode(3):
  19. // Scans the source data to find the null terminator, up to MaxBytes
  20. // Dest must have MaxBytes available in Dest.
  21. // MaxDestBytes includes the null terminator (last char in the buffer will be set to null)
  22. // Function result includes the null terminator.
  23. function UnicodeToUtf8(Dest: PChar; Source: PWideChar; MaxBytes: Integer): Integer; overload;
  24. function Utf8ToUnicode(Dest: PWideChar; Source: PChar; MaxChars: Integer): Integer; overload;
  25. // UnicodeToUtf8(4):
  26. // UTF8ToUnicode(4):
  27. // MaxDestBytes includes the null terminator (last char in the buffer will be set to null)
  28. // Function result includes the null terminator.
  29. // Nulls in the source data are not considered terminators - SourceChars must be accurate
  30. function UnicodeToUtf8(Dest: PChar; MaxDestBytes: Cardinal; Source: PWideChar; SourceChars: Cardinal): Cardinal; overload;
  31. function Utf8ToUnicode(Dest: PWideChar; MaxDestChars: Cardinal; Source: PChar; SourceBytes: Cardinal): Cardinal; overload;
  32. { WideString <-> UTF8 conversion }
  33. function UTF8Encode(const WS: WideString): UTF8String;
  34. function UTF8Decode(const S: UTF8String): WideString;
  35. { Ansi <-> UTF8 conversion }
  36. function AnsiToUtf8(const S: string): UTF8String;
  37. function Utf8ToAnsi(const S: UTF8String): string;
  38. implementation
  39. // UnicodeToUTF8(3):
  40. // Scans the source data to find the null terminator, up to MaxBytes
  41. // Dest must have MaxBytes available in Dest.
  42. function UnicodeToUtf8(Dest: PChar; Source: PWideChar; MaxBytes: Integer): Integer;
  43. var
  44.   len: Cardinal;
  45. begin
  46.   len := 0;
  47.   if Source <> nil then
  48.     while Source[len] <> #0 do
  49.       Inc(len);
  50.   Result := UnicodeToUtf8(Dest, MaxBytes, Source, len);
  51. end;
  52. // UnicodeToUtf8(4):
  53. // MaxDestBytes includes the null terminator (last char in the buffer will be set to null)
  54. // Function result includes the null terminator.
  55. // Nulls in the source data are not considered terminators - SourceChars must be accurate
  56. function UnicodeToUtf8(Dest: PChar; MaxDestBytes: Cardinal; Source: PWideChar; SourceChars: Cardinal): Cardinal;
  57. var
  58.   i, count: Cardinal;
  59.   c: Cardinal;
  60. begin
  61.   Result := 0;
  62.   if Source = nil then Exit;
  63.   count := 0;
  64.   i := 0;
  65.   if Dest <> nil then
  66.   begin
  67.     while (i < SourceChars) and (count < MaxDestBytes) do
  68.     begin
  69.       c := Cardinal(Source[i]);
  70.       Inc(i);
  71.       if c <= $7F then
  72.       begin
  73.         Dest[count] := Char(c);
  74.         Inc(count);
  75.       end
  76.       else if c > $7FF then
  77.       begin
  78.         if count + 3 > MaxDestBytes then
  79.           break;
  80.         Dest[count] := Char($E0 or (c shr 12));
  81.         Dest[count+1] := Char($80 or ((c shr 6) and $3F));
  82.         Dest[count+2] := Char($80 or (c and $3F));
  83.         Inc(count,3);
  84.       end
  85.       else //  $7F < Source[i] <= $7FF
  86.       begin
  87.         if count + 2 > MaxDestBytes then
  88.           break;
  89.         Dest[count] := Char($C0 or (c shr 6));
  90.         Dest[count+1] := Char($80 or (c and $3F));
  91.         Inc(count,2);
  92.       end;
  93.     end;
  94.     if count >= MaxDestBytes then count := MaxDestBytes-1;
  95.     Dest[count] := #0;
  96.   end
  97.   else
  98.   begin
  99.     while i < SourceChars do
  100.     begin
  101.       c := Integer(Source[i]);
  102.       Inc(i);
  103.       if c > $7F then
  104.       begin
  105.         if c > $7FF then
  106.           Inc(count);
  107.         Inc(count);
  108.       end;
  109.       Inc(count);
  110.     end;
  111.   end;
  112.   Result := count+1;  // convert zero based index to byte count
  113. end;
  114. function Utf8ToUnicode(Dest: PWideChar; Source: PChar; MaxChars: Integer): Integer;
  115. var
  116.   len: Cardinal;
  117. begin
  118.   len := 0;
  119.   if Source <> nil then
  120.     while Source[len] <> #0 do
  121.       Inc(len);
  122.   Result := Utf8ToUnicode(Dest, MaxChars, Source, len);
  123. end;
  124. function Utf8ToUnicode(Dest: PWideChar; MaxDestChars: Cardinal; Source: PChar; SourceBytes: Cardinal): Cardinal;
  125. var
  126.   i, count: Cardinal;
  127.   c: Byte;
  128.   wc: Cardinal;
  129. begin
  130.   if Source = nil then
  131.   begin
  132.     Result := 0;
  133.     Exit;
  134.   end;
  135.   Result := Cardinal(-1);
  136.   count := 0;
  137.   i := 0;
  138.   if Dest <> nil then
  139.   begin
  140.     while (i < SourceBytes) and (count < MaxDestChars) do
  141.     begin
  142.       wc := Cardinal(Source[i]);
  143.       Inc(i);
  144.       if (wc and $80) <> 0 then
  145.       begin
  146.         if i >= SourceBytes then Exit;          // incomplete multibyte char
  147.         wc := wc and $3F;
  148.         if (wc and $20) <> 0 then
  149.         begin
  150.           c := Byte(Source[i]);
  151.           Inc(i);
  152.           if (c and $C0) <> $80 then Exit;      // malformed trail byte or out of range char
  153.           if i >= SourceBytes then Exit;        // incomplete multibyte char
  154.           wc := (wc shl 6) or (c and $3F);
  155.         end;
  156.         c := Byte(Source[i]);
  157.         Inc(i);
  158.         if (c and $C0) <> $80 then Exit;       // malformed trail byte
  159.         Dest[count] := WideChar((wc shl 6) or (c and $3F));
  160.       end
  161.       else
  162.         Dest[count] := WideChar(wc);
  163.       Inc(count);
  164.     end;
  165.     if count >= MaxDestChars then count := MaxDestChars-1;
  166.     Dest[count] := #0;
  167.   end
  168.   else
  169.   begin
  170.     while (i < SourceBytes) do
  171.     begin
  172.       c := Byte(Source[i]);
  173.       Inc(i);
  174.       if (c and $80) <> 0 then
  175.       begin
  176.         if i >= SourceBytes then Exit;          // incomplete multibyte char
  177.         c := c and $3F;
  178.         if (c and $20) <> 0 then
  179.         begin
  180.           c := Byte(Source[i]);
  181.           Inc(i);
  182.           if (c and $C0) <> $80 then Exit;      // malformed trail byte or out of range char
  183.           if i >= SourceBytes then Exit;        // incomplete multibyte char
  184.         end;
  185.         c := Byte(Source[i]);
  186.         Inc(i);
  187.         if (c and $C0) <> $80 then Exit;       // malformed trail byte
  188.       end;
  189.       Inc(count);
  190.     end;
  191.   end;
  192.   Result := count+1;
  193. end;
  194. function Utf8Encode(const WS: WideString): UTF8String;
  195. var
  196.   L: Integer;
  197.   Temp: UTF8String;
  198. begin
  199.   Result := '';
  200.   if WS = '' then Exit;
  201.   SetLength(Temp, Length(WS) * 3); // SetLength includes space for null terminator
  202.   L := UnicodeToUtf8(PChar(Temp), Length(Temp)+1, PWideChar(WS), Length(WS));
  203.   if L > 0 then
  204.     SetLength(Temp, L-1)
  205.   else
  206.     Temp := '';
  207.   Result := Temp;
  208. end;
  209. function Utf8Decode(const S: UTF8String): WideString;
  210. var
  211.   L: Integer;
  212.   Temp: WideString;
  213. begin
  214.   Result := '';
  215.   if S = '' then Exit;
  216.   SetLength(Temp, Length(S));
  217.   L := Utf8ToUnicode(PWideChar(Temp), Length(Temp)+1, PChar(S), Length(S));
  218.   if L > 0 then
  219.     SetLength(Temp, L-1)
  220.   else
  221.     Temp := '';
  222.   Result := Temp;
  223. end;
  224. function AnsiToUtf8(const S: string): UTF8String;
  225. begin
  226.   Result := Utf8Encode(S);
  227. end;
  228. function Utf8ToAnsi(const S: UTF8String): string;
  229. begin
  230.   Result := Utf8Decode(S);
  231. end;
  232. end.