Chars

This module provides common character oriented tests.

InRange

Check to see if a character, c, is in an inclusive range from a lower to upper character.

IsUpper

Check to see if a character is upper case

IsLower

Check to see if a character is lower case

IsAlpha

Check to see if a character is alphabetic, i.e. in the range of “a” to “z” or “A” to “Z”.

IsDigit

Check to see if a character is a digit, i.e. in range of “0” to “9”

IsAlphaNum

Check to see if a character is alpha or a digit

IsSpace

Check to see if a character is a space, tab, carriage return or line feed

AppendChar

Append a single char to the end of an ARRAY OF CHAR adjusting the terminating null character and return TRUE on success or FALSE otherwise.

AppendChars

Append an ARRAY OF CHAR to another the destination ARRAY OF CHAR.

Equal

Compares two ARRAY OF CHAR and returns TRUE if they match, FALSE otherwise

Clear

Sets all cells in an ARRAY OF CHAR to 0X.

TrimSpace

Trim the leading and trailing space characters from an ARRAY OF CHAR

TrimLeftSpace

Trim the leading space characters from an ARRAY OF CHAR

TrimRightSpace

Trim the trailing space characters from an ARRAY OF CHAR

StartsWith

Checks to see if a prefix ARRAY OF CHAR matches a target ARRAY OF CHAR return TRUE if found, FALSE otherwise

EndsWith

Checks to see if a suffix ARRAY OF CHAR matches a target ARRAY OF CHAR return TRUE if found, FALSE otherwise

TrimPrefix

Trim a prefix ARRAY OF CHAR from a target ARRAY OF CHAR

TrimSuffix

Trim a suffix ARRAY OF CHAR from a target ARRAY OF CHAR

Source code for Chars.Mod

MODULE Chars;
IMPORT Strings;
CONST
    MAXSTR* = 1024; (* or whatever *)
    (* byte constants *)
    LF* = 10;
    CR* = 13;
    (* Character constants *)
    ENDSTR* = 0X;
    NEWLINE* = 10X;
    TAB* = 9X;
    SPACE* = " ";
    DASH* = "-";
    CARET* = "^";
    TILDE* = "~";
    QUOTE* = CHR(34);
(* InRange -- given a character to check and an inclusive range of
characters in the ASCII character set. Compare the ordinal values
for inclusively. Return TRUE if in range FALSE otherwise. *)
PROCEDURE InRange* (c, lower, upper : CHAR) : BOOLEAN;
VAR inrange : BOOLEAN;
BEGIN
  IF (ORD(c) >= ORD(lower)) & (ORD(c) <= ORD(upper)) THEN
    inrange := TRUE;
  ELSE
    inrange := FALSE;
  END;
  RETURN inrange
END InRange;
(* IsUpper return true if the character is an upper case letter *)
PROCEDURE IsUpper*(c : CHAR) : BOOLEAN;
VAR isupper : BOOLEAN;
BEGIN
    IF InRange(c, "A", "Z") THEN
        isupper := TRUE;
    ELSE
        isupper := FALSE;
    END
    RETURN isupper
END IsUpper;
(* IsLower return true if the character is a lower case letter *)
PROCEDURE IsLower*(c : CHAR) : BOOLEAN;
VAR islower : BOOLEAN;
BEGIN
    IF InRange(c, "a", "a") THEN
        islower := TRUE;
    ELSE
        islower := FALSE;
    END
    RETURN islower
END IsLower;
(* IsDigit return true if the character in the range of "0" to "9" *)
PROCEDURE IsDigit*(c : CHAR) : BOOLEAN;
VAR isdigit : BOOLEAN;
BEGIN
    IF InRange(c, "0", "9") THEN
        isdigit := TRUE;
    ELSE
        isdigit := FALSE;
    END;
    RETURN isdigit
END IsDigit;
(* IsAlpha return true is character is either upper or lower case letter *)
PROCEDURE IsAlpha*(c : CHAR) : BOOLEAN;
VAR isalpha : BOOLEAN;
BEGIN
    IF IsUpper(c) OR IsLower(c) THEN
        isalpha := TRUE;
    ELSE
        isalpha := FALSE;
    END;
    RETURN isalpha
