home *** CD-ROM | disk | FTP | other *** search
/ Global Amiga Experience / globalamigaexperience.iso / compressed / development / clusterdemo.dms / clusterdemo.adf / Modules.lha / modules / txt / MStr.def < prev    next >
Text File  |  1994-05-25  |  8KB  |  163 lines
  1. |##########|
  2. |#MAGIC   #|CLABLLJH
  3. |#PROJECT #|""
  4. |#PATHS   #|"StdProject"
  5. |#FLAGS   #|xx---x--x---xxx-----------------
  6. |#USERSW  #|--------------------------------
  7. |#USERMASK#|--------------------------------
  8. |#SWITCHES#|xx---xxxxx------
  9. |##########|
  10. DEFINITION MODULE MStr;
  11. (* $A- *)
  12. FROM System IMPORT Regs;
  13.  
  14. TYPE
  15.   Equation = (smaller,equal,greater);
  16.   CapsArr  = ARRAY CHAR OF CHAR;
  17.  
  18. CONST
  19.   CAP      = CapsArr;
  20.  
  21. VAR
  22.   done : BOOLEAN;   (* Fehleranzeige *)
  23.  
  24.  
  25. PROCEDURE CapsString(VAR Str IN A0 : ARRAY OF CHAR);
  26.  
  27. (*----------------------------------------------------------------------------*)
  28. (* Funktion  : Prüft zwei Strings auf Gleichheit.                             *)
  29. (* Parameter : Str1,Str2   <- String, die verglichen werden sollen.           *)
  30. (*                         -> TRUE wenn gleich.                               *)
  31. (*----------------------------------------------------------------------------*)
  32.  
  33. PROCEDURE Equal(REF Str1 IN A0,
  34.                     Str2 IN A1 : ARRAY OF CHAR): BOOLEAN;
  35.  
  36.  
  37. (*----------------------------------------------------------------------------*)
  38. (* Funktion  : Wie Equal, jedoch ohne Beachtung der Groß/Kleinschreibung (a=A)*)
  39. (*----------------------------------------------------------------------------*)
  40.  
  41. PROCEDURE CapsEqual(REF Str1 IN A0,
  42.                         Str2 IN A1 : ARRAY OF CHAR):BOOLEAN;
  43.  
  44. (*----------------------------------------------------------------------------*)
  45. (* Funktion  : Prüft ob Str1 größer als Str2 ist.                             *)
  46. (* Parameter : Str1,Str2   <- String, die verglichen werden sollen.           *)
  47. (*                         -> TRUE wenn Str1 größer Str2.                     *)
  48. (*----------------------------------------------------------------------------*)
  49.  
  50. PROCEDURE Greater(REF Str1 IN A0,
  51.                       Str2 IN A1 : ARRAY OF CHAR):BOOLEAN;
  52.  
  53. (*----------------------------------------------------------------------------*)
  54. (* Funktion  : Vergleicht zwei Strings.                                       *)
  55. (* Parameter : Str1,Str2   <- String, die verglichen werden sollen.           *)
  56. (*                         -> smaller = Str1 kleiner Str2                     *)
  57. (*                            equal   = Str1 gleich  Str2                     *)
  58. (*                            greater = Str1 größer  Str2                     *)
  59. (*----------------------------------------------------------------------------*)
  60.  
  61. PROCEDURE Compare(REF Str1 IN A0,
  62.                       Str2 IN A1 : ARRAY OF CHAR):Equation;
  63.  
  64.  
  65. (*----------------------------------------------------------------------------*)
  66. (* Funktion  : Kopiert aus einem String ein Stück aus.                        *)
  67. (* Parameter : Str   <- QuellString                                           *)
  68. (*             pos   <- Position ab der kopiert werden soll.                  *)
  69. (*             len   <- Länge des Berichs, der kopiert werden soll.           *)
  70. (*             Segment -> kopierter Bereich.                                  *)
  71. (*----------------------------------------------------------------------------*)
  72.  
  73. PROCEDURE Seg(REF Str     IN A0 : ARRAY OF CHAR;
  74.                   pos     IN D2,
  75.                   len     IN D3 : INTEGER;
  76.               VAR Segment IN A1 : ARRAY OF CHAR);
  77.  
  78.  
  79. (*----------------------------------------------------------------------------*)
  80. (* Funktion  : Sucht nach dem ersten Auftreten eines Zeichens.                *)
  81. (* Parameter : Str  <- String in dem gesucht werden soll.                     *)
  82. (*             Ch   <- Zeichen, das gesucht werden soll.                      *)
  83. (*                  -> Position des gesuchten Zeichens.                       *)
  84. (* Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.        *)
  85. (*----------------------------------------------------------------------------*)
  86.  
  87. PROCEDURE First(REF Str IN A0 : ARRAY OF CHAR;Ch IN D2 : CHAR):INTEGER;
  88.  
  89.  
  90. (*----------------------------------------------------------------------------*)
  91. (* Funktion  : Sucht nach dem letzten Auftreten eines Zeichens                *)
  92. (* Parameter : Str  <- String in dem gesucht werden soll.                     *)
  93. (*             Ch   <- Zeichen, das gesucht werden soll.                      *)
  94. (*                  -> Position des gesuchten Zeichens.                       *)
  95. (* Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.        *)
  96. (*----------------------------------------------------------------------------*)
  97.  
  98. PROCEDURE Last(REF Str IN A0 : ARRAY OF CHAR;Ch IN D2 : CHAR):INTEGER;
  99.  
  100.  
  101. (*----------------------------------------------------------------------------*)
  102. (* Funktion  : Sucht nach dem ersten Auftreten eines Strings in einem anderen *)
  103. (* Parameter : Find <- String, der gesucht werden soll.                       *)
  104. (*             In   <- String, in dem gesucht werden soll.                    *)
  105. (*                  -> Position des gesuchten Strings.                        *)
  106. (* Bemerkung : Wird das Zeichen nicht gefunden, wird -1 zurückgegeben.        *)
  107. (*----------------------------------------------------------------------------*)
  108.  
  109. PROCEDURE Search(REF Find,In:ARRAY OF CHAR):INTEGER;
  110.  
  111.  
  112. (*----------------------------------------------------------------------------*)
  113. (* Funktion  : Fügt in einen String ein Stück ein.                            *)
  114. (* Parameter : Dest    <- String in den Eingefügt werden soll.                *)
  115. (*             Source  <- String der eingefügt werden soll.                   *)
  116. (*             pos     <- Position, ab der eingefügt werden soll.             *)
  117. (*----------------------------------------------------------------------------*)
  118.  
  119. PROCEDURE Insert(VAR Dest   : ARRAY OF CHAR;
  120.                  REF Source : ARRAY OF CHAR;pos : INTEGER);
  121.  
  122.  
  123. (*----------------------------------------------------------------------------*)
  124. (* Funktion  : Ersetzt einen Teil eines Strings durch einen anderen.          *)
  125. (* Parameter : Str   <- Str. durch den ein Teil von Into ersetzt werden soll. *)
  126. (*             Into  <- String in den ein Teil eingesetzt werden soll.        *)
  127. (*             pos   <- Position, ab der ersetzt werden soll.                 *)
  128. (* Bemerkung : Paßt Into nicht in Str, bleibt Str unverändert.                *)
  129. (*----------------------------------------------------------------------------*)
  130.  
  131. PROCEDURE Replace(REF Str   : ARRAY OF CHAR;
  132.                   VAR Into  : ARRAY OF CHAR;pos : INTEGER);
  133.  
  134.  
  135. (*----------------------------------------------------------------------------*)
  136. (* Funktion  : Scheidet einen Teil des Strings heraus.                        *)
  137. (* Parameter : Str <- String aus dem ausgeschnitten werden soll.              *)
  138. (*             pos <- Position ab der geschnitten werden soll.                *)
  139. (*             len <- Länge des Stücke, das ausgeschnitten werden soll.       *)
  140. (*----------------------------------------------------------------------------*)
  141.  
  142. PROCEDURE Delete(VAR Str IN A0 : ARRAY OF CHAR;pos IN D2,len IN D3 : INTEGER);
  143.  
  144. (*----------------------------------------------------------------------------*)
  145. (* Funktion  : Fügt zwei Strings zusammen.                                    *)
  146. (* Parameter : Dest        <- linker Teil des neuen Strings.                  *)
  147. (*             Source      <- rechter Teil des neuen Strings.                 *)
  148. (*             Dest        -> der aus Dest und Source zusammengesetzte neue   *)
  149. (*                            String.                                         *)
  150. (*----------------------------------------------------------------------------*)
  151.  
  152. PROCEDURE Concat(VAR Dest   IN A0 : ARRAY OF CHAR;
  153.                  REF Source IN A1 : ARRAY OF CHAR);
  154.  
  155. (*----------------------------------------------------------------------------*)
  156. (* Funktion  : Ermittelt die Länge eines Modula-Strings                       *)
  157. (* Parameter : Str         <- String                                          *)
  158. (*----------------------------------------------------------------------------*)
  159.  
  160. PROCEDURE Length(REF Str IN A0 : ARRAY OF CHAR):INTEGER;
  161.  
  162. END MStr.
  163.