home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1989 / 06 / hitech / dynarray.def < prev    next >
Encoding:
Modula Definition  |  1988-10-03  |  6.4 KB  |  122 lines
  1. DEFINITION MODULE DynArrayHandler;
  2.  
  3. (*-------------------------------------------------------------------*
  4.  * Dieses Modul umfa₧t die Verwaltung dynamischer Arrays mit         *
  5.  * beliebigen Typen bis zu einer Elementgrö₧e von <MaxElementSize>.  *
  6.  * Die Typenkompatibilität wird über die Grö₧e der übergebenen       *
  7.  * Variablen kontrolliert. Typenkonvertierungen sind mit Variablen   *
  8.  * unterschiedlichen Typs bei gleicher Grö₧e möglich.                *
  9.  * Die Grö₧e des Arrays wird über den grö₧ten Index, der beim        *
  10.  * Schreiben von Elementen verwendet wurde, bestimmen.               *
  11.  * Lesender Zugriff auf Indizes oberhalb des grö₧ten, zum Schreiben  *
  12.  * verwendeten Index, wird mit einer Fehlermeldung quittiert.        *
  13.  *-------------------------------------------------------------------*
  14.  * Copyright 1987: Dipl.-Inform. Frank F. Wachtmeister               *
  15.  *-------------------------------------------------------------------*)
  16.  
  17. FROM Streams IMPORT Stream;
  18. FROM SYSTEM  IMPORT BYTE;
  19.  
  20. CONST 
  21.    MaxElementSize = 256;
  22.  
  23.  
  24. TYPE
  25.    DynArray;  (* Opaque Type *)
  26.  
  27.       
  28. (*-------------------------------------------------------------------*
  29.  * DefDynArray definiert und initialisiert ein dynamisches Array vom *
  30.  * Typ init. Die Variable init wird hier auch als Initialisierung von*
  31.  * nicht explizit definierten Array-Elementen verwendet.             *
  32.  * So haben bei:                                                     *
  33.  *                                                                   *
  34.  * DefDynArray (dyn, init);                                          *
  35.  * Put (dyn, 50, a);                                                 *
  36.  *                                                                   *
  37.  * die Elemente von mit dem Index von 0 bis 49 den Wert von init;    *
  38.  * das Element mit Index 50 hat den Wert von a.                      *
  39.  *-------------------------------------------------------------------*)
  40.  
  41. PROCEDURE DefDynArray (VAR dyn: DynArray; init: ARRAY OF BYTE);
  42.  
  43.  
  44. (*-------------------------------------------------------------------*
  45.  * DeleteDynArray löscht ein dynamisches Array und gibt den          *
  46.  * benötigten Speicherplatz wieder frei.                             *
  47.  *-------------------------------------------------------------------*)
  48.  
  49. PROCEDURE DeleteDynArray (VAR dyn: DynArray);
  50.  
  51.  
  52. (*-------------------------------------------------------------------*
  53.  * Get liest aus dem dynamischen Array dyn das Element mit dem       *
  54.  * Index ind und speichert es in der übergebenen Variablen elem.     *
  55.  * Ist die Grö₧e der übergebenen Variablen ungleich der Grö₧e der    *
  56.  * Array-Elemente, kommt Fehlermeldung 107.                          *
  57.  * Ist der Index ind grö₧er als die Indizes bisher geschriebenener   *
  58.  * Elemente, kommt Fehlermeldung Nr. 108.                            *
  59.  * Fehlermeldung Nr. 109: Array Address Error sollte eigentlich nicht*
  60.  * kommen und lä₧t auf einen "wildernden Pointer" schlie₧en, der     *
  61.  * hoffentlich nicht zu diesem Modul gehört.                         *
  62.  *-------------------------------------------------------------------*)
  63.  
  64. PROCEDURE Get (VAR dyn: DynArray; ind: CARDINAL; VAR elem: ARRAY OF BYTE);
  65.  
  66.  
  67. (*-------------------------------------------------------------------*
  68.  * Put speichert die Variable elem im dynamischen Array dyn unter    *
  69.  * dem Index ind ab.                                                 *
  70.  * Ist die Grö₧e der übergebenen Variablen ungleich der Grö₧e der    *
  71.  * Array-Elemente, kommt Fehlermeldung 107.                          *
  72.  * Ist der Index ind grö₧er als die Indizes bisher geschriebenener   *
  73.  * Elemente, wird das Array entsprechend erweitert.                  *
  74.  * Für diesen Fall gilt:                                             *
  75.  * Alle Elemente vom ehemals letzten Element bis zum neuen Element   *
  76.  * werden mit dem Wert des an DefDynarray übergebenen Initiali-      *
  77.  * sierungswertes besetzt.                                           *
  78.  *-------------------------------------------------------------------*)
  79. PROCEDURE Put (VAR dyn: DynArray; ind: CARDINAL; VAR elem: ARRAY OF BYTE);
  80.  
  81.  
  82. (*-------------------------------------------------------------------*
  83.  * LastIndex gibt den letzten, zum Lesen erlaubten Index des         *
  84.  * dynamischen Arrays dyn zurück.                                    *
  85.  *-------------------------------------------------------------------*)
  86. PROCEDURE LastIndex (VAR dyn: DynArray): CARDINAL;
  87.  
  88.  
  89. (*-------------------------------------------------------------------*
  90.  * ElementSize gibt die Grö₧e eines einzelnen Array-Elementes in     *
  91.  * Byte zurück.                                                      *
  92.  *-------------------------------------------------------------------*)
  93. PROCEDURE ElementSize (VAR dyn: DynArray): CARDINAL;
  94.  
  95.  
  96. (*-------------------------------------------------------------------*
  97.  * LoadDynArray lädt aus dem Stream <in> die Elemente des Arrays.    *
  98.  * Die Variable <init> wird hier auch als Initialisierung von nicht  *
  99.  * explizit definierten Array-Elementen verwendet.                   *
  100.  * Siehe auch DefDynArray.                                           *
  101.  * Der Stream <in> mu₧ für READ geöffnet sein und entsprechendes     *
  102.  * Format besitzen:                                                  *
  103.  * Byte 0..1: Grö₧e eines Array-Elements                             *
  104.  * Byte 2..3: Anzahl der Elemente                                    *
  105.  * Byte 4..n: Array-Elemente                                         *
  106.  *-------------------------------------------------------------------*)
  107. PROCEDURE LoadDynArray (VAR in: Stream; 
  108.                         VAR dyn: DynArray; elem: ARRAY OF BYTE);
  109.  
  110. (*-------------------------------------------------------------------*
  111.  * SaveDynArray speichert ein dynamisches Array in den Stream <out>. *
  112.  * Der Stream <out> mu₧ für READWRITE geöffnet sein.                 *
  113.  * Die Variable <elem> dient zum Typ-Check und kann einen  beliebigen*
  114.  * Wert enthalten.                                                   *
  115.  * Das Array kann mit LoadDynArray wieder geladen werden.            *
  116.  * NICHT VERGESSEN: Stream <out> nach Aufruf SCHLIESSEN !!           *
  117.  *-------------------------------------------------------------------*)
  118. PROCEDURE SaveDynArray (VAR out: Stream; 
  119.                         VAR dyn: DynArray; elem: ARRAY OF BYTE);
  120. END DynArrayHandler.
  121.  
  122.