home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / m2posx14 / src / cstr.dpp < prev    next >
Encoding:
Modula Definition  |  1994-05-14  |  10.8 KB  |  208 lines
  1. DEFINITION MODULE cstr;
  2. __DEF_SWITCHES__
  3. #ifdef HM2
  4. #ifdef __LONG_WHOLE__
  5. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  6. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  7. #else
  8. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  9. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  10. #endif
  11. #endif
  12. (*****************************************************************************)
  13. (* Diese Prozeduren dienen der Bearbeitung von Strings nach 'C'-Konvention,  *)
  14. (* d.h. sie sind IMMER (einzige Ausnahme: "strncpy()") mit einem Nullbyte    *)
  15. (* abgeschlossen und werden durch einen Zeiger auf ihren ersten Buchstaben   *)
  16. (* repraesentiert. Die Prozeduren fangen Zeiger mit dem Wert NULL (nicht NIL)*)
  17. (* ab.                                                                       *)
  18. (* Laengenangaben werden zwar durch den Typ 'sizeT' repraesentiert, es       *)
  19. (* duerfen aber nur Werte im Bereich 'StrRange' benutzt werden.              *)
  20. (* --------------------------------------------------------------------------*)
  21. (* 05-Mai-94, Holger Kleinschmidt                                            *)
  22. (*****************************************************************************)
  23.  
  24. FROM types IMPORT
  25. (* TYPE *) int, sizeT, StrPtr, StrRange;
  26.  
  27. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  28.  
  29.  PROCEDURE strlen ((* EIN/ -- *) str : StrPtr ): sizeT;
  30.  
  31. (*---------------------------------------------------------------------------
  32.  | Liefert die Laenge von <str>^.                                            |
  33.   ---------------------------------------------------------------------------*)
  34.  
  35.  
  36.  PROCEDURE strcpy ((* EIN/ -- *) dst : StrPtr;
  37.                    (* EIN/ -- *) src : StrPtr );
  38.  
  39.  PROCEDURE strncpy ((* EIN/ -- *) dst : StrPtr;
  40.                     (* EIN/ -- *) src : StrPtr;
  41.                     (* EIN/ -- *) len : sizeT  );
  42.  
  43. (*---------------------------------------------------------------------------
  44.  | Zuweisung: <dst>^ := <src>^.                                              |
  45.  | "strncpy()" kopiert im Gegensatz zu "strcpy()" genau <len> Zeichen        |
  46.  | nach <dst>^. Falls <src>^ kuerzer als <len> ist, wird <dst>^ mit Nullbytes|
  47.  | auf <len> Zeichen aufgefuellt, falls jedoch <src>^ groesser oder gleich   |
  48.  | als <len> Zeichen ist, wird <dst>^ NICHT mit einem Nullbyte abgeschlossen!|
  49.   ---------------------------------------------------------------------------*)
  50.  
  51.  
  52.  PROCEDURE strlwr ((* EIN/ -- *) str : StrPtr );
  53.  
  54.  PROCEDURE strupr ((* EIN/ -- *) str : StrPtr );
  55.  
  56. (*---------------------------------------------------------------------------
  57.  | Die Prozeduren wandeln <str>^ in Klein- bzw. Grossbuchstaben.             |
  58.   ---------------------------------------------------------------------------*)
  59.  
  60.  
  61.  PROCEDURE strcat ((* EIN/ -- *) dst : StrPtr;
  62.                    (* EIN/ -- *) src : StrPtr );
  63.  
  64.  PROCEDURE strncat ((* EIN/ -- *) dst : StrPtr;
  65.                     (* EIN/ -- *) src : StrPtr;
  66.                     (* EIN/ -- *) len : sizeT  );
  67.  
  68. (*---------------------------------------------------------------------------
  69.  | Konkatenation: <dst>^ := <dst>^ ++ <src>^.                                |
  70.  | "strncat()" kopiert hoechstens <len> Zeichen von <src>^ ans Ende von      |
  71.  | <dst>^, <src>^ wird aber auf jeden Fall mit einem Nullbyte abgeschlossen. |
  72.   ---------------------------------------------------------------------------*)
  73.  
  74.  
  75.  PROCEDURE strcmp ((* EIN/ -- *) str1 : StrPtr;
  76.                    (* EIN/ -- *) str2 : StrPtr ): int;
  77.  
  78.  PROCEDURE strncmp ((* EIN/ -- *) str1  : StrPtr;
  79.                     (* EIN/ -- *) str2  : StrPtr;
  80.                     (* EIN/ -- *) len   : sizeT  ): int;
  81.  
  82.  PROCEDURE stricmp ((* EIN/ -- *) str1 : StrPtr;
  83.                     (* EIN/ -- *) str2 : StrPtr ): int;
  84.  
  85.  PROCEDURE strnicmp ((* EIN/ -- *) str1  : StrPtr;
  86.                      (* EIN/ -- *) str2  : StrPtr;
  87.                      (* EIN/ -- *) len   : sizeT  ): int;
  88.  
  89. (*---------------------------------------------------------------------------
  90.  | Vergleichen <str1>^ und <str2>^ zeichenweise miteinander. Wenn beide      |
  91.  | Strings gleich sind, wird Null geliefert; ist ein Zeichen aus <str1>^     |
  92.  | kleiner als das entsprechende Zeichen in <str2>^, wird ein Wert kleiner   |
  93.  | Null geliefert; ist ein Zeichen groesser, wird ein Wert groesser Null     |
  94.  | geliefert.                                                                |
  95.  | "strncmp()" vergleicht hoechstens <len> Zeichen miteinander.              |
  96.  | "str[n]icmp()" unterscheidet nicht zwischen Gross- und Kleinschreibung.   |
  97.   ---------------------------------------------------------------------------*)
  98.  
  99.  
  100.  PROCEDURE strchr ((* EIN/ -- *) s : StrPtr;
  101.                    (* EIN/ -- *) c : CHAR   ): StrPtr;
  102.  
  103.  PROCEDURE strrchr ((* EIN/ -- *) s : StrPtr;
  104.                     (* EIN/ -- *) c : CHAR   ): StrPtr;
  105.  
  106. (*---------------------------------------------------------------------------
  107.  | Suchen das erste bzw. letzte Auftreten von <c> in <s>^. Falls <c> gefunden|
  108.  | wird, wird ein Zeiger auf die Adresse in <s>^ geliefert, sonst NULL.      |
  109.   ---------------------------------------------------------------------------*)
  110.  
  111.  
  112.  PROCEDURE strstr ((* EIN/ -- *) str : StrPtr;
  113.                    (* EIN/ -- *) pat : StrPtr ): StrPtr;
  114.  
  115. (*---------------------------------------------------------------------------
  116.  | Liefert die Adresse des ersten Auftretens von <pat>^ in <str>^, sonst NULL|
  117.   ---------------------------------------------------------------------------*)
  118.  
  119.  
  120.  PROCEDURE strpbrk ((* EIN/ -- *) str : StrPtr;
  121.                     (* EIN/ -- *) brk : StrPtr ): StrPtr;
  122.  
  123. (*---------------------------------------------------------------------------
  124.  | Liefert die Adresse des ersten Auftretens eines Zeichens aus <brk>^ in    |
  125.  | <s>^, sonst NULL.                                                         |
  126.   ---------------------------------------------------------------------------*)
  127.  
  128.  
  129.  PROCEDURE strerror ((* EIN/ -- *) err : int ): StrPtr;
  130.  
  131. (*--------------------------------------------------------------------------
  132.  | Liefert einen Zeiger auf einen statischen String, der den Fehlercode     |
  133.  | <err> kurz beschreibt. Die Funktion wird durch das Locale 'LC_MESSAGES'  |
  134.  | beeinflusst.                                                             |
  135.  | Der Inhalt des Strings bleibt nur bis zum naechsten Aufruf der Funktion  |
  136.  | erhalten. Die Funktion ist nicht reentrant.                              |
  137.   --------------------------------------------------------------------------*)
  138.  
  139.  PROCEDURE strsignal ((* EIN/ -- *) sig : int ): StrPtr;
  140.  
  141. (*--------------------------------------------------------------------------
  142.  | Liefert einen Zeiger auf einen statischen String, der das Signal <sig>   |
  143.  | kurz beschreibt. Die Funktion wird durch das Locale 'LC_MESSAGES'        |
  144.  | beeinflusst.                                                             |
  145.  | Der Inhalt des Strings bleibt nur bis zum naechsten Aufruf der Funktion  |
  146.  | erhalten. Die Funktion ist nicht reentrant.                              |
  147.   --------------------------------------------------------------------------*)
  148.  
  149.  
  150.  PROCEDURE Token ((* EIN/ -- *)     str   : StrPtr;
  151.                   (* EIN/ -- *)     stop  : StrPtr;
  152.                   (* EIN/AUS *) VAR idx   : StrRange;
  153.                   (* EIN/AUS *) VAR l1    : StrRange;
  154.                   (* EIN/AUS *) VAR l2    : StrRange;
  155.                   (* -- /AUS *) VAR tlen  : StrRange;
  156.                   (* -- /AUS *) VAR token : StrPtr   ): BOOLEAN;
  157.  
  158. (*---------------------------------------------------------------------------
  159.  | <str>^ wird in Token zerlegt, die jeweils durch eins der Zeichen aus      |
  160.  | <stop>^ begrenzt sind. Stehen zwei Trennzeichen hintereinander --         |
  161.  | hoechstens durch Leerzeichen voneinander getrennt -- wird als Token ein   |
  162.  | Leerstring geliefert (<tlen> = 0). Steht am Anfang oder Ende von <str>^   |
  163.  | ein Trennzeichen, ist das Token ebenfalls ein Leerstring.                 |
  164.  | <token> zeigt auf den Beginn des jeweiligen Tokens in <str>^ ohne fueh-   |
  165.  | rende Leerzeichen. Ohne abschliessende Leerzeichen ist das Token <tlen>   |
  166.  | Zeichen lang. Das Token ist nicht durch ein Nullbyte abgeschlossen, da    |
  167.  | <str>^ nicht veraendert wird, es muss also auf jeden Fall <tlen> heran-   |
  168.  | gezogen werden, um das Token an einen ``sicheren Ort'' umzukopieren.      |
  169.  | Ist <str>^ vollstaendig durchsucht, wird als Funktionswert FALSE zurueck- |
  170.  | geliefert, sodass "Token()" z.B. in einer WHILE-Schleife verwendet werden |
  171.  | kann. In <idx>, <l1> und <l2> bewahrt die Prozedur Informationen auf, die |
  172.  | sie fuer den naechsten Aufruf benoetigt; diese sind fuer den Benutzer ohne|
  173.  | Belang und duerfen nicht veraendert werden. Vor dem ERSTEN Aufruf der     |
  174.  | Prozedur MUSS jedoch <idx> den Startindex erhalten, ab dem mit der Suche  |
  175.  | in <str>^ begonnen werden soll; <l1> MUSS auf Null gesetzt werden. Diese  |
  176.  | beiden Initialisierungen muessen genau einmal vor dem ersten Aufruf der   |
  177.  | Prozedur gemacht werden!                                                  |
  178.   ---------------------------------------------------------------------------*)
  179.  
  180.  
  181.  PROCEDURE AssignM2ToC ((* EIN/ -- *) REF strM2 : ARRAY OF CHAR;
  182.                         (* EIN/ -- *)     sizeC : StrRange;
  183.                         (* EIN/ -- *)     strC  : StrPtr        );
  184.  
  185. (*---------------------------------------------------------------------------
  186.  | Wandelt einen M2- in einen C-String um.                                   |
  187.  | <strC> muss auf einen Speicherbereich ausreichender Laenge zeigen. Es     |
  188.  | werden maximal <sizeC> Zeichen kopiert. Falls <strM2> groesser oder gleich|
  189.  | <sizeC> Zeichen ist, werden genau <sizeC> Zeichen nach <strC> kopiert,    |
  190.  | aber NICHT mit einem Nullbyte abgeschlossen. Nur wenn <strM2> kuerzer als |
  191.  | <sizeC> Zeichen ist, wird <strC> mit einem Nullbyte abgeschlossen. Diese  |
  192.  | Prozedur entspricht damit "strncpy()".                                    |
  193.   ---------------------------------------------------------------------------*)
  194.  
  195.  PROCEDURE AssignCToM2 ((* EIN/ -- *)     strC  : StrPtr;
  196.                         (* EIN/ -- *)     max   : StrRange;
  197.                         (* -- /AUS *) VAR strM2 : ARRAY OF CHAR );
  198.  
  199. (*---------------------------------------------------------------------------
  200.  | Wandelt einen C- in einen M2-String um.                                   |
  201.  | Es werden hoechstens <max> Zeichen von <strC>^ nach <strM2> kopiert.      |
  202.  | Wenn <max> gleich Null ist, wird versucht, <strC>^ komplett nach <strM2>  |
  203.  | zu kopieren. Falls <strM2> nicht gross genug ist, wird entsprechend       |
  204.  | gekuerzt.                                                                 |
  205.   ---------------------------------------------------------------------------*)
  206.  
  207. END cstr.
  208.