home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / program / m2posx02 / pstring.dpp < prev    next >
Encoding:
Modula Definition  |  1993-10-23  |  11.7 KB  |  228 lines
  1. DEFINITION MODULE pSTRING;
  2.  
  3. (*****************************************************************************)
  4. (* Allgemeine Stringfunktionen                                               *)
  5. (* Es muss gelten: HIGH(str) < MAX(INTEGER) !                                *)
  6. (* --------------------------------------------------------------------------*)
  7. (* 06-Jan-93, Holger Kleinschmidt                                            *)
  8. (*****************************************************************************)
  9.  
  10. CONST EOS = 0C;
  11.  
  12. TYPE
  13.   StrRange   = [0..30000]; (* bel. Obergrenze *)
  14.   ArrayRange = [0..5000];  (* bel. Obergrenze *)
  15.  
  16.   StrPtr     = POINTER TO ARRAY StrRange OF CHAR; (* nicht ohne Index deref. *)
  17.   StrArray   = POINTER TO ARRAY ArrayRange OF StrPtr; (* dito *)
  18.  
  19. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  20.  
  21.  PROCEDURE SLEN ((* EIN/ -- *) REF s : ARRAY OF CHAR ): CARDINAL;
  22.  
  23. (*---------------------------------------------------------------------------
  24.  | Liefert die Laenge von <s> als Funktionswert.                             |
  25.   ---------------------------------------------------------------------------*)
  26.  
  27.  
  28.  PROCEDURE ASSIGN ((* EIN/ -- *) REF src : ARRAY OF CHAR;
  29.                    (* -- /AUS *) VAR dst : ARRAY OF CHAR );
  30.  
  31. (*---------------------------------------------------------------------------
  32.  | Zuweisungsoperation: <dst> := <src>. Falls <dst> nicht gross genug ist,   |
  33.  | um <src> aufzunehmen, wird der String gekuerzt.                           |
  34.   ---------------------------------------------------------------------------*)
  35.  
  36.  
  37.  PROCEDURE CONCAT ((* EIN/ -- *)     s1  : ARRAY OF CHAR;
  38.                    (* EIN/ -- *)     s2  : ARRAY OF CHAR;
  39.                    (* -- /AUS *) VAR dst : ARRAY OF CHAR );
  40.  
  41. (*---------------------------------------------------------------------------
  42.  | Weist <dst> die Konkatenation von <s1> und <s2> zu: <dst> := <s1> ++ <s2>.|
  43.  | Falls <dst> nicht gross genug ist, wird das Ergebnis der Konkatenation    |
  44.  | gekuerzt.                                                                 |
  45.   ---------------------------------------------------------------------------*)
  46.  
  47.  
  48.  PROCEDURE APPEND ((* EIN/ -- *)     app : ARRAY OF CHAR;
  49.                    (* EIN/AUS *) VAR dst : ARRAY OF CHAR );
  50.  
  51.  PROCEDURE APPENDN ((* EIN/ -- *)     len : CARDINAL;
  52.                     (* EIN/ -- *)     app : ARRAY OF CHAR;
  53.                     (* EIN/AUS *) VAR dst : ARRAY OF CHAR );
  54.  
  55.  PROCEDURE APPENDCHR ((* EIN/ -- *)     c   : CHAR;
  56.                       (* EIN/AUS *) VAR dst : ARRAY OF CHAR );
  57.  
  58. (*---------------------------------------------------------------------------
  59.  | "APPEND()" haengt <app> an den alten Inhalt von <dst> an.                 |
  60.  | "APPENDN()" haengt maximal <len> Zeichen von <app> an den alten Inhalt von|
  61.  | <dst> an.                                                                 |
  62.  | "APPENDCHR" haengt das Zeichen <c> an den alten Inhalt von <dst> an.      |
  63.  | Falls <dst> nicht gross genug ist, wird entsprechend gekuerzt.            |
  64.   ---------------------------------------------------------------------------*)
  65.  
  66.  
  67.  PROCEDURE COPY ((* EIN/ -- *)     from : CARDINAL;
  68.                  (* EIN/ -- *)     len  : CARDINAL;
  69.                  (* EIN/ -- *)     src  : ARRAY OF CHAR;
  70.                  (* -- /AUS *) VAR dst  : ARRAY OF CHAR );
  71.  
  72. (*---------------------------------------------------------------------------
  73.  | Kopiert vom Index <from> an maximal <len> Zeichen aus <src> nach <dst>.   |
  74.  | Falls <from> ausserhalb von <src> liegt, wird <dst> zum leeren String.    |
  75.  | Falls <dst> nicht gross genug ist, wird entsprechend gekuerzt.            |
  76.   ---------------------------------------------------------------------------*)
  77.  
  78.  
  79.  PROCEDURE INSERT ((* EIN/ -- *)     at  : CARDINAL;
  80.                    (* EIN/ -- *)     ins : ARRAY OF CHAR;
  81.                    (* EIN/AUS *) VAR s   : ARRAY OF CHAR );
  82.  
  83. (*---------------------------------------------------------------------------
  84.  | Fuegt <ins> in den String <s> ab dem Index <at> ein. Falls <s> nicht gross|
  85.  | genug ist, wird entsprechend gekuerzt.                                    |
  86.   ---------------------------------------------------------------------------*)
  87.  
  88.  
  89.  PROCEDURE DELETE ((* EIN/ -- *)     from : CARDINAL;
  90.                    (* EIN/ -- *)     len  : CARDINAL;
  91.                    (* EIN/AUS *) VAR s    : ARRAY OF CHAR );
  92.  
  93. (*---------------------------------------------------------------------------
  94.  | Entfernt aus dem String <s> ab dem Index <from> maximal <len> Zeichen.    |
  95.  | Falls <from> ausserhalb von <s> liegt, passiert nichts.                   |
  96.   ---------------------------------------------------------------------------*)
  97.  
  98.  
  99.  PROCEDURE LOWER ((* EIN/AUS *) VAR s : ARRAY OF CHAR );
  100.  
  101.  PROCEDURE UPPER ((* EIN/AUS *) VAR s : ARRAY OF CHAR );
  102.  
  103. (*---------------------------------------------------------------------------
  104.  | "LOWER()" wandelt alle Grossbuchstaben in <s> in Kleinbuchstaben um.      |
  105.  | "UPPER()" wandelt alle Kleinbuchstaben in <s> in Grossbuchstaben um.      |
  106.   ---------------------------------------------------------------------------*)
  107.  
  108.  
  109.  PROCEDURE EQUAL ((* EIN/ -- *) REF s1 : ARRAY OF CHAR;
  110.                   (* EIN/ -- *) REF s2 : ARRAY OF CHAR ): BOOLEAN;
  111.  
  112.  PROCEDURE EQUALN ((* EIN/ -- *)     len : CARDINAL;
  113.                    (* EIN/ -- *) REF s1  : ARRAY OF CHAR;
  114.                    (* EIN/ -- *) REF s2  : ARRAY OF CHAR ): BOOLEAN;
  115.  
  116. (*---------------------------------------------------------------------------
  117.  | "EQUAL()" testet, ob die Strings <s1> und <s2> gleich sind.               |
  118.  | "EQUALN()" testet, ob die maximal <len> ersten Zeichen von <s1> und <s2>  |
  119.  | gleich sind.                                                              |
  120.   ---------------------------------------------------------------------------*)
  121.  
  122.  
  123.  PROCEDURE COMPARE ((* EIN/ -- *) REF s1 : ARRAY OF CHAR;
  124.                     (* EIN/ -- *) REF s2 : ARRAY OF CHAR ): INTEGER;
  125.  
  126.  PROCEDURE COMPAREN ((* EIN/ -- *)     len : CARDINAL;
  127.                      (* EIN/ -- *) REF s1  : ARRAY OF CHAR;
  128.                      (* EIN/ -- *) REF s2  : ARRAY OF CHAR ): INTEGER;
  129.  
  130. (*---------------------------------------------------------------------------
  131.  | "COMPARE()" vergleicht die Strings <s1> und <s2> bzgl. ihrer ASCII-Ordnung|
  132.  | Wenn <s1> ``groesser'' ist, ist der Funktionswert positiv, wenn <s1>      |
  133.  | ``kleiner'' ist, ist der Funktionswert negativ, wenn beide gleich sind,   |
  134.  | ist der Funktionswert Null.                                               |
  135.  | "COMPAREN()" vergleicht maximal die ersten <len> Zeichen.                 |
  136.   ---------------------------------------------------------------------------*)
  137.  
  138.  
  139.  PROCEDURE LPOS ((* EIN/ -- *)     from : CARDINAL;
  140.                  (* EIN/ -- *) REF pat  : ARRAY OF CHAR;
  141.                  (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  142.  
  143.  PROCEDURE RPOS ((* EIN/ -- *)     from : CARDINAL;
  144.                  (* EIN/ -- *) REF pat  : ARRAY OF CHAR;
  145.                  (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  146.  
  147.  PROCEDURE LPOSCHR ((* EIN/ -- *)     from : CARDINAL;
  148.                     (* EIN/ -- *)     c    : CHAR;
  149.                     (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  150.  
  151.  PROCEDURE RPOSCHR ((* EIN/ -- *)     from : CARDINAL;
  152.                     (* EIN/ -- *)     c    : CHAR;
  153.                     (* EIN/ -- *) REF s    : ARRAY OF CHAR ): INTEGER;
  154.  
  155.  PROCEDURE LPOSCHRSET ((* EIN/ -- *)     from : CARDINAL;
  156.                        (* EIN/ -- *) REF set  : ARRAY OF CHAR;
  157.                        (* EIN/ -- *) REF str  : ARRAY OF CHAR ): INTEGER;
  158.  
  159.  PROCEDURE RPOSCHRSET ((* EIN/ -- *)     from : CARDINAL;
  160.                        (* EIN/ -- *) REF set  : ARRAY OF CHAR;
  161.                        (* EIN/ -- *) REF str  : ARRAY OF CHAR ): INTEGER;
  162.  
  163. (*---------------------------------------------------------------------------
  164.  | "LPOS()" sucht das erste Auftreten des Strings <pat> ab dem Index <from>  |
  165.  | im String <s>. Falls die Suche erfolgreich war, wird als Funktionswert der|
  166.  | Index des ersten Zeichens von <pat> in <s> zurueckgegeben. Falls <pat>    |
  167.  | nicht gefunden wurde, wird als Funktionswert -1 zurueckgegeben.           |
  168.  | "RPOS()" sucht das LETZTE Auftreten des Strings <pat> in <s>, wobei <from>|
  169.  | die oberste Grenze fuer den ersten Buchstaben von <pat> darstellt.        |
  170.  | Liegt <from> ausserhalb von <s>, wird vom Ende von <s> aus gesucht.       |
  171.  | "LPOSCHR()" und "RPOSCHR()" suchen auf die gleiche Weise nach dem Auftre- |
  172.  | ten des Buchstabens <c> in <s>.                                           |
  173.  | "LPOSCHRSET()" und "RPOSCHRSET()" suchen nach dem Auftreten eines Buch-   |
  174.  | stabens aus der Menge <set> in <s>.                                       |
  175.   ---------------------------------------------------------------------------*)
  176.  
  177.  
  178.  PROCEDURE TOKEN ((* EIN/ -- *)     str   : ARRAY OF CHAR;
  179.                   (* EIN/ -- *)     stop  : ARRAY OF CHAR;
  180.                   (* EIN/AUS *) VAR idx   : CARDINAL;
  181.                   (* EIN/AUS *) VAR l1    : CARDINAL;
  182.                   (* EIN/AUS *) VAR l2    : CARDINAL;
  183.                   (* -- /AUS *) VAR token : ARRAY OF CHAR ): BOOLEAN;
  184.  
  185. (*---------------------------------------------------------------------------
  186.  | <str> wird in Token zerlegt, die jeweils durch eins der Zeichen aus <stop>|
  187.  | begrenzt sind. Stehen zwei Trennzeichen hintereinander -- hoechstens durch|
  188.  | Leerzeichen voneinander getrennt -- wird als Token ein Leerstring gelie-  |
  189.  | fert. In <token> steht das jeweilige Token ohne fuehrende und abschliess- |
  190.  | ende Leerzeichen. Ist <str> vollstaendig durchsucht, wird als Funktions-  |
  191.  | wert FALSE zurueckgeliefert, sodass "TOKEN()" z.B. in einer WHILE-Schleife|
  192.  | verwendet werden kann. In <idx>, <l1> und <l2> bewahrt die Prozedur Infor-|
  193.  | mationen auf, die sie fuer den naechsten Aufruf benoetigt; diese sind fuer|
  194.  | den Benutzer ohne Belang und duerfen nicht veraendert werden. Vor dem     |
  195.  | ERSTEN Aufruf der Prozedur MUSS jedoch <idx> den Startindex erhalten, ab  |
  196.  | dem mit der Suche in <str> begonnen werden soll; <l1> MUSS auf Null ge-   |
  197.  | setzt werden. Diese beiden Zuweisungen muessen genau einmal vor dem ersten|
  198.  | Aufruf der Prozedur gemacht werden!                                       |
  199.   ---------------------------------------------------------------------------*)
  200.  
  201.  
  202.  
  203.  
  204.  PROCEDURE LenC ((* EIN/ -- *) strC : StrPtr ): CARDINAL;
  205.  
  206.  PROCEDURE AssignM2ToC ((* EIN/ -- *) strM2 : ARRAY OF CHAR;
  207.                         (* EIN/ -- *) sizeC : StrRange;
  208.                         (* EIN/ -- *) strC  : StrPtr        );
  209.  
  210.  PROCEDURE AssignCToM2 ((* EIN/ -- *)     strC  : StrPtr;
  211.                         (* -- /AUS *) VAR strM2 : ARRAY OF CHAR );
  212.  
  213. (*---------------------------------------------------------------------------
  214.  | Diese Prozeduren dienen der Bearbeitung von Strings nach 'C'-Konvention,  |
  215.  | d.h. sie sind IMMER mit einem Nullbyte abgeschlossen und werden durch     |
  216.  | einen Zeiger auf ihren ersten Buchstaben repraesentiert.                  |
  217.  | "LenC()" liefert als Funktionswert die Laenge eines 'C'-Strings.          |
  218.  | "AssignM2ToC()" und "AssignCToM2()" wandeln die MODULA- und C-Stringre-   |
  219.  | praesentationen ineinander um. Falls <strM2> bei "AssignCToM2()" nicht    |
  220.  | gross genug ist, wird entsprechend gekuerzt. <strC> muss bei "AssignM2ToC"|
  221.  | auf einen Speicherbereich ausreichender Laenge zeigen. Es werden maximal  |
  222.  | <size> - 1 Zeichen kopiert. <size> bezeichnet den Platz in <strC>^ fuer   |
  223.  | String und Nullbyte.                                                      |
  224.   ---------------------------------------------------------------------------*)
  225.  
  226. END pSTRING.
  227.  
  228.