--- Merging r32264 into '.':

U    utils/tply/lextable.pas
U    utils/tply/plex.pas
--- Recording mergeinfo for merge of r32264 into '.':
 G   .

# revisions: 32264

git-svn-id: branches/fixes_3_0@33789 -

.gitattributes

@@ -9166,6 +9166,11 @@ rtl/objpas/sysutils/syscodepagesh.inc svneol=native#text/pascal
 rtl/objpas/sysutils/sysencoding.inc svneol=native#text/pascal
 rtl/objpas/sysutils/sysencodingh.inc svneol=native#text/pascal
 rtl/objpas/sysutils/sysformt.inc svneol=native#text/plain
+rtl/objpas/sysutils/syshelp.inc svneol=native#text/plain
+rtl/objpas/sysutils/syshelpb.inc svneol=native#text/plain
+rtl/objpas/sysutils/syshelpf.inc svneol=native#text/plain
+rtl/objpas/sysutils/syshelph.inc svneol=native#text/plain
+rtl/objpas/sysutils/syshelpo.inc svneol=native#text/plain
 rtl/objpas/sysutils/sysint.inc svneol=native#text/plain
 rtl/objpas/sysutils/sysinth.inc svneol=native#text/plain
 rtl/objpas/sysutils/syspch.inc svneol=native#text/plain

rtl/amicommon/sysutils.pp

@@ -27,6 +27,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 {$DEFINE OS_FILESETDATEBYNAME}
 {$DEFINE HAS_SLEEP}

rtl/embedded/sysutils.pp

@@ -20,6 +20,11 @@ unit sysutils;
 
 interface
 
+{$DEFINE HAS_SLEEP}
+{$DEFINE HAS_OSERROR}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
+
 { used OS file system APIs use ansistring }
 {$define SYSUTILS_HAS_ANSISTR_FILEUTIL_IMPL}
 { OS has an ansistring/single byte environment variable API }

rtl/emx/sysutils.pp

@@ -21,6 +21,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
  Dos;

rtl/gba/sysutils.pp

@@ -28,6 +28,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 {$DEFINE HAS_SLEEP}
 {$DEFINE HAS_OSERROR}

rtl/go32v2/sysutils.pp

@@ -23,6 +23,8 @@ interface
 {$MODESWITCH out}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
   go32,dos;

rtl/inc/ustringh.inc

