path: root/app/gs.warenhaus/1.01/doc/gs-Warenhaus-6

#limit (11.0)##pagelength (16.5)##block#                                   
#start (2.0,0.0)# 
#page (61)# 
#headodd# 
#center#gs-Warenhaus#right#% 
 
#end# 
#headeven# 
%#center#gs-Warenhaus
 
#end# 
#center#1 
 
#center##on("b")#6  Beschreibung der Programmierschnittstelle#off("b")# 
 
 
In allen GRIN-Projekten soll - zumindest als Erweiterung - der Aspekt des
"algorithmischen Problemlösens" mit in den Unterricht eingebracht werden. Deshalb
ist auch in dem Soester Programm zum Projekt WARENHAUS eine Programmier­
schnittstelle realisiert, die es erlaubt, mit Hilfe eines eng begrenzten Befehlssatzes
kleine Programme zur Steuerung der Abläufe im Modell-Warenhaus zu schreiben. 
 
Wir haben lange überlegt, ob wir diese Programmierschnittstelle überhaupt nach­
bilden sollten, weil wir der Meinung sind, daß beim Projekt WARENHAUS das
algorithmische Problemlösen, wenn überhaupt, nur eine sehr untergeordnete Rolle
spielt. Als Randproblematik kann man hier vielleicht untersuchen, wie die Menu-
Funktionen unter dem Oberbegriff 'Kommandos' (vgl. Kapitel 5.4) aufgebaut sind,
und man kann versuchen, diese in eigenen kleinen Programmen nach- oder umzu­
bilden. 
 
Unser zweites Problem war, ob wir uns bei einer eventuellen Nachbildung der
Programmierschnittstelle auch wirklich streng an die Soester Vorgaben halten sollten,
auch wenn sie unseren Vorstellungen und Konzepten teilweise zuwiderlaufen. Eigent­
lich sind wir der Meinung, daß uns mit der Programmiersprache ELAN bereits ein
ausgezeichnetes Hilfsmittel zur Verfügung steht, um auch in der Sekundarstufe I in
das algorithmische Problemlösen einzuführen. Gerade das Refinementkonzept - die
Methode der 'schrittweisen Verfeinerung' / der "Modularisierung im Kleinen" -
scheint uns besonders geeignet, typische Denkweisen des algorithmischen Problem­
lösens offenzulegen. Lediglich die Konstruktion einer Zählschleife und den Umgang
mit den Fehlermeldungen des ELAN-Compilers halten wir bei Anfängern für etwas
problematisch. 
 
Wir haben uns deshalb entschlossen, Ihnen die Programmierschnittstelle in zwei
Versionen zur Verfügung zu stellen: In der 'ELAN-Version' können Sie in der üblichen
#page# 
ELAN-Umgebung programmieren; das bietet sich z.B. an, wenn Sie #on("b")#gs-Warenhaus#off("b")#
im Wahlpflichtbereich bzw. im Differenzierungsbereich 9/10 einsetzen möchten. Es
ist dann dort nicht nötig, erst eine neue, weniger komfortable "Programmiersprache"
zu erlernen. 
 
Für den GRIN-Bereich enthält #on("b")#gs-Warenhaus#off("b")# eine weitere Programmierebene
('GRIN-Version'), die an die Soester Vorgaben angelehnt ist, und die es erlaubt, die
dort benutzten Schreibweisen von Befehlen und Kontrollstrukturen zu übernehmen.
Allerdings haben wir dabei eine grundsätzliche Änderung bezüglich der Modularisie­
rungsmöglichkeit von 'GRIN-Programmen' vorgenommen, auf die wir in Kapitel 6.1
näher eingehen werden. 
 
Ein 'GRIN-Programm' wird bei der Ausführung des Menupunktes 's Starten' (vgl.
Kapitel 5.5) zunächst in ein ELAN-Programm übersetzt und dabei auf formale
Korrektheit überprüft. Werden keine Fehler festgestellt, so wird nun seinerseits das
ELAN-Programm vom Compiler übersetzt und anschließend ausgeführt. Als Benutzer
werden Sie dabei nicht mit Fehlermeldungen des Compilers konfrontiert, da der
#on("b")#gs-Warenhaus#off("b")#-Übersetzer vorher alle formalen Fehler abfängt und zum Korrigieren
anbietet. 
 
