Sie lernen nun, wie Sie einen Benutzer zur Eingabe von Daten auffordern (d.h. der Benutzer soll einen Start- und Endnamen für die Ausgabe eingeben).
Wenn Sie mit den Übungen in diesem Dokument fertig sind, wird Ihre Beispielanwendung aus den folgenden Modulen bestehen:
Dieses Dokument enthält die folgenden Übungen:
Sie werden Ihr Programm jetzt so verändern, dass Eingabefelder für die
Start- und Endnamen in der Ausgabe angezeigt werden. Hierzu benutzen Sie das
INPUT-Statement.
Eingabefelder definieren
Geben Sie Folgendes unter END-DEFINE ein:
INPUT (AD=MT) "Start:" #NAME-START / "End: " #NAME-END
Der Session-Parameter AD steht für
"Attribute Definition" (Attributdefinition). Sein Wert
"M" steht für "Modifiable output field"
(modifizierbares Ausgabefeld) und der Wert "T" steht
für "translate lowercase to uppercase" (Übersetzen von
Kleinbuchstaben in Großbuchstaben).
Der Wert "M" in
AD=MT bedeutet, dass die mit INIT
definierten Vorgabewerte (d.h.: "ADKINSON" und
"BENNETT") in den Eingabefeldern angezeigt werden.
Der Benutzer kann andere Werte eingeben. Wenn Sie den Wert
"M" weglassen, bleiben die Eingabefelder leer,
obwohl Vorgabewerte definiert wurden.
Der Wert "T" in
AD=MT bedeutet, dass jede Eingabe, die in
Kleinbuchstaben gemacht wurde, vor der weiteren Verarbeitung in Großbuchstaben
übersetzt wird. Dies ist wichtig, weil die Namen in der Demodatenbank komplett
in Großbuchstaben definiert wurden. Wenn Sie den Wert
"T" weglassen, müssen Sie alle Namen komplett in
Großbuchstaben angeben. Andernfalls wird der angegebene Name nicht
gefunden.
"Start:" und "End:" sind Textfelder
(Bezeichnungen). Sie werden in Anführungszeichen eingegeben.
#NAME-START und #NAME-END sind Datenfelder
(Eingabefelder), in denen der Benutzer den gewünschten Start- und Endnamen
eingeben kann.
Der Schrägstrich (/) bedeutet, dass die nachfolgenden Felder in einer neuen Zeile angezeigt werden sollen.
Ihr Programm sollte nun folgendermaßen aussehen:
DEFINE DATA
LOCAL
1 #NAME-START (A20) INIT <"ADKINSON">
1 #NAME-END (A20) INIT <"BENNETT">
1 EMPLOYEES-VIEW VIEW OF EMPLOYEES
2 FULL-NAME
3 NAME (A20)
2 DEPT (A6)
2 LEAVE-DATA
3 LEAVE-DUE (N2)
END-DEFINE
*
INPUT (AD=MT)
"Start:" #NAME-START /
"End: " #NAME-END
*
READ EMPLOYEES-VIEW BY NAME
STARTING FROM #NAME-START
ENDING AT #NAME-END
*
DISPLAY NAME 3X DEPT 3X LEAVE-DUE
*
END-READ
*
END
Führen Sie das Programm mit RUN aus.
Die Ausgabe enthält die Felder, die Sie gerade definiert haben.
Start: ADKINSON
End: BENNETT
Behalten Sie die Vorgabewerte bei und drücken Sie EINGABE.
Die Liste der Mitarbeiter wird nun angezeigt.
Drücken Sie wiederholt EINGABE bis Sie wieder im
Programmeditor sind, oder geben Sie
EDIT in der MORE-Zeile
ein.
Speichern Sie das Programm mit STOW.
Sie lernen jetzt eine weitere Möglichkeit kennen, den Benutzer zur Eingabe aufzufordern. Sie werden mit dem Map-Editor eine Map erstellen, die dieselben Felder enthält, die Sie vorher in Ihrem Programm definiert haben. Eine Map ist ein separates Objekt; sie wird benutzt, um das Layout der Benutzeroberfläche von der Geschäftslogik der Anwendung zu trennen.
Die Map, die Sie jetzt erstellen werden, wird folgendermaßen aussehen:
Ob _ Ob D CLS ATT DEL CLS ATT DEL
. . T D Blnk T I ?
. . A D _ A I )
. . A N ^ M D &
. . M I : O D +
. . O I (
. .
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
(XXXXXXXXXX (XXXXXXXX
Start :XXXXXXXXXXXXXXXXXXXX
End :XXXXXXXXXXXXXXXXXXXX
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Mset Exit Test Edit -- - + Full < > Let |
Die erste Zeile der Map enthält Systemvariablen für das aktuelle Datum und die aktuelle Uhrzeit. Es gibt zwei Datenfelder (Eingabefelder), in denen der Benutzer einen Startnamen und einen Endnamen eingeben kann. Vor den Datenfeldern befinden sich Textfelder (Bezeichnungen).
Die Länge eines Feldes wird durch eine Reihe von "X"-Zeichen dargestellt. Für die Unterscheidung der verschiedenen Feldtypen werden Delimiter-Zeichen benutzt. In unserer Beispiel-Map werden die folgenden Delimiter-Zeichen verwendet:
| Delimiter | Feldtyp |
|---|---|
| ( | Systemvariable. |
| : | Datenfeld. |
Für die oben gezeigte Map sind die folgenden Schritte erforderlich:
Sie werden jetzt den Map-Editor aufrufen, mit dem Sie das Layout Ihrer Map gestalten. Der Map-Editor kann über das Menü Edit Map aufgerufen werden.
Das Menü Edit Map aufrufen
Geben Sie in der Kommandozeile des Programmeditors einen Punkt (.) ein, um zum Menü Development Functions zurückzukehren.
Geben Sie unten im Menü Development Functions die folgenden Informationen ein und drücken Sie EINGABE:
Code .. E Type .. M
Name .. ________________________________
Command ===>
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Menu Exit Canc |
"E" steht für die Funktion Edit Object (Objekt editieren), und "M" steht für den Objekttyp Map.
Anmerkung:
Es wäre auch möglich gewesen, den Code
"C" für Create Object (Objekt
erstellen) einzugeben. In diesem Fall wären Sie aber dazu aufgefordert worden,
einen Objektnamen anzugeben.
Das Menü Edit Map erscheint.
16:43:41 ***** NATURAL MAP EDITOR ***** 2007-03-20
User SAG - Edit Map - Library TUTORIAL
Code Function
---- ---------------------------------
D Field and Variable Definitions
E Edit Map
I Initialize new Map
H Initialize a new Help Map
M Maintenance of Profiles & Devices
S Save Map
T Test Map
W Stow Map
? Help
. Exit
Code .. I Name .. ________ Profile .. SYSPROF_
Command ===>
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Exit Test Edit |
Eine neue Map initialisieren
Geben Sie unten im Menü Edit Map die folgenden Informationen ein und drücken Sie EINGABE:
Code .. I Name .. MAP01___ Profile .. SYSPROF_
Command ===>
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Exit Test Edit |
Der Bildschirm Define Map Settings erscheint.
16:43:42 Define Map Settings for MAP 2007-03-20
Delimiters Format Context
----------------- --------------------------- --------------------------
Cls Att CD Del Page Size ...... 23 Device Check .... ________
T D BLANK Line Size ...... 79 WRITE Statement _
T I ? Column Shift ... 0 (0/1) INPUT Statement X
A D _ Layout ......... ________ Help ____________________
A I ) dynamic ....... N (Y/N) as field default N (Y/N)
A N ^ Zero Print ..... N (Y/N)
M D & Case Default ... UC (UC/LC)
M I : Manual Skip .... N (Y/N) Automatic Rule Rank 1
O D + Decimal Char ... . Profile Name .... SYSPROF
O I ( Standard Keys .. N (Y/N)
Justification .. L (L/R) Filler Characters
Print Mode ..... __ ------------------------
Optional, Partial ....
Control Var .... ________ Required, Partial ....
Optional, Complete ...
Required, Complete ...
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Exit Let |
In diesem Bildschirm definieren Sie die Standardeinstellungen einer Map (zum Beispiel, die Größe der Map). Es ist auch möglich, die Delimiter-Zeichen in diesem Bildschirm zu ändern. Für dieses Tutorial werden Sie jedoch die Standard-Delimiter-Zeichen verwenden. Sie werden nur die Füllzeichen (Filler Characters) definieren (siehe den nächsten Schritt).
Ein Delimiter-Zeichen steht für eine Kombination aus Klasse und Attribut, die einem Feld zugeordnet ist. In diesem Tutorial werden die fett dargestellten Delimiter-Zeichen verwendet:
Delimiters ----------------- Cls Att CD Del T D BLANK T I ? A D _ A I ) A N ^ M D & M I : O D + O I ( |
Der Doppelpunkt bedeutet, dass ein Feld ein modifizierbares Ein- und Ausgabefeld ist ("M" in der Spalte Cls) und dass es hervorgehoben (intensiviert) ist ("I" in der Spalte Att).
Die öffnende Klammer bedeutet, dass ein Feld nur zur Ausgabe (Output) dient ("O" in der Spalte Cls) und dass es hervorgehoben (intensiviert) ist ("I" in der Spalte Att).
Wenn kein Delimiter-Zeichen benutzt wird (dies ist im Bildschirm mit "BLANK" angegeben), so bedeutet das, dass das Feld eine Textkonstante ("T" in der Spalte Cls) mit Standardattributen (Default Attributes) ist ("D" in der Spalte Att).
Geben Sie für jede Füllzeichenoption einen Unterstrich (_) ein, so wie es unten dargestellt ist:
Filler Characters ------------------------ Optional, Partial .... _ Required, Partial .... _ Optional, Complete ... _ Required, Complete ... _ |
Füllzeichen werden in der Map benutzt, um leere Positionen in den Eingabefeldern zu füllen, damit der Benutzer bei der Dateneingabe die exakte Position und Länge eines Feldes erkennen kann.
Drücken Sie EINGABE um die Änderungen zu speichern.
Drücken Sie noch einmal EINGABE, um den Editierbereich der Map aufzurufen.
Der Editierbereich der Map wird im Split-Screen-Modus angezeigt.
Ob _ Ob D CLS ATT DEL CLS ATT DEL
. . T D Blnk T I ?
. . A D _ A I )
. . A N ^ M D &
. . M I : O D +
. . O I (
. .
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Mset Exit Test Edit -- - + Full < > Let |
Anmerkung:
Der Bildschirm Define Map Settings erscheint
nur, wenn Sie eine neue Map initialisieren. Wenn Sie eine Map editieren, können
Sie den Bildschirm Define Map Settings aufrufen, indem Sie
im Editierbereich der Map (siehe den Bildschirm oben) PF2 (Mset)
drücken.
Im Split-Screen-Modus werden in der oberen Bildschirmhälfte die gültigen Delimiter-Zeichen angezeigt. In der unteren Bildschirmhälfte befindet sich der Editierbereich, in dem Sie die Map erstellen werden.
Anders als im Programmeditor und Data-Area-Editor (der später in diesem Tutorial beschrieben wird), gibt es beim Map-Editor keine Kommandozeile oder Aufforderung für die Eingabe von Natural-Systemkommandos. Viele Funktionen im Map-Editor werden mit Zeilen- oder Feldkommandos ausgeführt (siehe unten) oder mit PF-Tasten.
Mit PF9 schalten Sie um zwischen Split-Screen-Modus und ungeteiltem Bildschirm, in dem der Editierbereich in voller Größe angezeigt wird.
Sie werden jetzt zwei Textfelder (auch Konstanten oder Bezeichnungen genannt) in der Map definieren.
Textfelder definieren
Stellen Sie den Cursor im Editierbereich der Map auf die erste Position der vierten Zeile und geben Sie Folgendes ein:
Start
Stellen Sie den Cursor auf die erste Position der nächsten Zeile und geben Sie Folgendes ein:
End
Ihre Map sollte nun folgendermaßen aussehen:
Ob _ Ob D CLS ATT DEL CLS ATT DEL
. . T D Blnk T I ?
. . A D _ A I )
. . A N ^ M D &
. . M I : O D +
. . O I (
. .
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
Start
End
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Mset Exit Test Edit -- - + Full < > Let |
Anmerkung:
Wenn Sie Ihre letzten Änderungen rückgängig machen wollen,
drücken Sie PF12 bevor Sie EINGABE
drücken.
Sie werden jetzt zwei Datenfelder in der Map definieren. Dies sind die Eingabefelder, in denen der Benutzer den Start- und Endnamen eingeben kann.
Sie können die Datenfelder auf zwei verschiedene Arten definieren: auf die herkömmliche Art, wobei es in Ihrer Verantwortung liegt, die Länge des Datenfelds korrekt anzugeben, oder auf eine benutzerfreundliche Art, wobei Sie das Datenfeld einfach aus einer Liste auswählen und die Länge bereits korrekt definiert ist. Diese beiden Arten sind unten beschrieben.
Datenfeld definieren und dabei die Länge selbst angeben
Geben Sie Folgendes hinter dem Textfeld Start ein (lassen Sie ein Leerzeichen zwischen dem Textfeld und dem Datenfeld):
:X(20)
Der Doppelpunkt (:) ist das Delimiter-Zeichen, das das Datenfeld als modifizierbar und intensiviert kennzeichnet. Das Datenfeld wird mit einer Länge von 20 Zeichen definiert. Die Länge des Feldes wird durch die "X"-Zeichen dargestellt.
Drücken Sie EINGABE.
Ihre Map sollte nun folgendermaßen aussehen:
Ob _ Ob D CLS ATT DEL CLS ATT DEL
. . T D Blnk T I ?
. . A D _ A I )
. . A N ^ M D &
. . M I : O D +
. . O I (
. .
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
Start :XXXXXXXXXXXXXXXXXXXX
End
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Mset Exit Test Edit -- - + Full < > Let |
Datenfeld aus einer Liste auswählen
Geben Sie Folgendes im Feld Ob ein (dieses Feld befindet sich oben links im Bildschirm) und drücken Sie EINGABE:
P PGM01
Die Datenfelder, die zurzeit vom Programm PGM01 benutzt
werden, werden jetzt im Bildschirm angezeigt. Vor den Feldern, die in der Map
benutzt werden können, steht eine Nummer.
Ob P PGM01 Ob D CLS ATT DEL CLS ATT DEL
1 #NAME-START A20 . T D Blnk T I ?
2 #NAME-END A20 . A D _ A I )
. EMPLOYEES-VIEW *V1 . A N ^ M D &
. FULL-NAME *2 . M I : O D +
3 NAME A20 . O I (
4 DEPT A6 .
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
Start :XXXXXXXXXXXXXXXXXXXX
End
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
Help Mset Exit Test Edit -- - + Full < > Let |
Nicht alle im Programm PGM01 definierten Datenfelder
werden im Bildschirm angezeigt. Um die Liste der Datenfelder durchzublättern,
geben Sie eines der folgendes Kommandos im Feld Ob ein
(d.h. im dem Feld, das zurzeit den Buchstaben "P"
enthält).
| Kommando | Beschreibung |
|---|---|
+ |
In der Liste nach vorne blättern. |
- |
In der Liste nach hinten blättern. |
++ |
An das Ende der Liste gehen. |
-- |
An den Anfang der Liste gehen. |
Geben Sie Folgendes hinter dem Textfeld End ein (lassen Sie ein Leerzeichen zwischen dem Textfeld und dem Datenfeld) und drücken Sie EINGABE:
:2
Der Doppelpunkt (:) ist das Delimiter-Zeichen, das das Datenfeld als
modifizierbar und intensiviert kennzeichnet. Die Nummer 2 ist
#NAME-END zugeordnet.
Das Datenfeld ist automatisch mit der korrekten Länge definiert (20 Zeichen in diesem Fall). Die Länge des Feldes wird durch die "X"-Zeichen dargestellt.
Folgendes gilt nur für das Datenfeld für den Startnamen, das Sie manuell definiert haben. Es gilt nicht für das Datenfeld für den Endnamen, das Sie aus einer Liste ausgewählt haben: Wenn Sie ein neues Datenfeld für eine Benutzervariable erstellen, wird von Natural ein Name für dieses Feld vergeben. Dieser Feldname enthält eine Nummer. Sie müssen die Namen der neu erstellten Felder an die Namen anpassen, die in Ihrem Programm definiert wurden.
Sie werden jetzt dafür sorgen, dass dieselben Namen wie in Ihrem
Programm benutzt werden: #NAME-START und #NAME-END.
Die Ausgabe dieser Felder (d.h. die Benutzereingabe) wird an die entsprechenden
Benutzervariablen in Ihrem Programm übergeben.
Namen für Datenfelder definieren
Geben Sie Folgendes ab der ersten Position des Datenfeldes für den Startnamen ein und drücken Sie EINGABE:
.E
Oder:
Stellen Sie den Cursor im Datenfeld an eine beliebige Position und
drücken Sie PF5.
Für das markierte Feld werden erweiterte Feldinformationen angezeigt:
Fld #001 Fmt A20
-------------------------------------------------------------------------------
AD= MIT'_'____ ZP= SG= HE= _____________________ Rls 0
AL= _____ CD= __ CV= ________________________________ Mod Undef
PM= __ DF= DY= ______________________________
EM= __________________________ SB= ________________________________
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
Start .EXXXXXXXXXXXXXXXXXXX
End :XXXXXXXXXXXXXXXXXXXX
Enter-PF1---PF2---PF3---PF4---PF5---PF6---PF7---PF8---PF9---PF10--PF11--PF12---
HELP Mset Exit <--- ---> -- - + < > Let |
Das Feld Fld in der oberen linken Bildschirmecke enthält den Feldnamen, der von Natural vergeben wurde: "#001".
Geben Sie "#NAME-START" im Feld Fld ein.
Drücken Sie PF3, um die Funktion zu beenden.
Da das Datenfeld für den Endname in der vorherigen Übung aus
einer Liste ausgewählt wurde, ist es nicht erforderlich, die Schritte oben für
den Endnamen zu wiederholen. In diesem Fall ist #NAME-END bereits
definiert. Wenn Sie möchten, können Sie dies mit dem Kommando
.E wie oben beschrieben überprüfen.
Anmerkung:
Bei #NAME-END hat der Session-Parameter
AD den zusätzlichen Wert "L",
der bei #NAME-START nicht definiert ist.
"L" bedeutet, dass der Wert dieses Feldes
linksbündig angezeigt wird. Da dies bei alphanumerischen Feldern die Vorgabe
ist, ist es nicht nötig, dies für #NAME-START zu
definieren.
Natural-Systemvariablen enthalten Information über die aktuelle Natural-Session, wie zum Beispiel die aktuelle Library, Benutzer, oder Datum und Uhrzeit. Diese Informationen können an jedem beliebigen Punkt in einem Natural-Programm referenziert werden. Alle Systemvariablen beginnen mit einem Stern (*).
Sie werden jetzt Systemvariablen für Datum und Uhrzeit in der Map
einfügen. Wenn das Programm mit RUN ausgeführt wird,
werden das aktuelle Datum und die aktuelle Uhrzeit in der Map angezeigt.
Systemvariablen einfügen
Stellen Sie den Cursor an die erste Position der ersten Zeile und geben Sie Folgendes ein:
(*DAT4I
Die öffnende Klammer ist das Delimiter-Zeichen, das die Systemvariable als intensiviertes Ausgabefeld kennzeichnet.
Stellen Sie den Cursor an die erste Position der zweiten Zeile und geben Sie Folgendes ein:
(*TIMX
Ihre Map sollte nun folgendermaßen aussehen:
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
(*DAT4I
(*TIMX
Start :XXXXXXXXXXXXXXXXXXXX
End :XXXXXXXXXXXXXXXXXXXX |
Drücken Sie EINGABE.
"X"-Zeichen werden jetzt statt der Systemvariablennamen angezeigt.
Sie werden die Felder, die Sie eingegeben haben, jetzt mit Zeilenkommandos und Feldkommandos verschieben.
Ein Feld verschieben
Geben Sie das folgende Feldkommando beginnend in der ersten Position der Systemvariablen in der zweiten Zeile ein:
.M
Beispiel:
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
(XXXXXXXXXX
.MXXXXXXX
Start :XXXXXXXXXXXXXXXXXXXX
End :XXXXXXXXXXXXXXXXXXXX |
Ein Feldkommando wird am Anfang eines Feldes eingegeben. Es gilt nur für das Feld, in dem Sie es eingeben.
Stellen Sie den Cursor an die Position, an die Sie die Systemvariable verschieben möchten (Spalte 70 in der ersten Zeile).
Drücken Sie EINGABE.
Die Systemvariable wird an die Cursorposition verschoben.
Leerzeile einfügen
Geben Sie das folgende Zeilenkommando beginnend in der ersten Position der vierten Zeile (Startname) ein:
..I(1)
Beispiel:
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
(XXXXXXXXXX (XXXXXXXX
..I(1):XXXXXXXXXXXXXXXXXXXX
End :XXXXXXXXXXXXXXXXXXXX |
Ein Zeilenkommando wird am Anfang einer Zeile eingegeben. Es gilt für die komplette Zeile, in der Sie es eingeben.
Drücken Sie EINGABE.
Eine Leerzeile wird unter der Zeile eingefügt, in der Sie das Zeilenkommando eingegeben haben.
Zeile zentrieren
Geben Sie das folgende Zeilenkommando beginnend in der ersten Position der vierten Zeile (Startname) ein:
..C
Beispiel:
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
(XXXXXXXXXX (XXXXXXXX
..Crt :XXXXXXXXXXXXXXXXXXXX
End :XXXXXXXXXXXXXXXXXXXX |
Drücken Sie EINGABE.
Die Zeile wird zentriert.
Mehrere Felder verschieben
Geben Sie das folgende Feldkommando beginnend in der ersten Position des Textfeldes in der sechsten Zeile (End) ein und in der ersten Position des Datenfeldes in dieser Zeile:
.M
Beispiel:
001 --010---+----+----+---030---+----+----+---050---+----+----+---070---+----
(XXXXXXXXXX (XXXXXXXX
Start :XXXXXXXXXXXXXXXXXXXX
.Md .MXXXXXXXXXXXXXXXXXXX |
Stellen Sie den Cursor an die Position, an der das Textfeld beginnen soll (Spalte 30 in der sechsten Zeile).
Drücken Sie EINGABE.
Beide Felder werden verschoben.
Die Map sollte jetzt so aussehen wie am Anfang dieses Abschnitts.
Um zu überprüfen, ob Ihre Map wie beabsichtigt funktioniert, werden Sie sie jetzt testen.
Map testen
Drücken Sie PF4.
Die folgende Ausgabe wird angezeigt.
2007-03-20 13:39:55
Start ____________________
End ____________________
|
Das Eingabefeld für den Startnamen ist automatisch markiert, da es das erste Eingabefeld in der Map ist. Beide Eingabefelder enthalten Füllzeichen.
Anmerkung:
Wenn der Einfügemodus aktiv ist, muss der Benutzer die
Füllzeichen löschen, damit die Eingabe von Text möglich ist. Im
Überschreibemodus, der standardmäßig aktiv ist,
ist dies nicht erforderlich.
Drücken Sie EINGABE, um zum Map-Editor zurückzukehren.
Wenn die Map erfolgreich getestet wurde, müssen Sie sie mit
STOW speichern, damit sie von Ihrem Programm
gefunden werden kann.
Map mit STOW speichern
Drücken Sie PF3, um zum Menü Edit Map zurückzukehren.
Geben Sie Folgendes im Feld Code ein und drücken Sie EINGABE:
W
Sobald eine Map mit STOW gespeichert wurde,
kann Sie mit einem WRITE- oder INPUT-Statement aus
einem Natural-Programm heraus aufgerufen werden.
Map aus dem Programm aufrufen
Kehren Sie zum Programmeditor zurück, indem Sie eines der folgenden Kommandos in der Kommandozeile des Menüs Edit Map eingeben.
EDIT PGM01
E PGM01
Ersetzen Sie die vorher definierten INPUT-Zeilen durch
die folgende Zeile:
INPUT USING MAP 'MAP01'
Hiermit wird die von Ihnen erstellte Map aufgerufen.
Der Name der Map muss in einfache Anführungszeichen gesetzt werden, um die Map von einer Benutzervariablen zu unterscheiden.
Ihr Programm sollte nun folgendermaßen aussehen:
DEFINE DATA
LOCAL
1 #NAME-START (A20) INIT <"ADKINSON">
1 #NAME-END (A20) INIT <"BENNETT">
1 EMPLOYEES-VIEW VIEW OF EMPLOYEES
2 FULL-NAME
3 NAME (A20)
2 DEPT (A6)
2 LEAVE-DATA
3 LEAVE-DUE (N2)
END-DEFINE
*
INPUT USING MAP 'MAP01'
*
READ EMPLOYEES-VIEW BY NAME
STARTING FROM #NAME-START
ENDING AT #NAME-END
*
DISPLAY NAME 3X DEPT 3X LEAVE-DUE
*
END-READ
*
END
Führen Sie das Programm mit RUN aus.
Ihre Map wird nun angezeigt.
Drücken Sie wiederholt EINGABE bis Sie zum Programmeditor
zurückkehren, oder geben Sie EDIT in der
MORE-Zeile ein.
Speichern Sie das Programm mit STOW.
So wie Ihr Programm jetzt kodiert ist, werden keine Daten gefunden, wenn kein Endname angegeben wird.
Sie werden jetzt die Anfangswerte für Start- und Endname entfernen; danach müssen diese Namen immer vom Benutzer angegeben werden. Um zu gewährleisten, dass ein Endname immer benutzt wird, auch wenn er vom Benutzer nicht eingegeben wurde, werden Sie Ihrem Programm nun ein entsprechendes Statement hinzufügen.
Den Endnamen benutzen
Gehen Sie zum DEFINE DATA-Block und entfernen Sie die
Anfangswerte (INIT) für die Felder #NAME-START und
#NAME-END, so dass die entsprechenden Zeilen folgendermaßen
aussehen:
1 #NAME-START (A20) 1 #NAME-END (A20)
Geben Sie Folgendes unter INPUT USING MAP 'MAP01'
ein:
IF #NAME-END = ' ' THEN
MOVE #NAME-START TO #NAME-END
END-IF
Wenn das Feld #NAME-END leer ist (d.h. wenn der Benutzer
keinen Endnamen angibt), wird der Startname automatisch als Endname
benutzt.
Anmerkung:
Statt des Statements MOVE #NAME-START TO #NAME-END
können Sie auch die folgende Variante des ASSIGN- oder
COMPUTE-Statements benutzen: #NAME-END :=
#NAME-START.
Ihr Programm sollte nun folgendermaßen aussehen:
DEFINE DATA
LOCAL
1 #NAME-START (A20)
1 #NAME-END (A20)
1 EMPLOYEES-VIEW VIEW OF EMPLOYEES
2 FULL-NAME
3 NAME (A20)
2 DEPT (A6)
2 LEAVE-DATA
3 LEAVE-DUE (N2)
END-DEFINE
*
INPUT USING MAP 'MAP01'
*
IF #NAME-END = ' ' THEN
MOVE #NAME-START TO #NAME-END
END-IF
*
READ EMPLOYEES-VIEW BY NAME
STARTING FROM #NAME-START
ENDING AT #NAME-END
*
DISPLAY NAME 3X DEPT 3X LEAVE-DUE
*
END-READ
*
END
Führen Sie das Programm mit RUN aus.
Geben Sie in der daraufhin erscheinenden Map "JONES" in dem Feld für den Startnamen ein und drücken Sie EINGABE.
In der daraufhin erscheinenden Liste werden jetzt nur die Mitarbeiter mit dem Namen "Jones" angezeigt.
Drücken Sie EINGABE, um zum Programmeditor zurückzukehren.
Speichern Sie das Programm mit STOW.
Sie können nun mit den nächsten Übungen fortfahren: Verarbeitungsschleifen und Labels.