Zstr.pas

unit Zstr;

interface

type
  TZstr = Record
    str: pchar;
    top: integer;
    tail: integer;
    tail2: integer;
  end;

function ZstrToString(var Str: TZstr; Top: integer = -1; Tail: integer = -1): string;
function StringToZstr(const Str: string): TZstr;
function ZstrLength(var Str: TZstr): integer;
procedure ZstrClear(var Str: TZstr);
procedure ZstrAppend(var Str: TZstr; const Str2: string); overload;
procedure ZstrAppend(var Str: TZstr; var Str2: TZstr); overload;
function ZstrPos(var Str: TZstr; const Word: string): integer;
function ZstrCountWord(var Str: TZstr; const Word: string): integer;
function ZstrSeparateWord(var Str: TZstr; const Word: string; var Str2: TZstr): boolean;
function ZstrSeparateLf(var Str: TZstr; var Str2: TZstr): boolean;
function ZstrSeparateBracket(var Str: TZstr; var Str2: TZstr): boolean;

implementation

function ZstrToString(var Str: TZstr; Top: integer = -1; Tail: integer = -1): string;
var
  i: integer;
begin
  if Top = -1 then begin
    Top := Str.top;
  end;
  if Tail = -1 then begin
    Tail := Str.tail;
  end;
  SetLength(result, Tail - Top);
  for i := 0 to Tail - Top - 1 do begin
    result[i + 1] := Str.str[Top + i];
  end;
end;

function StringToZstr(const Str: string): TZstr;
begin
  result.str := @Str[1];
  result.top := 0;
  result.tail := Length(Str);
  result.tail2 := result.tail;
end;

function ZstrLength(var Str: TZstr): integer;
begin
  result := Str.tail - Str.top;
end;

procedure ZstrClear(var Str: TZstr);
begin
  Str.top := 0;
  Str.tail := 0;
end;

procedure ZstrAppend(var Str: TZstr; const Str2: string);
var
  i: integer;
  n: integer;
begin
  n := Length(Str2);
  if Str.tail2 - Str.tail < n then begin
    n := Str.tail2 - Str.tail;
  end;
  for i := 0 to n - 1 do begin
    Str.str[Str.tail + i] := Str2[i + 1];
  end;
  Str.tail := Str.tail + n;
end;

procedure ZstrAppend(var Str: TZstr; var Str2: TZstr);
var
  i: integer;
  n: integer;
begin
  n := Str2.tail - Str2.top;
  if Str.tail2 - Str.tail < n then begin
    n := Str.tail2 - Str.tail;
  end;
  for i := 0 to n - 1 do begin
    Str.str[Str.tail + i] := Str2.str[Str2.top + i];
  end;
  Str.tail := Str.tail + n;
end;

function ZstrPos(var Str: TZstr; const Word: string): integer;
var
  i: integer;
  j: integer;
  n: integer;
  m: integer;
begin
  result := -1;
  n := Length(Word);
  if n > 0 then begin
    m := Str.tail - n + 1;
    for i := Str.top to m - 1 do begin
      if Str.str[i] = Word[0 + 1] then begin
        result := i;
        for j := 1 to n - 1 do begin
          if Str.str[i + j] <> Word[j + 1] then begin
            result := -1;
            break;
          end;
        end;
        if result >= 0 then begin
          break;
        end;
      end;
    end;
  end;
end;

function ZstrSeparateWord(var Str: TZstr; const Word: string; var Str2: TZstr): boolean;
var
  n: integer;
begin
  n := ZstrPos(Str, Word);
  if n < 0 then begin
    Str2.str := Str.str;
    Str2.top := Str.top;
    Str2.tail := Str.tail;
    Str2.tail2 := Str.tail2;
    Str.top := Str.tail;
    result := false;
  end else begin
    Str2.str := Str.str;
    Str2.top := Str.top;
    Str2.tail := n;
    Str2.tail2 := Str.tail2;
    Str.top := n + Length(Word);
    result := true;
  end;
end;

function ZstrCountWord(var Str: TZstr; const Word: string): integer;
var
  zTmp: TZstr;
  k: integer;
begin
  result := 0;
  zTmp := Str;
  while ZstrLength(zTmp) > 0 do begin
    k := ZstrPos(zTmp, Word);
    if k < 0 then begin
      break;
    end;
    zTmp.top := k + Length(Word);
    Inc(result);
  end;
end;

function ZstrSeparateLf(var Str: TZstr; var Str2: TZstr): boolean;
begin
  result := ZstrSeparateWord(Str, #$0a, Str2);
end;

function ZstrSeparateBracket(var Str: TZstr; var Str2: TZstr): boolean;
begin
  result := ZstrSeparateWord(Str, '<>', Str2);
end;

end.