Sollte das System nach erfolgreicher Übersetzung und/oder Compilation bei der
Ausführung des Programms einen Fehler "bemerken" (z.B. falscher Aufruf eines
Befehles), so wird das Programm automatisch abgebrochen und die entsprechende
Fehlermeldung mit der Nummer der Programmzeile, in der der Fehler bemerkt
wurde, im unteren Teil des Bildschirmes in einem 'notebook' gezeigt. Im oberen Teil
wird das Programm zum Verbessern angeboten, wobei der Cursor am Anfang der
fehlerhaften Zeile steht (gilt auch für die 'ELAN-Version'). 
 
In beiden Versionen der Programmierschnittstelle ist die Schreibweise der Befehle bis
auf die Groß- und Kleinschreibung identisch. Folgende Befehle stehen zu Verfügung: 
#page# 
      GRIN-Version      |       ELAN-Version 
------------------------+------------------------------
  Artikelnummer lesen   |   artikelnummer lesen 
  Artikeldaten eingeben |   artikeldaten eingeben 
  Kundennummer lesen    |   kundennummer lesen 
  Kundendaten eingeben  |   kundendaten eingeben 
  neues Blatt           |   neues blatt 
  Rechnungskopf         |   rechnungskopf 
  Artikel kaufen        |   artikel kaufen 
  Abrechnung            |   abrechnung 
  Auskunft              |   auskunft 
  Bildschirm neu        |   bildschirm neu 
                        |   nachbestellen 
                        |   dezimalwert lesen 
                        |   bitmuster lesen 
                        |
 
 
Die drei letzten Befehle der ELAN-Version haben wir in den GRIN-Befehlssatz nicht
mit aufgenommen, weil wir hier den Befehlssatz möglichst klein (und damit über­
sichtlich) halten wollten und diese Befehle bereits unter dem Oberbegriff
'Kommandos' als Menu-Funktionen zur Verfügung stehen. (Ebenso könnte man bei
dem Befehl 'Auskunft' argumentieren. Die entsprechende Menu-Funktion 'Auskunft
einholen' liefert bei jeder Anwahl jedoch immer nur #on("b")#eine#off("b")# Auskunft; in einem
Programm kann man nun die Ausgabe mehrerer Auskünfte hintereinander
realisieren.) 
 
Die genaue Wirkung der Befehle werden wir in Kapitel 6.3 noch detailliert
beschreiben. Sie entsprechen im wesentlichen den Soester Befehlen, die im
WARENHAUS-Begleitheft des LSW (siehe Anhang) auf den Seiten 99/100 aufgelistet
sind. (Die anderen dort zu findenden Befehle gehören eigentlich nicht in die Befehls­
liste der Programmierschnittstelle, weil sie nicht von Programmen aus sondern nur in
einem 'Direktbefehgs-Modus' als Kommando aufrufbar sind! Diese Befehle sind auch
#page# 
#on("b")#keine#off("b")# Programmierbefehle im eigentlichen Sinne, sondern entweder "Macros" zum
"Handling" des Warenhausmodells oder Systemkommandos. #on("b")#gs-Warenhaus#off("b")# stellt
diese Befehle unter ähnlichen Namen als Menu-Funktionen zur Verfügung.) 
 
 
 
#on("b")#6.1  Schreibweisen und Syntaxregeln in GRIN-Programmen#off("b")# 
 
Die Regeln, die beim Schreiben eines ELAN-Programms zu beachten sind, werden im
EUMEL/ELAN-Benutzerhandbuch beschrieben; wir werden uns daher hier auf die
GRIN-Version konzentrieren. 
 
Beginnen wir mit einem Beispiel aus dem WARENHAUS-Begleitheft des LSW. Dort
finden Sie auf Seite 70 (unten) das folgende Programm: 
 
#on("b")#
   PROGRAMM Rechnung schreiben 
     neues Blatt 
     Kundennummer lesen 
     WENN nicht Stoptaste gedrückt 
       Rechnungskopf 
       WIEDERHOLE 
         Artikelnummer lesen 
         WENN nicht Stoptaste gedrückt 
           Artikel kaufen 
         ENDE WENN 
       BIS Stoptaste gedrückt 
       Abrechnung 
     ENDE WENN 
   ENDE PROGRAMM #off("b")# 
 
Sie können dieses Programm ohne Änderungen übernehmen und starten,
#on("b")#gs-Warenhaus#off("b")# wird es ohne Beanstandungen ausführen. Bezüglich der Übersicht­
lichkeit und des Programmierstils kann man hier sicher geteilter Meinung sein,
darauf gehen wir später noch ein. 
#page# 
Wir möchten Ihnen zunächst einige Regeln zur Schreibweise und Syntax in 'GRIN-
Programmen' aufzeigen, die sich im obigen Beispiel-Programm beobachten lassen: 
 
