|##########|
|#MAGIC   #|CLABLJFA
|#PROJECT #|""
|#PATHS   #|"StdProject"
|#FLAGS   #|xx---x--x---x-x-----------------
|#USERSW  #|--------------------------------
|#USERMASK#|--------------------------------
|#SWITCHES#|xx---xxxxx------
|##########|
|==============================================================================|
| Modul      : Strings                                                         |
| Autor      : Thomas Pfrengle + Ulrich Sigmund                                |
| Datum      : 29.9.1991                                                       |
| Verwendung : Bearbeitung von ClusterStrings mit Laufzeitchecks.              |
| Änderungen : -                                                               |
|==============================================================================|
DEFINITION MODULE Strings;

FROM System     IMPORT Regs,SysStringPtr,Equation;
FROM Dos        IMPORT BSTR;
FROM Resources  IMPORT ContextPtr,NoContext;
FROM Exceptions IMPORT RangeViolation;

TYPE
  MString  = ARRAY OF CHAR;


(*=========================== 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  : Wie CapsEqual, jedoch für BCPL-Strings.
|

PROCEDURE BCPL_Equal(str1 IN A0,
                     str2 IN A1 : BSTR):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   <- String, 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.
|

PROCEDURE First(REF str IN A0 : STRING;ch IN D2 : CHAR):INTEGER;


|
| Funktion  : Sucht nach dem nächsten Auftreten eines Zeichens.
| Parameter : str  <- String in dem gesucht werden soll.
|             Ch   <- Zeichen, das gesucht werden soll.
|             pos  <- Position ab der gesucht wird.
|                  -> Position des gesuchten Zeichens.
| Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.
|

PROCEDURE Next(REF str IN A0 : STRING;ch IN D2 : CHAR;pos IN D3 : INTEGER):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 voherigen Auftreten eines Zeichens.
| Parameter : str  <- String in dem gesucht werden soll.
|             ch   <- Zeichen, das gesucht werden soll.
|             pos  <- Position ab der gesucht wird.
|                  -> Position des gesuchten Zeichens.
| Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.
|
| tested
PROCEDURE Prev(REF str IN A0 : STRING;ch IN D2 : CHAR;pos IN D3 : INTEGER):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 : STRING):INTEGER;


|
| Funktion  : Sucht nach dem nächsten Auftreten eines Strings.
| Parameter : find <- String, der gesucht werden soll.
|             in   <- String, in dem gesucht werden soll.
|             pos  <- Position ab der gesucht wird.
|                  -> Position des gesuchten Strings.
| Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.
|
| tested
PROCEDURE SearchNext(REF find,in : STRING;pos : CARDINAL):INTEGER;


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


|
| 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.
|                   -> kopierter Bereich
| tested
$$OwnHeap:=TRUE
PROCEDURE Seg(REF str IN A0 : STRING;pos IN D2,len IN D3 : INTEGER):STRING;


|
| Funktion  : Setzt eine Liste von Strings zu einem zusammen.
| Parameter : strs        <- Liste von Strings.
|                         -> zusammengesetzter neuer
|                            String.
| tested
$$OwnHeap:=TRUE
PROCEDURE Concat(REF strs : LIST OF STRING):STRING;


|
| Funktion  : Fügt in einen String ein Stück ein und gibt das Ergebnis zurück*)
| Parameter : str  <- String der Eingefügt werden soll.
|             into <- String in den eingefügt werden soll.
|             pos  <- Position, ab der eingefügt werden soll.
|                  -> Ergebnisstring.
| tested
$$OwnHeap:=TRUE
PROCEDURE Insert(REF str,into : STRING;pos : INTEGER):STRING;


|
| Funktion  : Scheidet einen Teil des Strings heraus.
| Parameter : str <- String der als Vorlage dient.
|             pos <- Position ab der geschnitten werden soll.
|             len <- Länge des Stücke, das ausgeschnitten werden soll.
|                 -> Ergebnisstring
| tested
$$OwnHeap:=TRUE
PROCEDURE Delete(REF str : STRING;pos,len : INTEGER):STRING;


|
| Funktion  : Ersetzt einen Teil eines Strings durch einen anderen.
| Parameter : str   <- Quellstring
|             Into  <- String durch den ein Teil von str ersetzt werden soll.
|             pos   <- Position, ab der ersetzt werden soll.
|                   -> Ergebnisstring.
| Bemerkung : Paßt Into nicht in str, wird ein RangeCheck ausgelöst.
|
| tested
$$OwnHeap:=TRUE
PROCEDURE Replace(REF str,into : STRING;pos IN D2 : INTEGER):STRING;