@@ -52,7 +52,11 @@ procedure DefaultUnicode2AnsiMove(source:punicodechar;var dest:RawByteString;cp
 procedure DefaultAnsi2UnicodeMove(source:pchar;cp : TSystemCodePage;var dest:unicodestring;len:SizeInt);
 
 Type
-  TStandardCodePageEnum = (
+  TCompareOption = (coLingIgnoreCase, coLingIgnoreDiacritic, coIgnoreCase,
+                    coIgnoreKanaType, coIgnoreNonSpace, coIgnoreSymbols, coIgnoreWidth,
+                    coLingCasing, coDigitAsNumbers, coStringSort);
+  TCompareOptions = set of TCompareOption;
+                                              TStandardCodePageEnum = (
     scpAnsi,                 // system Ansi code page (GetACP on windows)
     scpConsoleInput,         // system console input code page (GetConsoleCP on windows)
     scpConsoleOutput,        // system console output code page (GetConsoleOutputCP on windows)
@@ -78,8 +82,9 @@ Type
     CompUCS2 : function(p1,p2:PUCS2Char) : shortint;
     CompUCS4 : function(p1,p2:PUC42Char) : shortint;
 }
-    CompareWideStringProc : function(const s1, s2 : WideString) : PtrInt;
-    CompareTextWideStringProc : function(const s1, s2 : WideString): PtrInt;
+    CompareWideStringProc : function(const s1, s2 : WideString; Options : TCompareOptions) : PtrInt;
+    // CompareTextWideStringProc is CompareWideStringProc with coIgnoreCase in options.
+//    CompareTextWideStringProc : function(const s1, s2 : WideString): PtrInt;
     { return value: number of code points in the string. Whenever an invalid
       code point is encountered, all characters part of this invalid code point
       are considered to form one "character" and the next character is
@@ -109,8 +114,9 @@ Type
     Ansi2UnicodeMoveProc : procedure(source:pchar;cp : TSystemCodePage;var dest:unicodestring;len:SizeInt);
     UpperUnicodeStringProc : function(const S: UnicodeString): UnicodeString;
     LowerUnicodeStringProc : function(const S: UnicodeString): UnicodeString;
-    CompareUnicodeStringProc : function(const s1, s2 : UnicodeString) : PtrInt;
-    CompareTextUnicodeStringProc : function(const s1, s2 : UnicodeString): PtrInt;
+    CompareUnicodeStringProc : function(const s1, s2 : UnicodeString; Options : TCompareOptions) : PtrInt;
+    // CompareTextUnicodeStringProc is CompareUnicodeStringProc with coIgnoreCase in options.
+    /// CompareTextUnicodeStringProc : function(const s1, s2 : UnicodeString): PtrInt;
 
     { codepage retrieve function }
     GetStandardCodePageProc: function(const stdcp: TStandardCodePageEnum): TSystemCodePage;

rtl/inc/ustrings.inc

@@ -2291,7 +2291,7 @@ function StubUnicodeCase(const s : UnicodeString) : UnicodeString;
     unimplementedunicodestring;
   end;
 
-function StubCompareUnicodeString(const s1, s2 : UnicodeString) : PtrInt;
+function StubCompareUnicodeString(const s1, s2 : UnicodeString; Options : TCompareOptions) : PtrInt;
   begin
     unimplementedunicodestring;
   end;
@@ -2301,7 +2301,7 @@ function StubWideCase(const s: WideString): WideString;
     unimplementedunicodestring;
   end;
 
-function StubCompareWideString(const s1, s2 : WideString) : PtrInt;
+function StubCompareWideString(const s1, s2 : WideString; Options : TCompareOptions) : PtrInt;
   begin
     unimplementedunicodestring;
   end;
@@ -2324,9 +2324,8 @@ procedure initunicodestringmanager;
     widestringmanager.LowerUnicodeStringProc:=@StubUnicodeCase;
 {$endif HAS_WIDESTRINGMANAGER}
     widestringmanager.CompareWideStringProc:=@StubCompareWideString;
-    widestringmanager.CompareTextWideStringProc:=@StubCompareWideString;
+//    widestringmanager.CompareTextWideStringProc:=@StubCompareWideString;
     widestringmanager.CompareUnicodeStringProc:=@StubCompareUnicodeString;
-    widestringmanager.CompareTextUnicodeStringProc:=@StubCompareUnicodeString;
     widestringmanager.CharLengthPCharProc:=@DefaultCharLengthPChar;
     widestringmanager.CodePointLengthProc:=@DefaultCodePointLength;
     widestringmanager.GetStandardCodePageProc:=@DefaultGetStandardCodePage;

rtl/macos/sysutils.pp

@@ -24,6 +24,8 @@ interface
 {$modeswitch out}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
   MacOSTP;

rtl/msdos/sysutils.pp

@@ -23,6 +23,8 @@ interface
 {$MODESWITCH out}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
   {go32,}dos;

rtl/nativent/sysutils.pp

@@ -21,6 +21,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
   ndk;

rtl/nds/sysutils.pp

@@ -28,6 +28,9 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
+
 {$DEFINE HAS_OSERROR}
 {$DEFINE HAS_SLEEP}
 { used OS file system APIs use ansistring }

rtl/netware/sysutils.pp

@@ -21,6 +21,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses DOS;
 

rtl/netwlibc/sysutils.pp

@@ -20,6 +20,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses Libc,DOS;
 

rtl/objpas/fpwidestring.pp

@@ -406,10 +406,22 @@ begin
   Result := CompareUnicodeStringUCA(p1,p2,l1,l2);
 end;
 
-function CompareUnicodeString(const s1, s2 : UnicodeString) : PtrInt;
+function CompareUnicodeString(const s1, s2 : UnicodeString;Options : TCompareOptions) : PtrInt;
+Var
+  us1,us2 : UnicodeString;
 begin
   if (current_Collation=nil) then
-    exit(OldManager.CompareUnicodeStringProc(s1,s2));
+    exit(OldManager.CompareUnicodeStringProc(s1,s2,Options));
+  if (coIgnoreCase in Options) then  
+    begin
+    us1:=UpperUnicodeString(s1);
+    us2:=UpperUnicodeString(s2);
+    end
+  else
+    begin
+    us1:=S1;
+    us2:=S2;
+    end;  
   Result:=CompareUnicodeString(
             PUnicodeChar(Pointer(s1)),
             PUnicodeChar(Pointer(s2)),
@@ -417,25 +429,39 @@ begin
           );
 end;
 
-function CompareWideString(const s1, s2 : WideString) : PtrInt;
+function CompareWideString(const s1, s2 : WideString; Options : TCompareOptions) : PtrInt;
+
+Var
+  us1,us2 : WideString;
+   
 begin
   if (current_Collation=nil) then
-    exit(OldManager.CompareWideStringProc(s1,s2));
+    exit(OldManager.CompareWideStringProc(s1,s2,Options));
+  if (coIgnoreCase in Options) then  
+    begin
+    us1:=UpperWideString(s1);
+    us2:=UpperWideString(s2);
+    end
+  else
+    begin
+    us1:=S1;
+    us2:=S2;
+    end;  
   Result:=CompareUnicodeString(
-            PUnicodeChar(Pointer(s1)),
-            PUnicodeChar(Pointer(s2)),
-            Length(s1),Length(s2)
+            PUnicodeChar(Pointer(us1)),
+            PUnicodeChar(Pointer(us2)),
+            Length(us1),Length(us2)
           );
 end;
 
 function CompareTextUnicodeString(const s1, s2 : UnicodeString) : PtrInt;
 begin
-  Result:=CompareUnicodeString(UpperUnicodeString(s1),UpperUnicodeString(s2));
+  Result:=CompareUnicodeString(s1,s2,[coIgnoreCase]);
 end;
 
 function CompareTextWideString(const s1, s2 : WideString) : PtrInt;
 begin
-  Result:=CompareWideString(UpperWideString(s1),UpperWideString(s2));
+  Result:=CompareWideString(s1,s2,[coIgnoreCase]);
 end;
 
 procedure EnsureAnsiLen(var S: AnsiString; const len: SizeInt); inline;
@@ -649,7 +675,7 @@ begin
   Ansi2UnicodeMove(S1,DefaultSystemCodePage,a,Len1);
   b := '';
   Ansi2UnicodeMove(S2,DefaultSystemCodePage,b,Len2);
-  Result := CompareUnicodeString(a,b);
+  Result := CompareUnicodeString(a,b,[]);
 end;
 
 function StrLCompAnsiString(S1, S2: PAnsiChar; MaxLen: PtrUInt): PtrInt;
@@ -746,7 +772,6 @@ begin
       LowerWideStringProc:=@LowerWideString;
 
       CompareWideStringProc:=@CompareWideString;
-      CompareTextWideStringProc:=@CompareTextWideString;
 {$else FPC_WIDESTRING_EQUAL_UNICODESTRING}
       Ansi2WideMoveProc:=@Ansi2UnicodeMove;
 
@@ -754,7 +779,6 @@ begin
       LowerWideStringProc:=@LowerUnicodeString;
 
       CompareWideStringProc:=@CompareUnicodeString;
-      CompareTextWideStringProc:=@CompareTextUnicodeString;
 {$endif FPC_WIDESTRING_EQUAL_UNICODESTRING}
 
       CharLengthPCharProc:=@CharLengthPChar;
@@ -778,7 +802,6 @@ begin
       UpperUnicodeStringProc:=@UpperUnicodeString;
       LowerUnicodeStringProc:=@LowerUnicodeString;
       CompareUnicodeStringProc:=@CompareUnicodeString;
-      CompareTextUnicodeStringProc:=@CompareTextUnicodeString;
     end;
   SetUnicodeStringManager(locWideStringManager);
 

rtl/objpas/sysutils/syshelp.inc

@@ -0,0 +1,1618 @@
+{%mainunit syshelpers.pp}
+
+{ ---------------------------------------------------------------------
+  TGUIDHelper
+  ---------------------------------------------------------------------}
+
+Procedure NotImplemented(S : String);
+
+begin
+  Raise Exception.Create('Not yet implemented : '+S);
+end;
+
+Class function TGUIDHelper.Create(const Data; BigEndian: Boolean): TGUID; overload; static;
+
+Const
+  GUIDSize = SizeOf(TGUID);
+
+Var
+  B : Array[1..GUIDSize] of Byte;
+
+begin
+  Move(Data,B,GUIDSize);
+  Result:=Create(B,0,BigEndian);
+end;
+
+class function TGUIDHelper.Create(const Data: array of Byte; AStartIndex: Cardinal; BigEndian: Boolean): TGUID; overload; static;
+
+Var
+  A : Cardinal;
+  B,C : Word;
+
+begin
+  if ((System.Length(Data)-AStartIndex)<16) then
+    raise EArgumentException.CreateFmt('The length of a GUID array must be at least %d',[]);
+  Move(Data[AStartIndex],A,SizeOf(Cardinal));
+  Move(Data[AStartIndex+4],B,SizeOf(Word));
+  Move(Data[AStartIndex+6],C,SizeOf(Word));
+//  Writeln('BigEndian : ',BigEndian,', CPU bigendian : ',(CPUendian=TEndian.Big));
+  if BigEndian<>(CPUendian=TEndian.Big) then
+    begin
+//    Writeln('Swapping');
+    A:=SwapEndian(A);
+    B:=SwapEndian(B);
+    C:=SwapEndian(C);
+    end;
+  Result:=Create(A,B,C,Data[AStartIndex+8],Data[AStartIndex+9],Data[AStartIndex+10],Data[AStartIndex+11],Data[AStartIndex+12],Data[AStartIndex+13],Data[AStartIndex+14],Data[AStartIndex+15]);
+end;
+
+Class Function TGUIDHelper.Create(const Data; DataEndian: TEndian = CPUEndian): TGUID; overload; static; inline;
+
+begin
+  Result:=Create(Data,DataEndian=TEndian.Big)
+end;
+
+Class Function TGUIDHelper.Create(const B: TBytes; DataEndian: TEndian = CPUEndian): TGUID; overload; static; inline;
+
+begin
+  Result:=Create(B,0,DataEndian);
+end;
+
+Class Function TGUIDHelper.Create(const B: TBytes; AStartIndex: Cardinal; DataEndian: TEndian = CPUEndian): TGUID; overload; static;
+
+begin
+  if ((System.Length(B)-AStartIndex)<16) then
+    raise EArgumentException.CreateFmt('The length of a GUID array must be at least %d',[]);
+  Result:=Create(B,AStartIndex,DataEndian=TEndian.Big);
+end;
+
+Class Function TGUIDHelper.Create(const S: string): TGUID; overload; static;
+
+begin
+  Result:=StringToGUID(S);
+end;
+
+Class Function TGUIDHelper.Create(A: Integer; B: SmallInt; C: SmallInt; const D: TBytes): TGUID; overload; static;
+
+begin
+  if (System.Length(D)<>8) then
+    raise EArgumentException.CreateFmt('The length of a GUID array must be %d',[]);
+  Result:=Create(Cardinal(A),Word(B),Word(C),D[0],D[1],D[2],D[3],D[4],D[5],D[6],D[7]);
+end;
+
+Class Function TGUIDHelper.Create(A: Integer; B: SmallInt; C: SmallInt; D, E, F, G, H, I, J, K: Byte): TGUID; overload; static;
+
+begin
+  Result:=Create(Cardinal(A),Word(B),Word(C),D,E,F,G,H,I,J,K);
+end;
+
+Class Function TGUIDHelper.Create(A: Cardinal; B: Word; C: Word; D, E, F, G, H, I, J, K: Byte): TGUID; overload; static;
+
+begin
+  Result.D1 := Cardinal(A);
+  Result.D2 := Word(B);
+  Result.D3 := Word(C);
+  Result.D4[0] := D;
+  Result.D4[1] := E;
+  Result.D4[2] := F;
+  Result.D4[3] := G;
+  Result.D4[4] := H;
+  Result.D4[5] := I;
+  Result.D4[6] := J;
+  Result.D4[7] := K;
+end;
+
+Class Function TGUIDHelper.NewGuid: TGUID; static;
+
+begin
+  CreateGUID(Result)
+end;
+
+Function TGUIDHelper.ToByteArray(DataEndian: TEndian = CPUEndian): TBytes;
+
+begin
+  SetLength(Result, 16);
+  if DataEndian<>CPUEndian then
+    begin
+    PCardinal(@Result[0])^ := SwapEndian(D1);
+    PWord(@Result[4])^ := SwapEndian(D2);
+    PWord(@Result[6])^ := SwapEndian(D3);
+    Move(D4, Result[8], 8);
+    end
+  else
+    Move(D1, Result[0], SizeOf(Self));
+
+end;
+
+Function TGUIDHelper.ToString(SkipBrackets : Boolean = False): string;
+
+begin
+  Result:=GuidToString(Self);
+  If SkipBrackets then
+    Result:=Copy(Result,2,Length(Result)-2);
+end;
+
+{ ---------------------------------------------------------------------
+  TStringHelper
+  ---------------------------------------------------------------------}
+
+Function HaveChar(AChar : Char; const AList: array of Char) : Boolean;
+
+Var
+  I : Integer;
+
+begin
+  I:=0;
+  Result:=False;
+  While (Not Result) and (I<Length(AList)) do
+    begin
+    Result:=(AList[i]=AChar);
+    Inc(I);
+    end;
+end;
+
+function TStringHelper.GetChar(AIndex: Integer): Char;
+begin
+  Result:=Self[AIndex+1];
+end;
+
+
+function TStringHelper.GetLength: Integer;
+
+begin
+  Result:=System.Length(Self);
+end;
+
+
+class function TStringHelper.Compare(const A: string; const B: string): Integer;
+begin
+  Result:=Compare(A,0,B,0,System.Length(B),[]);
+end;
+
+
+class function TStringHelper.Compare(const A: string; const B: string;
+  IgnoreCase: Boolean): Integer; //deprecated 'Use same with TCompareOptions';
+begin
+  if IgnoreCase then
+    Result:=Compare(A,B,[coIgnoreCase])
+  else
+    Result:=Compare(A,B,[]);
+end;
+
+
+class function TStringHelper.Compare(const A: string; const B: string;
+  Options: TCompareOptions): Integer;
+begin
+  Result:=Compare(A,0,B,0,System.Length(B),Options);
+end;
+
+
+class function TStringHelper.Compare(const A: string; IndexA: Integer;
+  const B: string; IndexB: Integer; ALen: Integer): Integer;
+begin
+  Result:=Compare(A,IndexA,B,IndexB,ALen,[]);
+end;
+
+
+class function TStringHelper.Compare(const A: string; IndexA: Integer;
+  const B: string; IndexB: Integer; ALen: Integer; IgnoreCase: Boolean
+  ): Integer; //deprecated 'Use same with TCompareOptions';
+begin
+  if IgnoreCase then
+    Result:=Compare(A,IndexA,B,IndexB,ALen,[coIgnoreCase])
+  else
+    Result:=Compare(A,IndexA,B,IndexB,ALen,[])
+end;
+
+
+class function TStringHelper.Compare(const A: string; IndexA: Integer;
+  const B: string; IndexB: Integer; ALen: Integer; Options: TCompareOptions
+  ): Integer;
+
+Var
+  l : Integer;
+
+begin
+  L:=ALen;
+  If (L>system.Length(A)-IndexA) then
+    L:=system.Length(A)-IndexA;
+  If (L>system.Length(B)-IndexB) then
+    L:=system.Length(B)-IndexB;
+  if (coIgnoreCase in Options) then
+    begin
+    Result:=strlicomp(PAnsiChar(@A[IndexA+1]),PAnsiChar(@B[IndexB+1]),L)
+    end
+  else
+    Result:=strlcomp(PAnsiChar(@A[IndexA+1]),PAnsiChar(@B[IndexB+1]),L);
+end;
+
+
+class function TStringHelper.CompareOrdinal(const A: string; const B: string
+  ): Integer;
+
+Var
+  L : Integer;
+
+begin
+  L:=System.Length(B);
+  if L>System.Length(A) then
+    L:=System.Length(A);
+  Result:=CompareOrdinal(A,0,B,0,L);
+end;
+
+
+class function TStringHelper.CompareOrdinal(const A: string; IndexA: Integer;
+  const B: string; IndexB: Integer; ALen: Integer): Integer;
+
+begin
+  Result:=StrLComp(PAnsiChar(@A[IndexA+1]), PAnsiChar(@B[IndexB+1]), ALen);
+end;
+
+
+class function TStringHelper.CompareText(const A: string; const B: string
+  ): Integer;
+begin
+  Result:=Sysutils.CompareText(A,B);
+end;
+
+
+class function TStringHelper.Copy(const Str: string): string;
+begin
+  Result:=Str;
+  UniqueString(Result);
+end;
+
+
+class function TStringHelper.Create(AChar: Char; ACount: Integer): string;
+begin
+   Result:=StringOfChar(AChar,ACount);
+end;
+
+
+class function TStringHelper.Create(const AValue: array of Char): string;
+
+begin
+  Result:=Create(AValue,0,System.Length(AValue));
+end;
+
+
+class function TStringHelper.Create(const AValue: array of Char;
+  StartIndex: Integer; ALen: Integer): string;
+begin
+  SetLength(Result,ALen);
+  if ALen>0 then
+    Move(AValue[StartIndex],Result[1],ALen);
+end;
+
+
+class function TStringHelper.EndsText(const ASubText, AText: string): Boolean;
+begin
+  Result:=(ASubText<>'') and (sysutils.CompareText(System.Copy(AText,System.Length(AText)-System.Length(ASubText)+1,System.Length(ASubText)),ASubText)=0);
+end;
+
+
+class function TStringHelper.Equals(const a: string; const b: string): Boolean;
+begin
+  Result:=A=B;
+end;
+
+
+class function TStringHelper.Format(const AFormat: string;
+  const args: array of const): string;
+begin
+  Result:=Sysutils.Format(AFormat,Args);
+end;
+
+
+class function TStringHelper.IsNullOrEmpty(const AValue: string): Boolean;
+begin
+  Result:=system.Length(AValue)=0;
+end;
+
+
+class function TStringHelper.IsNullOrWhiteSpace(const AValue: string): Boolean;
+begin
+  Result:=system.Length(SysUtils.Trim(AValue))=0;
+end;
+
+
+class function TStringHelper.Join(const Separator: string;
+  const Values: array of const): string;
+
+Var
+  SValues : Array of string;
+  I,L : Integer;
+  S : String;
+  P : ^TVarRec;
+
+begin
+  L:=System.Length(Values);
+  SetLength(SValues,L);
+  Dec(L);
+  for I:=0 to L do
+    begin
+    S:='';
+    P:=@Values[I];
+    Case P^.VType of
+      vtInteger  : S:=IntToStr(P^.VInteger);
+      vtBoolean  : S:=BoolToStr(P^.VBoolean, True);
+      vtChar     : S:=P^.VChar;
+      vtPChar    : S:= string(P^.VPChar);
+      {$ifndef FPUNONE}
+      vtExtended : S:=FloatToStr(P^.VExtended^);
+      {$endif}
+      vtObject   : S:=TObject(P^.VObject).Classname;
+      vtClass    : S:=P^.VClass.Classname;
+      vtCurrency : S:=CurrToStr(P^.VCurrency^);
+      vtVariant  : S:=(P^.VVariant^);
+      vtInt64    : S:=IntToStr(PInt64(P^.VInt64)^);
+      vtQword    : S:=IntToStr(PQWord(P^.VQword)^);
+      vtWideChar     : S:=WideString(P^.VWideChar);
+      vtPWideChar     : S:=WideString(P^.VPWideChar);
+      vtUnicodeString : S:=UnicodeString(P^.VUnicodeString);
+      vtAnsiString    : S:=Ansistring(P^.VAnsiString);
+    else
+      S:=Format('Unknown type: %d',[P^.VType]);
+    end;
+    SValues[I]:=S;
+    end;
+  Result:=Join(Separator,SValues);
+end;
+
+
+class function TStringHelper.Join(const Separator: string;
+  const Values: array of string): string;
+begin
+  Result:=Join(Separator,Values,0,System.Length(Values));
+end;
+
+
+class function TStringHelper.Join(const Separator: string;
+  const Values: array of string; StartIndex: Integer; ACount: Integer): string;
+
+Var
+  I,L,VLen : integer;
+
+begin
+  VLen:=High(Values);
+  If (ACount<0) or ((StartIndex>0) and (StartIndex>VLen)) then
+    raise ERangeError.Create(SRangeError);
+  If (ACount=0) or (VLen<0) then
+    Result:=''
+  else
+    begin
+    L:=StartIndex+ACount-1;
+    if L>Vlen then
+      L:=VLen;
+    Result:=Values[StartIndex];
+    For I:=StartIndex+1 to L do
+      Result:=Result+Separator+Values[I];
+    end;
+end;
+
+
+class function TStringHelper.LowerCase(const S: string): string;
+begin
+  Result:=sysutils.Lowercase(S);
+end;
+
+
+class function TStringHelper.Parse(const AValue: Boolean): string;
+begin
+  Result:=BoolToStr(AValue);
+end;
+
+
+class function TStringHelper.Parse(const AValue: Extended): string;
+begin
+  Result:=FloatToStr(AValue);
+end;
+
+
+class function TStringHelper.Parse(const AValue: Int64): string;
+begin
+  Result:=IntToStr(AValue);
+end;
+
+
+class function TStringHelper.Parse(const AValue: Integer): string;
+begin
+  Result:=IntToStr(AValue);
+end;
+
+
+class function TStringHelper.ToBoolean(const S: string): Boolean;
+begin
+  Result:=StrToBool(S);
+end;
+
+
+class function TStringHelper.ToDouble(const S: string): Double;
+begin
+  Result:=StrToFloat(S);
+end;
+
+
+class function TStringHelper.ToExtended(const S: string): Extended;
+begin
+  Result:=StrToFloat(S);
+end;
+
+
+class function TStringHelper.ToInt64(const S: string): Int64;
+begin
+  Result:=StrToInt64(S);
+end;
+
+
+class function TStringHelper.ToInteger(const S: string): Integer;
+begin
+  Result:=StrToInt(S);
+end;
+
+
+class function TStringHelper.ToSingle(const S: string): Single;
+begin
+  Result:=StrToFloat(S);
+end;
+
+
+class function TStringHelper.UpperCase(const S: string): string;
+begin
+  Result:=sysutils.Uppercase(S);
+end;
+
+
+function TStringHelper.CompareTo(const B: string): Integer;
+begin
+  // Order is important
+  Result:=sysUtils.StrComp(PChar(Self),PChar(B));
+end;
+
+procedure TStringHelper.CopyTo(SourceIndex: Integer; var destination: array of Char; DestinationIndex: Integer; ACount: Integer);
+
+Var
+  P1,P2 : PChar;
+begin
+//  Writeln('((',DestinationIndex,'+',ACount,')<',System.Length(Destination),')  : ', ((DestinationIndex+ACount)<System.Length(Destination)));
+  if ((DestinationIndex+ACount)<=System.Length(Destination)) then
+    begin
+//    Writeln('AHA');
+    P1:=@Self[SourceIndex+1];
+    P2:=@Destination[DestinationIndex];
+    Move(P1^,P2^,ACount*SizeOf(Char));
+    end;
+end;
+
+function TStringHelper.Contains(const AValue: string): Boolean;
+begin
+  Result:=Pos(AValue,Self)>0;
+end;
+
+
+function TStringHelper.CountChar(const C: Char): Integer;
+
+Var
+  S : Char;
+begin
+  Result:=0;
+  For S in Self do
+    if (S=C) then
+      Inc(Result);
+end;
+
+
+function TStringHelper.DeQuotedString: string;
+begin
+  Result:=DeQuotedString('''');
+end;
+
+
+function TStringHelper.DeQuotedString(const AQuoteChar: Char): string;
+
+var
+  L,I : Integer;
+  Res : Array of Char;
+  PS,PD : PChar;
+  IsQuote : Boolean;
+
+begin
+  L:=System.Length(Self);
+  if (L<2) or Not ((Self[1]=AQuoteChar) and (Self[L]=AQuoteChar)) then
+    Exit(Self);
+  SetLength(Res,L);
+  IsQuote:=False;
+  PS:=@Self[2];
+  PD:=@Res[0];
+  For I:=2 to L-1 do
+    begin
+    if (PS^=AQuoteChar) then
+      begin
+      IsQuote:=Not IsQuote;
+      if Not IsQuote then
+        begin
+        PD^:=PS^;
+        Inc(PD);
+        end;
+      end
+    else
+      begin
+      if IsQuote then
+        IsQuote:=false;
+      PD^:=PS^;
+      Inc(PD);
+      end;
+    Inc(PS);
+    end;
+  SetString(Result,@Res[0],PD-@Res[0]);
+end;
+
+
+function TStringHelper.EndsWith(const AValue: string): Boolean;
+begin
+  Result:=EndsWith(AValue,False);
+end;
+
+
+function TStringHelper.EndsWith(const AValue: string; IgnoreCase: Boolean): Boolean;
+
+Var
+  L : integer;
+  S : String;
+begin
+  L:=system.Length(AVAlue);
+  Result:=L>0;
+  if Result then
+    begin
+    S:=system.Copy(Self,Length-L+1,L);
+    Result:=system.Length(S)=L;
+    if Result then
+      if IgnoreCase then
+        Result:=CompareText(S,AValue)=0
+      else
+        Result:=S=AValue;
+    end;
+end;
+
+function TStringHelper.Equals(const AValue: string): Boolean;
+begin
+  Result:=(Self=AValue);
+end;
+
+function TStringHelper.Format(const args: array of const): string;
+begin
+  Result:=Format(Self,Args);
+end;
+
+
+function TStringHelper.GetHashCode: Integer;
+
+// Taken from contnrs, fphash
+var
+  P,pmax : PChar;
+begin
+{$push}
+{$Q-}
+  Result:=0;
+  P:=Pchar(Self);
+  pmax:=p+length;
+  while (p<pmax) do
+    begin
+    Result:=LongWord(LongInt(Result shl 5) - LongInt(Result)) xor LongWord(P^);
+    Inc(p);
+    end;
+{$pop}
+end;
+
+
+function TStringHelper.IndexOf(AValue: Char): Integer;
+begin
+  Result:=IndexOf(AValue,0,Length);
+end;
+
+
+function TStringHelper.IndexOf(const AValue: string): Integer;
+begin
+  Result:=IndexOf(AValue,0,Length);
+end;
+
+
+function TStringHelper.IndexOf(AValue: Char; StartIndex: Integer): Integer;
+begin
+  Result:=IndexOf(AValue,StartIndex,Length);
+end;
+
+
+function TStringHelper.IndexOf(const AValue: string; StartIndex: Integer
+  ): Integer;
+begin
+  Result:=IndexOf(AValue,StartIndex,Length);
+end;
+
+
+function TStringHelper.IndexOf(AValue: Char; StartIndex: Integer;
+  ACount: Integer): Integer;
+
+Var
+  S : String;
+
+begin
+  S:=System.Copy(Self,StartIndex+1,ACount);
+  Result:=Pos(AValue,S)-1;
+  if Result<>-1 then
+    Result:=Result+StartIndex;
+end;
+
+
+function TStringHelper.IndexOf(const AValue: string; StartIndex: Integer;
+  ACount: Integer): Integer;
+
+Var
+  S : String;
+
+begin
+  S:=System.Copy(Self,StartIndex+1,ACount);
+  Result:=Pos(AValue,S)-1;
+  if Result<>-1 then
+    Result:=Result+StartIndex;
+end;
+
+function TStringHelper.IndexOfUnQuoted(const AValue: string; StartQuote,
+  EndQuote: Char; StartIndex: Integer = 0): Integer;
+
+Var
+  LV : Integer;
+
+  Function MatchAt(I : Integer) : Boolean ; Inline;
+
+  Var
+    J : integer;
+
+  begin
+    J:=1;
+    Repeat
+      Result:=(Self[I+J-1]=AValue[j]);
+      Inc(J);
+    Until (Not Result) or (J>LV);
+  end;
+
+Var
+  I,L: Integer;
+  Q : Integer;
+
+begin
+  Result:=-1;
+  LV:=system.Length(AValue);
+  L:=Length-LV+1;
+  if L<0 then
+    L:=0;
+  I:=StartIndex+1;
+  Q:=0;
+  if StartQuote=EndQuote then
+    begin
+    While (Result=-1) and (I<=L) do
+      begin
+      if (Self[I]=StartQuote) then
+        Q:=1-Q;
+      if (Q=0) and MatchAt(i) then
+        Result:=I-1;
+      Inc(I);
+      end;
+    end
+  else
+    begin
+    While (Result=-1) and (I<=L) do
+      begin
+      if Self[I]=StartQuote then
+        Inc(Q)
+      else if (Self[I]=EndQuote) and (Q>0) then
+        Dec(Q);
+      if (Q=0) and MatchAt(i) then
+        Result:=I-1;
+      Inc(I);
+      end;
+    end;
+end;
+
+
+function TStringHelper.IndexOfAny(const AnyOf: array of Char): Integer;
+begin
+  Result:=IndexOfAny(AnyOf,0,Length);
+end;
+
+
+function TStringHelper.IndexOfAny(const AnyOf: array of Char;
+  StartIndex: Integer): Integer;
+begin
+  Result:=IndexOfAny(AnyOf,StartIndex,Length);
+end;
+
+
+function TStringHelper.IndexOfAny(const AnyOf: array of Char;
+  StartIndex: Integer; ACount: Integer): Integer;
+
+Var
+  i,L : Integer;
+
+begin
+  I:=StartIndex+1;
+  L:=I+ACount-1;
+  If L>Length then
+    L:=Length;
+  Result:=-1;
+  While (Result=-1) and (I<=L) do
+    begin
+    if HaveChar(Self[i],AnyOf) then
+      Result:=I-1;
+    Inc(I);
+    end;
+end;
+
+function TStringHelper.IndexOfAny(const AnyOf: array of String): Integer;
+begin
+  Result:=IndexOfAny(AnyOf,0,Length);
+end;
+
+function TStringHelper.IndexOfAny(const AnyOf: array of String;
+  StartIndex: Integer): Integer;
+begin
+  Result:=IndexOfAny(AnyOf,StartIndex,Length-StartIndex);
+end;
+
+function TStringHelper.IndexOfAny(const AnyOf: array of String;
+  StartIndex: Integer; ACount: Integer): Integer;
+
+Var
+  M : Integer;
+
+begin
+  Result:=IndexOfAny(AnyOf,StartIndex,ACount,M);
+end;
+
+function TStringHelper.IndexOfAny(const AnyOf: array of String;
+  StartIndex: Integer; ACount: Integer; out AMatch: Integer): Integer;
+
+Var
+  L,I : Integer;
+
+begin
+  Result:=-1;
+  For I:=0 to System.Length(AnyOf)-1 do
+    begin
+    L:=IndexOf(AnyOf[i],StartIndex,ACount);
+    If (L>=0) and ((Result=-1) or (L<Result)) then
+      begin
+      Result:=L;
+      AMatch:=I;
+      end;
+    end;
+end;
+
+
+function TStringHelper.IndexOfAnyUnquoted(const AnyOf: array of Char;
+  StartQuote, EndQuote: Char): Integer;
+begin
+  Result:=IndexOfAnyUnquoted(AnyOf,StartQuote,EndQuote,0,Length);
+end;
+
+
+function TStringHelper.IndexOfAnyUnquoted(const AnyOf: array of Char;
+  StartQuote, EndQuote: Char; StartIndex: Integer): Integer;
+begin
+  Result:=IndexOfAnyUnquoted(AnyOf,StartQuote,EndQuote,StartIndex,Length);
+end;
+
+
+function TStringHelper.IndexOfAnyUnquoted(const AnyOf: array of Char;
+  StartQuote, EndQuote: Char; StartIndex: Integer; ACount: Integer): Integer;
+
+Var
+  I,L : Integer;
+  Q : Integer;
+
+begin
+  Result:=-1;
+  L:=StartIndex+ACount-1;
+  if L>Length then
+    L:=Length;
+  I:=StartIndex+1;
+  Q:=0;
+  if StartQuote=EndQuote then
+    begin
+    While (Result=-1) and (I<=L) do
+      begin
+      if (Self[I]=StartQuote) then
+        Q:=1-Q;
+      if (Q=0) and HaveChar(Self[i],AnyOf) then
+        Result:=I-1;
+      Inc(I);
+      end;
+    end
+  else
+  begin
+    While (Result=-1) and (I<=L) do
+      begin
+      if Self[I]=StartQuote then
+        Inc(Q)
+      else if (Self[I]=EndQuote) and (Q>0) then
+        Dec(Q);
+      if (Q=0) and HaveChar(Self[i],AnyOf) then
+        Result:=I-1;
+      Inc(I);
+      end;
+    end;
+
+end;
+
+function TStringHelper.IndexOfAnyUnquoted(const AnyOf: array of string;
+  StartQuote, EndQuote: Char; StartIndex: Integer; out Matched: Integer
+  ): Integer;
+
+Var
+  L,I : Integer;
+
+begin
+  Result:=-1;
+  For I:=0 to System.Length(AnyOf)-1 do
+    begin
+    L:=IndexOfUnquoted(AnyOf[i],StartQuote,EndQuote,StartIndex);
+    If (L>=0) and ((Result=-1) or (L<Result)) then
+      begin
+      Result:=L;
+      Matched:=I;
+      end;
+    end;
+end;
+
+
+function TStringHelper.Insert(StartIndex: Integer; const AValue: string
+  ): string;
+begin
+  system.Insert(AValue,Self,StartIndex+1);
+  Result:=Self;
+end;
+
+
+function TStringHelper.IsDelimiter(const Delimiters: string; Index: Integer
+  ): Boolean;
+begin
+  Result:=sysutils.IsDelimiter(Delimiters,Self,Index+1);
+end;
+
+
+function TStringHelper.IsEmpty: Boolean;
+begin
+  Result:=(Length=0)
+end;
+
+
+function TStringHelper.LastDelimiter(const Delims: string): Integer;
+begin
+  Result:=sysutils.LastDelimiter(Delims,Self)-1;
+end;
+
+
+function TStringHelper.LastIndexOf(AValue: Char): Integer;
+begin
+  Result:=LastIndexOf(AValue,Length-1,Length);
+end;
+
+
+function TStringHelper.LastIndexOf(const AValue: string): Integer;
+begin
+  Result:=LastIndexOf(AValue,Length-1,Length);
+end;
+
+
+function TStringHelper.LastIndexOf(AValue: Char; AStartIndex: Integer): Integer;
+begin
+  Result:=LastIndexOf(AValue,AStartIndex,Length);
+end;
+
+
+function TStringHelper.LastIndexOf(const AValue: string; AStartIndex: Integer
+  ): Integer;
+begin
+  Result:=LastIndexOf(AValue,AStartIndex,Length);
+end;
+
+
+function TStringHelper.LastIndexOf(AValue: Char; AStartIndex: Integer;
+  ACount: Integer): Integer;
+
+Var
+  Min : Integer;
+
+begin
+  Result:=AStartIndex+1;
+  Min:=Result-ACount+1;
+  If Min<1 then
+    Min:=1;
+  While (Result>=Min) and (Self[Result]<>AValue) do
+    Dec(Result);
+  if Result<Min then
+    Result:=-1
+  else
+    Result:=Result-1;
+end;
+
+
+function TStringHelper.LastIndexOf(const AValue: string; AStartIndex: Integer;
+  ACount: Integer): Integer;
+begin
+  Result:=LastIndexOf(AValue,AStartIndex,AStartIndex+1);
+end;
+
+
+function TStringHelper.LastIndexOfAny(const AnyOf: array of Char): Integer;
+begin
+  Result:=LastIndexOfAny(AnyOf,Length-1,Length);
+end;
+
+
+function TStringHelper.LastIndexOfAny(const AnyOf: array of Char;
+  AStartIndex: Integer): Integer;
+begin
+  Result:=LastIndexOfAny(AnyOf,AStartIndex,Length);
+end;
+
+
+function TStringHelper.LastIndexOfAny(const AnyOf: array of Char;
+  AStartIndex: Integer; ACount: Integer): Integer;
+
+Var
+  Min : Integer;
+
+begin
+  Result:=AStartIndex+1;
+  Min:=Result-ACount+1;
+  If Min<1 then
+    Min:=1;
+  While (Result>=Min) and Not HaveChar(Self[Result],AnyOf) do
+    Dec(Result);
+  if Result<Min then
+    Result:=-1
+  else
+    Result:=Result-1;
+end;
+
+
+function TStringHelper.PadLeft(ATotalWidth: Integer): string;
+begin
+  Result:=PadLeft(ATotalWidth,' ');
+end;
+
+
+function TStringHelper.PadLeft(ATotalWidth: Integer; PaddingChar: Char): string;
+Var
+  L : Integer;
+
+begin
+  Result:=Self;
+  L:=ATotalWidth-Length;
+  If L>0 then
+    Result:=StringOfChar(PaddingChar,L)+Result;
+end;
+
+
+function TStringHelper.PadRight(ATotalWidth: Integer): string;
+begin
+  Result:=PadRight(ATotalWidth,' ');
+end;
+
+
+function TStringHelper.PadRight(ATotalWidth: Integer; PaddingChar: Char
+  ): string;
+
+Var
+  L : Integer;
+
+begin
+  Result:=Self;
+  L:=ATotalWidth-Length;
+  If L>0 then
+    Result:=Result+StringOfChar(PaddingChar,L);
+end;
+
+
+function TStringHelper.QuotedString: string;
+begin
+  Result:=QuotedStr(Self);
+end;
+
+
+function TStringHelper.QuotedString(const AQuoteChar: Char): string;
+begin
+  Result:=AnsiQuotedStr(Self,AQuoteChar);
+end;
+
+
+function TStringHelper.Remove(StartIndex: Integer): string;
+begin
+  Result:=Remove(StartIndex,Self.Length-StartIndex);
+end;
+
+
+function TStringHelper.Remove(StartIndex: Integer; ACount: Integer): string;
+begin
+  Result:=Self;
+  System.Delete(Result,StartIndex+1,ACount);
+end;
+
+
+function TStringHelper.Replace(OldChar: Char; NewChar: Char): string;
+begin
+  Result:=Replace(OldChar,NewChar,[rfReplaceAll]);
+end;
+
+
+function TStringHelper.Replace(OldChar: Char; NewChar: Char;
+  ReplaceFlags: TReplaceFlags): string;
+begin
+  Result:=StringReplace(Self,OldChar,NewChar,ReplaceFlags);
+end;
+
+
+function TStringHelper.Replace(const OldValue: string; const NewValue: string
+  ): string;
+begin
+  Result:=Replace(OldValue,NewValue,[rfReplaceAll]);
+end;
+
+
+function TStringHelper.Replace(const OldValue: string; const NewValue: string;
+  ReplaceFlags: TReplaceFlags): string;
+begin
+  Result:=StringReplace(Self,OldValue,NewValue,ReplaceFlags);
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char): TStringArray;
+begin
+  Result:=SPlit(Separators,#0,#0,Length,TStringSplitOptions([]));
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char; ACount: Integer
+  ): TStringArray;
+begin
+  Result:=SPlit(Separators,#0,#0,ACount,TStringSplitOptions([]));
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char;
+  Options: TStringSplitOptions): TStringArray;
+begin
+  Result:=SPlit(Separators,Length,Options);
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char; ACount: Integer;
+  Options: TStringSplitOptions): TStringArray;
+begin
+  Result:=SPlit(Separators,#0,#0,ACount,Options);
+end;
+
+
+function TStringHelper.Split(const Separators: array of string): TStringArray;
+begin
+  Result:=Split(Separators,Length);
+end;
+
+
+function TStringHelper.Split(const Separators: array of string; ACount: Integer
+  ): TStringArray;
+begin
+  Result:=Split(Separators,ACount,TStringSplitOptions([]));
+end;
+
+
+function TStringHelper.Split(const Separators: array of string;
+  Options: TStringSplitOptions): TStringArray;
+begin
+  Result:=Split(Separators,Length,Options);
+end;
+
+
+function TStringHelper.Split(const Separators: array of string;
+  ACount: Integer; Options: TStringSplitOptions): TStringArray;
+begin
+  Result:=Split(Separators,#0,#0,ACount,Options);
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char; AQuote: Char
+  ): TStringArray;
+begin
+  Result:=Split(Separators,AQuote,AQuote);
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char; AQuoteStart,
+  AQuoteEnd: Char): TStringArray;
+begin
+  Result:=Split(Separators,AQuoteStart,AQuoteEnd,TStringSplitOptions([]));
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char; AQuoteStart,
+  AQuoteEnd: Char; Options: TStringSplitOptions): TStringArray;
+begin
+  Result:=Split(Separators,AQuoteStart,AQuoteEnd,Length,Options);
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char; AQuoteStart,
+  AQuoteEnd: Char; ACount: Integer): TStringArray;
+begin
+  Result:=Split(Separators,AQuoteStart,AQuoteEnd,ACount,TStringSplitOptions([]));
+end;
+
+
+function TStringHelper.Split(const Separators: array of Char; AQuoteStart,
+  AQuoteEnd: Char; ACount: Integer; Options: TStringSplitOptions): TStringArray;
+
+Const
+  BlockSize = 10;
+
+  Function NextSep(StartIndex : integer) : Integer;
+
+  begin
+    if (AQuoteStart<>#0) then
+      Result:=Self.IndexOfAnyUnQuoted(Separators,AQuoteStart,AQuoteEnd,StartIndex)
+    else
+      Result:=Self.IndexOfAny(Separators,StartIndex);
+  end;
+
+  Procedure MaybeGrow(Curlen : Integer);
+
+  begin
+    if System.Length(Result)<=CurLen then
+      SetLength(Result,System.Length(Result)+BlockSize);
+  end;
+
+Var
+  Sep,LastSep,Len : integer;
+  T : String;
+
+begin
+  SetLength(Result,BlockSize);
+  Len:=0;
+  LastSep:=0;
+  Sep:=NextSep(0);
+  While (Sep<>-1) and ((ACount=0) or (Len<ACount)) do
+    begin
+    T:=SubString(LastSep,Sep-LastSep);
+//    Writeln('Examining >',T,'< at pos,',LastSep,' till pos ',Sep);
+    If (T<>'') or (not (ExcludeEmpty=Options)) then
+      begin
+      MaybeGrow(Len);
+      Result[Len]:=T;
+      Inc(Len);
+      end;
+    LastSep:=Sep+1;
+    Sep:=NextSep(LastSep);
+    end;
+  if (LastSep<Length-1) and ((ACount=0) or (Len<ACount)) then
+    begin
+    T:=SubString(LastSep);
+//    Writeln('Examining >',T,'< at pos,',LastSep,' till pos ',Sep);
+    MaybeGrow(Len);
+    Result[Len]:=T;
+    Inc(Len);
+    end;
+  SetLength(Result,Len);
+end;
+
+
+function TStringHelper.Split(const Separators: array of string; AQuote: Char
+  ): TStringArray;
+begin
+  Result:=SPlit(Separators,AQuote,AQuote);
+end;
+
+
+function TStringHelper.Split(const Separators: array of string; AQuoteStart,
+  AQuoteEnd: Char): TStringArray;
+begin
+  Result:=SPlit(Separators,AQuoteStart,AQuoteEnd,Length,TStringSplitOptions([]));
+end;
+
+
+function TStringHelper.Split(const Separators: array of string; AQuoteStart,
+  AQuoteEnd: Char; Options: TStringSplitOptions): TStringArray;
+begin
+  Result:=SPlit(Separators,AQuoteStart,AQuoteEnd,Length,Options);
+end;
+
+
+function TStringHelper.Split(const Separators: array of string; AQuoteStart,
+  AQuoteEnd: Char; ACount: Integer): TStringArray;
+begin
+  Result:=SPlit(Separators,AQuoteStart,AQuoteEnd,ACount,TStringSplitOptions([]));
+end;
+
+
+function TStringHelper.Split(const Separators: array of string; AQuoteStart,
+  AQuoteEnd: Char; ACount: Integer; Options: TStringSplitOptions): TStringArray;
+Const
+  BlockSize = 10;
+
+  Function NextSep(StartIndex : integer; out Match : Integer) : Integer;
+
+  begin
+    if (AQuoteStart<>#0) then
+      Result:=Self.IndexOfAnyUnQuoted(Separators,AQuoteStart,AQuoteEnd,StartIndex,Match)
+    else
+      Result:=Self.IndexOfAny(Separators,StartIndex,Length,Match);
+    if Result<>-1 then
+  end;
+
+  Procedure MaybeGrow(Curlen : Integer);
+
+  begin
+    if System.Length(Result)<=CurLen then
+      SetLength(Result,System.Length(Result)+BlockSize);
+  end;
+
+Var
+  Sep,LastSep,Len,Match : integer;
+  T : String;
+
+begin
+  SetLength(Result,BlockSize);
+  Len:=0;
+  LastSep:=0;
+  Sep:=NextSep(0,Match);
+  While (Sep<>-1) and ((ACount=0) or (Len<ACount)) do
+    begin
+    T:=SubString(LastSep,Sep-LastSep);
+    If (T<>'') or (not (ExcludeEmpty=Options)) then
+      begin
+      MaybeGrow(Len);
+      Result[Len]:=T;
+      Inc(Len);
+      end;
+    LastSep:=Sep+System.Length(Separators[Match]);
+    Sep:=NextSep(LastSep,Match);
+    end;
+  if (LastSep<Length-1) and ((ACount=0) or (Len<ACount)) then
+    begin
+    T:=SubString(LastSep);
+//    Writeln('Examining >',T,'< at pos,',LastSep,' till pos ',Sep);
+    MaybeGrow(Len);
+    Result[Len]:=T;
+    Inc(Len);
+    end;
+  SetLength(Result,Len);
+end;
+
+
+function TStringHelper.StartsWith(const AValue: string): Boolean;
+begin
+  Result:=StartsWith(AValue,False);
+end;
+
+
+function TStringHelper.StartsWith(const AValue: string; IgnoreCase: Boolean
+  ): Boolean;
+Var
+  L : Integer;
+begin
+  L:=System.Length(AValue);
+  Result:=L>0;
+  if Result then
+    if IgnoreCase then
+      Result:=StrLiComp(PChar(AValue),PChar(Self),L)=0
+    else
+      Result:=StrLComp(PChar(AValue),PChar(Self),L)=0
+end;
+
+
+function TStringHelper.Substring(AStartIndex: Integer): string;
+begin
+  Result:=Self.SubString(AStartIndex,Self.Length-AStartIndex);
+end;
+
+
+function TStringHelper.Substring(AStartIndex: Integer; ALen: Integer): string;
+begin
+  Result:=system.Copy(Self,AStartIndex+1,ALen);
+end;
+
+
+function TStringHelper.ToBoolean: Boolean;
+begin
+  Result:=StrToBool(Self);
+end;
+
+
+function TStringHelper.ToInteger: Integer;
+begin
+  Result:=StrToInt(Self);
+end;
+
+
+function TStringHelper.ToInt64: Int64;
+begin
+  Result:=StrToInt64(Self);
+end;
+
+
+function TStringHelper.ToSingle: Single;
+begin
+  Result:=StrToFLoat(Self);
+end;
+
+
+function TStringHelper.ToDouble: Double;
+begin
+  Result:=StrToFLoat(Self);
+end;
+
+
+function TStringHelper.ToExtended: Extended;
+begin
+  Result:=StrToFLoat(Self);
+end;
+
+
+function TStringHelper.ToCharArray: TCharArray;
+
+begin
+  Result:=ToCharArray(0,Self.Length);
+end;
+
+
+function TStringHelper.ToCharArray(AStartIndex: Integer; ALen: Integer
+  ): TCharArray;
+
+Var
+  I : Integer;
+
+begin
+  SetLength(Result,ALen);
+  For I:=0 to ALen-1 do
+    Result[I]:=Self[AStartIndex+I+1];
+end;
+
+
+function TStringHelper.ToLower: string;
+begin
+  Result:=LowerCase(Self);
+end;
+
+
+function TStringHelper.ToLowerInvariant: string;
+begin
+  Result:=LowerCase(Self);
+end;
+
+
+function TStringHelper.ToUpper: string;
+begin
+  Result:=UpperCase(Self);
+end;
+
+
+function TStringHelper.ToUpperInvariant: string;
+begin
+  Result:=UpperCase(Self);
+end;
+
+
+function TStringHelper.Trim: string;
+begin
+  Result:=SysUtils.Trim(Self);
+end;
+
+
+function TStringHelper.TrimLeft: string;
+begin
+  Result:=SysUtils.TrimLeft(Self);
+end;
+
+
+function TStringHelper.TrimRight: string;
+begin
+  Result:=SysUtils.TrimRight(Self);
+end;
+
+
+function TStringHelper.Trim(const ATrimChars: array of Char): string;
+begin
+  Result:=Self.TrimLeft(ATrimChars).TrimRight(ATrimChars);
+end;
+
+
+function TStringHelper.TrimLeft(const ATrimChars: array of Char): string;
+
+Var
+  I,Len : Integer;
+
+begin
+  I:=1;
+  Len:=Self.Length;
+  While (I<=Len) and HaveChar(Self[i],ATrimChars) do Inc(I);
+  if I=1 then
+    Result:=Self
+  else if I>Len then
+    Result:=''
+  else
+    Result:=system.Copy(Self,I,Len-I+1);
+end;
+
+
+function TStringHelper.TrimRight(const ATrimChars: array of Char): string;
+
+Var
+  I,Len : Integer;
+
+begin
+  Len:=Self.Length;
+  I:=Len;
+  While (I>=1) and HaveChar(Self[i],ATrimChars) do Dec(I);
+  if I<1 then
+    Result:=''
+  else if I=Len then
+    Result:=Self
+  else
+    Result:=system.Copy(Self,1,I);
+end;
+
+
+function TStringHelper.TrimEnd(const ATrimChars: array of Char): string;
+begin
+  Result:=TrimRight(ATrimChars);
+end;
+
+
+function TStringHelper.TrimStart(const ATrimChars: array of Char): string;
+begin
+  Result:=TrimLeft(ATrimChars);
+end;
+
+{ ---------------------------------------------------------------------
+  TSingleHelper
+  ---------------------------------------------------------------------}
+
+{$MACRO ON}
+
+{$IFDEF FPC_HAS_TYPE_SINGLE}
+{$define TFLOATHELPER:=TSingleHelper}
+{$define FLOATTYPE:=Single}
+{$i syshelpf.inc}
+{$ENDIF FPC_HAS_TYPE_SINGLE}
+
+{ ---------------------------------------------------------------------
+  TDoubleHelper
+  ---------------------------------------------------------------------}
+{$IFDEF FPC_HAS_TYPE_DOUBLE}
+{$define TFLOATHELPER:=TDoubleHelper}
+{$define FLOATTYPE:=Double}
+{$i syshelpf.inc}
+{$ENDIF FPC_HAS_TYPE_DOUBLE}
+
+{ ---------------------------------------------------------------------
+  TExtendedHelper
+  ---------------------------------------------------------------------}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+{$define TFLOATHELPER:=TExtendedHelper}
+{$define FLOATTYPE:=Extended}
+{$i syshelpf.inc}
+{$ENDIF FPC_HAS_TYPE_EXTENDED}
+
+{ ---------------------------------------------------------------------
+  TByteHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TByteHelper}
+{$define TORDINALTYPE:=Byte}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TShortintHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TShortIntHelper}
+{$define TORDINALTYPE:=ShortInt}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TSmallintHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TSmallIntHelper}
+{$define TORDINALTYPE:=SmallInt}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TWordHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TWordHelper}
+{$define TORDINALTYPE:=Word}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TCardinalHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TCardinalHelper}
+{$define TORDINALTYPE:=Cardinal}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TIntegerHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TIntegerHelper}
+{$define TORDINALTYPE:=Integer}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TInt64Helper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TInt64Helper}
+{$define TORDINALTYPE:=Int64}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TQWordHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TQWordHelper}
+{$define TORDINALTYPE:=QWord}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TNativeIntHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TNativeIntHelper}
+{$define TORDINALTYPE:=NativeInt}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TNativeUIntHelper
+  ---------------------------------------------------------------------}
+
+{$define TORDINALHELPER:=TNativeUIntHelper}
+{$define TORDINALTYPE:=NativeUInt}
+{$i syshelpo.inc}
+
+{ ---------------------------------------------------------------------
+  TBooleanHelper
+  ---------------------------------------------------------------------}
+
+{$define TBOOLHELPER:=TBooleanHelper}
+{$define TBOOLTYPE:=Boolean}
+{$i syshelpb.inc}
+
+{ ---------------------------------------------------------------------
+  TByteBoolHelper
+  ---------------------------------------------------------------------}
+
+{$define TBOOLHELPER:=TByteBoolHelper}
+{$define TBOOLTYPE:=ByteBool}
+{$i syshelpb.inc}
+
+{ ---------------------------------------------------------------------
+  TWordBoolHelper
+  ---------------------------------------------------------------------}
+
+{$define TBOOLHELPER:=TWordBoolHelper}
+{$define TBOOLTYPE:=WordBool}
+{$i syshelpb.inc}
+
+{ ---------------------------------------------------------------------
+  TLongBoolHelper
+  ---------------------------------------------------------------------}
+
+
+{$define TBOOLHELPER:=TLongBoolHelper}
+{$define TBOOLTYPE:=LongBool}
+{$i syshelpb.inc}
+

rtl/objpas/sysutils/syshelpb.inc

@@ -0,0 +1,36 @@
+
+Class Function TBOOLHELPER.Parse(const S: string): Boolean; inline; static;
+
+begin
+  Result:=StrToBool(S);
+end;
+
+Class Function TBOOLHELPER.Size: Integer; inline; static;
+
+begin
+  Result:=SizeOf(TBOOLTYPE);
+end;
+
+Class Function TBOOLHELPER.ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
+
+begin
+  Result:=BoolToStr(AValue,UseBoolStrs=TUseBoolStrs.True);
+end;
+
+Class Function TBOOLHELPER.TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
+
+begin
+  Result:=TryStrToBool(S,AValue);
+end;
+
+Function TBOOLHELPER.ToInteger: Integer; inline;
+
+begin
+  Result:=Integer(Self);
+end;
+
+Function TBOOLHELPER.ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
+
+begin
+  Result:=BoolToStr(Self,UseBoolStrs=TUseBoolStrs.True);
+end;

rtl/objpas/sysutils/syshelpf.inc

@@ -0,0 +1,235 @@
+Class Function TFLOATHELPER.IsNan(const AValue: FLOATTYPE): Boolean; overload; inline; static;
+
+begin
+  Result:=AValue=Nan;
+end;
+
+Class Function TFLOATHELPER.IsInfinity(const AValue: FLOATTYPE): Boolean; overload; inline; static;
+
+begin
+  Result:=(AValue=PositiveInfinity) or (AValue=NegativeInfinity);
+end;
+
+Class Function TFLOATHELPER.IsNegativeInfinity(const AValue: FLOATTYPE): Boolean; overload; inline; static;
+
+begin
+  Result:=AValue=NegativeInfinity;
+end;
+
+Class Function TFLOATHELPER.IsPositiveInfinity(const AValue: FLOATTYPE): Boolean; overload; inline; static;
+
+begin
+  Result:=(AValue=PositiveInfinity);
+end;
+
+Class Function TFLOATHELPER.Parse(const AString: string): FLOATTYPE; overload; inline; static;
+
+begin
+  Result:=StrToFloat(AString,DefaultFormatSettings);
+end;
+
+Class Function TFLOATHELPER.Parse(const AString: string; const AFormatSettings: TFormatSettings): FLOATTYPE; overload; inline; static;
+
+begin
+  Result:=StrToFloat(AString,AFormatSettings);
+end;
+
+Class Function TFLOATHELPER.Size: Integer; inline; static;
+
+begin
+  Result:=SizeOf(FLOATTYPE);
+end;
+
+Class Function TFLOATHELPER.ToString(const AValue: FLOATTYPE): string; overload; inline; static;
+
+begin
+  Result:=FloatToStr(AValue,DefaultFormatSettings);
+end;
+
+Class Function TFLOATHELPER.ToString(const AValue: FLOATTYPE; const AFormatSettings: TFormatSettings): string; overload; inline; static;
+
+begin
+  Result:=FloatToStr(AValue,AFormatSettings);
+end;
+
+Class Function TFLOATHELPER.ToString(const AValue: FLOATTYPE; const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline; static;
+
+begin
+  Result:=FloatToStrF(AValue,AFormat,APrecision,ADigits,DefaultFormatSettings);
+end;
+
+Class Function TFLOATHELPER.ToString(const AValue: FLOATTYPE; const AFormat: TFloatFormat; const APrecision, ADigits: Integer;  const AFormatSettings: TFormatSettings): string;
+overload; inline; static;
+
+begin
+  Result:=FloatToStrF(AValue,AFormat,APrecision,ADigits,AFormatSettings);
+end;
+
+Class Function TFLOATHELPER.TryParse(const AString: string; out AValue: FLOATTYPE): Boolean; overload; inline; static;
+
+begin
+  Result:=TryStrToFloat(AString,AValue,DefaultFormatSettings);
+end;
+
+Class Function TFLOATHELPER.TryParse(const AString: string; out AValue: FLOATTYPE; const AFormatSettings: TFormatSettings): Boolean; overload; inline;
+static;
+
+begin
+  Result:=TryStrToFloat(AString,AValue,AFormatSettings);
+end;
+
+
+Function TFLOATHELPER.GetB(AIndex: Cardinal): Byte;
+
+begin
+  if (AIndex>=SizeOf(FLOATTYPE)) then
+    system.Error(reRangeError);
+  Result:=PByte(@Self)[AIndex];
+end;
+
+Function TFLOATHELPER.GetW(AIndex: Cardinal): Word;
+
+begin
+  if (AIndex>=(SizeOf(FLOATTYPE) div SizeOf(Word))) then
+    system.Error(reRangeError);
+  Result:=PWord(@Self)[AIndex];
+end;
+
+Function TFLOATHELPER.GetE: QWord; inline;
+
+begin
+end;
+
+Function TFLOATHELPER.GetF: QWord; inline;
+
+begin
+end;
+
+Function TFLOATHELPER.GetS: Boolean; inline;
+
+begin
+end;
+
+procedure TFLOATHELPER.SetB(AIndex: Cardinal; const AValue: Byte);
+
+begin
+  if (AIndex>=SizeOf(FLOATTYPE)) then
+    system.Error(reRangeError);
+  PByte(@Self)[AIndex]:=AValue;
+end;
+
+procedure TFLOATHELPER.SetW(AIndex: Cardinal; const AValue: Word);
+
+begin
+  if (AIndex>=(SizeOf(FLOATTYPE) div SizeOf(Word))) then
+    system.Error(reRangeError);
+  PWord(@Self)[AIndex]:=AValue;
+end;
+
+procedure TFLOATHELPER.SetE(AValue: QWord);
+
+begin
+end;
+
+procedure TFLOATHELPER.SetF(AValue: QWord);
+
+begin
+end;
+
+procedure TFLOATHELPER.SetS(AValue: Boolean);
+
+begin
+end;
+
+
+Procedure TFLOATHELPER.BuildUp(const ASignFlag: Boolean; const AMantissa: QWord; const AExponent: Integer);
+
+begin
+  Self := 0.0;
+  SetS(ASignFlag);
+  SetE(AExponent + $3FF);
+  SetF(AMantissa and $000FFFFFFFFFFFFF);
+end;
+
+Function TFLOATHELPER.Exponent: Integer;
+
+var
+  F,E : QWord;
+begin
+  Result:=0; // Zero, inf, Nan
+  E:=GetE;
+  F:=GetF;
+  if (0<E) and (E<$77FF) then
+    Result:=E-$3FF
+  else if (E=0) and (F<>0) then
+    Result:=-1022
+end;
+
+Function TFLOATHELPER.Fraction: Extended;
+
+begin
+end;
+
+Function TFLOATHELPER.IsInfinity: Boolean; overload; inline;
+
+begin
+  Result:=(Self=PositiveInfinity) or (Self=NegativeInfinity);
+end;
+
+Function TFLOATHELPER.IsNan: Boolean; overload; inline;
+
+begin
+  Result:=(Self=Nan);
+end;
+
+Function TFLOATHELPER.IsNegativeInfinity: Boolean; overload; inline;
+
+begin
+  Result:=(Self=NegativeInfinity);
+end;
+
+Function TFLOATHELPER.IsPositiveInfinity: Boolean; overload; inline;
+
+begin
+  Result:=(Self=PositiveInfinity);
+end;
+
+Function TFLOATHELPER.Mantissa: QWord;
+
+begin
+end;
+
+Function TFLOATHELPER.SpecialType: TFloatSpecial;
+
+begin
+  if IsNan then
+    Result:=fsNan
+  else if IsNegativeInfinity then
+    Result:=fsNInf
+  else if IsPositiveInfinity then
+    Result:=fsInf
+end;
+
+Function TFLOATHELPER.ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline;
+
+begin
+  Result:=FloatToStrF(Self,AFormat,APrecision,ADigits,DefaultFormatSettings);
+end;
+
+Function TFLOATHELPER.ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline;
+
+begin
+  Result:=FloatToStrF(Self,AFormat,APrecision,ADigits,AFormatSettings);
+end;
+
+Function TFLOATHELPER.ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
+
+begin
+  Result:=FloatToStr(Self,AFormatSettings);
+end;
+
+Function TFLOATHELPER.ToString: string; overload; inline;
+
+begin
+  Result:=FloatToStr(Self,DefaultFormatSettings);
+end;

rtl/objpas/sysutils/syshelph.inc

@@ -0,0 +1,616 @@
+{%mainunit syshelpers.pp}
+
+Type
+  generic TArray<T> = array of T;
+  TStringArray = Array of string;
+  TCharArray = Array of char;
+{$SCOPEDENUMS ON}
+  TEndian = (Little,Big);
+{$SCOPEDENUMS OFF}
+
+Const
+  CPUEndian = {$IFDEF FPC_LITTLE_ENDIAN}TEndian.Little{$ELSE}TEndian.Big{$ENDIF};
+
+Type
+  TGuidHelper = record helper for TGUID
+    Class function Create(const Data; BigEndian: Boolean): TGUID; overload; static;
+    class function Create(const Data: array of Byte; AStartIndex: Cardinal; BigEndian: Boolean): TGUID; overload; static;
+    Class Function Create(const Data; DataEndian: TEndian = CPUEndian): TGUID; overload; static; inline;
+    Class Function Create(const B: TBytes; DataEndian: TEndian = CPUEndian): TGUID; overload; static; inline;
+    Class Function Create(const B: TBytes; AStartIndex: Cardinal; DataEndian: TEndian = CPUEndian): TGUID; overload; static;
+    Class Function Create(const S: string): TGUID; overload; static;
+    Class Function Create(A: Integer; B: SmallInt; C: SmallInt; const D: TBytes): TGUID; overload; static;
+    Class Function Create(A: Integer; B: SmallInt; C: SmallInt; D, E, F, G, H, I, J, K: Byte): TGUID; overload; static;
+    Class Function Create(A: Cardinal; B: Word; C: Word; D, E, F, G, H, I, J, K: Byte): TGUID; overload; static;
+    Class Function NewGuid: TGUID; static;
+    Function ToByteArray(DataEndian: TEndian = CPUEndian): TBytes;
+    Function ToString(SkipBrackets: Boolean = False): string;
+  end;
+
+
+  TCompareOption = system.TCompareOption;
+  TCompareOptions = system.TCompareOptions;
+
+  TStringSplitOptions = (None, ExcludeEmpty);
+
+  { TStringHelper }
+
+  TStringHelper = Type Helper for AnsiString
+  Private
+    Function GetChar(AIndex : Integer) : Char;
+    Function GetLength : Integer;
+  public
+    const Empty = '';
+    // Methods
+    Class Function Compare(const A: string; const B: string): Integer; overload; static; //inline;
+    Class Function Compare(const A: string; const B: string; IgnoreCase: Boolean): Integer; overload; static; //inline; //deprecated 'Use same with TCompareOptions';
+    Class Function Compare(const A: string; const B: string; Options: TCompareOptions): Integer; overload; static; // inline;
+    Class Function Compare(const A: string; IndexA: Integer; const B: string; IndexB: Integer; ALen: Integer): Integer; overload; static; // inline;
+    Class Function Compare(const A: string; IndexA: Integer; const B: string; IndexB: Integer; ALen: Integer; IgnoreCase: Boolean): Integer; overload; static; // inline; //deprecated 'Use same with TCompareOptions';
+    Class Function Compare(const A: string; IndexA: Integer; const B: string; IndexB: Integer; ALen: Integer; Options: TCompareOptions): Integer; overload; static;//  inline;
+    Class Function CompareOrdinal(const A: string; const B: string): Integer; overload; static;
+    Class Function CompareOrdinal(const A: string; IndexA: Integer; const B: string; IndexB: Integer; ALen: Integer): Integer; overload; static;
+    Class Function CompareText(const A: string; const B: string): Integer; static; inline;
+    Class Function Copy(const Str: string): string; inline; static;
+    Class Function Create(AChar: Char; ACount: Integer): string; overload; inline; static;
+    Class Function Create(const AValue: array of Char): string; overload; static;
+    Class Function Create(const AValue: array of Char; StartIndex: Integer; ALen: Integer): string; overload; static;
+    Class Function EndsText(const ASubText, AText: string): Boolean; static;
+    Class Function Equals(const a: string; const b: string): Boolean; overload; static;
+    Class Function Format(const AFormat: string; const args: array of const): string; overload; static;
+    Class Function IsNullOrEmpty(const AValue: string): Boolean; static;
+    Class Function IsNullOrWhiteSpace(const AValue: string): Boolean; static;
+    Class Function Join(const Separator: string; const Values: array of const): string; overload; static;
+    Class Function Join(const Separator: string; const Values: array of string): string; overload; static;
+    Class Function Join(const Separator: string; const Values: array of string; StartIndex: Integer; ACount: Integer): string; overload; static;
+    Class Function LowerCase(const S: string): string; overload; static; inline;
+    Class Function Parse(const AValue: Boolean): string; overload; static; inline;
+    Class Function Parse(const AValue: Extended): string; overload; static;inline;
+    Class Function Parse(const AValue: Int64): string; overload; static; inline;
+    Class Function Parse(const AValue: Integer): string; overload; static; inline;
+    Class Function ToBoolean(const S: string): Boolean; overload; static; inline;
+    Class Function ToDouble(const S: string): Double; overload; static; inline;
+    Class Function ToExtended(const S: string): Extended; overload; static; inline;
+    Class Function ToInt64(const S: string): Int64; overload; static; inline;
+    Class Function ToInteger(const S: string): Integer; overload; static; inline;
+    Class Function ToSingle(const S: string): Single; overload; static; inline;
+    Class Function UpperCase(const S: string): string; overload; static; inline;
+    Function CompareTo(const B: string): Integer;
+    Function Contains(const AValue: string): Boolean;
+    procedure CopyTo(SourceIndex: Integer; var destination: array of Char; DestinationIndex: Integer; ACount: Integer);
+    Function CountChar(const C: Char): Integer;
+    Function DeQuotedString: string; overload;
+    Function DeQuotedString(const AQuoteChar: Char): string; overload;
+    Function EndsWith(const AValue: string): Boolean; overload; inline;
+    Function EndsWith(const AValue: string; IgnoreCase: Boolean): Boolean; overload;
+    Function Equals(const AValue: string): Boolean; overload;
+    Function Format(const args: array of const): string; overload;
+    Function GetHashCode: Integer;
+    Function IndexOf(AValue: Char): Integer; overload; inline;
+    Function IndexOf(const AValue: string): Integer; overload; inline;
+    Function IndexOf(AValue: Char; StartIndex: Integer): Integer; overload;
+    Function IndexOf(const AValue: string; StartIndex: Integer): Integer; overload;
+    Function IndexOf(AValue: Char; StartIndex: Integer; ACount: Integer): Integer; overload;
+    Function IndexOf(const AValue: string; StartIndex: Integer; ACount: Integer): Integer; overload;
+    Function IndexOfUnQuoted(const AValue: string; StartQuote, EndQuote: Char; StartIndex: Integer = 0): Integer; overload;
+    Function IndexOfAny(const AnyOf: array of Char): Integer; overload;
+    Function IndexOfAny(const AnyOf: array of Char; StartIndex: Integer): Integer; overload;
+    Function IndexOfAny(const AnyOf: array of Char; StartIndex: Integer; ACount: Integer): Integer; overload;
+    Function IndexOfAny(const AnyOf: array of String): Integer; overload;
+    Function IndexOfAny(const AnyOf: array of String; StartIndex: Integer): Integer; overload;
+    Function IndexOfAny(const AnyOf: array of String; StartIndex: Integer; ACount: Integer): Integer; overload;
+    Function IndexOfAny(const AnyOf: array of String; StartIndex: Integer; ACount: Integer; Out AMatch : Integer): Integer; overload;
+    Function IndexOfAnyUnquoted(const AnyOf: array of Char; StartQuote, EndQuote: Char): Integer; overload;
+    Function IndexOfAnyUnquoted(const AnyOf: array of Char; StartQuote, EndQuote: Char; StartIndex: Integer): Integer; overload;
+    Function IndexOfAnyUnquoted(const AnyOf: array of Char; StartQuote, EndQuote: Char; StartIndex: Integer; ACount: Integer): Integer; overload;
+    function IndexOfAnyUnquoted(const AnyOf: array of string; StartQuote, EndQuote: Char; StartIndex: Integer; Out Matched: Integer): Integer; overload;
+    Function Insert(StartIndex: Integer; const AValue: string): string;
+    Function IsDelimiter(const Delimiters: string; Index: Integer): Boolean;
+    Function IsEmpty: Boolean;
+    Function LastDelimiter(const Delims: string): Integer;
+    Function LastIndexOf(AValue: Char): Integer; overload;
+    Function LastIndexOf(const AValue: string): Integer; overload;
+    Function LastIndexOf(AValue: Char; AStartIndex: Integer): Integer; overload;
+    Function LastIndexOf(const AValue: string; AStartIndex: Integer): Integer; overload;
+    Function LastIndexOf(AValue: Char; AStartIndex: Integer; ACount: Integer): Integer; overload;
+    Function LastIndexOf(const AValue: string; AStartIndex: Integer; ACount: Integer): Integer; overload;
+    Function LastIndexOfAny(const AnyOf: array of Char): Integer; overload;
+    Function LastIndexOfAny(const AnyOf: array of Char; AStartIndex: Integer): Integer; overload;
+    Function LastIndexOfAny(const AnyOf: array of Char; AStartIndex: Integer; ACount: Integer): Integer; overload;
+    Function PadLeft(ATotalWidth: Integer): string; overload; inline;
+    Function PadLeft(ATotalWidth: Integer; PaddingChar: Char): string; overload; inline;
+    Function PadRight(ATotalWidth: Integer): string; overload; inline;
+    Function PadRight(ATotalWidth: Integer; PaddingChar: Char): string; overload; inline;
+    Function QuotedString: string; overload;
+    Function QuotedString(const AQuoteChar: Char): string; overload;
+    Function Remove(StartIndex: Integer): string; overload; inline;
+    Function Remove(StartIndex: Integer; ACount: Integer): string; overload; inline;
+    Function Replace(OldChar: Char; NewChar: Char): string; overload;
+    Function Replace(OldChar: Char; NewChar: Char; ReplaceFlags: TReplaceFlags): string; overload;
+    Function Replace(const OldValue: string; const NewValue: string): string; overload;
+    Function Replace(const OldValue: string; const NewValue: string; ReplaceFlags: TReplaceFlags): string; overload;
+    Function Split(const Separators: array of Char): TStringArray; overload;
+    Function Split(const Separators: array of Char; ACount: Integer): TStringArray; overload;
+    Function Split(const Separators: array of Char; Options: TStringSplitOptions): TStringArray; overload;
+    Function Split(const Separators: array of Char; ACount: Integer; Options: TStringSplitOptions): TStringArray; overload;
+    Function Split(const Separators: array of string): TStringArray; overload;
+    Function Split(const Separators: array of string; ACount: Integer): TStringArray; overload;
+    Function Split(const Separators: array of string; Options: TStringSplitOptions): TStringArray; overload;
+    Function Split(const Separators: array of string; ACount: Integer; Options: TStringSplitOptions): TStringArray; overload;
+    Function Split(const Separators: array of Char; AQuote: Char): TStringArray; overload;
+    Function Split(const Separators: array of Char; AQuoteStart, AQuoteEnd: Char): TStringArray; overload;
+    Function Split(const Separators: array of Char; AQuoteStart, AQuoteEnd: Char; Options: TStringSplitOptions): TStringArray; overload;
+    Function Split(const Separators: array of Char; AQuoteStart, AQuoteEnd: Char; ACount: Integer): TStringArray; overload;
+    Function Split(const Separators: array of Char; AQuoteStart, AQuoteEnd: Char; ACount: Integer; Options: TStringSplitOptions): TStringArray; overload;
+    Function Split(const Separators: array of string; AQuote: Char): TStringArray; overload;
+    Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: Char): TStringArray; overload;
+    Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: Char; Options: TStringSplitOptions): TStringArray; overload;
+    Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: Char; ACount: Integer): TStringArray; overload;
+    Function Split(const Separators: array of string; AQuoteStart, AQuoteEnd: Char; ACount: Integer; Options: TStringSplitOptions): TStringArray; overload;
+    Function StartsWith(const AValue: string): Boolean; overload; inline;
+    Function StartsWith(const AValue: string; IgnoreCase: Boolean): Boolean; overload;
+    Function Substring(AStartIndex: Integer): string; overload;
+    Function Substring(AStartIndex: Integer; ALen: Integer): string; overload;
+    Function ToBoolean: Boolean; overload; inline;
+    Function ToInteger: Integer; overload; inline;
+    Function ToInt64: Int64; overload; inline;
+    Function ToSingle: Single; overload; inline;
+    Function ToDouble: Double; overload; inline;
+    Function ToExtended: Extended; overload; inline;
+    Function ToCharArray: TCharArray; overload;
+    Function ToCharArray(AStartIndex: Integer; ALen: Integer): TCharArray; overload;
+    Function ToLower: string; overload; inline;
+    Function ToLowerInvariant: string;
+    Function ToUpper: string; overload; inline;
+    Function ToUpperInvariant: string; inline;
+    Function Trim: string; overload;
+    Function TrimLeft: string; overload;
+    Function TrimRight: string; overload;
+    Function Trim(const ATrimChars: array of Char): string; overload;
+    Function TrimLeft(const ATrimChars: array of Char): string; overload;
+    Function TrimRight(const ATrimChars: array of Char): string; overload;
+    Function TrimEnd(const ATrimChars: array of Char): string; deprecated 'Use TrimRight';
+    Function TrimStart(const ATrimChars: array of Char): string; deprecated 'Use TrimLeft';
+    property Chars[AIndex: Integer]: Char read GetChar;
+    property Length: Integer read GetLength;
+  end;
+
+{$IFDEF FPC_HAS_TYPE_SINGLE}
+  TSingleHelper = Type Helper for Single
+    Function GetB(AIndex: Cardinal): Byte;
+    Function GetW(AIndex: Cardinal): Word;
+    Function GetE: QWord; inline;
+    Function GetF: QWord; inline;
+    Function GetS: Boolean; inline;
+    procedure SetB(AIndex: Cardinal; const AValue: Byte);
+    procedure SetW(AIndex: Cardinal; const AValue: Word);
+    procedure SetE(AValue: QWord);
+    procedure SetF(AValue: QWord);
+    procedure SetS(AValue: Boolean);
+  public
+{$push}
+{$R-}
+{$Q-}
+    const
+      Epsilon          : Single = 1.4012984643248170709e-45;
+      MaxValue         : Single = 340282346638528859811704183484516925440.0;
+      MinValue         : Single = -340282346638528859811704183484516925440.0;
+      PositiveInfinity : Single = 1.0/0.0;
+      NegativeInfinity : Single = -1.0/0.0;
+      NaN              : Single = 0.0/0.0;
+{$POP}
+    Class Function IsNan(const AValue: Single): Boolean; overload; inline; static;
+    Class Function IsInfinity(const AValue: Single): Boolean; overload; inline; static;
+    Class Function IsNegativeInfinity(const AValue: Single): Boolean; overload; inline; static;
+    Class Function IsPositiveInfinity(const AValue: Single): Boolean; overload; inline; static;
+    Class Function Parse(const AString: string): Single; overload; inline; static;
+    Class Function Parse(const AString: string; const AFormatSettings: TFormatSettings): Single; overload; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Single): string; overload; inline; static;
+    Class Function ToString(const AValue: Single; const AFormatSettings: TFormatSettings): string; overload; inline; static;
+    Class Function ToString(const AValue: Single; const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline; static;
+    Class Function ToString(const AValue: Single; const AFormat: TFloatFormat; const APrecision, ADigits: Integer;
+                               const AFormatSettings: TFormatSettings): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Single): Boolean; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Single; const AFormatSettings: TFormatSettings): Boolean; overload; inline; static;
+
+    Procedure BuildUp(const ASignFlag: Boolean; const AMantissa: QWord; const AExponent: Integer);
+    Function Exponent: Integer;
+    Function Fraction: Extended;
+    Function IsInfinity: Boolean; overload; inline;
+    Function IsNan: Boolean; overload; inline;
+    Function IsNegativeInfinity: Boolean; overload; inline;
+    Function IsPositiveInfinity: Boolean; overload; inline;
+    Function Mantissa: QWord;
+    Function SpecialType: TFloatSpecial;
+    Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline;
+    Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline;
+    Function ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
+    Function ToString: string; overload; inline;
+
+    property Bytes[AIndex: Cardinal]: Byte read GetB write SetB;
+    property Words[AIndex: Cardinal]: Word read GetW write SetW;
+    property Sign: Boolean read GetS write SetS;
+    property Exp: QWord read GetE write SetE;
+    property Frac: QWord read GetF write SetF;
+  end;
+{$ENDIF FPC_HAS_TYPE_SINGLE}
+
+{$IFDEF FPC_HAS_TYPE_DOUBLE}
+  TDoubleHelper = Type Helper for Double
+  private
+    Function GetB(AIndex: Cardinal): Byte;
+    Function GetW(AIndex: Cardinal): Word;
+    Function GetE: QWord; inline;
+    Function GetF: QWord; inline;
+    Function GetS: Boolean; inline;
+    procedure SetB(AIndex: Cardinal; const AValue: Byte);
+    procedure SetW(AIndex: Cardinal; const AValue: Word);
+    procedure SetE(AValue: QWord);
+    procedure SetF(AValue: QWord);
+    procedure SetS(AValue: Boolean);
+  public
+    const
+    {$push}
+    {$R-}
+    {$Q-}
+      Epsilon          : Double = 4.9406564584124654418e-324;
+      MaxValue         : Double = 1.7976931348623157081e+308;
+      MinValue         : Double = -1.7976931348623157081e+308;
+      PositiveInfinity : Double = 1.0/0.0;
+      NegativeInfinity : Double = -1.0/0.0;
+      NaN              : Double = 0.0/0.0;
+    {$POP}
+    Class Function IsInfinity(const AValue: Double): Boolean; overload; inline; static;
+    Class Function IsNan(const AValue: Double): Boolean; overload; inline; static;
+    Class Function IsNegativeInfinity(const AValue: Double): Boolean; overload; inline; static;
+    Class Function IsPositiveInfinity(const AValue: Double): Boolean; overload; inline; static;
+    Class Function Parse(const AString: string): Double; overload; inline; static;
+    Class Function Parse(const AString: string; const AFormatSettings: TFormatSettings): Double; overload; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Double): string; overload; inline; static;
+    Class Function ToString(const AValue: Double; const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline; static;
+    Class Function ToString(const AValue: Double; const AFormat: TFloatFormat; const APrecision, ADigits: Integer;  const AFormatSettings: TFormatSettings): string; overload; inline; static;
+    Class Function ToString(const AValue: Double; const AFormatSettings: TFormatSettings): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Double): Boolean; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Double; const AFormatSettings: TFormatSettings): Boolean; overload; inline; static;
+
+    Procedure BuildUp(const ASignFlag: Boolean; const AMantissa: QWord; const AExponent: Integer);
+    Function Exponent: Integer;
+    Function Fraction: Extended;
+    Function IsInfinity: Boolean; overload; inline;
+    Function IsNan: Boolean; overload; inline;
+    Function IsNegativeInfinity: Boolean; overload; inline;
+    Function IsPositiveInfinity: Boolean; overload; inline;
+    Function Mantissa: QWord;
+    Function SpecialType: TFloatSpecial;
+    Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline;
+    Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline;
+    Function ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
+    Function ToString: string; overload; inline;
+
+    property Bytes[AIndex: Cardinal]: Byte read GetB write SetB;  // 0..7
+    property Words[AIndex: Cardinal]: Word read GetW write SetW; // 0..3
+    property Sign: Boolean read GetS write SetS;
+    property Exp: QWord read GetE write SetE;
+    property Frac: QWord read GetF write SetF;
+  end;
+{$ENDIF FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+  TExtendedHelper = Type Helper for Extended
+  private
+    Function GetB(AIndex: Cardinal): Byte;
+    Function GetW(AIndex: Cardinal): Word;
+    Function GetE: QWord; inline;
+    Function GetF: QWord; inline;
+    Function GetS: Boolean; inline;
+    procedure SetB(AIndex: Cardinal; const AValue: Byte);
+    procedure SetW(AIndex: Cardinal; const AValue: Word);
+    procedure SetE(AValue: QWord);
+    procedure SetF(AValue: QWord);
+    procedure SetS(AValue: Boolean);
+  public
+    {$push}
+    {$R-}
+    {$Q-}
+    const
+      Epsilon           : Extended = 3.64519953188247460253e-4951;
+      MaxValue          : Extended = 1.18973149535723176505e+4932;
+      MinValue          : Extended = -1.18973149535723176505e+4932;
+      PositiveInfinity  : Extended = 1.0/0.0;
+      NegativeInfinity  : Extended = -1.0/0.0;
+      NaN               : Extended = 0.0/0.0;
+    {$POP}
+    Class Function ToString(const AValue: Extended): string; overload; inline; static;
+    Class Function ToString(const AValue: Extended; const AFormatSettings: TFormatSettings): string; overload; inline; static;
+    Class Function ToString(const AValue: Extended; const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline; static;
+    Class Function ToString(const AValue: Extended; const AFormat: TFloatFormat; const APrecision, ADigits: Integer; const AFormatSettings: TFormatSettings): string; overload; inline; static;
+    Class Function Parse(const AString: string): Extended; overload; inline; static;
+    Class Function Parse(const AString: string; const AFormatSettings: TFormatSettings): Extended; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Extended): Boolean; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Extended; const AFormatSettings: TFormatSettings): Boolean; overload; inline; static;
+    Class Function IsNan(const AValue: Extended): Boolean; overload; inline; static;
+    Class Function IsInfinity(const AValue: Extended): Boolean; overload; inline; static;
+    Class Function IsNegativeInfinity(const AValue: Extended): Boolean; overload; inline; static;
+    Class Function IsPositiveInfinity(const AValue: Extended): Boolean; overload; inline; static;
+    Class Function Size: Integer; inline; static;
+
+    procedure BuildUp(const ASignFlag: Boolean; const AMantissa: QWord; Const AExponent: Integer);
+    Function Exponent: Integer;
+    Function Fraction: Extended;
+    Function IsInfinity: Boolean; overload; inline;
+    Function IsNan: Boolean; overload; inline;
+    Function IsNegativeInfinity: Boolean; overload; inline;
+    Function IsPositiveInfinity: Boolean; overload; inline;
+    Function Mantissa: QWord;
+    Function SpecialType: TFloatSpecial;
+    Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer): string; overload; inline;
+    Function ToString(const AFormat: TFloatFormat; const APrecision, ADigits: Integer;  const AFormatSettings: TFormatSettings): string; overload; inline;
+    Function ToString(const AFormatSettings: TFormatSettings): string; overload; inline;
+    Function ToString: string; overload; inline;
+
+    property Bytes[AIndex: Cardinal]: Byte read GetB write SetB;
+    property Words[AIndex: Cardinal]: Word read GetW write SetW;
+    property Sign: Boolean read GetS write SetS;
+    property Exp: QWord read GetE write SetE;
+    property Frac: QWord read GetF write SetF;
+  end;
+{$ENDIF FPC_HAS_TYPE_EXTENDED}
+
+  TByteHelper = Type Helper for Byte
+  public
+    const
+      MaxValue = 255;
+      MinValue = 0;
+  public
+    Class Function Parse(const AString: string): Byte; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Byte): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Byte): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TShortIntHelper = Type Helper for ShortInt
+  public
+    const
+      MaxValue = 127;
+      MinValue = -128;
+  public
+    Class Function Parse(const AString: string): ShortInt; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: ShortInt): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: ShortInt): Boolean; inline; static;
+  public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TSmallIntHelper = Type Helper for SmallInt
+  public
+    const
+      MaxValue = 32767;
+      MinValue = -32768;
+  public
+    Class Function Parse(const AString: string): SmallInt; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: SmallInt): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: SmallInt): Boolean; inline; static;
+  public
+    Function ToString: string; overload; inline;
+    Function ToBoolean: Boolean; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+  end;
+
+  TWordHelper = Type Helper for Word
+  public
+    const
+      MaxValue = 65535;
+      MinValue = 0;
+  Public
+    Class Function Parse(const AString: string): Word; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Word): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Word): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TCardinalHelper = Type Helper for Cardinal { for LongWord Type too }
+  public
+    const
+      MaxValue = 4294967295;
+      MinValue = 0;
+  Public
+    Class Function Parse(const AString: string): Cardinal; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Cardinal): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Cardinal): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TIntegerHelper = Type Helper for Integer { for LongInt Type too }
+  public
+    const
+      MaxValue = 2147483647;
+      MinValue = -2147483648;
+  Public
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Integer): string; overload; inline; static;
+    Class Function Parse(const AString: string): Integer; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Integer): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TInt64Helper = Type Helper for Int64
+  public
+    const
+      MaxValue = 9223372036854775807;
+      MinValue = -9223372036854775808;
+  Public
+    Class Function Parse(const AString: string): Int64; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Int64): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: Int64): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TQWordHelper = Type Helper for QWord
+  public
+    const
+      MaxValue = 18446744073709551615;
+      MinValue = 0;
+  Public
+    Class Function Parse(const AString: string): QWord; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: QWord): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: QWord): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TNativeIntHelper = Type Helper for NativeInt
+  public
+    const
+{$IFDEF CPU64BITS}
+      MaxValue = 9223372036854775807;
+      MinValue = -9223372036854775808;
+{$ELSE !CPU64BITS}
+      MaxValue = 2147483647;
+      MinValue = -2147483648;
+{$ENDIF CPU64BITS}
+  Public
+    Class Function Parse(const AString: string): NativeInt; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: NativeInt): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: NativeInt): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  TNativeUIntHelper = Type Helper for NativeUInt
+  public
+    const
+{$IFDEF CPU64BITS}
+      MaxValue = 18446744073709551615;
+{$ELSE !CPU64BITS}
+      MaxValue = 4294967295;
+{$ENDIF CPU64BITS}
+      MinValue = 0;
+  Public
+    Class Function Parse(const AString: string): NativeUInt; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: NativeUInt): string; overload; inline; static;
+    Class Function TryParse(const AString: string; out AValue: NativeUInt): Boolean; inline; static;
+  Public
+    Function ToBoolean: Boolean; inline;
+    Function ToDouble: Double; inline;
+    Function ToExtended: Extended; inline;
+    Function ToHexString(const AMinDigits: Integer): string; overload; inline;
+    Function ToHexString: string; overload; inline;
+    Function ToSingle: Single; inline;
+    Function ToString: string; overload; inline;
+  end;
+
+  {$SCOPEDENUMS ON}
+    TUseBoolStrs = (False, True);
+  {$SCOPEDENUMS OFF}
+
+  TBooleanHelper = Type Helper for Boolean
+  public
+    Class Function Parse(const S: string): Boolean; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
+    Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
+  Public
+    Function ToInteger: Integer; inline;
+    Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
+  end;
+
+  TByteBoolHelper = Type Helper for ByteBool
+  public
+    Class Function Parse(const S: string): Boolean; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
+    Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
+  Public
+    Function ToInteger: Integer; inline;
+    Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
+  end;
+
+  TWordBoolHelper = Type Helper for WordBool
+  public
+    Class Function Parse(const S: string): Boolean; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
+    Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
+  Public
+    Function ToInteger: Integer; inline;
+    Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
+  end;
+
+  TLongBoolHelper = Type Helper for LongBool
+  public
+    Class Function Parse(const S: string): Boolean; inline; static;
+    Class Function Size: Integer; inline; static;
+    Class Function ToString(const AValue: Boolean; UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline; static;
+    Class Function TryToParse(const S: string; out AValue: Boolean): Boolean; inline; static;
+  public
+    Function ToInteger: Integer; inline;
+    Function ToString(UseBoolStrs: TUseBoolStrs = TUseBoolStrs.False): string; overload; inline;
+  end;

rtl/objpas/sysutils/syshelpo.inc

@@ -0,0 +1,71 @@
+
+Class Function TORDINALHELPER.Parse(const AString: string): TORDINALTYPE; inline; static;
+
+begin
+  Result:=StrToInt(AString);
+end;
+
+Class Function TORDINALHELPER.Size: Integer; inline; static;
+
+begin
+  Result:=SizeOf(TORDINALTYPE);
+end;
+
+Class Function TORDINALHELPER.ToString(const AValue: TORDINALTYPE): string; overload; inline; static;
+
+begin
+  Result:=IntToStr(AValue);
+end;
+
+Class Function TORDINALHELPER.TryParse(const AString: string; out AValue: TORDINALTYPE): Boolean; inline; static;
+
+Var
+  C : Integer;
+
+begin
+  Val(AString,AValue,C);
+  Result:=(C=0);
+end;
+
+Function TORDINALHELPER.ToBoolean: Boolean; inline;
+
+begin
+  Result:=(Self<>0);
+end;
+
+Function TORDINALHELPER.ToDouble: Double; inline;
+
+begin
+  Result:=Self;
+end;
+
+Function TORDINALHELPER.ToExtended: Extended; inline;
+
+begin
+  Result:=Self;
+end;
+
+Function TORDINALHELPER.ToHexString(const AMinDigits: Integer): string;
+overload; inline;
+
+begin
+  Result:=HexStr(Self,AMinDigits);
+end;
+
+Function TORDINALHELPER.ToHexString: string; overload; inline;
+
+begin
+  Result:=HexStr(Self,SizeOf(TORDINALTYPE)*2);
+end;
+
+Function TORDINALHELPER.ToSingle: Single; inline;
+
+begin
+  Result:=Self;
+end;
+
+Function TORDINALHELPER.ToString: string; overload; inline;
+
+begin
+  Result:=IntToStr(Self);
+end;

rtl/objpas/sysutils/sysuni.inc

@@ -108,25 +108,25 @@ function UnicodeLowerCase(const s : UnicodeString) : UnicodeString;{$ifdef SYSUT
 
 function UnicodeCompareStr(const s1, s2 : UnicodeString) : PtrInt;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareUnicodeStringProc(s1,s2);
+    result:=widestringmanager.CompareUnicodeStringProc(s1,s2,[]);
   end;
 
 
 function UnicodeSameStr(const s1, s2 : UnicodeString) : Boolean;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareUnicodeStringProc(s1,s2)=0;
+    result:=widestringmanager.CompareUnicodeStringProc(s1,s2,[])=0;
   end;
 
 
 function UnicodeCompareText(const s1, s2 : UnicodeString) : PtrInt;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareTextUnicodeStringProc(s1,s2);
+    result:=widestringmanager.CompareUnicodeStringProc(s1,s2,[coIgnoreCase]);
   end;
   
   
 function UnicodeSameText(const s1, s2 : UnicodeString) : Boolean;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareTextUnicodeStringProc(s1,s2)=0;
+    result:=widestringmanager.CompareUnicodeStringProc(s1,s2,[coIgnoreCase])=0;
   end;
   
 

rtl/objpas/sysutils/sysutilh.inc

@@ -307,6 +307,9 @@ Type
   { read thread handling }
   {$i systhrdh.inc}
 
+  { Type Helpers}
+  {$i syshelph.inc}
+
   procedure FreeAndNil(var obj);
 
   { interface handling }

rtl/objpas/sysutils/sysutils.inc

@@ -39,7 +39,9 @@
 
   { variant error codes }
   {$i varerror.inc}
-
+  
+  { Type helpers}
+  {$i syshelp.inc}
 
   {$ifndef OS_FILEISREADONLY}
   Function FileIsReadOnly(const FileName: RawByteString): Boolean;

rtl/objpas/sysutils/syswide.inc

@@ -64,25 +64,25 @@ function WideLowerCase(const s : WideString) : WideString;{$ifdef SYSUTILSINLINE
 
 function WideCompareStr(const s1, s2 : WideString) : PtrInt;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareWideStringProc(s1,s2);
+    result:=widestringmanager.CompareWideStringProc(s1,s2,[]);
   end;
 
 
 function WideSameStr(const s1, s2 : WideString) : Boolean;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareWideStringProc(s1,s2)=0;
+    result:=widestringmanager.CompareWideStringProc(s1,s2,[])=0;
   end;
 
 
 function WideCompareText(const s1, s2 : WideString) : PtrInt;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareTextWideStringProc(s1,s2);
+    result:=widestringmanager.CompareWideStringProc(s1,s2,[coIgnoreCase]);
   end;
   
   
 function WideSameText(const s1, s2 : WideString) : Boolean;{$ifdef SYSUTILSINLINE}inline;{$endif}
   begin
-    result:=widestringmanager.CompareTextWideStringProc(s1,s2)=0;
+    result:=widestringmanager.CompareWideStringProc(s1,s2,[coIgnoreCase])=0;
   end;
   
 

rtl/os2/sysucode.inc

@@ -1252,13 +1252,19 @@ begin
 end;
 
 
-function OS2CompareUnicodeString (const S1, S2: UnicodeString): PtrInt;
+function OS2CompareUnicodeString (const S1, S2: UnicodeString; Options : TCompareOptions): PtrInt;
 var
   HS1, HS2: UnicodeString;
+  
 begin
   { UniStrColl interprets null chars as end-of-string -> filter out }
   HS1 := NoNullsUnicodeString (S1);
   HS2 := NoNullsUnicodeString (S2);
+  if coIgnoreCase in Options then
+    begin
+    HS1:=OS2UpperUnicodeString(HS1);
+    HS2:=OS2UpperUnicodeString(HS2);
+    end;
   Result := Sys_UniStrColl (DefLocObj, PWideChar (HS1), PWideChar (HS2));
   if Result < -1 then
    Result := -1
@@ -1694,15 +1700,12 @@ begin
   WideStringManager.UpperWideStringProc := @OS2UpperUnicodeString;
   WideStringManager.LowerWideStringProc := @OS2LowerUnicodeString;
   WideStringManager.CompareWideStringProc := @OS2CompareUnicodeString;
-  WideStringManager.CompareTextWideStringProc := @OS2CompareTextUnicodeString;
     { Unicode }
   WideStringManager.Unicode2AnsiMoveProc := @OS2Unicode2AnsiMove;
   WideStringManager.Ansi2UnicodeMoveProc := @OS2Ansi2UnicodeMove;
   WideStringManager.UpperUnicodeStringProc := @OS2UpperUnicodeString;
   WideStringManager.LowerUnicodeStringProc := @OS2LowerUnicodeString;
   WideStringManager.CompareUnicodeStringProc := @OS2CompareUnicodeString;
-  WideStringManager.CompareTextUnicodeStringProc :=
-                                                  @OS2CompareTextUnicodeString;
     { Codepage }
   WideStringManager.GetStandardCodePageProc := @OS2GetStandardCodePage;
 (*

rtl/os2/sysutils.pp

@@ -21,6 +21,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 {$DEFINE HAS_SLEEP}
 {$DEFINE HAS_OSERROR}

rtl/unix/cwstring.pp

@@ -766,36 +766,59 @@ function WideStringToUCS4StringNoNulls(const s : WideString) : UCS4String;
   end;
 
 
-function CompareWideString(const s1, s2 : WideString) : PtrInt;
+function CompareWideString(const s1, s2 : WideString; Options : TCompareOptions) : PtrInt;
 {$if not(defined (aix) and defined(cpupowerpc32))}
   var
     hs1,hs2 : UCS4String;
+    us1,us2 : WideString;
+    
   begin
     { wcscoll interprets null chars as end-of-string -> filter out }
-    hs1:=WideStringToUCS4StringNoNulls(s1);
-    hs2:=WideStringToUCS4StringNoNulls(s2);
+    if coIgnoreCase in Options then
+      begin
+      us1:=UpperWideString(s1);
+      us2:=UpperWideString(s2);
+      end     
+    else      
+      begin   
+      us1:=s1;
+      us2:=s2;
+      end;  
+    hs1:=WideStringToUCS4StringNoNulls(us1);
+    hs2:=WideStringToUCS4StringNoNulls(us2);
     result:=wcscoll(pwchar_t(hs1),pwchar_t(hs2));
   end;
 {$else}
   { AIX/PPC32 has a 16 bit wchar_t }
   var
     i, len: longint;
+    us1,us2 : WideString;
     hs1, hs2: array of widechar;
   begin
-    len:=length(s1);
+    if coIgnoreCase in Options then
+      begin
+      us1:=UpperWideString(s1);
+      us2:=UpperWideString(s2);
+      end
+    else
+      begin
+      us1:=s1;
+      us2:=s2;
+      end;  
+    len:=length(us1);
     setlength(hs1,len+1);
     for i:=1 to len do
-      if s1[i]<>#0 then
-        hs1[i-1]:=s1[i]
+      if us1[i]<>#0 then
+        hs1[i-1]:=us1[i]
       else
         hs1[i-1]:=#32;
     hs1[len]:=#0;
 
-    len:=length(s2);
+    len:=length(us2);
     setlength(hs2,len+1);
     for i:=1 to len do
-      if s2[i]<>#0 then
-        hs2[i-1]:=s2[i]
+      if us2[i]<>#0 then
+        hs2[i-1]:=us2[i]
       else
         hs2[i-1]:=#32;
     hs2[len]:=#0;
@@ -804,11 +827,6 @@ function CompareWideString(const s1, s2 : WideString) : PtrInt;
 {$endif}
 
 
-function CompareTextWideString(const s1, s2 : WideString): PtrInt;
-  begin
-    result:=CompareWideString(UpperWideString(s1),UpperWideString(s2));
-  end;
-
 
 { return value: number of code points in the string. Whenever an invalid
   code point is encountered, all characters part of this invalid code point
@@ -1080,7 +1098,7 @@ begin
       LowerWideStringProc:=@LowerWideString;
 
       CompareWideStringProc:=@CompareWideString;
-      CompareTextWideStringProc:=@CompareTextWideString;
+//      CompareTextWideStringProc:=@CompareTextWideString;
 
       CharLengthPCharProc:=@CharLengthPChar;
       CodePointLengthProc:=@CodePointLength;
@@ -1103,7 +1121,6 @@ begin
       UpperUnicodeStringProc:=@UpperWideString;
       LowerUnicodeStringProc:=@LowerWideString;
       CompareUnicodeStringProc:=@CompareWideString;
-      CompareTextUnicodeStringProc:=@CompareTextWideString;
       { CodePage }
       GetStandardCodePageProc:=@GetStandardCodePage;
     end;

rtl/unix/sysutils.pp

@@ -20,6 +20,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 {$if (defined(BSD) or defined(SUNOS)) and defined(FPC_USE_LIBC)}
 {$define USE_VFORK}

rtl/watcom/sysutils.pp

@@ -23,6 +23,8 @@ interface
 {$modeswitch out}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
   watcom,dos;

rtl/wii/sysutils.pp

@@ -28,6 +28,9 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
+
 {$DEFINE HAS_SLEEP}
 { used OS file system APIs use ansistring }
 {$define SYSUTILS_HAS_ANSISTR_FILEUTIL_IMPL}

rtl/win/sysutils.pp

@@ -21,6 +21,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
   windows;
@@ -1283,10 +1285,25 @@ function DoCompareStringW(P1, P2: PWideChar; L1, L2: PtrUInt; Flags: DWORD): Ptr
       RaiseLastOSError;
   end;
 
-function Win32CompareWideString(const s1, s2 : WideString) : PtrInt;
-  begin
-    Result:=DoCompareStringW(PWideChar(s1), PWideChar(s2), Length(s1), Length(s2), 0);
-  end;
+const
+  WinAPICompareFlags : array [TCompareOption] of LongWord 
+    = (LINGUISTIC_IGNORECASE,  LINGUISTIC_IGNOREDIACRITIC, NORM_IGNORECASE, 
+       NORM_IGNOREKANATYPE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS, NORM_IGNOREWIDTH,
+       NORM_LINGUISTIC_CASING, SORT_DIGITSASNUMBERS, SORT_STRINGSORT);
+       
+function Win32CompareWideString(const s1, s2 : WideString; Options : TCompareOptions) : PtrInt;
+
+Var
+  O : LongWord;              
+  CO : TCompareOption;
+   
+begin
+  O:=0;  
+  for CO in TCompareOption do
+    if CO in Options then
+      O:=O or WinAPICompareFlags[CO];
+  Result:=DoCompareStringW(PWideChar(s1), PWideChar(s2), Length(s1), Length(s2), O);
+end;
 
 
 function Win32CompareTextWideString(const s1, s2 : WideString) : PtrInt;
@@ -1372,10 +1389,19 @@ function Win32AnsiStrUpper(Str: PChar): PChar;
     result:=str;
   end;
 
-function Win32CompareUnicodeString(const s1, s2 : UnicodeString) : PtrInt;
-  begin
-    Result:=DoCompareStringW(PWideChar(s1), PWideChar(s2), Length(s1), Length(s2), 0);
-  end;
+function Win32CompareUnicodeString(const s1, s2 : UnicodeString; Options : TCompareOptions) : PtrInt;
+
+Var
+  O : LongWord;              
+  CO : TCompareOption;
+   
+begin
+  O:=0;  
+  for CO in TCompareOption do
+    if CO in Options then
+      O:=O or WinAPICompareFlags[CO];
+    Result:=DoCompareStringW(PWideChar(s1), PWideChar(s2), Length(s1), Length(s2), O);
+end;
 
 
 function Win32CompareTextUnicodeString(const s1, s2 : UnicodeString) : PtrInt;
@@ -1399,7 +1425,6 @@ procedure InitWin32Widestrings;
       > 0 if that's the length in bytes of the code point }
 //!!!!    CodePointLengthProc : function(const Str: PChar; MaxLookAead: PtrInt): Ptrint;
     widestringmanager.CompareWideStringProc:=@Win32CompareWideString;
-    widestringmanager.CompareTextWideStringProc:=@Win32CompareTextWideString;
     widestringmanager.UpperAnsiStringProc:=@Win32AnsiUpperCase;
     widestringmanager.LowerAnsiStringProc:=@Win32AnsiLowerCase;
     widestringmanager.CompareStrAnsiStringProc:=@Win32AnsiCompareStr;
@@ -1411,7 +1436,6 @@ procedure InitWin32Widestrings;
     widestringmanager.StrLowerAnsiStringProc:=@Win32AnsiStrLower;
     widestringmanager.StrUpperAnsiStringProc:=@Win32AnsiStrUpper;
     widestringmanager.CompareUnicodeStringProc:=@Win32CompareUnicodeString;
-    widestringmanager.CompareTextUnicodeStringProc:=@Win32CompareTextUnicodeString;
   end;
 
 { Platform-specific exception support }

rtl/win/wininc/defines.inc

@@ -332,6 +332,7 @@
      NORM_IGNOREKANATYPE        = $00010000;
      NORM_IGNOREWIDTH           = $00020000;
      NORM_LINGUISTIC_CASING     = $08000000;
+     SORT_DIGITSASNUMBERS       = $00000008;
      SORT_STRINGSORT = 4096;
      LCMAP_BYTEREV = 2048;
      LCMAP_FULLWIDTH = 8388608;

rtl/wince/sysutils.pp

@@ -21,6 +21,8 @@ interface
 {$MODESWITCH OUT}
 { force ansistrings }
 {$H+}
+{$modeswitch typehelpers}
+{$modeswitch advancedrecords}
 
 uses
   dos,

utils/tply/lextable.pas

@@ -77,7 +77,7 @@ type
 SymTable = array [1..max_keys] of record
              pname  : StrPtr;
                (* print name; empty entries are denoted by pname=nil *)
-             case sym_type : ( none, macro_sym, start_state_sym ) of
+             case sym_type : ( none_sym, macro_sym, start_state_sym ) of
              macro_sym : ( subst : StrPtr );
                (* macro substitution *)
              start_state_sym : ( start_state : Integer );
@@ -212,7 +212,7 @@ procedure entry(k : Integer; symbol : String);
     with sym_table^[k] do
       begin
         pname    := newStr(symbol);
-        sym_type := none;
+        sym_type := none_sym;
       end
   end(*entry*);
 

utils/tply/plex.pas

@@ -96,7 +96,7 @@ procedure define_start_state ( symbol : String; pos : Integer );
 {$else}
     with sym_table^[key(symbol, max_keys, lookup, entry)] do
 {$endif}
-      if sym_type=none then
+      if sym_type=none_sym then
         begin
           inc(n_start_states);
           if n_start_states>max_start_states then
@@ -119,7 +119,7 @@ procedure define_macro ( symbol, replacement : String );
 {$else}
     with sym_table^[key('{'+symbol+'}', max_keys, lookup, entry)] do
 {$endif}
-      if sym_type=none then
+      if sym_type=none_sym then
         begin
           sym_type := macro_sym;
           subst    := newStr(strip(replacement));