-  In jeder Zeile darf nur #on("b")#ein#off("b")# Befehl stehen; Befehgs-Trennzeichen (wie etwa das
   Semikolon in ELAN) werden deshalb nicht verwendet. Leerzeichen können
   beliebig gesetzt werden, auch leere Zeilen sind zulässig, nicht jedoch
   Kommentare. 
 
-  Das Arbeiten mit Variablen (gleich welcher Art) ist #on("b")#nicht#off("b")# möglich; alle Befehle
   sind datentypfrei. 
 
-  Schlüsselworte für Kontrollstrukturen (wie z.B. WIEDERHOLE, WENN etc.)
   werden in GROSSBUCHSTABEN geschrieben, Ausführungsbefehle und
   Bedingungen hingegen klein und gemäß den Regeln der deutschen Sprache mit
   großem Anfangsbuchstaben bei Substantiven. Diese Festlegung bezüglich der
   Groß- und Kleinschreibung ist bei den von #on("b")#gs-Warenhaus#off("b")# zur Verfügung ge­
   stellten Befehlen #on("b")#verbindlich#off("b")#, d.h. alle Warenhaus-#on("b")#Grund#off("b")#befehle und Kontroll­
   strukturen müssen (bis auf Leerzeichen) genauso geschrieben werden, wie sie in
   den Kapiteln 6.2 und 6.3 vorgegeben werden! (In der Soester Software können
   dagegen Groß- und Kleinbuchstaben beliebig verwendet werden, sodaß dort z.B.
   neben 'neues Blatt' auch 'neues blatt', "NEueS BlaTT" u.ä. als identisch ange­
   sehen werden.) 
 
-  Jedes 'GRIN-Programm' beginnt mit dem 'Schlüsselwort' <PROGRAMM>,
   gefolgt von einem Programmnamen, der beliebig gewählt werden kann, jedoch
   noch in diese Zeile passen muß. Sinnvoll ist es, hier z.B. den Namen der
   Programmdatei einzutragen. 
 
-  Jedes 'GRIN-Programm' endet mit der Zeile <ENDE PROGRAMM>. Nach dieser
   Zeile dürfen nur noch leere Zeilen folgen, es sei denn zwischen <PROGRAMM
   Programmname> und <ENDE PROGRAMM> wurden Befehle benutzt, die
   nicht zum Warenhaus-Grundbefehlssatz gehören. Solche Befehle müssen in einer
   'Befehlserklärung' nach Programmende definiert werden. 
#page# 
Das obige Programm befriedigt vom äußeren Erscheinungbild her einen PASCAL-
Programmierer wahrscheinlich völlig, einen ELAN-Verwöhnten jedoch sicher nicht.
Die Soester WARENHAUS-Software bietet keinerlei Möglichkeit der Modularisierung
#on("b")#innerhalb#off("b")# eines Programms (Refinement-/Prozedurkonzept o.ä.). Es gibt dort nur die
Möglichkeit, fertiggestellte Programme unter dem Programmnamen dem Basis­
befehlssatz "hinzuzufügen" - ein Vorgang, der dem Insertieren unter EUMEL/ELAN
ähnelt. Obwohl es unter EUMEL/ELAN ein leichtes gewesen wäre, diese Möglichkeit
ebenfalls zu realisieren, haben wir davon Abstand genommen, weil auf diese Weise an
jedem Arbeitsplatz eine "eigene" Programmierumgebung entstehen würde. Wir sind
der Meinung, daß für Schüler der Sekundarstufe I eine #on("b")#feste Modellumgebung als
Basis#off("b")# vorhanden sein muß. Außerdem erscheint uns bei der Programmierung "im
Kleinen" die "Bottom-Up"-Technik  unangemessen und für den Anfänger viel zu
unübersichtlich zu sein; viel eher wäre hier die "Top-Down"-Methode angebracht. Wir
haben daher die Programmierumgebung in anderer Richtung erweitert und eine
Modularisierungsmöglichkeit realisiert, die dem Refinementkonzept nachempfunden
ist und damit unseren didaktisch-methodischen Vorstellungen viel eher entspricht. 
 
Bei #on("b")#gs-Warenhaus#off("b")# werden etwa benutzte 'eigene' Befehle #on("b")#innerhalb derselben#off("b")#
Programmdatei 'erklärt' und zwar #on("b")#nach#off("b")# dem Ende des eigentlichen 'Haupt­
programms', d.h. also nach der Zeile <ENDE PROGRAMM>. Mit Hilfe dieser Mög­
lichkeit könnte das obige Programm besser strukturiert etwa so aussehen: 
 