|
| Funktion  : Vervielfältigt einen String in einen anderen und gibt diesen
|             zurück. Z.B. Dup("Str",3)="StrStrStr".
| Parameter : str  <-  String der Vervielfälltigt werden soll.
|             num  <-  Zahl der Vervielfälltigungen
|                  ->  Ergebnisstring
| tested
$$OwnHeap:=TRUE
PROCEDURE Dup(REF str IN A0 : STRING;num IN D2 : INTEGER):STRING;


|
| Funktion  : Füllt einen Teil eines Strings mit Zeichen.
| Parameter : str   <- String, in dem gefüllt werden soll.
|             ch    <- Zeichen mit dem gefüllt werden soll.
|             pos   <- Position,ab der gefüllt werden soll.
|             len   <- Anzahl Felder, die gefüllt werden sollen.
|                   -> Ergebnisstring
| tested
$$OwnHeap:=TRUE
PROCEDURE Fill(REF str : STRING;ch : CHAR;pos,len : CARDINAL):STRING;


|
| 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 CutOut(REF str     IN A0 : STRING;
                     pos     IN D2,
                     len     IN D3 : INTEGER;
                 VAR segment       : 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 InsertIn(REF str    IN A0 : STRING;
                   VAR into         : STRING;
                       pos    IN D2 : INTEGER);


|
| Funktion  : Ersetzt einen Teil eines Strings durch einen anderen.
| Parameter : str   <- String in den ein Teil eingesetzt werden soll.
|             into  <- String durch den ein Teil von str ersetzt werden soll.
|             pos   <- Position, ab der ersetzt werden soll.
| Bemerkung : Paßt Into nicht in str, bleibt str unverändert.
|
| tested
PROCEDURE ReplaceIn(REF str   IN A0 : STRING;
                    VAR into        : 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 Erase(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 Append(VAR dest : STRING;REF source IN A1 : STRING);



(*======================== Conversion ========================================*)


|
| Funktion  : Gibt einen Zeiger auf einen SystemString zurück nach Übergabe
|             eines ClusterStrings.
| Parameter : str         <- ClusterString.
|                         -> Zeiger auf SystemString.
| tested
PROCEDURE SysStr(REF str IN A0 : STRING):SysStringPtr;


|
| Funktion  : Gibt einen ClusterString nach übergabe eines Zeigers auf einen
|             SystemString zurück.
| Parameter : Ptr         <- Zeiger auf SystemString.
|                         -> ClusterString.
|
$$OwnHeap:=TRUE
PROCEDURE Str(ptr IN A0 : SysStringPtr):STRING;

|
| Funktion  : Gibt einen Zeiger auf einen BCPL-String zurück nach Übergabe
|             eines ClusterStrings.
| Parameter : str         <- ClusterString.
|                         -> Zeiger auf BCPL-String.
|
PROCEDURE CreateBSTR(REF str      IN A0 : STRING;
                         resident IN D2 : BOOLEAN := FALSE;
                         context  IN A1 : ContextPtr:=NoContext):BSTR;


|
| Funktion  : Gibt einen ClusterString nach übergabe eines Zeigers auf einen
|             BCPL-String zurück.
| Parameter : ptr         <- Zeiger auf BCPL-String.
|                         -> ClusterString.
|
$$OwnHeap:=TRUE
PROCEDURE BSTRtoString(ptr IN A0 : BSTR):STRING;


|
| Funktion  : Wandelt einen Clusterstring in einen ModulaString um.
|             eines ClusterStrings.
| Parameter : str         <-  ClusterString.
|             mStr        <-> ModulaString.
|

PROCEDURE StrToMStr(REF str IN A0 : STRING;VAR mStr : MString);


|
| Funktion  : Gibt einen ClusterString nach übergabe eines ModulaStrings
|             zurück.
| Parameter : mStr        <- ModulaString.
|                         -> ClusterString.
|
$$OwnHeap:=TRUE
PROCEDURE MStrToStr(REF mStr : MString):STRING;



GROUP
  All  = Equation,MString,Equal,CapsEqual,BCPL_Equal,Greater,CapsGreater,
         Compare,First,Next,Last,Prev,Search,SearchNext,Seg,Concat,Insert,
         Delete,Replace,Dup,Fill,CutOut,InsertIn,ReplaceIn,Erase,Append,
         SysStr,Str,CreateBSTR,BSTRtoString,MStrToStr;

END Strings.