IMPLEMENTATION MODULE Strings;
(* NUL-terminated string operations, matching the V3 CHAR-array model
   (every CHAR array reserves a terminator slot at index = count) and
   gm2's conventions. Length scans for the terminator rather than using
   the descriptor count, so fixed-size buffers holding shorter strings
   behave correctly. *)

PROCEDURE Length (VAR s : ARRAY OF CHAR) : INTEGER;
VAR i : INTEGER;
BEGIN
  i := 0;
  WHILE (i <= HIGH(s)) AND (s[i] # CHR(0)) DO INC(i) END;
  RETURN i
END Length;

PROCEDURE Assign (VAR src, dst : ARRAY OF CHAR);
VAR i, n, cap : INTEGER;
BEGIN
  n := Length(src);
  cap := HIGH(dst);
  IF n > cap THEN n := cap END;
  i := 0;
  WHILE i < n DO
    dst[i] := src[i];
    i := i + 1
  END;
  dst[n] := CHR(0)
END Assign;

PROCEDURE Copy (VAR src, dst : ARRAY OF CHAR);
BEGIN
  Assign(src, dst)
END Copy;

PROCEDURE Concat (VAR s1, s2 : ARRAY OF CHAR; VAR dst : ARRAY OF CHAR);
VAR i, n1, n2, cap : INTEGER;
BEGIN
  n1 := Length(s1);
  n2 := Length(s2);
  cap := HIGH(dst);
  IF n1 > cap THEN n1 := cap END;
  IF n1 + n2 > cap THEN n2 := cap - n1 END;
  IF n2 < 0 THEN n2 := 0 END;
  i := 0;
  WHILE i < n1 DO
    dst[i] := s1[i];
    i := i + 1
  END;
  i := 0;
  WHILE i < n2 DO
    dst[n1 + i] := s2[i];
    i := i + 1
  END;
  dst[n1 + n2] := CHR(0)
END Concat;

PROCEDURE Delete (VAR s : ARRAY OF CHAR; start, count : INTEGER);
VAR n, i : INTEGER;
BEGIN
  n := Length(s);
  IF start < 0 THEN start := 0 END;
  IF start > n THEN start := n END;
  IF count < 0 THEN count := 0 END;
  IF start + count > n THEN count := n - start END;
  i := start;
  WHILE i + count < n DO
    s[i] := s[i + count];
    i := i + 1
  END;
  s[n - count] := CHR(0)
END Delete;

PROCEDURE Append (VAR src, dst : ARRAY OF CHAR);
VAR n, m, cap, i : INTEGER;
BEGIN
  n := Length(dst);
  m := Length(src);
  cap := HIGH(dst);
  IF n + m > cap THEN m := cap - n END;
  IF m < 0 THEN m := 0 END;
  i := 0;
  WHILE i < m DO
    dst[n + i] := src[i];
    i := i + 1
  END;
  dst[n + m] := CHR(0)
END Append;

PROCEDURE Equal (VAR s1, s2 : ARRAY OF CHAR) : BOOLEAN;
VAR i, n1, n2 : INTEGER;
BEGIN
  n1 := Length(s1); n2 := Length(s2);
  IF n1 # n2 THEN RETURN FALSE END;
  i := 0;
  WHILE i < n1 DO
    IF s1[i] # s2[i] THEN RETURN FALSE END;
    i := i + 1
  END;
  RETURN TRUE
END Equal;

PROCEDURE Pos (VAR pattern, s : ARRAY OF CHAR) : INTEGER;
VAR i, j, np, ns : INTEGER;
    found : BOOLEAN;
BEGIN
  np := Length(pattern);
  ns := Length(s);
  IF (np = 0) OR (np > ns) THEN RETURN 0 END;
  i := 0;
  WHILE i + np <= ns DO
    j := 0; found := TRUE;
    WHILE (j < np) AND found DO
      IF s[i + j] # pattern[j] THEN
        found := FALSE
      ELSE
        j := j + 1
      END
    END;
    IF found THEN RETURN i + 1 END;
    i := i + 1
  END;
  RETURN 0
END Pos;

PROCEDURE Compare (VAR s1, s2 : ARRAY OF CHAR) : INTEGER;
VAR i, n1, n2, n : INTEGER;
BEGIN
  n1 := Length(s1);
  n2 := Length(s2);
  n := n1;
  IF n2 < n THEN n := n2 END;
  i := 0;
  WHILE i < n DO
    IF s1[i] < s2[i] THEN RETURN -1
    ELSIF s1[i] > s2[i] THEN RETURN 1
    END;
    i := i + 1
  END;
  IF n1 < n2 THEN RETURN -1
  ELSIF n1 > n2 THEN RETURN 1
  END;
  RETURN 0
END Compare;

END Strings.