#on("b")#
   PROGRAMM Rechnung schreiben 
     neues Blatt 
     Kundennummer lesen 
     WENN nicht Stoptaste gedrückt 
       einkaufen mit Rechnung 
     ENDE WENN 
   ENDE PROGRAMM 
 
   einkaufen mit Rechnung: 
     Rechnungskopf 
     WIEDERHOLE 
       Artikelnummer lesen 
       Artikel eventuell kaufen 
     BIS Stoptaste gedrückt 
     Abrechnung 
#page# 
   Artikel eventuell kaufen: 
     WENN nicht Stoptaste gedrückt 
       Artikel kaufen 
     ENDE WENN 
#off("b")# 
 
 
Sie sehen, das Programm ist so zwar etwas länger, aber erheblich übersichtlicher
geworden. Für 'neue Befehle' und die zugehörigen 'Befehlserklärungen' gelten
folgende Grundsätze: 
 
-  Die 'Befehlserklärungen' müssen #on("b")#nach#off("b")# <ENDE PROGRAMM> aufgelistet
   werden. Die Reihenfolge ist beliebig. 
 
-  Eine 'Befehlserklärung' besteht aus dem zu erklärenden Befehl in (bis auf Leer­
   zeichen) völlig identischer Schreibweise (!) und einem nachfolgenden Doppel­
   punkt (:). 
 
-  Ein 'neuer Befehl' darf alle möglichen Zeichen enthalten außer einem Doppel­
   punkt (:). Außerdem darf solch ein Befehl #on("b")#nicht#off("b")# mit einem 'Schlüsselwort'
   beginnen (vgl. Kapitel 6.2). 
 
-  In 'Befehlserklärungen' können neben den Grundbefehlen auch wieder 'neue
   Befehle' benutzt werden, die dann wiederum erklärt werden müssen. 
 
-  Befehle dürfen nur #on("b")#einmal#off("b")# erklärt werden, auch wenn sie mehrfach benutzt
   werden. 
 
-  Es dürfen nur Befehle erklärt werden, die irgendwo auch wirklich benutzt
   werden. 
 
-  Befehlserklärungen sind nur möglich für #on("b")#Ausführungs-Befehle#off("b")#. Es lassen sich
   also z.B. keine neuen Bedingungen oder Kontrollstrukturen erklären! 
 
-  Es dürfen innerhalb eines Programms maximal 20 verschiedene 'neue Befehle'
   verwendet werden. (Diese Grenze dürfte in Warenhaus-Programmen kaum ein­
   mal erreicht werden!) 
#page# 
Formale Verstöße gegen diese Regeln werden bei dem Übersetzungsvorgang sofort
beim Auftauchen des ersten Fehlers zur Korrektur angeboten. Dabei wird in der
oberen Bildschirmhälfte das Programm editiert, wobei der Cursor an den Anfang der
Zeile gesetzt wird, in der sich der (erste) Fehler befindet. In der unteren Bildschirm­
hälfte wird über den Paralleleditor in einem 'notebook' die Art des Fehlers mit An­
gabe der Zeilennummer genauer beschrieben. 
 
In der Regel wird hier nur auf #on("b")#einen#off("b")# (nämlich den ersten auftauchenden) Fehler
hingewiesen, so daß Sie das Programm evtl. mehrfach starten müssen, bis alle Fehler
erkannt und beseitigt sind. Manchmal tauchen im Fehler-'notebook' aber auch
mehrere Fehlermeldungen auf (z.B. wenn 'neue Befehle' nicht erklärt oder erklärte
Befehle nicht benutzt wurden). In Extremfällen kann es dabei dazu kommen, daß
nicht mehr das ganze Fehler-'notebook' auf dem Bildschirm sichtbar ist. In diesem
Fall können Sie mit der Tastenfolge <ESC><w> den Cursor zwischen den beiden
Bildschirmhälften hin- und herschalten und mit den Pfeiltasten evtl. nicht-sichtbare
Teile des 'notebooks' oder der Programmdatei auf den Bildschirm holen. (Für
genauere Informationen über den Umgang mit dem EUMEL-Editor lesen Sie bitte im
EUMEL-Benutzerhandbuch nach.) 
 
 
#on("b")#6.2  Kontrollstrukturen#off("b")# 
 
