diff options
Diffstat (limited to 'app/gs.warenhaus/1.01/doc/gs-Warenhaus-6')
| -rw-r--r-- | app/gs.warenhaus/1.01/doc/gs-Warenhaus-6 | 589 |
1 files changed, 589 insertions, 0 deletions
diff --git a/app/gs.warenhaus/1.01/doc/gs-Warenhaus-6 b/app/gs.warenhaus/1.01/doc/gs-Warenhaus-6 new file mode 100644 index 0000000..3edf312 --- /dev/null +++ b/app/gs.warenhaus/1.01/doc/gs-Warenhaus-6 @@ -0,0 +1,589 @@ +#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. + + + |