2229 lines
52 KiB
ObjectPascal
2229 lines
52 KiB
ObjectPascal
{******************************************************************************}
|
|
{ }
|
|
{ Library: Fundamentals 5.00 }
|
|
{ File name: flcZeroTermStrings.pas }
|
|
{ File version: 5.03 }
|
|
{ Description: Zero terminated string utility functions }
|
|
{ }
|
|
{ Copyright: Copyright (c) 1999-2020, David J Butler }
|
|
{ All rights reserved. }
|
|
{ Redistribution and use in source and binary forms, with }
|
|
{ or without modification, are permitted provided that }
|
|
{ the following conditions are met: }
|
|
{ Redistributions of source code must retain the above }
|
|
{ copyright notice, this list of conditions and the }
|
|
{ following disclaimer. }
|
|
{ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND }
|
|
{ CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED }
|
|
{ WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED }
|
|
{ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A }
|
|
{ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL }
|
|
{ THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, }
|
|
{ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR }
|
|
{ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, }
|
|
{ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF }
|
|
{ USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) }
|
|
{ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER }
|
|
{ IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING }
|
|
{ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE }
|
|
{ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE }
|
|
{ POSSIBILITY OF SUCH DAMAGE. }
|
|
{ }
|
|
{ Github: https://github.com/fundamentalslib }
|
|
{ E-mail: fundamentals.library at gmail.com }
|
|
{ }
|
|
{ Revision history: }
|
|
{ }
|
|
{ 1999/10/19 0.01 Initial version. }
|
|
{ 2017/10/07 5.02 Split from flcStrings unit. }
|
|
{ 2018/08/12 5.03 String type changes. }
|
|
{ }
|
|
{ Supported compilers: }
|
|
{ }
|
|
{ Delphi 10 Win32 5.02 2016/01/09 }
|
|
{ }
|
|
{******************************************************************************}
|
|
|
|
{$INCLUDE ..\flcInclude.inc}
|
|
|
|
{$IFDEF FREEPASCAL}
|
|
{$WARNINGS OFF}
|
|
{$HINTS OFF}
|
|
{$ENDIF}
|
|
|
|
{$IFDEF DEBUG}
|
|
{$IFDEF TEST}
|
|
{$DEFINE ZERO_TERM_STRINGS_TEST}
|
|
{$ENDIF}
|
|
{$ENDIF}
|
|
|
|
unit flcZeroTermStrings;
|
|
|
|
interface
|
|
|
|
uses
|
|
{ Fundamentals }
|
|
flcStdTypes;
|
|
|
|
|
|
|
|
{ }
|
|
{ Zero terminated string pointer }
|
|
{ }
|
|
type
|
|
PStrZA = PByteChar;
|
|
PStrZW = PWideChar;
|
|
PStrZ = PChar;
|
|
|
|
|
|
|
|
{ }
|
|
{ Match }
|
|
{ }
|
|
function StrZMatchLenA(const P: PByteChar; const M: ByteCharSet; const MaxLen: Integer = -1): Integer;
|
|
function StrZMatchLenW(const P: PWideChar; const M: ByteCharSet; const MaxLen: Integer = -1): Integer; overload;
|
|
function StrZMatchLenW(const P: PWideChar; const M: TWideCharMatchFunction; const MaxLen: Integer = -1): Integer; overload;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrA(const P: PAnsiChar; const M: AnsiString): Boolean;
|
|
{$ENDIF}
|
|
function StrZMatchStrB(const P: PByteChar; const M: RawByteString): Boolean;
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrAW(const P: PWideChar; const M: AnsiString): Boolean;
|
|
{$ENDIF}
|
|
function StrZMatchStrBW(const P: PWideChar; const M: RawByteString): Boolean;
|
|
function StrZMatchStrU(const P: PWideChar; const M: UnicodeString): Boolean;
|
|
function StrZMatchStr(const P: PChar; const M: String): Boolean;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrNoAsciiCaseA(const P: PAnsiChar; const M: AnsiString): Boolean;
|
|
{$ENDIF}
|
|
function StrZMatchStrNoAsciiCaseB(const P: PByteChar; const M: RawByteString): Boolean;
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrNoAsciiCaseAW(const P: PWideChar; const M: AnsiString): Boolean;
|
|
{$ENDIF}
|
|
function StrZMatchStrNoAsciiCaseBW(const P: PWideChar; const M: RawByteString): Boolean;
|
|
function StrZMatchStrNoAsciiCaseU(const P: PWideChar; const M: UnicodeString): Boolean;
|
|
function StrZMatchStrNoAsciiCase(const P: PChar; const M: String): Boolean;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrAsciiA(const P: PAnsiChar; const M: AnsiString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
{$ENDIF}
|
|
function StrZMatchStrAsciiB(const P: PByteChar; const M: RawByteString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrAsciiAW(const P: PWideChar; const M: AnsiString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
{$ENDIF}
|
|
function StrZMatchStrAsciiBW(const P: PWideChar; const M: RawByteString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
function StrZMatchStrAsciiU(const P: PWideChar; const M: UnicodeString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
function StrZMatchStrAscii(const P: PChar; const M: String; const AsciiCaseSensitive: Boolean): Boolean;
|
|
|
|
|
|
|
|
{ }
|
|
{ Pos }
|
|
{ }
|
|
function StrZPosCharA(const F: AnsiChar; const S: PByteChar): Integer;
|
|
function StrZPosCharW(const F: WideChar; const S: PWideChar): Integer;
|
|
function StrZPosChar(const F: Char; const S: PChar): Integer;
|
|
|
|
function StrZPosCharSetA(const F: ByteCharSet; const S: PByteChar): Integer;
|
|
function StrZPosCharSetW(const F: ByteCharSet; const S: PWideChar): Integer; overload;
|
|
function StrZPosCharSetW(const F: TWideCharMatchFunction; const S: PWideChar): Integer; overload;
|
|
function StrZPosCharSet(const F: ByteCharSet; const S: PChar): Integer;
|
|
|
|
function StrZPosNotCharSetA(const F: ByteCharSet; const S: PByteChar): Integer;
|
|
function StrZPosNotCharSetW(const F: ByteCharSet; const S: PWideChar): Integer; overload;
|
|
function StrZPosNotCharSetW(const F: TWideCharMatchFunction; const S: PWideChar): Integer; overload;
|
|
function StrZPosNotCharSet(const F: ByteCharSet; const S: PChar): Integer;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZPosA(const F: AnsiString; const S: PAnsiChar): Integer;
|
|
{$ENDIF}
|
|
function StrZPosB(const F: RawByteString; const S: PByteChar): Integer;
|
|
function StrZPosU(const F: UnicodeString; const S: PWideChar): Integer;
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZPosAW(const F: AnsiString; const S: PWideChar): Integer;
|
|
{$ENDIF}
|
|
function StrZPosBW(const F: RawByteString; const S: PWideChar): Integer;
|
|
|
|
|
|
|
|
{ }
|
|
{ Skip }
|
|
{ }
|
|
function StrZSkipCharA(var P: PByteChar; const C: AnsiChar): Boolean; overload;
|
|
function StrZSkipCharA(var P: PByteChar; const C: ByteCharSet): Boolean; overload;
|
|
|
|
function StrZSkipCharW(var P: PWideChar; const C: WideChar): Boolean; overload;
|
|
function StrZSkipCharW(var P: PWideChar; const C: ByteCharSet): Boolean; overload;
|
|
function StrZSkipCharW(var P: PWideChar; const C: TWideCharMatchFunction): Boolean; overload;
|
|
|
|
function StrZSkipChar(var P: PChar; const C: Char): Boolean; overload;
|
|
function StrZSkipChar(var P: PChar; const C: ByteCharSet): Boolean; overload;
|
|
|
|
function StrZSkipAllA(var P: Pointer; const C: AnsiChar): Integer; overload;
|
|
function StrZSkipAllA(var P: Pointer; const C: ByteCharSet): Integer; overload;
|
|
|
|
function StrZSkipAllW(var P: PWideChar; const C: WideChar): Integer; overload;
|
|
function StrZSkipAllW(var P: PWideChar; const C: ByteCharSet): Integer; overload;
|
|
function StrZSkipAllW(var P: PWideChar; const C: TWideCharMatchFunction): Integer; overload;
|
|
|
|
function StrZSkipAll(var P: PChar; const C: Char): Integer; overload;
|
|
function StrZSkipAll(var P: PChar; const C: ByteCharSet): Integer; overload;
|
|
|
|
function StrZSkipToCharA(var P: Pointer; const C: AnsiChar): Integer; overload;
|
|
function StrZSkipToCharA(var P: Pointer; const C: ByteCharSet): Integer; overload;
|
|
function StrZSkipToCharW(var P: PWideChar; const C: WideChar): Integer; overload;
|
|
function StrZSkipToCharW(var P: PWideChar; const C: ByteCharSet): Integer; overload;
|
|
function StrZSkipToCharW(var P: PWideChar; const C: TWideCharMatchFunction): Integer; overload;
|
|
function StrZSkipToChar(var P: PChar; const C: ByteCharSet): Integer;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipToStrA(var P: PAnsiChar; const S: AnsiString; const AsciiCaseSensitive: Boolean = True): Integer;
|
|
{$ENDIF}
|
|
function StrZSkipToStrB(var P: PByteChar; const S: RawByteString; const AsciiCaseSensitive: Boolean = True): Integer;
|
|
function StrZSkipToStrU(var P: PWideChar; const S: UnicodeString; const AsciiCaseSensitive: Boolean = True): Integer;
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipToStrAW(var P: PWideChar; const S: AnsiString; const AsciiCaseSensitive: Boolean = True): Integer;
|
|
{$ENDIF}
|
|
function StrZSkipToStr(var P: PChar; const S: String; const AsciiCaseSensitive: Boolean = True): Integer;
|
|
|
|
function StrZSkip2CharSeq(var P: PByteChar; const S1, S2: ByteCharSet): Boolean;
|
|
function StrZSkip3CharSeq(var P: PByteChar; const S1, S2, S3: ByteCharSet): Boolean;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipStrA(var P: PAnsiChar; const S: AnsiString; const AsciiCaseSensitive: Boolean = True): Boolean;
|
|
{$ENDIF}
|
|
function StrZSkipStrB(var P: PByteChar; const S: RawByteString; const AsciiCaseSensitive: Boolean = True): Boolean;
|
|
function StrZSkipStrU(var P: PWideChar; const S: UnicodeString; const AsciiCaseSensitive: Boolean = True): Boolean;
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipStrAW(var P: PWideChar; const S: AnsiString; const AsciiCaseSensitive: Boolean = True): Boolean;
|
|
{$ENDIF}
|
|
function StrZSkipStrBW(var P: PWideChar; const S: RawByteString; const AsciiCaseSensitive: Boolean = True): Boolean;
|
|
function StrZSkipStr(var P: PChar; const S: String; const AsciiCaseSensitive: Boolean = True): Boolean;
|
|
|
|
|
|
|
|
{ }
|
|
{ Extract }
|
|
{ }
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractAllA(var P: PAnsiChar; const C: AnsiChar): AnsiString; overload;
|
|
function StrZExtractAllA(var P: PAnsiChar; const C: ByteCharSet): AnsiString; overload;
|
|
{$ENDIF}
|
|
|
|
function StrZExtractAllU(var P: PWideChar; const C: WideChar): UnicodeString; overload;
|
|
function StrZExtractAllU(var P: PWideChar; const C: ByteCharSet): UnicodeString; overload;
|
|
function StrZExtractAllU(var P: PWideChar; const C: TWideCharMatchFunction): UnicodeString; overload;
|
|
|
|
function StrZExtractAll(var P: PChar; const C: Char): String; overload;
|
|
function StrZExtractAll(var P: PChar; const C: ByteCharSet): String; overload;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractToA(var P: PAnsiChar; const C: AnsiChar): AnsiString; overload;
|
|
function StrZExtractToA(var P: PAnsiChar; const C: ByteCharSet): AnsiString; overload;
|
|
{$ENDIF}
|
|
function StrZExtractToU(var P: PWideChar; const C: WideChar): UnicodeString; overload;
|
|
function StrZExtractToU(var P: PWideChar; const C: ByteCharSet): UnicodeString; overload;
|
|
function StrZExtractToU(var P: PWideChar; const C: TWideCharMatchFunction): UnicodeString; overload;
|
|
function StrZExtractTo(var P: PChar; const C: ByteCharSet): String;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractToStrA(var P: PAnsiChar; const S: AnsiString; const CaseSensitive: Boolean = True): AnsiString;
|
|
{$ENDIF}
|
|
function StrZExtractToStrB(var P: PByteChar; const S: RawByteString; const CaseSensitive: Boolean = True): RawByteString;
|
|
function StrZExtractToStrU(var P: PWideChar; const S: UnicodeString; const CaseSensitive: Boolean = True): UnicodeString;
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractToStrAU(var P: PWideChar; const S: AnsiString; const CaseSensitive: Boolean = True): UnicodeString;
|
|
{$ENDIF}
|
|
function StrZExtractToStr(var P: PChar; const S: String; const CaseSensitive: Boolean = True): String;
|
|
|
|
const
|
|
zchSingleQuote = AnsiChar('''');
|
|
zchDoubleQuote = AnsiChar('"');
|
|
zcsQuotes = [zchSingleQuote, zchDoubleQuote];
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractQuotedA(var P: PAnsiChar; var S: AnsiString; const Quote: ByteCharSet = zcsQuotes): Boolean;
|
|
{$ENDIF}
|
|
function StrZExtractQuotedB(var P: PByteChar; var S: RawByteString; const Quote: ByteCharSet = zcsQuotes): Boolean;
|
|
function StrZExtractQuotedU(var P: PWideChar; var S: UnicodeString; const Quote: ByteCharSet = zcsQuotes): Boolean;
|
|
function StrZExtractQuoted(var P: PChar; var S: String; const Quote: ByteCharSet = zcsQuotes): Boolean;
|
|
|
|
|
|
|
|
implementation
|
|
|
|
uses
|
|
{ Fundamentals }
|
|
flcUtils,
|
|
flcASCII;
|
|
|
|
|
|
|
|
{ }
|
|
{ Match }
|
|
{ }
|
|
function StrZMatchLenA(const P: PByteChar; const M: ByteCharSet; const MaxLen: Integer): Integer;
|
|
var Q : PByteChar;
|
|
L : Integer;
|
|
C : AnsiChar;
|
|
begin
|
|
Q := P;
|
|
L := MaxLen;
|
|
Result := 0;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while L <> 0 do
|
|
begin
|
|
C := Q^;
|
|
if Ord(C) = 0 then
|
|
exit;
|
|
if C in M then
|
|
begin
|
|
Inc(Q);
|
|
if L > 0 then
|
|
Dec(L);
|
|
Inc(Result);
|
|
end
|
|
else
|
|
exit;
|
|
end;
|
|
end;
|
|
|
|
function StrZMatchLenW(const P: PWideChar; const M: ByteCharSet; const MaxLen: Integer): Integer;
|
|
var Q : PWideChar;
|
|
L : Integer;
|
|
C : WideChar;
|
|
begin
|
|
Q := P;
|
|
L := MaxLen;
|
|
Result := 0;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while L <> 0 do
|
|
begin
|
|
C := Q^;
|
|
if C = #0 then
|
|
exit;
|
|
if WideCharInCharSet(C, M) then
|
|
begin
|
|
Inc(Q);
|
|
if L > 0 then
|
|
Dec(L);
|
|
Inc(Result);
|
|
end
|
|
else
|
|
exit;
|
|
end;
|
|
end;
|
|
|
|
function StrZMatchLenW(const P: PWideChar; const M: TWideCharMatchFunction; const MaxLen: Integer): Integer;
|
|
var Q : PWideChar;
|
|
L : Integer;
|
|
C : WideChar;
|
|
begin
|
|
Q := P;
|
|
L := MaxLen;
|
|
Result := 0;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while L <> 0 do
|
|
begin
|
|
C := Q^;
|
|
if C = #0 then
|
|
exit;
|
|
if M(C) then
|
|
begin
|
|
Inc(Q);
|
|
if L > 0 then
|
|
Dec(L);
|
|
Inc(Result);
|
|
end
|
|
else
|
|
exit;
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrA(const P: PAnsiChar; const M: AnsiString): Boolean;
|
|
var T, Q : PAnsiChar;
|
|
I, L : Integer;
|
|
C : AnsiChar;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if (Ord(C) = 0) or (C <> Q^) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end else
|
|
begin
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZMatchStrB(const P: PByteChar; const M: RawByteString): Boolean;
|
|
var T, Q : PByteChar;
|
|
I, L : Integer;
|
|
C : AnsiChar;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if (Ord(C) = 0) or (C <> Q^) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end else
|
|
begin
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrAW(const P: PWideChar; const M: AnsiString): Boolean;
|
|
var T : PWideChar;
|
|
Q : PAnsiChar;
|
|
I, L : Integer;
|
|
C : WideChar;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if (C = #0) or (Ord(C) <> Ord(Q^)) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end else
|
|
begin
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZMatchStrBW(const P: PWideChar; const M: RawByteString): Boolean;
|
|
var T : PWideChar;
|
|
Q : PByteChar;
|
|
I, L : Integer;
|
|
C : WideChar;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if (C = #0) or (Ord(C) <> Ord(Q^)) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end else
|
|
begin
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
function StrZMatchStrU(const P: PWideChar; const M: UnicodeString): Boolean;
|
|
var T, Q : PWideChar;
|
|
I, L : Integer;
|
|
C : WideChar;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if (C = #0) or (C <> Q^) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end else
|
|
begin
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
function StrZMatchStr(const P: PChar; const M: String): Boolean;
|
|
var T, Q : PChar;
|
|
I, L : Integer;
|
|
C : Char;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if (C = #0) or (C <> Q^) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end else
|
|
begin
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrNoAsciiCaseA(const P: PAnsiChar; const M: AnsiString): Boolean;
|
|
var T, Q : PByte;
|
|
I, L : Integer;
|
|
C, D : Byte;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := Pointer(P);
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if C = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
D := Q^;
|
|
if C <> D then
|
|
begin
|
|
C := AsciiLowCaseLookup[C];
|
|
D := AsciiLowCaseLookup[D];
|
|
if C <> D then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
end;
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
Result := True;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZMatchStrNoAsciiCaseB(const P: PByteChar; const M: RawByteString): Boolean;
|
|
var T, Q : PByte;
|
|
I, L : Integer;
|
|
C, D : Byte;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := Pointer(P);
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if C = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
D := Q^;
|
|
if C <> D then
|
|
begin
|
|
C := AsciiLowCaseLookup[C];
|
|
D := AsciiLowCaseLookup[D];
|
|
if C <> D then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
end;
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrNoAsciiCaseAW(const P: PWideChar; const M: AnsiString): Boolean;
|
|
var T : PWideChar;
|
|
Q : PByteChar;
|
|
I, L : Integer;
|
|
C : WideChar;
|
|
D : AnsiChar;
|
|
E, F : Byte;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if C = #0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
D := Q^;
|
|
if Ord(C) <> Ord(D) then
|
|
begin
|
|
if (Ord(C) >= $80) or (Ord(D) >= $80) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
E := AsciiLowCaseLookup[Ord(C)];
|
|
F := AsciiLowCaseLookup[Ord(D)];
|
|
if E <> F then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
end;
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
Result := True;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZMatchStrNoAsciiCaseBW(const P: PWideChar; const M: RawByteString): Boolean;
|
|
var T : PWideChar;
|
|
Q : PByteChar;
|
|
I, L : Integer;
|
|
C : WideChar;
|
|
D : AnsiChar;
|
|
E, F : Byte;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if C = #0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
D := Q^;
|
|
if Ord(C) <> Ord(D) then
|
|
begin
|
|
if (Ord(C) >= $80) or (Ord(D) >= $80) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
E := AsciiLowCaseLookup[Ord(C)];
|
|
F := AsciiLowCaseLookup[Ord(D)];
|
|
if E <> F then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
end;
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
function StrZMatchStrNoAsciiCaseU(const P: PWideChar; const M: UnicodeString): Boolean;
|
|
var T, Q : PWideChar;
|
|
I, L : Integer;
|
|
C, D : WideChar;
|
|
E, F : Byte;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if C = #0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
D := Q^;
|
|
if C <> D then
|
|
begin
|
|
if (Ord(C) >= $80) or (Ord(D) >= $80) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
E := AsciiLowCaseLookup[Ord(C)];
|
|
F := AsciiLowCaseLookup[Ord(D)];
|
|
if E <> F then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
end;
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
function StrZMatchStrNoAsciiCase(const P: PChar; const M: String): Boolean;
|
|
var T, Q : PChar;
|
|
I, L : Integer;
|
|
C, D : Char;
|
|
E, F : Byte;
|
|
begin
|
|
L := Length(M);
|
|
if L = 0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
T := P;
|
|
Q := Pointer(M);
|
|
for I := 1 to L do
|
|
begin
|
|
C := T^;
|
|
if C = #0 then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
D := Q^;
|
|
if C <> D then
|
|
begin
|
|
{$IFDEF StringIsUnicode}
|
|
if (Ord(C) >= $80) or (Ord(D) >= $80) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
{$ENDIF}
|
|
E := AsciiLowCaseLookup[Ord(C)];
|
|
F := AsciiLowCaseLookup[Ord(D)];
|
|
if E <> F then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
end;
|
|
Inc(T);
|
|
Inc(Q);
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrAsciiA(const P: PAnsiChar; const M: AnsiString;
|
|
const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
if AsciiCaseSensitive then
|
|
Result := StrZMatchStrA(P, M)
|
|
else
|
|
Result := StrZMatchStrNoAsciiCaseA(P, M);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZMatchStrAsciiB(const P: PByteChar; const M: RawByteString;
|
|
const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
if AsciiCaseSensitive then
|
|
Result := StrZMatchStrB(P, M)
|
|
else
|
|
Result := StrZMatchStrNoAsciiCaseB(P, M);
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZMatchStrAsciiAW(const P: PWideChar; const M: AnsiString;
|
|
const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
if AsciiCaseSensitive then
|
|
Result := StrZMatchStrAW(P, M)
|
|
else
|
|
Result := StrZMatchStrNoAsciiCaseAW(P, M);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZMatchStrAsciiBW(const P: PWideChar; const M: RawByteString;
|
|
const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
if AsciiCaseSensitive then
|
|
Result := StrZMatchStrBW(P, M)
|
|
else
|
|
Result := StrZMatchStrNoAsciiCaseBW(P, M);
|
|
end;
|
|
|
|
function StrZMatchStrAsciiU(const P: PWideChar; const M: UnicodeString;
|
|
const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
if AsciiCaseSensitive then
|
|
Result := StrZMatchStrU(P, M)
|
|
else
|
|
Result := StrZMatchStrNoAsciiCaseU(P, M);
|
|
end;
|
|
|
|
function StrZMatchStrAscii(const P: PChar; const M: String; const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
if AsciiCaseSensitive then
|
|
Result := StrZMatchStr(P, M)
|
|
else
|
|
Result := StrZMatchStrNoAsciiCase(P, M);
|
|
end;
|
|
|
|
|
|
|
|
{ }
|
|
{ Pos }
|
|
{ }
|
|
function StrZPosCharA(const F: AnsiChar; const S: PByteChar): Integer;
|
|
var C : AnsiChar;
|
|
P : PByteChar;
|
|
begin
|
|
if not Assigned(S) or (Ord(F) = 0) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
C := P^;
|
|
while C <> F do
|
|
if Ord(C) = 0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end
|
|
else
|
|
begin
|
|
Inc(Result);
|
|
Inc(P);
|
|
C := P^;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosCharW(const F: WideChar; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) or (F = #0) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
C := P^;
|
|
while C <> F do
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end
|
|
else
|
|
begin
|
|
Inc(Result);
|
|
Inc(P);
|
|
C := P^;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosChar(const F: Char; const S: PChar): Integer;
|
|
var C : Char;
|
|
P : PChar;
|
|
begin
|
|
if not Assigned(S) or (F = #0) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
C := P^;
|
|
while C <> F do
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end
|
|
else
|
|
begin
|
|
Inc(Result);
|
|
Inc(P);
|
|
C := P^;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosCharSetA(const F: ByteCharSet; const S: PByteChar): Integer;
|
|
var C : AnsiChar;
|
|
P : PByteChar;
|
|
begin
|
|
if not Assigned(S) or (F = []) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if Ord(C) = 0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if C in F then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosCharSetW(const F: ByteCharSet; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) or (F = []) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if Ord(C) <= $FF then
|
|
if AnsiChar(Ord(C)) in F then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosCharSetW(const F: TWideCharMatchFunction; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) or not Assigned(F) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if F(C) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosCharSet(const F: ByteCharSet; const S: PChar): Integer;
|
|
var C : Char;
|
|
P : PChar;
|
|
begin
|
|
if not Assigned(S) or (F = []) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
{$IFDEF StringIsUnicode}
|
|
if Ord(C) <= $FF then
|
|
if AnsiChar(Ord(C)) in F then
|
|
break;
|
|
{$ELSE}
|
|
if C in F then
|
|
break;
|
|
{$ENDIF}
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosNotCharSetA(const F: ByteCharSet; const S: PByteChar): Integer;
|
|
var C : AnsiChar;
|
|
P : PByteChar;
|
|
begin
|
|
if not Assigned(S) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if Ord(C) = 0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if not (C in F) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosNotCharSetW(const F: ByteCharSet; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if Ord(C) >= $100 then
|
|
break;
|
|
if not (AnsiChar(Ord(C)) in F) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosNotCharSetW(const F: TWideCharMatchFunction; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if not F(C) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosNotCharSet(const F: ByteCharSet; const S: PChar): Integer;
|
|
var C : Char;
|
|
P : PChar;
|
|
begin
|
|
if not Assigned(S) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
{$IFDEF StringIsUnicode}
|
|
if Ord(C) >= $100 then
|
|
break;
|
|
if not (AnsiChar(Ord(C)) in F) then
|
|
break;
|
|
{$ELSE}
|
|
if not (C in F) then
|
|
break;
|
|
{$ENDIF}
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZPosA(const F: AnsiString; const S: PAnsiChar): Integer;
|
|
var C : AnsiChar;
|
|
P : PAnsiChar;
|
|
begin
|
|
if not Assigned(S) or (Length(F) = 0) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if Ord(C) = 0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if StrZMatchStrA(P, F) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZPosB(const F: RawByteString; const S: PByteChar): Integer;
|
|
var C : AnsiChar;
|
|
P : PByteChar;
|
|
begin
|
|
if not Assigned(S) or (Length(F) = 0) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if Ord(C) = 0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if StrZMatchStrB(P, F) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
function StrZPosU(const F: UnicodeString; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) or (F = '') then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if StrZMatchStrU(P, F) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZPosAW(const F: AnsiString; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) or (Length(F) = 0) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if StrZMatchStrAW(P, F) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZPosBW(const F: RawByteString; const S: PWideChar): Integer;
|
|
var C : WideChar;
|
|
P : PWideChar;
|
|
begin
|
|
if not Assigned(S) or (Length(F) = 0) then
|
|
Result := -1
|
|
else
|
|
begin
|
|
Result := 0;
|
|
P := S;
|
|
repeat
|
|
C := P^;
|
|
if C = #0 then
|
|
begin
|
|
Result := -1;
|
|
exit;
|
|
end;
|
|
if StrZMatchStrBW(P, F) then
|
|
break;
|
|
Inc(Result);
|
|
Inc(P);
|
|
until False;
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
{ }
|
|
{ Skip }
|
|
{ }
|
|
function StrZSkipCharA(var P: PByteChar; const C: AnsiChar): Boolean;
|
|
var Q : PByteChar;
|
|
D : AnsiChar;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) or (Ord(C) = 0) then
|
|
Result := False
|
|
else
|
|
begin
|
|
D := Q^;
|
|
if Ord(D) = 0 then
|
|
Result := False else
|
|
if D = C then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkipCharA(var P: PByteChar; const C: ByteCharSet): Boolean;
|
|
var Q : PByteChar;
|
|
D : AnsiChar;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
Result := False
|
|
else
|
|
begin
|
|
D := Q^;
|
|
if Ord(D) = 0 then
|
|
Result := False else
|
|
if D in C then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkipCharW(var P: PWideChar; const C: WideChar): Boolean;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) or (Ord(C) = 0) then
|
|
Result := False
|
|
else
|
|
begin
|
|
D := Q^;
|
|
if D = #0 then
|
|
Result := False else
|
|
if D = C then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkipCharW(var P: PWideChar; const C: ByteCharSet): Boolean;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
Result := False
|
|
else
|
|
begin
|
|
D := Q^;
|
|
if D = #0 then
|
|
Result := False else
|
|
if Ord(D) >= $100 then
|
|
Result := False
|
|
else
|
|
if AnsiChar(Ord(D)) in C then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkipCharW(var P: PWideChar; const C: TWideCharMatchFunction): Boolean;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
Result := False
|
|
else
|
|
begin
|
|
D := Q^;
|
|
if D = #0 then
|
|
Result := False else
|
|
if C(D) then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkipChar(var P: PChar; const C: Char): Boolean;
|
|
var Q : PChar;
|
|
D : Char;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) or (C = #0) then
|
|
Result := False
|
|
else
|
|
begin
|
|
D := Q^;
|
|
if D = #0 then
|
|
Result := False else
|
|
if D = C then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkipChar(var P: PChar; const C: ByteCharSet): Boolean;
|
|
var Q : PChar;
|
|
D : Char;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
Result := False
|
|
else
|
|
begin
|
|
D := Q^;
|
|
if D = #0 then
|
|
Result := False else
|
|
{$IFDEF StringIsUnicode}
|
|
if Ord(D) >= $100 then
|
|
Result := False
|
|
else
|
|
if AnsiChar(Ord(D)) in C then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
{$ELSE}
|
|
if D in C then
|
|
begin
|
|
Inc(P);
|
|
Result := True;
|
|
end
|
|
{$ENDIF}
|
|
else
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkipAllA(var P: Pointer; const C: AnsiChar): Integer;
|
|
var Q : PByteChar;
|
|
D : AnsiChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) or (Ord(C) = 0) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (Ord(D) = 0) or (D <> C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipAllA(var P: Pointer; const C: ByteCharSet): Integer;
|
|
var Q : PByteChar;
|
|
D : AnsiChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (Ord(D) = 0) or not (D in C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipAllW(var P: PWideChar; const C: WideChar): Integer;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) or (C = #0) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (D = #0) or (D <> C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipAllW(var P: PWideChar; const C: ByteCharSet): Integer;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (D = #0) or (Ord(D) >= $100) then
|
|
break;
|
|
if not (AnsiChar(Ord(D)) in C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipAllW(var P: PWideChar; const C: TWideCharMatchFunction): Integer;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if D = #0 then
|
|
break;
|
|
if not C(D) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipAll(var P: PChar; const C: Char): Integer;
|
|
var Q : PChar;
|
|
D : Char;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) or (C = #0) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (D = #0) or (D <> C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipAll(var P: PChar; const C: ByteCharSet): Integer;
|
|
var Q : PChar;
|
|
D : Char;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
{$IFDEF StringIsUnicode}
|
|
if (D = #0) or (Ord(D) >= $100) then
|
|
break;
|
|
if not (AnsiChar(Ord(D)) in C) then
|
|
break;
|
|
{$ELSE}
|
|
if (D = #0) or not (D in C) then
|
|
break;
|
|
{$ENDIF}
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipToCharA(var P: Pointer; const C: AnsiChar): Integer;
|
|
var Q : PByteChar;
|
|
D : AnsiChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (Ord(D) = 0) or (D = C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipToCharA(var P: Pointer; const C: ByteCharSet): Integer;
|
|
var Q : PByteChar;
|
|
D : AnsiChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (Ord(D) = 0) or (D in C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipToCharW(var P: PWideChar; const C: WideChar): Integer;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (D = #0) or (D = C) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipToCharW(var P: PWideChar; const C: ByteCharSet): Integer;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if (D = #0) or (Ord(D) >= $100) then
|
|
break;
|
|
if AnsiChar(Ord(D)) in C then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipToCharW(var P: PWideChar; const C: TWideCharMatchFunction): Integer;
|
|
var Q : PWideChar;
|
|
D : WideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if D = #0 then
|
|
break;
|
|
if C(D) then
|
|
break;
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipToChar(var P: PChar; const C: ByteCharSet): Integer;
|
|
var Q : PChar;
|
|
D : Char;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
repeat
|
|
D := Q^;
|
|
if D = #0 then
|
|
break;
|
|
{$IFDEF StringIsUnicode}
|
|
if Ord(D) >= $100 then
|
|
break;
|
|
if AnsiChar(Ord(D)) in C then
|
|
break;
|
|
{$ELSE}
|
|
if D in C then
|
|
break;
|
|
{$ENDIF}
|
|
Inc(Q);
|
|
Inc(Result);
|
|
until False;
|
|
P := Q;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipToStrA(var P: PAnsiChar; const S: AnsiString; const AsciiCaseSensitive: Boolean): Integer;
|
|
var Q : PAnsiChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while (Ord(Q^) <> 0) and not StrZMatchStrAsciiA(Q, S, AsciiCaseSensitive) do
|
|
begin
|
|
Inc(Q);
|
|
Inc(Result);
|
|
end;
|
|
P := Q;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZSkipToStrB(var P: PByteChar; const S: RawByteString; const AsciiCaseSensitive: Boolean): Integer;
|
|
var Q : PByteChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while (Ord(Q^) <> 0) and not StrZMatchStrAsciiB(Q, S, AsciiCaseSensitive) do
|
|
begin
|
|
Inc(Q);
|
|
Inc(Result);
|
|
end;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkipToStrU(var P: PWideChar; const S: UnicodeString; const AsciiCaseSensitive: Boolean): Integer;
|
|
var Q : PWideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while (Q^ <> #0) and not StrZMatchStrAsciiU(Q, S, AsciiCaseSensitive) do
|
|
begin
|
|
Inc(Q);
|
|
Inc(Result);
|
|
end;
|
|
P := Q;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipToStrAW(var P: PWideChar; const S: AnsiString; const AsciiCaseSensitive: Boolean): Integer;
|
|
var Q : PWideChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while (Q^ <> #0) and not StrZMatchStrAsciiAW(Q, S, AsciiCaseSensitive) do
|
|
begin
|
|
Inc(Q);
|
|
Inc(Result);
|
|
end;
|
|
P := Q;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZSkipToStr(var P: PChar; const S: String; const AsciiCaseSensitive: Boolean): Integer;
|
|
var Q : PChar;
|
|
begin
|
|
Result := 0;
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
exit;
|
|
while (Q^ <> #0) and not StrZMatchStrAscii(Q, S, AsciiCaseSensitive) do
|
|
begin
|
|
Inc(Q);
|
|
Inc(Result);
|
|
end;
|
|
P := Q;
|
|
end;
|
|
|
|
function StrZSkip2CharSeq(var P: PByteChar; const S1, S2: ByteCharSet): Boolean;
|
|
var Q : PByteChar;
|
|
C : AnsiChar;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
C := Q^;
|
|
if (Ord(C) = 0) or not (C in S1) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
Inc(Q);
|
|
C := Q^;
|
|
if (Ord(C) = 0) or not (C in S2) then
|
|
Result := False
|
|
else
|
|
begin
|
|
Inc(P, 2);
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
function StrZSkip3CharSeq(var P: PByteChar; const S1, S2, S3: ByteCharSet): Boolean;
|
|
var Q : PByteChar;
|
|
C : AnsiChar;
|
|
begin
|
|
Q := P;
|
|
if not Assigned(Q) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
C := Q^;
|
|
if (Ord(C) = 0) or not (C in S1) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
Inc(Q);
|
|
C := Q^;
|
|
if (Ord(C) = 0) or not (C in S2) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
Inc(Q);
|
|
C := Q^;
|
|
if (Ord(C) = 0) or not (C in S3) then
|
|
Result := False
|
|
else
|
|
begin
|
|
Inc(P, 3);
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipStrA(var P: PAnsiChar; const S: AnsiString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
Result := StrZMatchStrAsciiA(P, S, AsciiCaseSensitive);
|
|
if Result then
|
|
Inc(P, Length(S));
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZSkipStrB(var P: PByteChar; const S: RawByteString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
Result := StrZMatchStrAsciiB(P, S, AsciiCaseSensitive);
|
|
if Result then
|
|
Inc(P, Length(S));
|
|
end;
|
|
|
|
function StrZSkipStrU(var P: PWideChar; const S: UnicodeString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
Result := StrZMatchStrAsciiU(P, S, AsciiCaseSensitive);
|
|
if Result then
|
|
Inc(P, Length(S));
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZSkipStrAW(var P: PWideChar; const S: AnsiString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
Result := StrZMatchStrAsciiAW(P, S, AsciiCaseSensitive);
|
|
if Result then
|
|
Inc(P, Length(S));
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZSkipStrBW(var P: PWideChar; const S: RawByteString; const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
Result := StrZMatchStrAsciiBW(P, S, AsciiCaseSensitive);
|
|
if Result then
|
|
Inc(P, Length(S));
|
|
end;
|
|
|
|
function StrZSkipStr(var P: PChar; const S: String; const AsciiCaseSensitive: Boolean): Boolean;
|
|
begin
|
|
Result := StrZMatchStrAscii(P, S, AsciiCaseSensitive);
|
|
if Result then
|
|
Inc(P, Length(S));
|
|
end;
|
|
|
|
|
|
|
|
{ }
|
|
{ Extract }
|
|
{ }
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractAllA(var P: PAnsiChar; const C: AnsiChar): AnsiString;
|
|
var Q : PAnsiChar;
|
|
I : Integer;
|
|
begin
|
|
Q := P;
|
|
I := StrZSkipAllA(Pointer(P), C);
|
|
Result := StrPToStrA(Q, I);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractAllA(var P: PAnsiChar; const C: ByteCharSet): AnsiString;
|
|
var Q : PAnsiChar;
|
|
I : Integer;
|
|
begin
|
|
Q := P;
|
|
I := StrZSkipAllA(Pointer(P), C);
|
|
Result := StrPToStrA(Q, I);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZExtractAllU(var P: PWideChar; const C: WideChar): UnicodeString;
|
|
var Q : PWideChar;
|
|
I : Integer;
|
|
begin
|
|
Q := P;
|
|
I := StrZSkipAllW(P, C);
|
|
Result := StrPToStrU(Q, I);
|
|
end;
|
|
|
|
function StrZExtractAllU(var P: PWideChar; const C: ByteCharSet): UnicodeString;
|
|
var Q : PWideChar;
|
|
I : Integer;
|
|
begin
|
|
Q := P;
|
|
I := StrZSkipAllW(P, C);
|
|
Result := StrPToStrU(Q, I);
|
|
end;
|
|
|
|
function StrZExtractAllU(var P: PWideChar; const C: TWideCharMatchFunction): UnicodeString;
|
|
var Q : PWideChar;
|
|
I : Integer;
|
|
begin
|
|
Q := P;
|
|
I := StrZSkipAllW(P, C);
|
|
Result := StrPToStrU(Q, I);
|
|
end;
|
|
|
|
function StrZExtractAll(var P: PChar; const C: Char): String;
|
|
var Q : PChar;
|
|
I : Integer;
|
|
begin
|
|
Q := P;
|
|
I := StrZSkipAll(P, C);
|
|
Result := StrPToStr(Q, I);
|
|
end;
|
|
|
|
function StrZExtractAll(var P: PChar; const C: ByteCharSet): String;
|
|
var Q : PChar;
|
|
I : Integer;
|
|
begin
|
|
Q := P;
|
|
I := StrZSkipAll(P, C);
|
|
Result := StrPToStr(Q, I);
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractToA(var P: PAnsiChar; const C: AnsiChar): AnsiString;
|
|
var Q : PAnsiChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := StrZSkipToCharA(Pointer(P), C);
|
|
Result := StrPToStrA(Q, L);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractToA(var P: PAnsiChar; const C: ByteCharSet): AnsiString;
|
|
var Q : PAnsiChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := StrZSkipToCharA(Pointer(P), C);
|
|
Result := StrPToStrA(Q, L);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZExtractToU(var P: PWideChar; const C: WideChar): UnicodeString;
|
|
var Q : PWideChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := StrZSkipToCharW(P, C);
|
|
Result := StrPToStrU(Q, L);
|
|
end;
|
|
|
|
function StrZExtractToU(var P: PWideChar; const C: ByteCharSet): UnicodeString;
|
|
var Q : PWideChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := StrZSkipToCharW(P, C);
|
|
Result := StrPToStrU(Q, L);
|
|
end;
|
|
|
|
function StrZExtractToU(var P: PWideChar; const C: TWideCharMatchFunction): UnicodeString;
|
|
var Q : PWideChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := StrZSkipToCharW(P, C);
|
|
Result := StrPToStrU(Q, L);
|
|
end;
|
|
|
|
function StrZExtractTo(var P: PChar; const C: ByteCharSet): String;
|
|
var Q : PChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := StrZSkipToChar(P, C);
|
|
Result := StrPToStr(Q, L);
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractToStrA(var P: PAnsiChar; const S: AnsiString;
|
|
const CaseSensitive: Boolean): AnsiString;
|
|
var Q : PAnsiChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := 0;
|
|
while (Ord(P^) <> 0) and not StrZMatchStrAsciiA(P, S, CaseSensitive) do
|
|
begin
|
|
Inc(P);
|
|
Inc(L);
|
|
end;
|
|
Result := StrPToStrA(Q, L);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZExtractToStrB(var P: PByteChar; const S: RawByteString;
|
|
const CaseSensitive: Boolean): RawByteString;
|
|
var Q : PByteChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := 0;
|
|
while (Ord(P^) <> 0) and not StrZMatchStrAsciiB(P, S, CaseSensitive) do
|
|
begin
|
|
Inc(P);
|
|
Inc(L);
|
|
end;
|
|
Result := StrPToStrB(Q, L);
|
|
end;
|
|
|
|
function StrZExtractToStrU(var P: PWideChar; const S: UnicodeString;
|
|
const CaseSensitive: Boolean): UnicodeString;
|
|
var Q : PWideChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := 0;
|
|
while (P^ <> #0) and not StrZMatchStrAsciiU(P, S, CaseSensitive) do
|
|
begin
|
|
Inc(P);
|
|
Inc(L);
|
|
end;
|
|
Result := StrPToStrU(Q, L);
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractToStrAU(var P: PWideChar; const S: AnsiString;
|
|
const CaseSensitive: Boolean): UnicodeString;
|
|
var Q : PWideChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := 0;
|
|
while (P^ <> #0) and not StrZMatchStrAsciiAW(P, S, CaseSensitive) do
|
|
begin
|
|
Inc(P);
|
|
Inc(L);
|
|
end;
|
|
Result := StrPToStrU(Q, L);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZExtractToStr(var P: PChar; const S: String;
|
|
const CaseSensitive: Boolean): String;
|
|
var Q : PChar;
|
|
L : Integer;
|
|
begin
|
|
Q := P;
|
|
L := 0;
|
|
while (P^ <> #0) and not StrZMatchStrAscii(P, S, CaseSensitive) do
|
|
begin
|
|
Inc(P);
|
|
Inc(L);
|
|
end;
|
|
Result := StrPToStr(Q, L);
|
|
end;
|
|
|
|
{$IFDEF SupportAnsiString}
|
|
function StrZExtractQuotedA(var P: PAnsiChar; var S: AnsiString; const Quote: ByteCharSet): Boolean;
|
|
var Q : PAnsiChar;
|
|
C, D : AnsiChar;
|
|
L : Integer;
|
|
begin
|
|
C := P^;
|
|
if not (C in Quote) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
Inc(P);
|
|
Q := P;
|
|
L := 0;
|
|
repeat
|
|
D := P^;
|
|
if Ord(D) = 0 then
|
|
break;
|
|
if D = C then
|
|
begin
|
|
Inc(P);
|
|
break;
|
|
end;
|
|
Inc(P);
|
|
Inc(L);
|
|
until False;
|
|
S := StrPToStrA(Q, L);
|
|
Result := True;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function StrZExtractQuotedB(var P: PByteChar; var S: RawByteString; const Quote: ByteCharSet): Boolean;
|
|
var Q : PByteChar;
|
|
C, D : AnsiChar;
|
|
L : Integer;
|
|
begin
|
|
C := P^;
|
|
if not (C in Quote) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
Inc(P);
|
|
Q := P;
|
|
L := 0;
|
|
repeat
|
|
D := P^;
|
|
if Ord(D) = 0 then
|
|
break;
|
|
if D = C then
|
|
begin
|
|
Inc(P);
|
|
break;
|
|
end;
|
|
Inc(P);
|
|
Inc(L);
|
|
until False;
|
|
S := StrPToStrB(Q, L);
|
|
Result := True;
|
|
end;
|
|
|
|
function StrZExtractQuotedU(var P: PWideChar; var S: UnicodeString; const Quote: ByteCharSet): Boolean;
|
|
var Q : PWideChar;
|
|
C, D : WideChar;
|
|
L : Integer;
|
|
begin
|
|
C := P^;
|
|
if not WideCharInCharSet(C, Quote) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
Inc(P);
|
|
Q := P;
|
|
L := 0;
|
|
repeat
|
|
D := P^;
|
|
if D = #0 then
|
|
break;
|
|
if D = C then
|
|
begin
|
|
Inc(P);
|
|
break;
|
|
end;
|
|
Inc(P);
|
|
Inc(L);
|
|
until False;
|
|
S := StrPToStrU(Q, L);
|
|
Result := True;
|
|
end;
|
|
|
|
function StrZExtractQuoted(var P: PChar; var S: String; const Quote: ByteCharSet): Boolean;
|
|
var Q : PChar;
|
|
C, D : Char;
|
|
L : Integer;
|
|
begin
|
|
C := P^;
|
|
if not CharInCharSet(C, Quote) then
|
|
begin
|
|
Result := False;
|
|
exit;
|
|
end;
|
|
Inc(P);
|
|
Q := P;
|
|
L := 0;
|
|
repeat
|
|
D := P^;
|
|
if D = #0 then
|
|
break;
|
|
if D = C then
|
|
begin
|
|
Inc(P);
|
|
break;
|
|
end;
|
|
Inc(P);
|
|
Inc(L);
|
|
until False;
|
|
S := StrPToStr(Q, L);
|
|
Result := True;
|
|
end;
|
|
|
|
|
|
|
|
end.
|
|
|
|
|
|
|