Sowohl in ELAN-Programmen, als auch in GRIN-Programmen werden Kontroll­
strukturen durch 'Schlüsselworte' gekennzeichnet, die grundsätzlich in
GROSSBUCHSTABEN geschrieben werden müssen, um sie deutlich gegenüber Aus­
führungsbefehlen und Bedingungen abzuheben. In GRIN-Programmen gibt es
Schlüsselworte für den Anfang und das Ende eines Programms sowie für Schleifen
und einseitige Abfragen. Wir notieren hier nur die in GRIN-Programmen möglichen
Kontrollstrukturen und geben, wenn vorhanden, die zugehörige ELAN-Übersetzung in
Klammern an. 
 
 
#on("b")#Programm-Anfang/Ende:#off("b")# 
 
   #on("b")#PROGRAMM#off("b")# <Programmname> 
     <Anweisung 1> 
     <Anweisung 2> 
          . 
          . 
   #on("b")#ENDE PROGRAMM#off("b")# 
 
 
Jedes GRIN-(Haupt-)Programm beginnt mit dem Schlüsselwort 'PROGRAMM', gefolgt
von einem frei wählbaren Programmnamen, der jedoch in dieselbe Zeile passen
muß. Die Zeile 'ENDE PROGRAMM' zeigt das Ende eines GRIN-(Haupt-)Programms
an. Sowohl 'PROGRAMM', als auch 'ENDE PROGRAMM' dürfen in einer Programm­
datei nur #on("b")#einmal#off("b")# verwendet werden. Entsprechende Schlüsselworte in ELAN-
Programmen gibt es nicht. 
 
 
#on("b")#Schleifen:#off("b")# 
 
Schleifen müssen innerhalb des Hauptprogramms oder der Befehlserklärung, in der
sie geöffnet werden, auch wieder geschlossen werden. Schachtelungen sind zwar
zulässig, sollten aber aus Gründen der Übersichtlichkeit vermieden werden. Soll
dennoch innerhalb einer Schleife eine weitere Schleife verwendet werden, so sollte die
innere Schleife über einen 'neuen Befehl' in eine Befehlserklärung 'ausgelagert'
werden. Folgende Schleifenarten sind möglich: 
 
a) Zählschleife: 
 
   #on("b")#WIEDERHOLE#off("b")# <n> #on("b")#MAL#off("b")#    (ELAN: INT VAR i; 
     <Anweisung 1>              FOR i FROM 1 UPTO n REPEAT 
     <Anweisung 2>                . 
          .                       . 
          .                       . 
   #on("b")#ENDE WIEDERHOLE#off("b")#              END REPEAT) 
 
 
Die Anweisungen innerhalb der Schleife werden <n> - mal ausgeführt. 
 
 
b) Schleife mit Ausgangsbedingung: 
 
 
   #on("b")#WIEDERHOLE#off("b")#            (ELAN: REPEAT 
     <Anweisung 1>                . 
     <Anweisung 2>                . 
          .                       . 
          .                       . 
   #on("b")#BIS#off("b")# <Bedingung>              UNTIL bedingung END REPEAT) 
 
 
Die Anweisungen innerhalb der Schleife werden mindestens einmal ausgeführt und
dann solange wiederholt, bis die Bedingung erfüllt ist. Bei der Programmierung ist
darauf zu achten, daß durch die Anweisungen die Bedingung erfüllt werden kann,
denn sonst ist das Resultat eine 'Endlosschleife', deren Ausführung nur durch einen
totalen Programmabbruch (<ESC><h>) beendet werden kann. 
 
 
c) Zählschleife mit Ausgangsbedingung: 
 
 
   #on("b")#WIEDERHOLE#off("b")# <n> #on("b")#MAL#off("b")#    (ELAN: INT VAR i; 
     <Anweisung 1>              FOR i FROM 1 UPTO n REPEAT 
     <Anweisung 2>                . 
          .                       . 
          .                       . 
   #on("b")#BIS#off("b")# <Bedingung>              UNTIL bedingung END REPEAT) 
 
 
Die Anweisungen innerhalb der Schleife werden <n>-mal ausgeführt. Im Gegensatz
zur reinen Zählschleife können die Wiederholungen jedoch vorzeitig abgebrochen
werden, nämlich dann, wenn nach irgendeinem Schleifendurchlauf die Bedingung
erfüllt ist. 
 
 
d) Endlosschleife: 
 
 
   #on("b")#WIEDERHOLE#off("b")#            (ELAN: REPEAT 
     <Anweisung 1>                . 
     <Anweisung 2>                . 
          .                       . 
          .                       . 
   #on("b")#ENDE WIEDERHOLE#off("b")#              END REPEAT) 
 
 
