|##########|
|#MAGIC   #|CLABLLJH
|#PROJECT #|""
|#PATHS   #|"StdProject"
|#FLAGS   #|xx---x--x---xxx-----------------
|#USERSW  #|--------------------------------
|#USERMASK#|--------------------------------
|#SWITCHES#|xx---xxxxx------
|##########|
DEFINITION MODULE MStr;
(* $A- *)
FROM System IMPORT Regs;

TYPE
  Equation = (smaller,equal,greater);
  CapsArr  = ARRAY CHAR OF CHAR;

CONST
  CAP      = CapsArr;

VAR
  done : BOOLEAN;   (* Fehleranzeige *)


PROCEDURE CapsString(VAR Str IN A0 : ARRAY OF CHAR);

(*----------------------------------------------------------------------------*)
(* Funktion  : Prüft zwei Strings auf Gleichheit.                             *)
(* Parameter : Str1,Str2   <- String, die verglichen werden sollen.           *)
(*                         -> TRUE wenn gleich.                               *)
(*----------------------------------------------------------------------------*)

PROCEDURE Equal(REF Str1 IN A0,
                    Str2 IN A1 : ARRAY OF CHAR): BOOLEAN;


(*----------------------------------------------------------------------------*)
(* Funktion  : Wie Equal, jedoch ohne Beachtung der Groß/Kleinschreibung (a=A)*)
(*----------------------------------------------------------------------------*)

PROCEDURE CapsEqual(REF Str1 IN A0,
                        Str2 IN A1 : ARRAY OF CHAR):BOOLEAN;

(*----------------------------------------------------------------------------*)
(* Funktion  : Prüft ob Str1 größer als Str2 ist.                             *)
(* Parameter : Str1,Str2   <- String, die verglichen werden sollen.           *)
(*                         -> TRUE wenn Str1 größer Str2.                     *)
(*----------------------------------------------------------------------------*)

PROCEDURE Greater(REF Str1 IN A0,
                      Str2 IN A1 : ARRAY OF CHAR):BOOLEAN;

(*----------------------------------------------------------------------------*)
(* Funktion  : Vergleicht zwei Strings.                                       *)
(* Parameter : Str1,Str2   <- String, die verglichen werden sollen.           *)
(*                         -> smaller = Str1 kleiner Str2                     *)
(*                            equal   = Str1 gleich  Str2                     *)
(*                            greater = Str1 größer  Str2                     *)
(*----------------------------------------------------------------------------*)

PROCEDURE Compare(REF Str1 IN A0,
                      Str2 IN A1 : ARRAY OF CHAR):Equation;


(*----------------------------------------------------------------------------*)
(* Funktion  : Kopiert aus einem String ein Stück aus.                        *)
(* Parameter : Str   <- QuellString                                           *)
(*             pos   <- Position ab der kopiert werden soll.                  *)
(*             len   <- Länge des Berichs, der kopiert werden soll.           *)
(*             Segment -> kopierter Bereich.                                  *)
(*----------------------------------------------------------------------------*)

PROCEDURE Seg(REF Str     IN A0 : ARRAY OF CHAR;
                  pos     IN D2,
                  len     IN D3 : INTEGER;
              VAR Segment IN A1 : ARRAY OF CHAR);


(*----------------------------------------------------------------------------*)
(* Funktion  : Sucht nach dem ersten Auftreten eines Zeichens.                *)
(* Parameter : Str  <- String in dem gesucht werden soll.                     *)
(*             Ch   <- Zeichen, das gesucht werden soll.                      *)
(*                  -> Position des gesuchten Zeichens.                       *)
(* Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.        *)
(*----------------------------------------------------------------------------*)

PROCEDURE First(REF Str IN A0 : ARRAY OF CHAR;Ch IN D2 : CHAR):INTEGER;


(*----------------------------------------------------------------------------*)
(* Funktion  : Sucht nach dem letzten Auftreten eines Zeichens                *)
(* Parameter : Str  <- String in dem gesucht werden soll.                     *)
(*             Ch   <- Zeichen, das gesucht werden soll.                      *)
(*                  -> Position des gesuchten Zeichens.                       *)
(* Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.        *)
(*----------------------------------------------------------------------------*)

PROCEDURE Last(REF Str IN A0 : ARRAY OF CHAR;Ch IN D2 : CHAR):INTEGER;


(*----------------------------------------------------------------------------*)
(* Funktion  : Sucht nach dem ersten Auftreten eines Strings in einem anderen *)
(* Parameter : Find <- String, der gesucht werden soll.                       *)
(*             In   <- String, in dem gesucht werden soll.                    *)
(*                  -> Position des gesuchten Strings.                        *)
(* Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.        *)
(*----------------------------------------------------------------------------*)

PROCEDURE Search(REF Find,In:ARRAY OF CHAR):INTEGER;


(*----------------------------------------------------------------------------*)
(* Funktion  : Fügt in einen String ein Stück ein.                            *)
(* Parameter : Dest    <- String in den Eingefügt werden soll.                *)
(*             Source  <- String der eingefügt werden soll.                   *)
(*             pos     <- Position, ab der eingefügt werden soll.             *)
(*----------------------------------------------------------------------------*)

PROCEDURE Insert(VAR Dest   : ARRAY OF CHAR;
                 REF Source : ARRAY OF CHAR;pos : INTEGER);


(*----------------------------------------------------------------------------*)
(* Funktion  : Ersetzt einen Teil eines Strings durch einen anderen.          *)
(* Parameter : Str   <- Str. durch den ein Teil von Into ersetzt werden soll. *)
(*             Into  <- String in den ein Teil eingesetzt werden soll.        *)
(*             pos   <- Position, ab der ersetzt werden soll.                 *)
(* Bemerkung : Paßt Into nicht in Str, bleibt Str unverändert.                *)
(*----------------------------------------------------------------------------*)

PROCEDURE Replace(REF Str   : ARRAY OF CHAR;
                  VAR Into  : ARRAY OF CHAR;pos : INTEGER);


(*----------------------------------------------------------------------------*)
(* Funktion  : Scheidet einen Teil des Strings heraus.                        *)
(* Parameter : Str <- String aus dem ausgeschnitten werden soll.              *)
(*             pos <- Position ab der geschnitten werden soll.                *)
(*             len <- Länge des Stücke, das ausgeschnitten werden soll.       *)
(*----------------------------------------------------------------------------*)

PROCEDURE Delete(VAR Str IN A0 : ARRAY OF CHAR;pos IN D2,len IN D3 : INTEGER);

(*----------------------------------------------------------------------------*)
(* Funktion  : Fügt zwei Strings zusammen.                                    *)
(* Parameter : Dest        <- linker Teil des neuen Strings.                  *)
(*             Source      <- rechter Teil des neuen Strings.                 *)
(*             Dest        -> der aus Dest und Source zusammengesetzte neue   *)
(*                            String.                                         *)
(*----------------------------------------------------------------------------*)

PROCEDURE Concat(VAR Dest   IN A0 : ARRAY OF CHAR;
                 REF Source IN A1 : ARRAY OF CHAR);

(*----------------------------------------------------------------------------*)
(* Funktion  : Ermittelt die Länge eines Modula-Strings                       *)
(* Parameter : Str         <- String                                          *)
(*----------------------------------------------------------------------------*)

PROCEDURE Length(REF Str IN A0 : ARRAY OF CHAR):INTEGER;

END MStr.