END IsAlpha;
(* IsAlphaNum return true is IsAlpha or IsDigit *)
PROCEDURE IsAlphaNum* (c : CHAR) : BOOLEAN;
VAR isalphanum : BOOLEAN;
BEGIN
    IF IsAlpha(c) OR IsDigit(c) THEN
        isalphanum := TRUE;
    ELSE
        isalphanum := FALSE;
    END;
    RETURN isalphanum
END IsAlphaNum;
(* IsSpace returns TRUE if the char is a space, tab, carriage return or line feed *)
PROCEDURE IsSpace*(c : CHAR) : BOOLEAN;
VAR isSpace : BOOLEAN;
BEGIN
    isSpace := FALSE;
    IF (c = SPACE) OR (c = TAB) OR (ORD(c) = CR) OR (ORD(c) = LF) THEN
        isSpace := TRUE;
    END;
    RETURN isSpace
END IsSpace;
(* AppendChar - this copies the char and appends it to
   the destination. Returns FALSE if append fails. *)
PROCEDURE AppendChar*(c : CHAR; VAR dest : ARRAY OF CHAR) : BOOLEAN;
VAR res : BOOLEAN; l : INTEGER;
BEGIN
  l := Strings.Length(dest);
  (* NOTE: we need to account for a trailing 0X to end
     the string. *)
  IF l < (LEN(dest) - 1) THEN
    dest[l] := c;
    dest[l + 1] := 0X;
    res := TRUE;
  ELSE
    res := FALSE;
  END;
  RETURN res
END AppendChar;
(* AppendChars - copy the contents of src ARRAY OF CHAR to end of
   dest ARRAY OF CHAR *)