Die Anweisungen innerhalb der Schleife werden immer wieder ausgeführt. Da keine
begrenzte Anzahl von Durchläufen und auch keine Abbruchbedingung angegeben ist,
kann diese Schleife nur durch einen totalen Programmabbruch (<ESC><h>)
beendet werden. 
 
(Die Schleifenarten c) und d) sind in der Soester WARENHAUS-Software nicht vor­
 handen, ergaben sich bei der Konstruktion des #on("b")#gs-Warenhaus#off("b")#-Übersetzers wegen
 der analogen Strukturen in ELAN jedoch quasi "von selbst", so daß wir sie auch
 zugelassen haben. Schleifen mit Eingangsbedingung (ELAN: WHILE bedingung
 REPEAT ... END REPEAT) sind für GRIN-Programme jedoch nicht realisiert.) 
 
 
#on("b")#Einseitige Abfragen:#off("b")# 
 
 
   #on("b")#WENN#off("b")# <Bedingung>      (ELAN: IF bedingung 
     <Anweisung 1>                 THEN anweisung 1; 
     <Anweisung 2>                      anweisung 2; 
          .                                 . 
          .                                 . 
   #on("b")#ENDE WENN#off("b")#                    END IF) 
 
 
Die Anweisungen werden nur ausgeführt, wenn die Bedingung erfüllt ist. (Eine Ent­
sprechung zu der in ELAN möglichen 'zweiseitigen Abfrage' (IF ... THEN ... ELSE ...
END IF) gibt es in der GRIN-Version nicht!) 
 
