|##########|
|#MAGIC   #|CLABLJCG
|#PROJECT #|""
|#PATHS   #|"StdProject"
|#FLAGS   #|xx---x--x---x-x-----------------
|#USERSW  #|--------------------------------
|#USERMASK#|--------------------------------
|#SWITCHES#|xx---xxxxx------
|##########|
|==============================================================================|
| Modul      : Str                                                             |
| Autor      : Thomas Pfrengle + Ulrich Sigmund                                |
| Datum      : 14.9.1991                                                       |
| Verwendung : Bearbeitung von ClusterStrings ohne Laufzeitchecks.             |
| Änderungen : -                                                               |
|==============================================================================|

DEFINITION MODULE Str;

FROM System     IMPORT Regs,Equation;
FROM Exceptions IMPORT RangeViolation;

| A c h t u n g ! ! ! ! ! ! !
| Keine der Prozeduren in Str führt einen Bereichs-Check aus.
| Sie sind dafür besonders schnell. Also nur benutzen, wenn sicher
| ist, daß der String, der verwendet wird groß genug ist;
| sonst die Prozeduren aus Strings benutzen.



(*=================== Caps-Funktions =========================================*)

TYPE
  CapsArr  = ARRAY CHAR OF CHAR;

CONST
  CAP      = CapsArr;  | CAP[c] ergibt c als großen Buchstaben CAP["a"]="A"
  LOW      = CapsArr;  | LOW[c] ergibt c als kleinen Buchstaben LOW["A"]="a"

|
| Funktion  : Verwandelt alle Zeichen eines Strings in Kleinbuchstaben.
| Parameter : str         <- String, der verwandelt werden soll.
|
| tested
PROCEDURE LowerString(VAR str IN A0 : STRING);


|
| Funktion  : Verwandelt alle Zeichen eines Strings in Großbuchstaben.
| Parameter : str         <- String, der verwandelt werden soll.
|
|tested
PROCEDURE CapsString(VAR str IN A0 : STRING);


(*================ Compare ===================================================*)

|
| Funktion  : Prüft zwei Strings auf Gleichheit.
| Parameter : str1,str2   <- String, die verglichen werden sollen.
|                         -> TRUE wenn gleich.
|
|tested
PROCEDURE Equal(REF str1 IN A0,
                    str2 IN A1 : STRING): BOOLEAN;

|
| Funktion  : Wie Equal, jedoch ohne Beachtung der Groß/Kleinschreibung (a=A)
|
| tested
PROCEDURE CapsEqual(REF str1 IN A0,
                        str2 IN A1 : STRING):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.
|
| tested
PROCEDURE Greater(REF str1 IN A0,
                      str2 IN A1 : STRING):BOOLEAN;


|
| Funktion  : Prüft ob str1 größer als str2 ist. Ohne Berücksichtigung der
|             Groß/Kleinschreibung.
| Parameter : str1,str2   <- String, die verglichen werden sollen.
|                         -> TRUE wenn str1 größer str2.
|
| tested
PROCEDURE CapsGreater(REF str1 IN A0,
                          str2 IN A1 : STRING):BOOLEAN;


|
| Funktion  : Vergleicht zwei Strings.
| Parameter : str1,str2   <- Strings, die verglichen werden sollen.
|                         -> smaller = str1 kleiner str2
|                            equal   = str1 gleich  str2
|                            greater = str1 größer  str2
|
| tested
PROCEDURE Compare(REF str1 IN A0,
                      str2 IN A1 : STRING):Equation;


(*=============== Search =====================================================*)


|
| 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.
|
| tested
PROCEDURE First(REF str IN A0 : STRING;
                    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.
|
| tested
PROCEDURE Last(REF str IN A0 : STRING;
                   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.
|
| tested
PROCEDURE Search(REF find IN A0,
                     in   IN A1 : STRING):INTEGER;


(*================= Modify ===================================================*)

|
| Funktion  : Kopiert aus einem String ein Stück heraus.
| Parameter : str   <- QuellString
|             pos   <- Position ab der kopiert werden soll.
|             len   <- Länge des Berichs, der kopiert werden soll.
|             segment -> kopierter Bereich.
|
| tested
PROCEDURE Seg(REF str     IN A0 : STRING;
                  pos     IN D2,
                  len     IN D3 : INTEGER;
              VAR segment IN A1 : STRING);


|
| 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.
|
| tested
PROCEDURE Insert(REF str    IN A0 : STRING;
                 VAR into   IN A1 : STRING;
                     pos    IN D2 : INTEGER);


|
| Funktion  : Ersetzt einen Teil eines Strings durch einen anderen.
| Parameter : str   <- String durch den ein Teil von Str 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.
|
| tested
PROCEDURE Replace(REF str   IN A0 : STRING;
                  VAR into  IN A1 : STRING;
                      pos   IN D2 : 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.
|
|tested
PROCEDURE Delete(VAR str IN A0 : STRING;
                     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.
|
| tested
PROCEDURE Concat(VAR dest IN A0 : STRING;REF source IN A1 : STRING);


GROUP
  All  = Equation,CapsArr,CAP,LowerString,CapsString,Equal,CapsEqual,Greater,
         Compare,Seg,First,Last,Search,Insert,Replace,Delete,Concat,
         CapsGreater;


END Str.