PROCEDURE AppendChars*(src : ARRAY OF CHAR; VAR dest : ARRAY OF CHAR);
VAR i, j : INTEGER;
BEGIN
  i := 0;
  WHILE (i < LEN(dest)) & (dest[i] # 0X) DO
    i := i + 1;
  END;
  j := 0;
  WHILE (i < LEN(dest)) & (j < Strings.Length(src)) DO
    dest[i] := src[j];
    i := i + 1;
    j := j + 1;
  END;
  WHILE i < LEN(dest) DO
    dest[i] := 0X;
    i := i + 1;
  END;
END AppendChars;
(* Equal - compares two ARRAY OF CHAR and returns TRUE
if the characters match up to the end of string, FALSE otherwise. *)
PROCEDURE Equal*(a : ARRAY OF CHAR; b : ARRAY OF CHAR) : BOOLEAN;
VAR isSame : BOOLEAN; i : INTEGER;
BEGIN
  isSame := (Strings.Length(a) = Strings.Length(b));
  i := 0;
  WHILE isSame & (i < Strings.Length(a)) DO
    IF a[i] # b[i] THEN
      isSame := FALSE;
    END;
    i := i + 1;
  END;
  RETURN isSame
END Equal;
(* StartsWith - check to see of a prefix starts an ARRAY OF CHAR *)
PROCEDURE StartsWith*(prefix : ARRAY OF CHAR; VAR src : ARRAY OF CHAR) : BOOLEAN;
VAR startsWith : BOOLEAN; i: INTEGER;
BEGIN
    startsWith := FALSE;
    IF Strings.Length(prefix) <= Strings.Length(src) THEN
        startsWith := TRUE;
        i := 0;
        WHILE (i < Strings.Length(prefix)) & startsWith DO
            IF prefix[i] # src[i] THEN
                startsWith := FALSE;
            END;
            i := i + 1;
        END;
    END;    
    RETURN startsWith
END StartsWith;
(* EndsWith - check to see of a prefix starts an ARRAY OF CHAR *)
PROCEDURE EndsWith*(suffix : ARRAY OF CHAR; VAR src : ARRAY OF CHAR) : BOOLEAN;
VAR endsWith : BOOLEAN; i, j : INTEGER;
BEGIN
    endsWith := FALSE;
    IF Strings.Length(suffix) <= Strings.Length(src) THEN
        endsWith := TRUE;
        i := 0;
        j := Strings.Length(src) - Strings.Length(suffix);
        WHILE (i < Strings.Length(suffix)) & endsWith DO
            IF suffix[i] # src[j] THEN
                endsWith := FALSE;
            END;
            i := i + 1;
            j := j + 1;
        END;
    END;
    RETURN endsWith
END EndsWith;
(* Clear - resets all cells of an ARRAY OF CHAR to 0X *)
PROCEDURE Clear*(VAR a : ARRAY OF CHAR);
VAR i : INTEGER;
BEGIN
  FOR i := 0 TO (LEN(a) - 1) DO
    a[i] := 0X;
  END;
END Clear;
(* Shift returns the first character of an ARRAY OF CHAR and shifts the
remaining elements left appending an extra 0X if necessary *)
PROCEDURE Shift*(VAR src : ARRAY OF CHAR) : CHAR;
VAR i, last : INTEGER; c : CHAR;
BEGIN
    i := 0;
    c := src[i];
    Strings.Delete(src, 0, 1);
    last := Strings.Length(src) - 1;
    FOR i := last TO (LEN(src) - 1) DO
        src[i] := 0X;
    END;
    RETURN c
END Shift;
(* Pop returns the last non-OX element of an ARRAY OF CHAR replacing
   it with an OX *)
PROCEDURE Pop*(VAR src : ARRAY OF CHAR) : CHAR;
VAR i, last : INTEGER; c : CHAR;
BEGIN
    (* Move to the last non-0X cell *)
    i := 0;
    last := LEN(src);
    WHILE (i < last) & (src[i] # 0X) DO
       i := i + 1;
    END;
    IF i > 0 THEN
        i := i - 1;
    ELSE
        i := 0;
    END;
    c := src[i];
    WHILE (i < last) DO
        src[i] := 0X;
        i := i + 1;
    END;
    RETURN c
END Pop;
(* TrimLeftSpace - remove leading spaces from an ARRAY OF CHAR *)
PROCEDURE TrimLeftSpace*(VAR src : ARRAY OF CHAR);
VAR i : INTEGER;
BEGIN
    (* find the first non-space or end of the string *)
    i := 0;
    WHILE (i < LEN(src)) & IsSpace(src[i]) DO
        i := i + 1;
    END;
    (* Trims the beginning of the string *)
    IF i > 0 THEN
        Strings.Delete(src, 0, i);
    END;
END TrimLeftSpace;
(* TrimRightSpace - remove the trailing spaces from an ARRAY OF CHAR *)
PROCEDURE TrimRightSpace*(VAR src : ARRAY OF CHAR);
VAR i, l : INTEGER; 
BEGIN
    (* Find the first 0X, end of string *)
    l := Strings.Length(src);
    i := l - 1;
    (* Find the start of the trailing space sequence *)
    WHILE (i > 0) & IsSpace(src[i]) DO
        i := i - 1;
    END;
    (* Delete the trailing spaces *)
    Strings.Delete(src, i + 1, l - i);
END TrimRightSpace;
(* TrimSpace - remove leading and trailing space CHARS from an ARRAY OF CHAR *)
PROCEDURE TrimSpace*(VAR src : ARRAY OF CHAR);
BEGIN
    TrimLeftSpace(src);
    TrimRightSpace(src);    
END TrimSpace;    
    
(* TrimPrefix - remove a prefix ARRAY OF CHAR from a target ARRAY OF CHAR *)
PROCEDURE TrimPrefix*(prefix : ARRAY OF CHAR; VAR src : ARRAY OF CHAR);
VAR l : INTEGER;
BEGIN
    IF StartsWith(prefix, src) THEN
         l := Strings.Length(prefix);
         Strings.Delete(src, 0, l);
    END;
END TrimPrefix;
(* TrimSuffix - remove a suffix ARRAY OF CHAR from a target ARRAY OF CHAR *)
PROCEDURE TrimSuffix*(suffix : ARRAY OF CHAR; VAR src : ARRAY OF CHAR);
VAR i, l : INTEGER;
BEGIN
    IF EndsWith(suffix, src) THEN
        l := Strings.Length(src) - 1;
        FOR i := ((l - Strings.Length(suffix)) + 1) TO l DO
            src[i] := 0X;
        END;
    END;
END TrimSuffix;
END Chars.