Eine im Hauptprogramm oder in einer Befehlserklärung begonnene Abfrage ('WENN
...') muß auch im selben Programmteil wieder beendet werden. Ähnlich wie bei
Schleifen ist die Schachtelung von Abfragen innerhalb des Hauptprogramms oder
einer Befehlserklärung zwar zulässig, führt aber zu unübersichtlichen Programmen.
Auch hier sollte man innerhalb einer Abfrage eventuell notwendige weitere Abfragen
durch 'neue Befehle' in Befehlserklärungen auslagern. 
 
 
#on("b")#Zulässige Bedingungen:#off("b")# 
 
#on("b")#Stoptaste gedrückt#off("b")#    (ELAN: stoptaste gedrückt) 
 
   Die Bedingung ist erfüllt (d.h. liefert den Wert 'wahr'), wenn während des bis­
   herigen Programmablaufs die Tastenfolge <ESC><q> getippt worden ist;
   sonst ist sie nicht erfüllt (Wahrheitswert 'falsch'). (Das Tippen von <ESC><q>
   beim Verlassen einer Datei hat jedoch #on("b")#keinen#off("b")# Einfluß auf den Wahrheitswert der
   Bedingung!) 
 
   Bei jeder Ausführung der Befehle 'Artikelnummer lesen', 'Kundennummer lesen'
   und 'Auskunft' wird der Wahrheitswert der Bedingung zunächst immer auf
   'falsch' gesetzt (siehe 6.3), so daß die Abfrage der Bedingung nach einem dieser
   Befehle nur dann 'wahr' liefert, wenn #on("b")#während#off("b")# oder #on("b")#nach#off("b")# der letztmaligen Aus­
   führung eines der drei Befehle <ESC><q> getippt wurde; ein etwa vorher
   erfolgtes Tippen dieser Tastenfolge ist somit wirkungslos! 
 
 
#on("b")#nicht Stoptaste gedrückt#off("b")#    (ELAN: NOT stoptaste gedrückt) 
 
   Dieses ist das logische Gegenteil von 'Stoptaste gedrückt': 'nicht Stoptaste ge­
   drückt' ist erfüllt, wenn 'Stoptaste gedrückt' #on("b")#nicht#off("b")# erfüllt ist und umgekehrt. 
 
Um Probleme bei der Arbeit mit Terminals zu vermeiden, die nicht über den
deutschen Zeichensatz verfügen (Umlaute!), ist bei beiden Bedingungen auch die
Schreibweise 'gedrueckt' erlaubt. 
 
 
 
#on("b")#6.3  Detailbeschreibung der Warenhaus-Grundbefehle#off("b")# 
 
Wie bereits in 6.1 erwähnt, ist die im folgenden vorgegebene Schreibweise der Grund­
befehle bezüglich Groß- und Kleinschreibung verbindlich; Leerzeichen dagegen
können beliebig eingefügt oder auch weggelassen werden. Fett gedruckt steht immer
der GRIN-Befehl, in Klammern dahinter der zugehörige ELAN-Befehl. 
 
 
#on("b")#Artikelnummer lesen#off("b")#  (ELAN: artikelnummer lesen) 
 
  -  Der Wahrheitswert der Bedingung 'Stoptaste gedrückt' wird zunächst auf
     'falsch' gesetzt. 
  -  Der Benutzer wird aufgefordert, eine Artikelnummer einzugeben. Je nach
     Einstellung der 'Eingabeart' (vgl. Kapitel 5.3) erfolgt die Eingabe durch Ein­
     tippen einer Zahl über die Tastatur oder durch Einschieben einer Warenkarte
     in das Lesegerät. Eingaben über die Tastatur sind mit <RETURN> abzu­
     schließen. Akzeptiert werden nur Werte von 1 bis 15, ansonsten erfolgt eine
     Warnung, und die Eingabe wird wiederholt. 
  -  Durch Tippen der Tastenfolge <ESC><q> kann dieser Befehl abgebrochen
     werden, ohne daß eine Artikelnummer eingelesen wird. In diesem Falle wird
     der Wahrheitswert der Bedingung 'Stoptaste gedrückt' auf 'wahr' gesetzt, sonst
     bleibt der Wert auf 'falsch'. 
  -  Durch Tippen der Tastenfolge <ESC><h> wird die Ausführung des
     gesamten Programms abgebrochen. 
 
 
#on("b")#Artikeldaten eingeben#off("b")#  (ELAN: artikeldaten eingeben) 
 
  -  Der Befehl setzt voraus, daß zuvor eine Artikelnummer eingelesen wurde,
     ansonsten erfolgt eine entsprechende Fehlermeldung. 
  -  Die Angaben zu einem Artikel (Name, Preis, Mindestbestand, Bestand) können
     eingegeben bzw. verändert werden. 
  -  Alle Eingaben sind mit <RETURN> oder der Tastenfolge <ESC><q>
     abzuschließen. Durch <ESC><q> wird der Wahrheitswert der Bedingung
     'Stoptaste gedrückt' auf 'wahr' gesetzt. 
  -  Nach Abschluß der Eingaben werden die Artikeldaten in der Filial-Verwaltung
     gespeichert, worauf auch kurz hingewiesen wird. 
  -  Durch Tippen der Tastenfolge <ESC><h> während der Eingaben wird die
     Ausführung des gesamten Programms abgebrochen. 
 
 
#on("b")#Kundennummer lesen#off("b")#  (ELAN: kundennummer lesen) 
 
  -  Der Wahrheitswert der Bedingung 'Stoptaste gedrückt' wird zunächst auf
     'falsch' gesetzt. 
  -  Der Benutzer wird aufgefordert, eine Kundennummer einzugeben. Je nach
     Einstellung der 'Eingabeart' (vgl. Kapitel 5.3) erfolgt die Eingabe durch Ein­
     tippen einer Zahl über die Tastatur oder durch Einschieben einer Kundenkarte
     in das Lesegerät. Eingaben über die Tastatur sind mit <RETURN> abzu­
     schließen. Akzeptiert werden nur Werte von 129 bis 159, ansonsten erfolgt eine
     Warnung, und die Eingabe wird wiederholt. 
  -  Durch Tippen der Tastenfolge <ESC><q> kann dieser Befehl abgebrochen
     werden, ohne daß eine Kundennummer eingelesen wird. In diesem Falle wird
     der Wahrheitswert der Bedingung 'Stoptaste gedrückt' auf 'wahr' gesetzt, sonst
     bleibt der Wert auf 'falsch'. 
  -  Durch Tippen der Tastenfolge <ESC><h> wird die Ausführung des
     gesamten Programms abgebrochen. 
 
 
#on("b")#Kundendaten eingeben#off("b")#  (ELAN: kundendaten eingeben) 
 
  -  Der Befehl setzt voraus, daß zuvor eine Kundennummer eingelesen wurde,
     ansonsten erfolgt eine entsprechende Fehlermeldung. 
  -  Die Angaben zu einem Kunden (Name, Vorname, Geschlecht) können einge­
     geben bzw. verändert werden. 
  -  Alle Eingaben sind mit <RETURN> oder der Tastenfolge <ESC><q>
     abzuschließen. Durch <ESC><q> wird der Wahrheitswert der Bedingung
     'Stoptaste gedrückt' auf 'wahr' gesetzt. 
  -  Nach Abschluß der Eingaben werden die Kundendaten sowohl in der Filial-
     Verwaltung als auch in der Zentrale gespeichert, worauf auch kurz hingewiesen
     wird. 
  -  Durch Tippen der Tastenfolge <ESC><h> während der Eingaben wird die
     Ausführung des gesamten Programms abgebrochen. 
 
 
#on("b")#neues Blatt#off("b")#  (ELAN: neues blatt) 
 
  -  Das Rechnungsfenster auf dem Bildschirm wird gelöscht. 
  -  Für die Ausgabe der nächsten Rechnung auf dem Drucker wird eine neue
     Rechnungsdatei bereitgestellt. 
 
 
#on("b")#Rechnungskopf#off("b")#  (ELAN: rechnungskopf) 
 
  -  Ein Rechnungskopf wird auf dem Bildschirm ausgegeben. Falls zuvor eine
     Kundenummer eingelesen worden ist, unter der bereits Kundendaten einge­
     geben wurden, erscheint der Name des betreffenden Kunden im Rechnungs­
     kopf. 
  -  Der Rechnungskopf wird für einen eventuellen späteren Ausdruck in die
     Rechnungsdatei geschrieben. 
 
 
#on("b")#Artikel kaufen#off("b")#  (ELAN: artikel kaufen) 
 
  -  Der Befehl setzt voraus, daß zuvor eine Artikelnummer eingelesen worden ist,
     ansonsten erfolgt eine entsprechende Fehlermeldung. 
  -  Artikelname und -preis werden auf den Bildschirm und in die Rechnungsdatei
     geschrieben. 
  -  Der Kauf wird intern in den entsprechenden Filial-Dateien registriert. 
 
 
#on("b")#Abrechnung#off("b")#  (ELAN: abrechnung) 
 
  -  Die Preise der gekauften Artikel werden addiert. 
  -  Die Summe wird auf dem Bildschirm angezeigt und in die Rechnungsdatei
     geschrieben. 
  -  Der Benutzer wird gefragt, ob die Rechnung ausgedruckt werden soll. 
 
 
#on("b")#Auskunft#off("b")#  (ELAN: auskunft) 
 
  -  Der Wahrheitswert der Bedingung 'Stoptaste gedrückt' wird zunächst auf
     'falsch' gesetzt. 
  -  Der Benutzer wird aufgefordert, eine Codenummer einzugeben. Je nach Ein­
     stellung der 'Eingabeart' (vgl. Kapitel 5.3) erfolgt die Eingabe durch Eintippen
     einer Zahl über die Tastatur oder durch Einschieben einer Codekarte in das
     Lesegerät. Eingaben über die Tastatur sind mit <RETURN> abzuschließen.
     Akzeptiert werden nur zulässige Werte, ansonsten erfolgt eine Warnung, und
     die Eingabe wird wiederholt. Die Bedeutungen der einzelnen Auskunftscodes
     sind in Kapitel 5.4 unter der Menufunktion 'Auskunft einholen' beschrieben. 
  -  Durch Tippen der Tastenfolge <ESC><q> kann der Befehl abgebrochen
     werden, ohne daß eine Codenummer eingelesen wird. In diesem Falle wird der
     Wahrheitswert der Bedingung 'Stoptaste gedrückt' auf 'wahr' gesetzt, sonst
     bleibt der Wert auf 'falsch'. 
  -  Durch Tippen der Tastenfolge <ESC><h> wird die Ausführung des
     gesamten Programms abgebrochen. 
 
 
#on("b")#Bildschirm neu#off("b")#  (ELAN: bildschirm neu) 
 
  -  Der Programm-Eingangsbildschirm wird neu aufgebaut. Der Befehl wird
     benötigt, wenn die Fenstereinteilung auf dem Bildschirm wiederhergestellt
     werden soll (z.B. nach Ausgabe einer Liste bei dem Befehl 'Auskunft'). 
  -  Der Befehl wird beim Starten eines GRIN-Programms automatisch ausgeführt;
     bei ELAN-Programmen wird er automatisch am Anfang eines jeden Programms
     eingefügt, wenn das Programm nicht mit diesem Befehl beginnt. 
 
 
Neben diesen Befehlen stehen für ELAN-Programme noch drei weitere zur Verfügung,
die nicht zum GRIN-Befehlssatz gehören: 
 
        nachbestellen, 
        dezimalwert lesen, 
        bitmuster lesen. 
 
Diese Befehle entsprechen in ihrer Wirkung den gleichnamigen Menufunktionen
unter dem Oberbegriff 'Kommandos', die in Kapitel 5.4 beschrieben sind.