all: new TByteToByte/TByteToAnsiChar and similar types

Author: Arnaud Bouchez

src/core/mormot.core.base.pas

@@ -484,6 +484,17 @@ interface
   PObjectArray = ^TObjectArray;
   TPtrIntArray = array[ 0 .. MaxInt div SizeOf(PtrInt) - 1 ] of PtrInt;
   PPtrIntArray = ^TPtrIntArray;
+  TByteToByte = array[byte] of byte;
+  TByteToAnsiChar = array[byte] of AnsiChar;
+  TByteToWideChar = array[byte] of WideChar;
+  /// type of mormot.core.unicode TNormTable lookup table
+  TAnsiCharToAnsiChar = array[AnsiChar] of AnsiChar;
+  /// type of a lookup table used for fast two-digit chars conversion
+  TAnsiCharToWord = array[AnsiChar] of word;
+  PAnsiCharToWord = ^TAnsiCharToWord;
+  /// type of a lookup table used for fast two-digit chars conversion
+  TByteToWord = array[byte] of word;
+  PByteToWord = ^TByteToWord;
   PInt64Rec = ^Int64Rec;
   PLongRec = ^LongRec;
   PPShortString = ^PShortString;

src/core/mormot.core.buffers.pas

@@ -8636,7 +8636,7 @@ function UrlDecodeDouble(U: PUtf8Char; const Upper: RawUtf8;
 
 function UrlDecodeNeedParameters(U, CsvNames: PUtf8Char): boolean;
 var
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
   L: integer;
   Beg: PUtf8Char;
 // UrlDecodeNeedParameters('price=20.45&where=LastName%3D','price,where') will

src/core/mormot.core.data.pas

@@ -3964,7 +3964,7 @@ function GetSectionContent(SectionFirstLine: PUtf8Char): RawUtf8;
 function GetSectionContent(const Content, SectionName: RawUtf8): RawUtf8;
 var
   P: PUtf8Char;
-  UpperSection: array[byte] of AnsiChar;
+  UpperSection: TByteToAnsiChar;
 begin
   P := pointer(Content);
   PWord(UpperCopy255(UpperSection{%H-}, SectionName))^ := ord(']');
@@ -3978,7 +3978,7 @@ function DeleteSection(var Content: RawUtf8; const SectionName: RawUtf8;
   EraseSectionHeader: boolean): boolean;
 var
   P: PUtf8Char;
-  UpperSection: array[byte] of AnsiChar;
+  UpperSection: TByteToAnsiChar;
 begin
   result := false; // no modification
   P := pointer(Content);
@@ -4036,7 +4036,7 @@ procedure ReplaceSection(SectionFirstLine: PUtf8Char; var Content: RawUtf8;
 
 procedure ReplaceSection(var Content: RawUtf8; const SectionName, NewSectionContent: RawUtf8);
 var
-  UpperSection: array[byte] of AnsiChar;
+  UpperSection: TByteToAnsiChar;
   P: PUtf8Char;
 begin
   P := pointer(Content);
@@ -4069,7 +4069,7 @@ function FindIniNameValueInteger(P: PUtf8Char; const UpperName: RawUtf8): PtrInt
 function FindIniEntry(const Content, Section, Name, DefaultValue: RawUtf8): RawUtf8;
 var
   P: PUtf8Char;
-  UpperSection, UpperName: array[byte] of AnsiChar;
+  UpperSection, UpperName: TByteToAnsiChar;
 begin
   result := DefaultValue;
   P := pointer(Content);
@@ -4175,7 +4175,7 @@ procedure UpdateIniEntry(var Content: RawUtf8;
   SectionFound: boolean;
   i, UpperNameLength: PtrInt;
   V: RawUtf8;
-  UpperSection, UpperName: array[byte] of AnsiChar;
+  UpperSection, UpperName: TByteToAnsiChar;
 begin
   UpperNameLength := length(Name);
   PWord(UpperCopy255Buf(
@@ -4248,7 +4248,7 @@ function IniToObject(const Ini: RawUtf8; Instance: TObject;
   section, nested, json: PUtf8Char;
   name: PAnsiChar;
   n, v: RawUtf8;
-  up: array[byte] of AnsiChar;
+  up: TByteToAnsiChar;
 begin
   result := false; // true when at least one property has been read
   if (Ini = '') or
@@ -4462,7 +4462,7 @@ function HashIntern(P: PUtf8Char; L: PtrUInt): cardinal;
 
 function HashInternI(P: PUtf8Char; L: PtrUInt): cardinal;
 var
-  tmp: array[byte] of AnsiChar; // avoid slow heap allocation
+  tmp: TByteToAnsiChar; // avoid slow heap allocation
 begin
   if (P <> nil) and
      (L <> 0) then
@@ -5368,7 +5368,7 @@ function TRawUtf8List.EqualValueAt(Index: PtrInt; const aText: RawUtf8): boolean
 
 function TRawUtf8List.IndexOfName(const Name: RawUtf8): PtrInt;
 var
-  UpperName: array[byte] of AnsiChar;
+  UpperName: TByteToAnsiChar;
   table: PNormTable;
 begin
   if self <> nil then
@@ -6549,7 +6549,7 @@ function BinarySaveLength(Data: pointer; Info: PRttiInfo; Len: PInteger;
 var
   size: integer;
   W: TBufferWriter; // not very fast, but good enough (RecordSave don't use it)
-  temp: array[byte] of byte; // will use mostly TFakeWriterStream.Write()
+  temp: TByteToByte; // will use mostly TFakeWriterStream.Write()
   save: TRttiBinarySave;
 begin
   save := RTTI_BINARYSAVE[Info^.Kind];
@@ -9031,7 +9031,7 @@ function HashAnsiString(Item: PAnsiChar; Hasher: THasher): cardinal;
 
 function HashAnsiStringI(Item: PUtf8Char; Hasher: THasher): cardinal;
 var
-  tmp: array[byte] of AnsiChar; // avoid any slow heap allocation
+  tmp: TByteToAnsiChar; // avoid any slow heap allocation
 begin
   Item := PPointer(Item)^; // passed as non-nil PAnsiString reference
   if Item <> nil then
@@ -9062,7 +9062,7 @@ function HashSynUnicode(Item: PAnsiChar; Hasher: THasher): cardinal;
 
 function HashSynUnicodeI(Item: PSynUnicode; Hasher: THasher): cardinal;
 var
-  tmp: array[byte] of AnsiChar; // avoid slow heap allocation
+  tmp: TByteToAnsiChar; // avoid slow heap allocation
 begin
   if PtrUInt(Item^) <> 0 then
     result := Hasher(HashSeed, tmp{%H-}, UpperCopy255W(tmp{%H-}, Item^) - {%H-}tmp)
@@ -9081,7 +9081,7 @@ function HashWideString(Item: PWideString; Hasher: THasher): cardinal;
 
 function HashWideStringI(Item: PWideString; Hasher: THasher): cardinal;
 var
-  tmp: array[byte] of AnsiChar; // avoid slow heap allocation
+  tmp: TByteToAnsiChar; // avoid slow heap allocation
 begin
   if PtrUInt(Item^) <> 0 then
     result := Hasher(HashSeed, tmp{%H-},
@@ -9101,7 +9101,7 @@ function HashPUtf8Char(Item: PAnsiChar; Hasher: THasher): cardinal;
 
 function HashPUtf8CharI(Item: PUtf8Char; Hasher: THasher): cardinal;
 var
-  tmp: array[byte] of AnsiChar; // avoid slow heap allocation
+  tmp: TByteToAnsiChar; // avoid slow heap allocation
 begin
   Item := PPointer(Item)^; // passed as non-nil PPUtf8Char reference
   if Item <> nil then
@@ -9154,7 +9154,7 @@ function Hash512(Item: pointer; Hasher: THasher): cardinal;
 function VariantHash(const value: variant; CaseInsensitive: boolean;
   Hasher: THasher): cardinal;
 var
-  tmp: array[byte] of AnsiChar; // avoid heap allocation
+  tmp: TByteToAnsiChar; // avoid heap allocation
   vt: cardinal;
   S: TStream;
   W: TTextWriter;

src/core/mormot.core.json.pas

@@ -118,14 +118,14 @@   EJsonException = class(ESynException);
   // - 1 = JSON_ESCAPE_ENDINGZERO indicates #0 (end of string)
   // - 2 = JSON_ESCAPE_UNICODEHEX should be escaped as \u00xx
   // - b,t,n,f,r,\," as escaped character for #8,#9,#10,#12,#13,\,"
-  JSON_ESCAPE: array[byte] of byte;
+  JSON_ESCAPE: TByteToByte;
 
   /// 256-byte lookup table for fast branchless JSON text un-escaping
   // - #0 = JSON_UNESCAPE_UNEXPECTED for unexpected #0 or control char
   // - #1 = JSON_UNESCAPE_UTF16 for '\u0123' UTF-16 pattern
   // - #8,#9,#10,#12,#13 as unescaped char from b,t,n,f,r
   // - other characters are litterals and should be written as such
-  JSON_UNESCAPE: array[AnsiChar] of AnsiChar;
+  JSON_UNESCAPE: TAnsiCharToAnsiChar;
 
   /// how many initial chars of a JSON array are parsed for intial capacity
   // - used e.g. by _JL_DynArray() and TDocVariantData.InitJsonInPlace()
@@ -4298,7 +4298,7 @@ function JsonObjectItem(P: PUtf8Char; PropName: PUtf8Char; PropNameLen: PtrInt;
   PropNameFound: PRawUtf8): PUtf8Char;
 var
   name: ShortString; // no memory allocation nor P^ modification
-  PropNameUpper: array[byte] of AnsiChar;
+  PropNameUpper: TByteToAnsiChar;
   parser: TJsonGotoEndParser;
 begin
   if P <> nil then

src/core/mormot.core.os.posix.inc

@@ -2767,7 +2767,7 @@ function kenv(action: integer; name, value: PAnsiChar; len: integer): integer;
 
 function GetSmbEfiMem: RawByteString;
 var
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
   xaddr: PtrUInt;
 begin
   result := '';
@@ -2803,7 +2803,7 @@ const
 procedure _DirectSmbiosInfo(out info: TSmbiosBasicInfos);
 var
   i: PtrInt;
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
 begin
   for i := 0 to high(_KNOWN) do
     with _KNOWN[i] do

src/core/mormot.core.os.security.pas

@@ -1016,10 +1016,10 @@ function SecAclToBinary(const acl: TSecAcl): RawByteString;
         Int: TRawAceOperandInt);
       sctOctetString: (
         OctetBytes: cardinal;
-        Octet: array[byte] of byte);
+        Octet: TByteToByte);
       sctComposite: (
         CompositeBytes: cardinal;
-        Composite: array[byte] of byte);
+        Composite: TByteToByte);
       sctSid: (
         SidBytes: cardinal;
         Sid: TSid);
@@ -1030,7 +1030,7 @@ function SecAclToBinary(const acl: TSecAcl): RawByteString;
       sctResourceAttribute,
       sctDeviceAttribute: (
         UnicodeBytes: cardinal;
-        Unicode: array[byte] of WideChar);
+        Unicode: TByteToWideChar);
   end;
   PRawAceOperand = ^TRawAceOperand;
 
@@ -5237,7 +5237,7 @@ function CurrentUserIsAdmin: boolean;
 function LookupSid(sid: PSid; out name, domain: RawUtf8;
   const server: RawUtf8): TSidType;
 var
-  n, d: array[byte] of WideChar;
+  n, d: TByteToWideChar;
   s: TSynTempBuffer;
   nl, dl, use: cardinal;
 begin

src/core/mormot.core.os.windows.inc

@@ -1066,7 +1066,7 @@ const
 
 function GetExecutableName(aAddress: pointer): TFileName;
 var
-  tmp: array[byte] of WideChar;
+  tmp: TByteToWideChar;
   hm: HMODULE;
 begin
   result := '';
@@ -2892,7 +2892,7 @@ end;
 
 procedure GetUserHost(out User, Host: RawUtf8);
 var
-  tmp: array[byte] of WideChar;
+  tmp: TByteToWideChar;
   tmpsize: cardinal;
 begin
   tmpsize := SizeOf(tmp);

src/core/mormot.core.rtti.pas

@@ -3592,7 +3592,7 @@ procedure TRttiEnumType.AddCaptionStrings(Strings: TStrings;
   UsedValuesBits: pointer);
 var
   i, L: PtrInt;
-  Line: array[byte] of AnsiChar;
+  Line: TByteToAnsiChar;
   P: PAnsiChar;
   V: PShortString;
   s: string;
@@ -6319,7 +6319,7 @@ function GetSetCsvValue(aTypeInfo: PRttiInfo; Csv: PUtf8Char): QWord;
 
 procedure GetCaptionFromTrimmed(PS: PShortString; var result: string);
 var
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
   L: integer;
 begin
   L := ord(PS^[0]);

src/core/mormot.core.search.pas

@@ -606,7 +606,7 @@   TParserAbstract = class(TSynPersistent)
     fWords: array of TExprNodeWordAbstract;
     fWordCount: integer;
     fNoWordIsAnd: boolean;
-    fFoundStack: array[byte] of AnsiChar; // simple stack-based virtual machine
+    fFoundStack: TByteToAnsiChar; // simple stack-based virtual machine
     procedure ParseNextCurrentWord; virtual; abstract;
     function ParseExpr: TExprNode;
     function ParseFactor: TExprNode;

src/core/mormot.core.text.pas

@@ -2262,14 +2262,6 @@ function IsInvalidHttpHeader(head: PUtf8Char; headlen: PtrInt): boolean;
 
 { **************** Hexadecimal Text And Binary Conversion }
 
-type
-  /// type of a lookup table used for fast two-digit chars conversion
-  TAnsiCharToWord = array[AnsiChar] of word;
-  PAnsiCharToWord = ^TAnsiCharToWord;
-  /// type of a lookup table used for fast two-digit chars conversion
-  TByteToWord = array[byte] of word;
-  PByteToWord = ^TByteToWord;
-
 var
   /// conversion table from hexa chars into 0..15 binary data
   // - returns 255 for any character out of 0..9,A..Z,a..z range

src/core/mormot.core.unicode.pas

@@ -54,7 +54,7 @@   TUtf8Table = record
     /// the number of extra bytes in addition to the first UTF-8 byte
     // - since RFC 3629, only values within the 0..3 range should appear, i.e.
     // up to UTF8_MAXUTF16 within the UTF-16 surrogates range
-    Lookup: array[byte] of byte;
+    Lookup: TByteToByte;
     /// retrieve a >127 UCS-4 CodePoint from an UTF-8 sequence
     function GetHighUtf8Ucs4(var U: PUtf8Char): Ucs4CodePoint;
   end;
@@ -1187,12 +1187,12 @@ function StringToWinAnsi(const Text: string): WinAnsiString;
 
 type
   /// lookup table used for fast case conversion
-  TNormTable = packed array[AnsiChar] of AnsiChar;
+  TNormTable = TAnsiCharToAnsiChar;
   /// pointer to a lookup table used for fast case conversion
   PNormTable = ^TNormTable;
 
   /// lookup table used for fast case conversion
-  TNormTableByte = packed array[byte] of byte;
+  TNormTableByte = TByteToByte;
   /// pointer to a lookup table used for fast case conversion
   PNormTableByte = ^TNormTableByte;
 
@@ -1572,15 +1572,15 @@ function GetLineContains(p, pEnd, up: PUtf8Char): boolean;
 // - used internally for short keys match or case-insensitive hash
 // - returns final dest pointer
 // - will copy up to 255 AnsiChar (expect the dest buffer to be defined e.g. as
-// array[byte] of AnsiChar on the caller stack)
+// TByteToAnsiChar on the caller stack)
 function UpperCopy255(dest: PAnsiChar; const source: RawUtf8): PAnsiChar; overload;
   {$ifdef HASINLINE}inline;{$endif}
 
 /// copy source^ into a 256 chars dest^ buffer with 7-bit upper case conversion
 // - used internally for short keys match or case-insensitive hash
 // - returns final dest pointer
 // - will copy up to 255 AnsiChar (expect the dest buffer to be defined e.g. as
-// array[byte] of AnsiChar on the caller stack)
+// TByteToAnsiChar on the caller stack)
 function UpperCopy255Buf(dest: PAnsiChar; source: PUtf8Char; sourceLen: PtrInt): PAnsiChar;
 
 /// copy source into dest^ with WinAnsi 8-bit upper case conversion
@@ -9129,7 +9129,7 @@ procedure CamelCase(P: PAnsiChar; len: PtrInt; var s: RawUtf8; const isWord: TSy
 var
   i: PtrInt;
   d: PAnsiChar;
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
 begin
   if len > SizeOf(tmp) then
     len := SizeOf(tmp);
@@ -9198,7 +9198,7 @@ function LowerCamelCase(const text: RawUtf8): RawUtf8;
 
 procedure SnakeCase(P: PAnsiChar; len: PtrInt; var s: RawUtf8);
 var
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
   d: PAnsiChar;
   flags, last: TSnakeCase;
 begin
@@ -9247,7 +9247,7 @@ function SnakeCase(const text: RawUtf8): RawUtf8;
 
 function IsReservedKeyWord(const aName: RawUtf8): boolean;
 var
-  up: array[byte] of AnsiChar;
+  up: TByteToAnsiChar;
 begin
   UpperCopy255Buf(@up, pointer(aName), length(aName))^ := #0;
   result := FastFindPUtf8CharSorted(
@@ -9267,7 +9267,7 @@ function SanitizePascalName(const aName: RawUtf8; KeyWordCheck: boolean): RawUtf
 
 procedure GetCaptionFromPCharLen(P: PUtf8Char; out result: string);
 var
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
 begin
   if P = nil then
     exit;
@@ -9679,7 +9679,7 @@ function FastFindPUtf8CharSorted(P: PPUtf8CharArray; R: PtrInt; Value: PUtf8Char
 function FastFindUpperPUtf8CharSorted(P: PPUtf8CharArray; R: PtrInt;
   Value: PUtf8Char; ValueLen: PtrInt): PtrInt;
 var
-  tmp: array[byte] of AnsiChar;
+  tmp: TByteToAnsiChar;
 begin
   UpperCopy255Buf(@tmp, Value, ValueLen)^ := #0;
   result := FastFindPUtf8CharSorted(P, R, @tmp);