home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / m2posx14 / src / lib.dpp < prev    next >
Encoding:
Modula Definition  |  1994-05-04  |  10.0 KB  |  217 lines
  1. DEFINITION MODULE lib;
  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. (* Verschiedene Bibliotheksfunktionen                                        *)
  14. (* --------------------------------------------------------------------------*)
  15. (* 05-Mai-94, Holger Kleinschmidt                                            *)
  16. (*****************************************************************************)
  17.  
  18. FROM SYSTEM IMPORT
  19. (* TYPE *) ADDRESS;
  20.  
  21. FROM PORTAB IMPORT
  22. (* TYPE *) UNSIGNEDLONG, SIGNEDLONG;
  23.  
  24. FROM types IMPORT
  25. (* TYPE *) StrPtr, StrPPtr, sizeT, int, unsigned, long, unsignedlong;
  26.  
  27. (*=========================== "rand()" ======================================*)
  28.  
  29. CONST
  30. #if no_MIN_MAX
  31.   RandMax = 32767;
  32. #else
  33.   RandMax = MAX(int);
  34. #endif
  35.  
  36. (*================ "lfind()", "bsearch()", "qsort()" ========================*)
  37.  
  38. TYPE
  39.   CompareProc = PROCEDURE ((* par1 *) ADDRESS,
  40.                            (* par2 *) ADDRESS ): int;
  41.  
  42.   (* par1^  <  par2^  ==>  < 0
  43.    * par1^  =  par2^  ==>  = 0
  44.    * par1^  >  par2^  ==>  > 0
  45.    *
  46.    *
  47.    * Beispiel:
  48.    *
  49.    *   PROCEDURE cmp ((* EIN/ -- *) op1,
  50.    *                  (* EIN/ -- *) op2 : ADDRESS ): int;
  51.    *
  52.    *   TYPE ElemPtr = POINTER TO REAL; (* je nach Elementtyp *)
  53.    *
  54.    *   VAR ptr1 : ElemPtr;
  55.    *       ptr2 : ElemPtr;
  56.    *
  57.    *   BEGIN
  58.    *    ptr1 := op1;
  59.    *    ptr2 := op2;
  60.    *
  61.    *    IF ptr1^ < ptr2^ THEN
  62.    *      RETURN(-1);
  63.    *    ELSIF ptr1^ > ptr2^  THEN
  64.    *      RETURN(1);
  65.    *    ELSE
  66.    *      RETURN(0);
  67.    *    END;
  68.    *   END cmp;
  69.    *)
  70.  
  71. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  72.  
  73. (* Weder POSIX, noch Ansi-C: *)
  74.  PROCEDURE lfind ((* EIN/ -- *) key     : ADDRESS;
  75.                   (* EIN/ -- *) base    : ADDRESS;
  76.                   (* EIN/ -- *) nelems  : sizeT;
  77.                   (* EIN/ -- *) size    : sizeT;
  78.                   (* EIN/ -- *) compare : CompareProc ): ADDRESS;
  79.  
  80. (*--------------------------------------------------------------------------
  81.  | Prozedur fuer lineare Suche in einem Feld aus gleichartigen, direkt hin- |
  82.  | tereinander angeordneten Elementen (ACHTUNG: Fuellbytes muessen bei der  |
  83.  | Angabe von <size> beruecksichtigt werden!).                              |
  84.  | Falls das gesuchte Element gefunden wird, ist der Funktionswert dessen   |
  85.  | Adresse im Feld, sonst wird NULL zurueckgeliefert.                       |
  86.  |                                                                          |
  87.  | <base>    ist die Adresse des ersten Elementes des Feldes                |
  88.  | <nelems>  ist die Anzahl der Feldelemente                                |
  89.  | <size>    ist die Groesse eine Feldelementes in Bytes                    |
  90.  | <compare> ist die Vergleichsfunktion (siehe Def. 'CompareProc')          |
  91.  | <key>     ist die Adresse des gesuchten Elementes                        |
  92.   --------------------------------------------------------------------------*)
  93.  
  94.  
  95.  PROCEDURE bsearch ((* EIN/ -- *) key     : ADDRESS;
  96.                     (* EIN/ -- *) base    : ADDRESS;
  97.                     (* EIN/ -- *) nelems  : sizeT;
  98.                     (* EIN/ -- *) size    : sizeT;
  99.                     (* EIN/ -- *) compare : CompareProc  ): ADDRESS;
  100.  
  101. (*--------------------------------------------------------------------------
  102.  | Prozedur fuer binaere Suche in einem Feld aus gleichartigen, direkt hin- |
  103.  | tereinander angeordneten Elementen. Die Elemente muessen gemaess der     |
  104.  | verwendeten Vergleichsprozedur aufsteigend sortiert sein.                |
  105.  | Falls das gesuchte Element gefunden wird, ist der Funktionswert dessen   |
  106.  | Adresse im Feld, sonst wird NULL zurueckgeliefert.                       |
  107.  |                                                                          |
  108.  | Bedeutung der Parameter siehe: "lfind()"                                 |
  109.   --------------------------------------------------------------------------*)
  110.  
  111.  
  112.  PROCEDURE qsort ((* EIN/ -- *) base    : ADDRESS;
  113.                   (* EIN/ -- *) nelems  : sizeT;
  114.                   (* EIN/ -- *) size    : sizeT;
  115.                   (* EIN/ -- *) compare : CompareProc  );
  116.  
  117. (*--------------------------------------------------------------------------
  118.  | Prozedur fuer Sortierung nach dem ``Quicksort''-Algorithmus in einem Feld|
  119.  | aus gleichartigen, direkt hintereinander angeordneten Elementen.         |
  120.  | Die Sortierung ist nicht stabil, d.h. es ist nicht garantiert, dass die  |
  121.  | relative Ordnung von Elementen mit gleichem (Neben-)Schluessel erhalten  |
  122.  | bleibt.                                                                  |
  123.  | Stackbelastung: O(log(nelems))                                           |
  124.  |                                                                          |
  125.  | Bedeutung der Parameter siehe: "lfind()"                                 |
  126.    --------------------------------------------------------------------------*)
  127.  
  128.  
  129.  
  130. (* Weder POSIX, noch Ansi-C: *)
  131.  PROCEDURE itoa ((* EIN/ -- *) n    : int;
  132.                  (* EIN/ -- *) buf  : StrPtr;
  133.                  (* EIN/ -- *) base : int    );
  134.  
  135.  PROCEDURE ltoa ((* EIN/ -- *) n    : long;
  136.                  (* EIN/ -- *) buf  : StrPtr;
  137.                  (* EIN/ -- *) base : int    );
  138.  
  139.  PROCEDURE ultoa ((* EIN/ -- *) n    : unsignedlong;
  140.                   (* EIN/ -- *) buf  : StrPtr;
  141.                   (* EIN/ -- *) base : int           );
  142.  
  143. (*--------------------------------------------------------------------------
  144.  | Wandeln den Wert <n> in eine Stringrepraesentation um. Es wird die kuer- |
  145.  | zest moegliche Darstellung gewaehlt, d.h. es werden keine fuehrenden     |
  146.  | Nullen geschrieben, und bei positiven Zahlen wird kein Leerzeichen oder  |
  147.  | ein Plus verwendet. <base> bestimmt die Basis der Zahlendarstellung und  |
  148.  | muss innerhalb von [2..36] liegen; liegt <base> ausserhalb, wird Zehn    |
  149.  | angenommen.                                                              |
  150.   --------------------------------------------------------------------------*)
  151.  
  152.  
  153. (* Nicht POSIX, aber Ansi-C: *)
  154.  PROCEDURE strtol ((* EIN/ -- *) str  : StrPtr;
  155.                    (* EIN/ -- *) end  : StrPPtr;
  156.                    (* EIN/ -- *) base : int      ): long;
  157.  
  158.  PROCEDURE strtoul ((* EIN/ -- *) str  : StrPtr;
  159.                     (* EIN/ -- *) end  : StrPPtr;
  160.                     (* EIN/ -- *) base : int      ): unsignedlong;
  161.  
  162. (*--------------------------------------------------------------------------
  163.  | Wandelt die Stringrepraesentation <str> einer Zahl in ihre interne Dar-  |
  164.  | stellung, die als Funktionswert geliefert wird. Die Stringrepraesentation|
  165.  | muss der weiter unten angegebenen Syntax genuegen.                       |
  166.  |                                                                          |
  167.  | <end> ist der Index des ersten fuer die Umwandlung nicht mehr benutzten  |
  168.  | Zeichens; dieser kann auch ausserhalb von <str> liegen, falls die Reprae-|
  169.  | sentation durch das Stringende begrenzt wurde.                           |
  170.  | <base> ist die gewuenschte Basis der Zahl. gueltige Werte sind 0 und 2   |
  171.  | bis 36; andere Werte werden zu Null korrigiert. Ist <base> gleich Null,  |
  172.  | wird die Basis der Repraesentation entnommen, d.h. es koennen Binaer-,   |
  173.  | Oktal- und Sedezimalzahlen erkannt werden; ist der Zahl keine Basis vor- |
  174.  | angestellt, wird eine Dezimalzahl erwartet. Ist <base> gleich 2, 8 oder  |
  175.  | 16, so kann trotzdem zusaetzlich eine Basis der Zahl vorangestellt sein, |
  176.  | sie wird aber ignoriert, solange sie dem Wert von <base> entspricht.     |
  177.  |                                                                          |
  178.  | Wenn bei der Umwandlung ein Ueberlauf auftritt, wird als Funktionswert   |
  179.  | der jeweils groesst/kleinstmoegliche Wert zurueckgeliefert und 'errno'   |
  180.  | auf 'ERANGE' gesetzt.                                                    |
  181.  |                                                                          |
  182.  | Die Syntax:                                                              |
  183.  |                                                                          |
  184.  |   whole      ::= {SPACE}['+'|'-']('%'bin)|('$'hex)|('0'octHexNull)|(num) |
  185.  |                  Stringende|keine gueltige Ziffer                        |
  186.  |   octHexNull ::= ('x'|'X')hex|oct| e (* leer, fuer die NULL *)           |
  187.  |   bin        ::= bindigit{bindigit}                                      |
  188.  |   oct        ::= octdigit{octdigit}                                      |
  189.  |   hex        ::= hexdigit{hexdigit}                                      |
  190.  |   num        ::= digit{digit}                                            |
  191.  |   bindigit   ::= '0'|'1'                                                 |
  192.  |   octdigit   ::= bindigit|'2'..'7'                                       |
  193.  |   hexdigit   ::= octdigit|'8'|'9'|'a'..'f'|'A'..'F'                      |
  194.  |   digit      ::= hexdigit|'g'..'z'|'G'..'Z'                              |
  195.   --------------------------------------------------------------------------*)
  196.  
  197. (* Nicht POSIX, aber Ansi-C: *)
  198.  PROCEDURE atol ((* EIN/ -- *) str : StrPtr ): long;
  199.  
  200.  PROCEDURE atoi ((* EIN/ -- *) str : StrPtr ): int;
  201.  
  202.  
  203.  
  204.  PROCEDURE rand ( ): int;
  205.  
  206.  PROCEDURE srand ((* EIN/ -- *) seed : unsigned );
  207.  
  208. (*--------------------------------------------------------------------------
  209.  | "rand()" liefert eine Pseudozufallszahl im Bereich [0..RandMax]. Die     |
  210.  | jeweils letzte Zufallszahl wird gemerkt und als Ausgangspunkt fuer die   |
  211.  | Berechnung der naechsten verwendet. Mit "srand()" kann dieser Ausgangs-  |
  212.  | punkt explizit gesetzt werden, sodass reproduzierbare Zahlenfolgen moeg- |
  213.  | lich sind. Zu Programmstart wird als Ausgangswert die eins verwendet.    |
  214.   --------------------------------------------------------------------------*)
  215.  
  216. END lib.
  217.