home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 05 / texte / strukto.doc < prev    next >
Encoding:
Text File  |  1989-01-02  |  28.0 KB  |  456 lines

  1. «LR1»                                  STRUKTO
  2.                  Erstellung von Struktogrammen leicht gemacht
  3.  
  4.                  ein Programm von Thomas Kriegel
  5.  
  6. Struktogramme ermöglichen eine übersichtliche grafische Darstellung von Programmabläufen. Zur Erstellung ist jedoch ein hoher Aufwand an manuellen Tätigkeiten nötig, um eine ansprechende Darstellung zu erreichen.
  7. Das vorliegende Programm wurde entwickelt, um diesen Aufwand zu reduzieren :
  8. Es erzeugt formatierte Struktogramme. und Programmorganisationspläne
  9.  
  10. Die dazu benötigten Informationen entnimmt es einer Textdatei. Vor der Beschreibung des Programms seien noch einige Leistungsmerkmale aufgezählt :
  11.  
  12.    - Als Eingabedatei kann wahlweise eine Pascal-Source-Datei oder
  13.      eine spezielle Strukturdatei verwendet werden.
  14.    - Die Strukturdatei, die alle notwendigen Informationen zur Dar-
  15.      stellung des Struktogramms enthält, kann auch vom Programm
  16.      erzeugt werden.
  17.    - Die Ausgabe des Struktogramms kann wahlweise auf dem Schirm,
  18.      dem Drucker oder in eine Diskettendatei (z.B. zur Weiterverarbei-
  19.      tung mit einem Texteditor) erfolgen.
  20.    - Es lassen sich auch Programmorganisationspläne erstellen.
  21.    - Die erste Druckspalte und die Zeilenlänge können vom Benutzer
  22.      festgelegt werden - zur Darstellung der Struktogramme kann
  23.      zwischen Grafik- und Textzeichen gewählt werden.
  24.    - Die Fehlermeldungen werden in eine Fehlerdatei geschrieben.
  25.    - Die Bedienung ist menueorientiert.
  26.  
  27.  
  28. ════════════════
  29. Die Grundsymbole
  30. ════════════════
  31.  
  32. Die Bilder 1a..1h zeigen die grafische Darstellung und die Schlüsselbegriffe bzw. Befehlsfolgen, mit denen die einzelnen Strukturblöcke erzeugt werden können. Dabei kann anstelle von <BLOCK> wiederum jeder beliebige Strukturblock eingetragen werden. Die IF- und CASE-Blöcke wurden gegenüber der Norm dahingehend verändert, daß die einzelnen Alternativen nicht neben-, sondern untereinander angeordnet sind.
  33. Dies geht auf eine Anregung in (1) zurück und trägt dazu bei, den Verwaltungsaufwand des Programms in Grenzen zu halten. Gleichzeitig wird die Übersichtlichkeit der Darstellung verbessert (Geschachtelte IF-Anweisungen lassen sich, hält man sich an die Norm, nur sehr unübersichtlich darstellen). Der Unterprogrammblock wurde ebenfalls etwas abgewandelt.
  34.  
  35. ┌───────────────────────────────────────────────────────────────────┐
  36. │                                                                   │
  37. │   a) Programmgerüst                                               │
  38. │                                                                   │
  39. │    ┌─────────────────────────────┐                                │
  40. │    │ Programmname                │        Programm Programmname   │
  41. │    │ ┌───────────────────────────┤                                │
  42. │    │ │          <BLOCK>          │        <BLOCK>                 │
  43. │    │ └───────────────────────────┤                                │
  44. │    │                             │        #PROGRAMM               │
  45. │    └─────────────────────────────┘                                │
  46. │                                                                   │
  47. │                                                                   │
  48. │    b) Anweisung                                                   │
  49. │                                                                   │
  50. │    ┌─────────────────────────────┐                                │
  51. │    │      Anweisung              │        P Anweisung             │
  52. │    └─────────────────────────────┘                                │
  53. │                                                                   │
  54. │                                                                   │
  55. │   c) Unterprogramm                                                │
  56. │                                                                   │
  57. │    ┌───┬──────────────────┬──────┐                                │
  58. │    │   │   Unterprogramm  │      │        U Unterprogramm         │
  59. │    └───┴──────────────────┴──────┘                                │
  60. │                                                                   │
  61. │                                                                   │
  62. │                                                                   │
  63. │   d) WHILE-Schleife                                               │
  64. │                                                                   │
  65. │    ┌─────────────────────────────┐                                │
  66. │    │ Laufbedingung               │        While Laufbedingung     │
  67. │    │ ┌───────────────────────────┤                                │
  68. │    │ │          <BLOCK>          │        <BLOCK>                 │
  69. │    └─┴───────────────────────────┘        #W                      │
  70. │                                                                   │
  71. │                                                                   │
  72. │   e) REPEAT-Schleife                                              │
  73. │                                                                   │
  74. │    ┌─┬───────────────────────────┐        R                       │
  75. │    │ │          <BLOCK>          │        <BLOCK>                 │
  76. │    │ └───────────────────────────┤                                │
  77. │    │ Abbruchbedingung            │        #Repeat Abbruchbedingung│
  78. │    └─────────────────────────────┘                                │
  79. │                                                                   │
  80. │                                                                   │
  81. │   f) IF-Anweisung                                                 │
  82. │                                                                   │
  83. │    ┌─────────────────────────────┐                                │
  84. │    │ Bedingung   ?               │        if Bedingung            │
  85. │    │    ──┬──────────────────────┤        T                       │
  86. │    │ ja   │       <BLOCK1>       │        <BLOCK1>                │
  87. │    │    ──┼──────────────────────┤        E                       │
  88. │    │ nein │       <BLOCK2>       │        <BLOCK2>                │
  89. │    └──────┴──────────────────────┘        #i                      │
  90. │                                                                   │
  91. │                                                                   │
  92. │   g) CASE-Anweisung                                               │
  93. │                                                                   │
  94. │    ┌─────────────────────────────┐        case Verteiler          │
  95. │    │ Verteiler   ?               │        o Fall1                 │
  96. │    │      ──┬────────────────────┤        <BLOCK1>                │
  97. │    │ Fall1  │     <BLOCK1>       │        o Fall2                 │
  98. │    │      ──┼────────────────────┤        <BLOCK2>                │
  99. │    │ Fall2  │     <BLOCK2>       │        o Fall2                 │
  100. │    │      ──┼────────────────────┤        <BLOCK2>                │
  101. │    │ Else   │     <BLOCKn>       │        O Else                  │
  102. │    └────────┴────────────────────┘        <Blockn>                │
  103. │                                           #c                      │
  104. │                                                                   │
  105. │                                                                   │
  106. │   h) ergänzende Formatierung                                      │
  107. │                                                                   │
  108. │   ┌───────────────────────────┐                                   │
  109. │   │      <TEXT1>              │        A <TEXT1>                  │
  110. │   │      -> <TEXT2>           │       +A -> <TEXT2>               │
  111. │   │      -> <TEXT3>           │       +A -> <TEXT3>               │
  112. │   └───────────────────────────┘                                   │
  113. │                                                                   │
  114. │                                                                   │
  115. │   Abb. 1  Übersicht der darstellbaren Strukturblöcke und Befehls- │
  116. │           folgen, die diese Blöcke erzeugen.                      │
  117. └───────────────────────────────────────────────────────────────────┘
  118.  
  119. Statt eines Begriffes (z.B. "WHILE") kann als Schlüsselzeichen auch nur der Anfangsbuchstabe des Begriffes (hier "W") angegeben werden. In beiden Fällen ist sowohl Groß- als auch Kleinschreibung zulässig. Das Zeichen "#" wird eingesetzt, um einen Strukturblock, der wieder andere Strukturblöcke enthalten kann, abzuschließen. Es darf nur in Verbindung mit PROGRAMM, WHILE, REPEAT, IF und CASE eingesetzt werden. Die Verwendung von "#" ist notwendig, um die Aktualisierung verschiedener Parameter (Zeilenlänge, Zeilenaufbau) zu gewährleisten.
  120.  
  121.  
  122. ═══════════════════════════════
  123. Erstellung einer Struktur-Datei
  124. ═══════════════════════════════
  125.  
  126. Die Datei, welche den Aufbau des Struktogramms enthält, kann zum einen mit einem beliebigen Texteditor (z.B. Turbo-Pascal-Editor) erstellt werden, möglich ist aber auch die Verwendung einer Pascal-Quelldatei. Jede Datenzeile einer solchen Struktur-Datei hat folgenden Aufbau :
  127.           <BLOCKZEICHEN> <TEXT>
  128. <BLOCKZEICHEN> ist ein Schlüssel für den Strukturblock und kann sowohl das Schlüsselzeichen (z.B. "C" für "CASE") als auch die Bezeichnung des Blockes sein (also "CASE"). Der Text, der in das Struktursymbol eingetragen werden soll, muß vom Blockzeichen durch mindestens ein Leerzeichen getrennt werden und darf höchstens 100 Zeichen umfassen.
  129. Sollte sich der Text nicht in einer Ausgabezeile darstellen lassen, wird er auf mehrere Zeilen verteilt. Als "Trennstelle" wird ein Leerzeichen gesucht. Verläuft die Suche negativ, so wird eine Trennung auch mitten in einem Wort vorgenommen.
  130.  
  131. Text, der in einem OF-Zweig einer CASE-Struktur einzutragen ist, darf nicht länger als 11 Zeichen sein. Das Fragezeichen in der IF- bzw. CASE-Struktur wird vom Programm eingefügt. 
  132.  
  133. Die Daten jedes einzelnen Struktogramms müssen mit der Zeile "PROGRAMM <Name>" beginnen und mit "#PROGRAMM" beendet werden. Mehrere Struktogrammbeschreibungen können so in einer Textdatei untergebracht werden, indem man nach "#PROGRAMM" mit "PROGRAMM" das nächste Struktogramm beginnt. Bild 2 zeigt die Befehlsfolge, mit der das Struktogramm aus Bild 3 erzeugt wurde.
  134.  
  135. ┌─────────────────────────────────────────────┐
  136. │  Das Programm :                             │
  137. │                                             │
  138. │  program Fakultaet;                         │
  139. │  begin                                      │
  140. │    repeat                                   │
  141. │      repeat                                 │
  142. │        readln (Zahl);                       │
  143. │        if Zahl < 0                          │
  144. │          then writeln ('Fehler');           │
  145. │      until (Zahl >= 0);                     │
  146. │      i := 2;                                │
  147. │      Produkt := 1;                          │
  148. │      while i <= Zahl do                     │
  149. │      begin                                  │
  150. │        Produkt := Produkt * i;              │
  151. │        i := i + 1;                          │
  152. │      end;                                   │
  153. │      writeln ('Fakultaet : ', Produkt);     │
  154. │    until Zahl = 0;                          │
  155. │  end.                                       │
  156. │                                             │
  157. │                                             │
  158. │  und die Struktur-Datei :                   │
  159. │                                             │
  160. │  P Fakultaet                                │
  161. │  R                                          │
  162. │  R                                          │
  163. │  U readln (Zahl)                            │
  164. │  I Zahl < 0                                 │
  165. │  T                                          │
  166. │  U writeln ('Fehler')                       │
  167. │ #I                                          │
  168. │ #R (Zahl >= 0)                              │
  169. │  A i := 2                                   │
  170. │  A Produkt := 1                             │
  171. │  W i <= Zahl                                │
  172. │  A Produkt := Produkt + 1                   │
  173. │  A i := i + 1                               │
  174. │ #W                                          │
  175. │  U writeln ('Fakultaet : ', Produkt)        │
  176. │ #R Zahl = 0                                 │
  177. │ #P                                          │
  178. │                                             │
  179. │  Abb. 2                                     │
  180. └─────────────────────────────────────────────┘
  181.  
  182. ┌──────────────────────────────────────────────────┐
  183. │ Fakultaet                                        │
  184. │ ┌─┬─┬─────┬─────────────────────────────────┬────┤
  185. │ │ │ │     │         readln (Zahl)           │    │
  186. │ │ │ ├─────┴─────────────────────────────────┴────┤
  187. │ │ │ │ Zahl < 0  ?                                │
  188. │ │ │ │    ──┬─────┬──────────────────────────┬────┤
  189. │ │ │ │ ja   │     │   writeln ('Fehler')     │    │
  190. │ │ │ └──────┴─────┴──────────────────────────┴────┤
  191. │ │ │ (Zahl >= 0)                                  │
  192. │ │ ├──────────────────────────────────────────────┤
  193. │ │ │                    i := 2                    │
  194. │ │ ├──────────────────────────────────────────────┤
  195. │ │ │                 Produkt := 1                 │
  196. │ │ ├──────────────────────────────────────────────┤
  197. │ │ │ i <= Zahl                                    │
  198. │ │ │ ┌────────────────────────────────────────────┤
  199. │ │ │ │           Produkt := Produkt * i           │
  200. │ │ │ ├────────────────────────────────────────────┤
  201. │ │ │ │                 i := i + 1                 │
  202. │ │ ├─┴───┬───────────────────────────────────┬────┤
  203. │ │ │     │writeln ('Fakultaet : ', Produkt)  │    │
  204. │ │ └─────┴───────────────────────────────────┴────┤
  205. │ │ Zahl = 0                                       │
  206. │ └────────────────────────────────────────────────┤
  207. │                                                  │
  208. └──────────────────────────────────────────────────┘
  209.    Abb. 3
  210.  
  211. ┌────────────────────────────────────┐
  212. │  POP_ERSTELLEN                     │
  213. │     │                              │
  214. │     ├─LESE_DEF                     │
  215. │     │                              │
  216. │     ├─VERWEISE_ERSTELLEN           │
  217. │     │                              │
  218. │     └─SCHREIBE_POP                 │
  219. │          │                         │
  220. │          └─SCHREIBE_POP            │
  221. │                                    │
  222. │                                    │
  223. │ Abb. 4 Programmorganisationsplan   │
  224. └────────────────────────────────────┘
  225.  
  226.  
  227. ════════════
  228. Das Programm
  229. ════════════
  230.  
  231. In den Listings sind das Hauptprogramm und die Include-Files wiedergegeben. Die Include-Files müssen unter dem in der jeweils zweiten Zeile angegebenen Namen abgespeichert werden. Das Programm wurde mit Turbo-Pascal entwickelt (s.u.), sollte aber ohne großem Aufwand an andere Dialekte angepaßt werden können. Bei Turbo-Pascal unter CP/M-Systemen muß es mit der Compiler-Option "C" kompiliert werden, um ein COM-File zu erzeugen; im "Memory"-Modus ist es nicht lauffähig.
  232.  
  233. Nach dem Start erscheint ein Menue. Es bietet folgende Möglichkeiten :
  234.  
  235.    - L : Eine Struktur-Datei wird geladen. Der Name der Datei wird ohne
  236.          die Extension (Dateityp) "STG" eingegeben. Laufwerksangaben
  237.          sind erlaubt.
  238.  
  239.    - D : Mit diesem Befehl wird ein Struktogramm auf dem augenblick-
  240.          lich aktiven Ausgabemedium (Bildschirm, Drucker, Datei)
  241.          ausgegeben. Sollte bis zu diesem Zeitpunkt noch keine Datei
  242.          geladen worden sein, wird dies nachgeholt. Erfolgt die
  243.          Ausgabe auf den Bildschirm, so kann sie mit CTRL-S angehal-
  244.          ten werden, eine beliebige Taste startet die Ausgabe wieder.
  245.          Bei Ausgabe in eine Diskettendatei wird nach deren Fertig-
  246.          stellung eine Meldung auf dem Bildschirm ausgegeben.
  247.  
  248.    - G : Mit diesem Befehl ist es möglich, sogenannte Programmorganisa-
  249.          tionspläne (POP) zu erstellen. Ein POP gibt die Reihenfolge, in 
  250.          der Prozeduren andere Prozeduren aufrufen, als Baumdiagramm wie-
  251.          der. Der POP für die Prozedur ERSTELLE_POP ist in Bild 4 dar-
  252.          gestellt. Die Darstellungsform eines POP läßt sich ebenfalls
  253.          durch die Einstellungsmöglichkeiten des Parametermenues beein-
  254.          flussen. 
  255.  
  256.    - S : Diese Option startet die Abarbeitung eines Pascal-Source-
  257.          Textes. Der Name dieser Datei muß mit einer Extension ein-
  258.          gegeben werden. Diese Quelldatei muß vom Pascal-Compiler
  259.          fehlerfrei übersetzt werden können - nur dann entstehen sinn-
  260.          volle Resultate. Zusätzlich wird, falls dies im Parameter-
  261.          Menue eingestellt wurde (s.u.) der Name einer Struktur-Datei
  262.          abgefragt, in der die Strukturdaten abgespeichert werden
  263.          sollen. Dieser Name wird ohne Extension angegeben.
  264.  
  265.    - P : Dieser Menue-Punkt dient dazu, einige Druckparameter einzu-
  266.          stellen. Diese Parameter werden in Form eines Menues
  267.          angeboten (s.u.).
  268.  
  269.    - Q : Programmende
  270.  
  271.  
  272. Im Menue wird in der Zeile "Bearbeitete Datei" der Name der Struktur-Datei eingetragen, auf die zur Zeit zugegriffen wird. Solange mit dieser Datei gearbeitet werden soll, kann man die Ausgabe des Struktogramms mit "D" veranlassen. Um diese Datei zu wechseln, muß mit dem Menuepunkt "L" ein neuer Dateiname vereinbart werden.
  273.  
  274. Bei Auswahl der "P"-Option erscheint ein weiteres Menue, mit dem die folgenden Parameter verändert werden können :
  275.  
  276.    - L : Verändert den linken Rand, ab dem die Druckausgabe beginnen
  277.          soll. Der Rand kann beim Druck in den Spalten 1...50 beginnen.
  278.          Der voreingestellte Wert ist 5.
  279.  
  280.    - Z : Verändert die Breite einer Druckzeile. Es sind Werte im Bereich
  281.          von 11...92 zugelassen. Voreingestellt ist der Wert 60.
  282.  
  283.    - F : Bestimmt, um wieviele Spalten im POP-Ausdruck die aufgerufene
  284.          Prozedur nach rechts eingerückt wird. Hier sind Werte von 2...25
  285.          zugelassen, voreingestellt ist ein Wert von 5.
  286.  
  287.    - M : Mit diesem Befehl kann man bestimmen, wieviele Datensätze ei-
  288.          ner Quell-Datei zur gleichen Zeit im Speicher gehalten werden
  289.          sollen. Es ist dann sinnvoll, den Wert zu verkleinern, wenn
  290.          es beim Abarbeiten einer Datei zu einem "Stack-Overflow" kommt.
  291.          Der voreingestellte Wert beträgt 110, er kann im Bereich von
  292.          1 bis 600 verändert werden.
  293.  
  294.    - S : Die Ausgabe wird auf den Bildschirm geleitet. Dies ist die
  295.          Voreinstellung.
  296.  
  297.    - P : Die Ausgabe wird auf den Drucker geleitet.
  298.  
  299.    - D : Die Ausgabe wird in eine Datei geleitet, deren Name eingegeben
  300.          werden muß. Der Name wird ohne Extension angegeben - es wird
  301.          standardmäßig die Extension ".PRN" ergänzt.
  302.  
  303.    - O : Die Ausgabe des Struktogramms wird unterdrückt. Diese Option
  304.          ist sinnvoll, wenn aus einem Pascaltext eine Strukturdatei er-
  305.          stellt werden soll, die vor der endgültigen Erstellung des
  306.          Struktogramms noch überarbeitet werden soll.
  307.  
  308.    - E : Hiermit wird bestimmt, ob eine Strukturdatei erzeugt wird oder
  309.          nicht. (Voreinstellung : "JA"). Diese Option ist nur in Zu-
  310.          sammenhang mit der Abarbeitung einer Pascaldatei sinnvoll.
  311.  
  312.    - G : Durch diesen Befehl wird bestimmt, ob das Struktogramm aus
  313.          Graphikzeichen oder aus normalen Textzeichen aufgebaut werden
  314.          soll.
  315.  
  316.    - Q : Rückkehr ins Hauptmenue.
  317.  
  318.  
  319. ═══════════════
  320. Fehlermeldungen
  321. ═══════════════
  322.  
  323. Fehler, welche die Daten des Struktogramms betreffen (unbekannte Schlüsselbegriffe, unzulässige Verwendung von "#" etc.) werden in einer Fehlerdatei abgelegt. Der Name ist der gleiche wie der der bearbeiteten Strukturdatei. Die Extension ist ".ERR". In der Datei wird die Fehlermeldung zusammen mit der laufenden Nummer der Zeile, in der der Fehler auftrat, abgespeichert. Die Fehlerdatei kann man sich dann zusammen mit der Strukturdatei in den Texteditor laden, um Korrekturen durchzuführen.
  324.  
  325. In diesem Zusammenhang sei nochmals darauf hingewiesen, daß STRUKTO beim Abarbeiten einer Pascaldatei voraussetzt, daß diese fehlerfrei compiliert werden kann; es führt selbst keine Plausibilitätskontrollen durch. Auftretende Fehler werden daher erst beim Ausdruck des Struktogramms erkannt. Sollten beim Erstellen des Struktogramms Fehler auftreten, so wird nach Fertigstellung des Struktogramms eine entsprechende Meldung auf dem Bildschirm ausgegeben. Bei einem Fehler, der Ein-/Ausgabeoperationen betrifft, wird auf dem Bildschirm eine Meldung ausgegeben, welche die Fehlernummer des Turbo-Pascal-Systems enthält. Diese Meldung muß mit <ESC> bestätigt werden.
  326.  
  327.  
  328. ════════════════════════════
  329. Auswerten von Pascal-Dateien
  330. ════════════════════════════
  331.  
  332. Das Programm wertet eine Pascal-Source-Datei nach folgenden Grundsätzen aus :
  333.  
  334.    - Zeichenfolgen hinter den Schlüsselwörtern PROGRAM, PROCEDURE,
  335.      FUNCTION werden als Namen abgelegt.
  336.  
  337.    - Ineinander geschachtelte Prozeduren werden, mit der innersten 
  338.      beginnend, nacheinander dargestellt.
  339.  
  340.    - FORWARD- oder EXTERNAL-deklarierte Prozeduren werden überlesen.
  341.  
  342.    - Alle auf diese Schlüsselwörter folgenden TYPE-, CONST-, VAR-, 
  343.      LABEL-Vereinbarungen werden überlesen.
  344.  
  345.    - In Kommentarzeichen eingeschlossene Zeichenfolgen werden überlesen. 
  346.      Dies gilt auch für Compiler-Anweisungen.
  347.  
  348.    - FOR-Schleifen, für die es in der Norm kein Symbol gibt, werden als 
  349.      WHILE-Schleife nachgebildet :
  350.  
  351.         FOR i := anfang TO ende do ...
  352.  
  353.      wird dargestellt als
  354.  
  355.         A i := anfang - 1
  356.         W i < ende
  357.         A i := i + 1
  358.         .....
  359.         #W
  360.  
  361.    - Die WITH-Anweisung wird überlesen.
  362.  
  363.    - Eine Zeichenfolge, die kein Schlüsselwort enthält, wird als Anweisung 
  364.      dargestellt, falls sie ein ":=" enthält, ansonsten wird sie als Un-
  365.      terprogrammaufruf behandelt.
  366.  
  367.    - Ein GOTO-Befehl wird als Anweisung mit dem Eintrag "GOTO label" aus-
  368.      gegeben. Das Label wird an der entsprechenden Stelle in den Struktur-
  369.      block eingetragen.
  370.  
  371.  
  372. ════════════════════════════════════
  373. Weiterverarbeitung der Struktogramme
  374. ════════════════════════════════════
  375.  
  376. Nachdem ein Struktogramm in eine Diskettendatei ausgegeben wurd (D-Option in der Parameterauswahl), kann es mit einem Texteditor weiterverarbeitet werden. Es ist z.B. denkbar, das Struktogramm in eine Dokumentation einzubauen. Dies ist unter CP/M nur dann problemlos möglich, wenn man die Textzeichen anstatt der Graphikzeichen zur Erstellung des Struktogramms einsetzt. Die Graphikzeichen werden von Wordstar und dem Turbo-Pascal-Editor nicht erkannt, da das Bit 7 ausgeblendet wird.
  377.  
  378.  
  379. ══════════════════════════════════════════
  380. Generieren von Programmorganisationsplänen
  381. ══════════════════════════════════════════
  382.  
  383. Das Programm setzt voraus, daß ein vollständiges Programm analysiert werden soll, nur dann sind sinnvolle Ergebnisse zu erwarten. Der Quelltext wird in zwei Durchgängen analysiert. Im ersten Durchlauf werden sämtliche Programmdefinitionen, also das Schlüsselzeichen "P", ausgewertet und in eine Namenskette eingetragen. Im zweiten Durchgang werden dann die Zeilen mit den Schlüsselzeichen "U", "A", "W", "I", "C" und "#R" darauf geprüft, ob sie Namen, die in der Namenskette enthalten sind, beinhalten.
  384.  
  385. Trifft dies zu, werden die Verweise aufgebaut, die die Aufrufe in den einzelnen Prozeduren und Funktionen wiedergeben. Nachdem alle Verweise abgearbeitet sind, werden die Verweise ausgewertet und die Druckausgabe erstellt. 
  386.  
  387. Da in der Strukturdatei keine Variablendeklarationen vorhanden sind, besteht eine Schwachstelle, die sich nur mit hohem Aufwand beheben lassen würde. Verwendet man nämlich für eine Prozedur z.B. den Namen "Name1" und verwendet diesem Namen in einer anderen Prozedur als Variable in einer Anweisung, so wird auf hierfür ein Verweis aufgebaut. 
  388.  
  389. Mehrfach auftretende Unterprogrammaufrufe (z.B. auch rekursive Aufrufe), die immer wieder selbst den gleichen Aufrufumfang haben, werden nur einmal vollständig dargestellt, sodaß sich der Umfang des Programms auf eine Mindestmaß reduzieren läßt. Genauso werden mehrfache Aufrufe derselben Prozedur in einer Prozedur als ein Aufruf dargestellt.
  390.  
  391. In diesem Prozedurpaket werden Funktionen zur Pointermanipulation verwendet. Unter MS-DOS sind dies SEG, OFS und PTR; und CP/M ORD und PTR. Das Listing zeigt die MS-DOS-Version. In der CP/M-Version müssen die in Kommentarzeichen eingeschlossenen Befehle verwendet werden. Die Compileroption A- bzw. A+ sind nur in der CP/M-Version zu verwenden.
  392.  
  393. Für Anwender mit vergleichsweise "kleinem" Hauptspeicher (ca. 64KB, wie z.B. Apple IIe) gilt es nun, einen Kompromiß zu schließen. Das COM-File alleine ist nämlich schon 31 KB groß, sodaß, nachdem die Variablen angelegt worden sind, kaum noch Speicher für die interne Verwaltung übrig bleibt. Aufgrund der Aufrufhierarchie ist es auch nicht möglich, das Overlay-Konzept zu nutzen. Um sinnvoll arbeiten zu können, sollte man die Datei STRUKTO.PAS nochmals unter dem Namen POP.PAS anlegen, um dann die Include-Anweisungen (* $I ... *) wie folgt anzupassen :
  394.     STRUKTO.PAS included STRUKTO1.PAS, STRUKTO2.PAS, STRUKTO3.PAS.
  395.     POP.PAS included STRUKTO1.PAS, STRUKTO4.PAS
  396. Darüber hinaus sollte man die Prozedur MENUE in die Datei STRUKTO.PAS aufnehmen und aus der Datei STRUKTO1.PAS (bzw. POP.PAS) löschen. Die Prozedur AUSWAHL und MENUE können dann entsprechend angepaßt werden : in STRUKTO.PAS ist 'D', 'S', 'L', 'P' und 'Q' erlaubt, in POP.PAS 'G', 'L', 'P' und 'Q'.
  397.  
  398.  
  399. ══════════════
  400. Systemumgebung
  401. ══════════════
  402.  
  403. Das Programm wurd mit Turbo-Pascal 3.0 entwickelt. Es enthält nur wenige systemabhängige Variable, die nachstehend erläutert werden sollen.
  404.  
  405. Die Druckersteuerzeichen sind speziell an den EPSON-RX80 angepaßt.
  406. Dieser Drucker kann einen EPSON-spezifischen Graphikzeichensatz ausdrucken (2). Diese Fähigkeit wird vom Programm ausgenutzt. Für IBM-kompatible Geräte können stattdessen in der Prozedur "INIT-GRAPHIK" die Werte gemäß Bild 6 eingesetzt werden. Beim Einsatz eines Druckers, der Graphikzeichen zur Verfügung stellt, sollte man in der Prozedur "INIT" der Variabeln "ZEICHENSATZ" den Wert "GRAPHIK" zuweisen und den Prozeduraufruf "INIT-TEXT" durch "INIT-GRAPHIK" ersetzen.
  407.  
  408. ┌──────────────────────────────────────────────┐
  409. │                                              │
  410. │  Variable    Zeichen Apple  IBM  Textzeichen │
  411. │  ------------------------------------------- │
  412. │  Kreuz          ┼     128   197      +       │
  413. │  Kreuzoben      ┬     130   194      +       │
  414. │  Kreuzunten     ┴     129   193      +       │
  415. │  Kreuzrechts    ┤     131   180      +       │
  416. │  Kreuzlinks     ├     132   195      +       │
  417. │  Waagerecht     ─     133   196      -       │
  418. │  Senkrecht      │     134   179      I       │
  419. │  Obenlinks      ┌     135   218      +       │
  420. │  Obenrechts     ┐     136   191      +       │
  421. │  Untenlinks     └     137   192      +       │
  422. │  Untenrechts    ┘     138   217      +       │
  423. │                                              │
  424. │  Abb. 6                                      │
  425. └──────────────────────────────────────────────┘
  426.  
  427.  
  428. Weitere Druckbefehle werden in der Prozedur DRUCKER-STEUERUNG eingesetzt. Ihre Funktionen sind in Kommentaren angegeben, um die Anpassung an andere Drucker zu erleichtern.
  429.  
  430. Unter CP/M und Turbo-Pascal 2.0 funktioniert die Prozedur RELEASE nicht korrekt. Stattdessen muß - einem Vorschlag der Fa. Heimsoeth folgend  - die Ersatzprozedur RELEASE implementiert werden (Bild 7).
  431.  
  432.  
  433. ┌─────────────────────────────────────────────────────┐
  434. │ (* ----- Release fuer Turbo-Pascal 2.0 --- *)       │
  435. │ procedure Release (AHeapPointer : Integer_Pointer)  │; 
  436. │                                                     │
  437. │ var Frei : integer;                                 │
  438. │     HP   : integer absolute AHeapPointer;           │
  439. │                                                     │
  440. │ begin                                               │
  441. │   Frei := abs (HP - AHeapPointer);                  │
  442. │   freemem (AHeapPointer, Frei);                     │
  443. │                                                     │
  444. │ end;    (* Release *)                               │
  445. │                                                     │
  446. │ Abb. 7  RELEASE-Ersatzprozedur                      │
  447. └─────────────────────────────────────────────────────┘
  448.  
  449. ═══════════
  450. Literatur :
  451. ═══════════
  452.  
  453. (1) Althöfer, U., Computergerechte Flußdiagramme, Elektronik 14/85,
  454.     S.89
  455. (2) EPSON-Drucker-Handbuch
  456.