home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / program / m2posx02 / lib.dpp < prev    next >
Encoding:
Modula Definition  |  1993-10-23  |  14.2 KB  |  290 lines
  1. DEFINITION MODULE lib;
  2.  
  3. (*****************************************************************************)
  4. (* Verschiedene Bibliotheksfunktionen                                        *)
  5. (* --------------------------------------------------------------------------*)
  6. (* 12-Feb-93, Holger Kleinschmidt                                            *)
  7. (*****************************************************************************)
  8.  
  9. FROM SYSTEM IMPORT
  10. (* TYPE *) ADDRESS;
  11.  
  12. FROM types IMPORT
  13. (* TYPE *) UNSIGNEDLONG, SIGNEDLONG;
  14.  
  15. (*=========================== "rand()" ======================================*)
  16.  
  17. CONST
  18.   RANDMAX = 7FFFFFFFH;
  19.  
  20. (*================ "lfind()", "bsearch()", "qsort()" ========================*)
  21.  
  22. TYPE
  23.   CompareProc = PROCEDURE ((* par1 *) ADDRESS,
  24.                            (* par2 *) ADDRESS ): INTEGER;
  25.  
  26.   (* par1^  <  par2^  ==>  < 0
  27.    * par1^  =  par2^  ==>  = 0
  28.    * par1^  >  par2^  ==>  > 0
  29.    *
  30.    *
  31.    * Beispiel:
  32.    *
  33.    *   PROCEDURE cmp ((* EIN/ -- *) op1,
  34.    *                  (* EIN/ -- *) op2 : ADDRESS ): INTEGER;
  35.    *   VAR ptr1,
  36.    *       ptr2 : POINTER TO REAL; (* je nach Elementtyp *)
  37.    *
  38.    *   BEGIN
  39.    *    ptr1 := op1;
  40.    *    ptr2 := op2;
  41.    *
  42.    *    IF ptr1^ < ptr2^ THEN
  43.    *      RETURN(-1);
  44.    *    ELSIF ptr1^ > ptr2^  THEN
  45.    *      RETURN(1);
  46.    *    ELSE
  47.    *      RETURN(0);
  48.    *    END;
  49.    *   END cmp;
  50.    *)
  51.  
  52. (*========================= "fnmatch()" =====================================*)
  53.  
  54. CONST
  55.   ESCAPECHAR = 134C;
  56.   INVERTCHAR = '!';
  57.  
  58.  
  59. TYPE
  60.   FNMFlag = (
  61.     fnmPATHNAME, (* Wildcards ('*', '?') und Mengen ('[...]') ``matchen''
  62.                   * nicht ueber Verzeichnisgrenzen ('/') hinweg -> (Datei)Namen
  63.                   * werden durch '/.../' begrenzt.
  64.                   *)
  65.     fnmPERIOD,   (* Wildcards ('*', '?') und Mengen ('[...]') ``matchen''
  66.                   * kein fuehrendes '.' bei (Datei)Namen.
  67.                   *)
  68.     fnmNOESCAPE  (* Das Zeichen 'ESCAPECHAR' hebt nicht die Spezialbedeutung
  69.                   * von '*', '?', '[', ']' (und ESCAPECHAR) auf.
  70.                   *)
  71.   );
  72.  
  73.   FNMFlags = PACKEDSET OF FNMFlag;
  74.  
  75.  
  76. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  77. (* nicht POSIX: *)
  78.  PROCEDURE bcopy ((* EIN/ -- *) src : ADDRESS;
  79.                   (* EIN/ -- *) dst : ADDRESS;
  80.                   (* EIN/ -- *) len : UNSIGNEDLONG );
  81.  
  82. (*--------------------------------------------------------------------------
  83.  | Kopiert <len> Bytes von <src> nach <dst>. Die Bereiche duerfen sich      |
  84.  | ueberlappen. Wenn beide Adressen gerade oder ungerade sind, wird beson-  |
  85.  | ders schnell kopiert.                                                    |
  86.   --------------------------------------------------------------------------*)
  87.  
  88. (* nicht POSIX: *)
  89.  PROCEDURE bzero ((* EIN/ -- *) dst : ADDRESS;
  90.                   (* EIN/ -- *) len : UNSIGNEDLONG );
  91.  
  92. (*--------------------------------------------------------------------------
  93.  | Setzt <len> Bytes ab Adresse <dst> auf Null.                             |
  94.   --------------------------------------------------------------------------*)
  95.  
  96. (* nicht POSIX: *)
  97.  PROCEDURE bswap ((* EIN/ -- *) blk1 : ADDRESS;
  98.                   (* EIN/ -- *) blk2 : ADDRESS;
  99.                   (* EIN/ -- *) len  : UNSIGNEDLONG );
  100.  
  101. (*--------------------------------------------------------------------------
  102.  | Tauscht <len> Bytes ab Adresse <blk1> bzw. <blk2> gegeneinander aus.     |
  103.  | Die Speicherbereiche duerfen sich nicht ueberlappen.                     |
  104.   --------------------------------------------------------------------------*)
  105.  
  106.  
  107. (* nicht POSIX: *)
  108.  PROCEDURE lfind ((* EIN/ -- *) key     : ADDRESS;
  109.                   (* EIN/ -- *) base    : ADDRESS;
  110.                   (* EIN/ -- *) nelems  : UNSIGNEDLONG;
  111.                   (* EIN/ -- *) size    : UNSIGNEDLONG;
  112.                   (* EIN/ -- *) compare : CompareProc  ): ADDRESS;
  113.  
  114. (*--------------------------------------------------------------------------
  115.  | Prozedur fuer lineare Suche in einem Feld aus gleichartigen, direkt hin- |
  116.  | tereinander angeordneten Elementen (ACHTUNG: Fuellbytes muessen bei der  |
  117.  | Angabe von <size> beruecksichtigt werden!).                              |
  118.  | Falls das gesuchte Element gefunden wird, ist der Funktionswert dessen   |
  119.  | Adresse im Feld, sonst wird NULL zurueckgeliefert.                       |
  120.  |                                                                          |
  121.  | <base>    ist die Adresse des ersten Elementes des Feldes                |
  122.  | <nelems>  ist die Anzahl der Feldelemente                                |
  123.  | <size>    ist die Groesse eine Feldelementes in Bytes                    |
  124.  | <compare> ist die Vergleichsfunktion (siehe Def. 'CompareProc')          |
  125.  | <key>     ist die Adresse des gesuchten Elementes                        |
  126.   --------------------------------------------------------------------------*)
  127.  
  128.  
  129.  PROCEDURE bsearch ((* EIN/ -- *) key     : ADDRESS;
  130.                     (* EIN/ -- *) base    : ADDRESS;
  131.                     (* EIN/ -- *) nelems  : UNSIGNEDLONG;
  132.                     (* EIN/ -- *) size    : UNSIGNEDLONG;
  133.                     (* EIN/ -- *) compare : CompareProc  ): ADDRESS;
  134.  
  135.  
  136. (*--------------------------------------------------------------------------
  137.  | Prozedur fuer binaere Suche in einem Feld aus gleichartigen, direkt hin- |
  138.  | tereinander angeordneten Elementen. Die Elemente muessen gemaess der     |
  139.  | verwendeten Vergleichsprozedur aufsteigend sortiert sein.                |
  140.  | Falls das gesuchte Element gefunden wird, ist der Funktionswert dessen   |
  141.  | Adresse im Feld, sonst wird NULL zurueckgeliefert.                       |
  142.  |                                                                          |
  143.  | Bedeutung der Parameter siehe: "lfind()"                                 |
  144.   --------------------------------------------------------------------------*)
  145.  
  146.  
  147.  
  148.  
  149.  PROCEDURE qsort ((* EIN/ -- *) base    : ADDRESS;
  150.                   (* EIN/ -- *) nelems  : UNSIGNEDLONG;
  151.                   (* EIN/ -- *) size    : UNSIGNEDLONG;
  152.                   (* EIN/ -- *) compare : CompareProc  );
  153.  
  154. (*--------------------------------------------------------------------------
  155.  | Prozedur fuer Sortierung nach dem ``Quicksort''-Algorithmus in einem Feld|
  156.  | aus gleichartigen, direkt hintereinander angeordneten Elementen.         |
  157.  | Die Sortierung ist nicht stabil, d.h. es ist nicht garantiert, dass die  |
  158.  | relative Ordnung von Elementen mit gleichem (Neben-)Schluessel erhalten  |
  159.  | bleibt.                                                                  |
  160.  | Stackbelastung: O(log(nelems))                                           |
  161.  |                                                                          |
  162.  | Bedeutung der Parameter siehe: "lfind()"                                 |
  163.    --------------------------------------------------------------------------*)
  164.  
  165.  
  166.  
  167.  
  168. (* nicht POSIX: *)
  169.  PROCEDURE ltoa ((* EIN/ -- *)     n    : SIGNEDLONG;
  170.                  (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  171.                  (* EIN/ -- *)     base : CARDINAL      );
  172.  
  173.  PROCEDURE ultoa ((* EIN/ -- *)     n    : UNSIGNEDLONG;
  174.                   (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  175.                   (* EIN/ -- *)     base : CARDINAL      );
  176.  
  177. (*--------------------------------------------------------------------------
  178.  | Wandeln den Wert <n> in eine Stringrepraesentation um. Es wird die kuer- |
  179.  | zest moegliche Darstellung gewaehlt, d.h. es werden keine fuehrenden     |
  180.  | Nullen geschrieben, und bei positiven Zahlen wird kein Leerzeichen oder  |
  181.  | ein Plus verwendet. <base> bestimmt die Basis der Zahlendarstellung und  |
  182.  | muss innerhalb von [2..36] liegen; liegt <base> ausserhalb, wird Zehn    |
  183.  | angenommen.                                                              |
  184.   --------------------------------------------------------------------------*)
  185.  
  186.  
  187. (* nicht POSIX: *)
  188.  PROCEDURE strtol ((* EIN/ -- *) REF str  : ARRAY OF CHAR;
  189.                    (* -- /AUS *) VAR end  : CARDINAL;
  190.                    (* EIN/ -- *)     base : CARDINAL      ): SIGNEDLONG;
  191.  
  192.  PROCEDURE strtoul ((* EIN/ -- *) REF str  : ARRAY OF CHAR;
  193.                     (* -- /AUS *) VAR end  : CARDINAL;
  194.                     (* EIN/ -- *)     base : CARDINAL      ): UNSIGNEDLONG;
  195.  
  196. (*--------------------------------------------------------------------------
  197.  | Wandelt die Stringrepraesentation <str> einer Zahl in ihre interne Dar-  |
  198.  | stellung, die als Funktionswert geliefert wird. Die Stringrepraesentation|
  199.  | muss der weiter unten angegebenen Syntax genuegen.                       |
  200.  |                                                                          |
  201.  | <end> ist der Index des ersten fuer die Umwandlung nicht mehr benutzten  |
  202.  | Zeichens; dieser kann auch ausserhalb von <str> liegen, falls die Reprae-|
  203.  | sentation durch das Stringende begrenzt wurde.                           |
  204.  | <base> ist die gewuenschte Basis der Zahl. gueltige Werte sind 0 und 2   |
  205.  | bis 36; andere Werte werden zu Null korrigiert. Ist <base> gleich Null,  |
  206.  | wird die Basis der Repraesentation entnommen, d.h. es koennen Binaer-,   |
  207.  | Oktal- und Sedezimalzahlen erkannt werden; ist der Zahl keine Basis vor- |
  208.  | angestellt, wird eine Dezimalzahl erwartet. Ist <base> gleich 2, 8 oder  |
  209.  | 16, so kann trotzdem zusaetzlich eine Basis der Zahl vorangestellt sein, |
  210.  | sie wird aber ignoriert, solange sie dem Wert von <base> entspricht.     |
  211.  |                                                                          |
  212.  | Wenn bei der Umwandlung ein Ueberlauf auftritt, wird als Funktionswert   |
  213.  | der jeweils groesst/kleinstmoegliche Wert zurueckgeliefert und 'errno'   |
  214.  | auf 'ERANGE' gesetzt.                                                    |
  215.  |                                                                          |
  216.  | Die Syntax:                                                              |
  217.  |                                                                          |
  218.  |   whole      ::= {SPACE}['+'|'-']('%'bin)|('$'hex)|('0'octHexNull)|(num) |
  219.  |                  Stringende|keine gueltige Ziffer                        |
  220.  |   octHexNull ::= ('x'|'X')hex|oct| e (* leer, fuer die NULL *)           |
  221.  |   bin        ::= bindigit{bindigit}                                      |
  222.  |   oct        ::= octdigit{octdigit}                                      |
  223.  |   hex        ::= hexdigit{hexdigit}                                      |
  224.  |   num        ::= digit{digit}                                            |
  225.  |   bindigit   ::= '0'|'1'                                                 |
  226.  |   octdigit   ::= bindigit|'2'..'7'                                       |
  227.  |   hexdigit   ::= octdigit|'8'|'9'|'a'..'f'|'A'..'F'                      |
  228.  |   digit      ::= hexdigit|'g'..'z'|'G'..'Z'                              |
  229.   --------------------------------------------------------------------------*)
  230.  
  231.  
  232.  
  233. (* nicht POSIX: *)
  234.  PROCEDURE strerror ((* EIN/ -- *)     errnum : INTEGER;
  235.                      (* -- /AUS *) VAR errstr : ARRAY OF CHAR );
  236.  
  237. (*--------------------------------------------------------------------------
  238.  | Wandelt den Fehlercode <errnum> in einen kurzen Fehlertext <errstr>.     |
  239.   --------------------------------------------------------------------------*)
  240.  
  241.  
  242.  
  243.  PROCEDURE rand ( ): UNSIGNEDLONG;
  244.  
  245.  PROCEDURE srand ((* EIN/ -- *) seed : UNSIGNEDLONG );
  246.  
  247. (*--------------------------------------------------------------------------
  248.  | "rand()" liefert eine Pseudozufallszahl im Bereich [0..MAXRAND]. Die     |
  249.  | jeweils letzte Zufallszahl wird gemerkt und als Ausgangspunkt fuer die   |
  250.  | Berechnung der naechsten verwendet. Mit "srand()" kann dieser Ausgangs-  |
  251.  | punkt explizit gesetzt werden, sodass reproduzierbare Zahlenfolgen moeg- |
  252.  | lich sind. Zu Programmstart wird als Ausgangswert die eins verwendet.    |
  253.   --------------------------------------------------------------------------*)
  254.  
  255.  
  256.  
  257.  PROCEDURE fnmatch ((* EIN/ -- *) REF str   : ARRAY OF CHAR;
  258.                     (* EIN/ -- *) REF pat   : ARRAY OF CHAR;
  259.                     (* EIN/ -- *)     flags : FNMFlags      ): BOOLEAN;
  260.  
  261. (*-------------------------------------------------------------------------
  262.  | Testet, ob das Muster <pat> auf den String <str> passt.                 |
  263.  | Die folgenden Zeichen haben im Muster eine Spezialbedeutung:            |
  264.  |                                                                         |
  265.  |         '*': steht fuer beliebig viele (auch Null) Zeichen              |
  266.  |         '?': steht fuer genau ein beliebiges Zeichen                    |
  267.  |         '[': Leitet eine Mengendefinition ein, d.h das korrespondierende|
  268.  |              Zeichen im String muss ein Zeichen aus dieser Menge sein.  |
  269.  |         '-': Innerhalb einer Mengendefinition wird ein Bereich durch das|
  270.  |              unmittelbar davor und unmittelbar dahinter stehende Zeichen|
  271.  |              gebildet. Das korrespondierende Zeichen kann innerhalb und |
  272.  |              einschliesslich der Grenzen liegen.                        |
  273.  |              Als erstes oder letztes Element einer Menge steht es fuer  |
  274.  |              sich selbst.                                               |
  275.  |         ']': Beendet die Definition einer Menge; als erstes Element     |
  276.  |              einer Menge oder ohne ein vorausgehendes, noch nicht abge- |
  277.  |              schlossenes '[', steht es fuer sich selbst.                |
  278.  | INVERTCHAR : Als erstes Zeichen einer Mengendefinition bedeutet es, dass|
  279.  |              das korrespondierende Zeichen im String KEIN Zeichen aus   |
  280.  |              dieser Menge sein darf.                                    |
  281.  | ESCAPECHAR : Hebt die Sonderfunktion der obigen Zeichen und auch von    |
  282.  |              sich selbst auf; die uebrigen Zeichen werden nicht beein-  |
  283.  |              flusst.                                                    |
  284.  |                                                                         |
  285.  | Mit <flags> kann die Interpretation der obigen Spezialzeichen beein-    |
  286.  | flusst werden (siehe Definition von 'FNMFlag').                         |
  287.   -------------------------------------------------------------------------*)
  288.  
  289. END lib.
  290.