Flexible Modulprogrammierung mit ADIMENS Talk Teil 1: Menüsteuerung

Zweifellos hat das Datenbanksystem ADIMENS eine breite Akzeptanz bei den ATARI Anwendern gefunden. Einen wesentlichen Einfluß hat dabei die integrierte Kommandosprache ADIMENS Talk, die über die Befehle zur reinen Datenmanipulation hinausgeht und eine komplette Anwendungsprogrammierung zuläßt.

Willkommen zum 1. Teil der flexiblen Modulprogrammierung mit ADIMENS Talk. ADIMENS ist meines Erachtens eines der benutzerfreundlichsten und leistungsfähigsten Datenbanksysteme. Falls Sie es bereits einsetzen, vertieft diese Serie Ihre Kenntnisse. Wenn Sie es zum erstenmal benutzen, werden Sie feststellen, wie angenehm das Arbeiten mit ihm im allgemeinen und mit ADIMENS Talk im besonderen ist.

Der Inhalt dieser Serie ist auf die große Gruppe der semiprofessionellen Anwender abgestimmt, welcher mit diesen flexiblen Programmmoduln ein Instrument zur schnellen Entwicklung von EDV-Projekten kennenlernen wird. Neben den maschinenorientierten (z.B. Assembler) oder den problemorientierten Sprachen (z.B. Cobol), welche einen großen Aufwand für die Entwicklung von Programmen erfordern, hat man mit der Abfragesprache ADIMENS Talk eine integrierte Kommandosprache in der Hand, die über die Befehle zur reinen Datenmanipulation hinausgeht und eine komplette Anwendungsprogrammierung zuläßt.

Allgemeine Gesichtspunkte

ADIMENS Talk wird als Programmiersprache in einer Umgebung verwendet, in der die Benutzer keine professionellen Programmierer sind. Ich meine, daß Menschen, die Datenbanksysteme wie ADIMENS verwenden, nicht zwangsläufig zu Profi-Programmierern werden sollten. Andererseits sollte jeder zu den leistungsfähigen Computern und einer so leistungsfähigen Sprache, wie sie ADIMENS Talk bietet, Zugang haben.

Meiner Vorstellung nach sind Computer und Anwendungsprogramme schlicht Werkzeuge, die man für eine bestimmte Aufgabe benutzt und dann wieder beiseite legt. Sie sollten nicht mehr Zeit in Anspruch nehmen, als die zu erledigende Aufgabe erfordert.

Insbesondere die letztgenannte Eigenschaft ist für den Benutzer von größter Bedeutung, der auf die konventionellen Sprachen wie C, Fortran oder Pascal völlig verzichten will und eine Sprache auf höherem Niveau benutzen will, die jenen an Mächtigkeit weit überlegen ist.

Modulkonzeption

Mehrere Programmteile, die in einem logischen Zusammengang stehen, können zu Moduln zusammengefaßt werden. In den in dieser Serie vorgestellten flexiblen Moduln mit ADIMENS Talk wird jede Teilaufgabe, die in den meisten Anwendungsprogrammen bei Datenbankoperationen auftaucht, systematisch vorgestellt.

Dabei war stets das Ziel, Moduln zu erstellen, so daß eine Software in Form von austauschbaren Bauteilen zusammengestellt werden kann.

Ein wichtiger Bestandteil der Programmentwicklung wird dabei die Möglichkeit sein, die Datenbank-Abfragesprache zu erlernen und dann später diese Module nach eigenen Wünschen und Vorstellungen in ein Anwendungsprogramm zu implementieren.

Im Voraus darf hier schon gesagt werden, daß folgende Modultypen erarbeitet wurden.

Abb.1: Inhalt und Beziehung der Testphase zu den Softwareerstellungsphasen

Alle Funktionen werden anhand praxisnaher Beispiele vorgeführt und können vom Leser leicht nachvollzogen werden. Um den systematischen Aufbau der Moduln nicht zu beeinträchtigen, wird bewußt auf das Besprechen sämtlicher Kommandos und aller ihrer Varianten verzichtet, deren Aufzählung mehr verwirren würde als klären.

Das bedeutet für den Leser ganz konkret, daß er ADIMENS Talk schon nach kurzer Zeit für einfache Anwendungen nutzbar und das weitere Vordringen in verfeinerte Datenbanktechniken von seinen individuellen Bedürfnissen abhängig machen kann.

Die Programmierphilosophie

So selbsterklärend wie die Programmierschnittstelle von ADIMENS zu ADIMENS Talk ist wohl keine andere zur Zeit auf dem Markt befindliche Sprache. Weil aber Menschen unglaublich faul und ineffizient sein können, kann man in dieser Computersprache natürlich auch Fehler und Unsinn programmieren. Die Anziehungskraft von ADIMENS Talk besteht in den strukturierten Programmtexten und den leicht lesbaren Kommentaren.

Die Möglichkeit, ziemlich schnell Programme schreiben oder Probleme lösen zu können, sollte aber nicht daran hindern, die Programmtexte klar strukturiert und kommentiert zu erstellen.

Die Entwicklung eines Anwendungsprogrammes ist eine kreative Tätigkeit. Sie ist z.B. mit einer Konstruktionstätigkeit im ingenieurwissenschaftlichen Bereich zu vergleichen. Die ingenieurmäßige Entwicklung der Software, unter dem Namen Software-Engineering bekannt, wendet Methoden, Hilfmittel und Konzepte an, um festgelegte technische, ökonomische und soziale Ziele zu erreichen. Die Entwicklung von Software geschieht nach Abb. 1 in der Analysephase, Spezifikationsphase, Entwurfsphase, Programmierphase, Implementierungsphase, Testphase und Wartungsphase. Auf die einzelnen Phasen soll hier nicht näher eingegangen werden. Interessierte Leser können jedoch eine sehr gute Beschreibung dieser einzelnen Phasen in / 1/ nachlesen.

Programmiermethoden

Komplizierte und komplexe Probleme werden meiner Meinung nach am besten dadurch gelöst, daß sie hierarchisch strukturiert werden und dann vom Kopf (TOP) aus gelöst werden. Den Anfang bildet eine globale Aufgabenstellung, die in mehrere Hauptfunktionen und weitere Unterfunktionen unterteilt wird. Das Ergebnis einer derartigen Aufteilung sind klare und übersichtliche Programmteile. Auf jeder Ebene wird das Problem vollständig dargestellt, da jedes Programm auf der nächst höheren Ebene durch seinen Aufruf repräsentiert wird. Ein Vergleich der Darstellung eines Problems auf verschiedenen Hierarchieebenen führt dazu, daß die höhere Ebene angibt, was zu tun ist, während die tiefere angibt, wie es zu tun ist.

Anders ausgedrückt: Es steht bei der hierarchischen Gliederung die Num-memstelle oder der Nummemteil des Moduls in eindeutiger Abhängigkeit von der vorhergehenden Stelle (siehe Abb. 2). Ein typisches Beispiel für eine solche hierarchische Gliederung ist das Postleitzahlensystem. Eine Gruppe wird nur dann eindeutig gekennzeichnet, wenn alle vorhergehenden Stellen mit angeführt werden.

Abb.2: Hierarchie Struktur bei der TOP-DOWN-Programmierung

Diese ebene Entwurfsstrategie wird auch als “TOP-DOWN-Entwurf“ bezeichnet, wobei die Vorgehens weise, nämlich die wiederholte Verfeinerung eines allgemeinen Lösungsansatzes - “Stepwise Refinement“ - beschrieben wird. Dabei ist der TOP-DOWN-Entwurf kein einmaliger Vorgang. Er wiederholt sich quasi auf jeder Ebene, d.h. “Untermodule“ werden nach dem gleichen Muster in weitere Untermodule zerlegt usw.

Konzeption der Menüsteuerung

Beziehen wir dies auf unser Anwendungsprogramm, so müssen wir uns zuerst einmal überlegen, wie unsere Menü-Anzeige aussehen soll. Aus Abb.3 wird ersichtlich, daß dem Anwender laut Anzeige des 1. Menüs 4 Möglichkeiten zur Auswahl geboten werden. Wählt man die “1“ für Stammdaten, hat man 9 Auswahlmöglichkeiten. Die Aufbaustruktur ist also hierarchisch gegliedert und entspricht dem TOP-DOWN-Entwurf.

Man sollte sich am Anfang eines Aufbaus zuallererst einmal Gedanken darüber machen, welche Teilaufgaben implementiert werden sollen. Danach sollte die Struktur so geordnet werden, daß man einen systematischen und klar definierter Aufbau vorliegen hat. Sie sollten dabei immer beachten, daß sich jedes Untermodul in eindeutiger Abhängigkeit von dem vorhergehenden Modul befindet.

Abb.3: TOP-DOWN Entwurf des Menüs

Es gibt einen alten Begriff in der Computerwelt: “benutzerfreundlich“. Unter Benutzerfreundlichkeit eines Anwendungsprogrammes wird die Zufriedenheit eines Benutzers bei der Handhabung seines Programmes verstanden. Die Software-Ergonomie spielt dabei eine wesentliche Rolle. Software-Ergonomie ist die nach arbeitspsychologischen Erfordernissen durchgeführte Gestaltung der Software.

Zusammenfassend kann man sagen, daß nur klare Strukturen, eindeutig ansprechbare Menüpunkte und eine extrem kurze Informationseingabe Sie ein Minimum an Zeitaufwand und Nerven kosten.

Nachdem Sie ihre Programmiermethoden sorgfältig entworfen haben, kann mit der Programmierung begonnen werden. Als Anhaltspunkt kann man sagen, daß die Programmierphase in etwa die gleiche Zeit benötigt wie die Vorbereitung und Organisation. Die letzte anschließende Phase an die Programmierung ist die Testphase. In der Regel werden sich in dieser Phase noch Programmänderungswünsche ergeben. Die Testphase wird in etwa so lange wie die Programmierungsphase oder die Vorbereitungsphase dauern.

Das Struktogramm

Ein Programm besteht im Prinzip nur aus einer Reihe von fortlaufenden Befehlen, die der Reihe nach abgearbeitet werden. In einem Struktogramm sieht das folgendermaßen aus (siehe Abb. 4): Jeder Kasten stellt einen Befehl bzw. eine Anweisungsgruppe dar. Die Anweisungsgruppen sind am linken oberen Ende mit einem numerierten Kästchen gekennzeichnet. Das hat den besonderen Vorteil, daß im späteren Quelltext des Programmes diese Anweisungsgruppe in einer Kommentarzeile ebenfalls gekennzeichnet werden kann. Damit findet man sich wesentlich schneller in dem Programm zurecht, oder man kann bei einem längeren Programm direkt nach dieser Zeichenfolge suchen lassen. Die dargestellte Anweisungskennzeichnung im Quelltext in Abb. 4 unten zeigt die Struktur des Programmes.

Wichtig ist, daß in dieser Phase der Arbeit versucht werden sollte, keine ADIMENS Talk-Syntax zu verwenden sondern Klartext. Zum Beispiel “Eingabe Identnummer“ statt “@ 22,14 SAY“ Bitte geben Sie die Identnummer ein “GET PICTURE“ ######“. Das ist äußerst praktisch, da man dann ein Struktogramm ohne Probleme in verschiedene Hochsprachen umsetzen kann. Ebenso werden die Übersichtlichkeit auf der einen und die Verständlichkeit und die Modifikationsfähigkeit des Programmes auf der anderen Seite wesentlich verbessert.

Abb.4: Darstellung von Struktogrammen

Die DO WHILE-Schleifen-Struktur

Nun kommt man gleich zu der ersten Form des Struktogrammes - der DO WHILE-Schleife. Sie prüft bereits am Anfang, ob die Bedingung erfüllt ist und läuft nur dann in den Programmblock innerhalb der Schleife hinein. Ist die Bedingung nicht erfüllt, wird das Programm hinter dem Blockende fortgesetzt-Die Schleifen - Konstruktion in ADIMENS lautet:

    DO WHILE < Bedingung >
        < Anweisungsblock > 
    ENDDO

Mit WHILE wird ein Anweisungsblock SO LANGE erneut abgearbeitet, bis die einleitende Bedingung nicht mehr erfüllt ist. Als Bedingung kann jeder logische Ausdruck angegeben werden.

Die Überprüfung dieser Bedingung erfolgt nur einmal pro Durchgang, und zwar am Anfang der Schleife (—> also auch vor dem ersten Durchgang). Es gibt damit die Möglichkeit, daß eine DO WHILE Schleife bei einer entsprechenden Bedingung erst gar nicht zum Laufen kommt.

Beispiel:

    i = 0
    DO WHILE (i < 5 ) 
        i = i+ 1
        ?? i 
    ENDDO 

Bildschirmausgabe: 1 2 3 4 5

Die Darstellung im Struktogramm und die konzeptionelle Umsetzung in den Quelltext bei ADIMENS Talk sieht man in Abb. 5. Hier ist noch anzumerken, daß die Befehle LOOP und EXIT bei der Programmierung in dieser Serie nicht verwendet werden. Ein Sprung an den Anfang oder ein Abbruch einer Schleife wird deshalb ignoriert.

Die IF-THEN-ELSE-Abfrage

Ein anderer Bestandteil der strukturierten Programmierung ist die “IF- THEN-ELSE” Abfrage. Versucht man diesen Befehl zu übersetzen, lautet er “WENN-DANN-ANSONSTEN“. Zur Steuerung größerer Programmabläufe ist diese Kontrollstruktur unersetzlich. Man wird bald erkennen, daß die wesentlichen Programmstrukturen mit diesem Befehl erstellt werden können.

Die Anweisung lautet in ADIMENS:

    IF < Bedingung >
        Anweisungsblock 1 
    ELSE
        Anweisungsblock 2 
    ENDIF

Die Anweisungen nach ELSE werden dann ausgeführt, wenn die Bedingung der IF-Anweisung nicht erfüllt ist. Sollen mehrere Alternativen abgearbeitet werden, kann eine reine Verwendung der IF-Anweisungen sehr rasch unübersichtlich werden. Vor allem muß jeder mit der IF < Bedingung > neu begonnene Block auch wieder an irgend einer Stelle des Programmes mit ENDIF abgeschlossen werden.

Im Struktogramm (siehe Abb. 5) wird dies noch deutlicher. Benötigt man den ELSE-Block nicht, so läßt man ihn einfach weg, und der Platz innerhalb der Anweisung 2 bleibt leer.

Abb.5: Konzeptionelle Umsetzung der DO-WHILE-Struktur

Eine einfachere und lesbare Struktur für die Auswahl eines bestimmten Falles ist durch eine CASE-Schachtelung möglich:

    DO CASE
        CASE < Bedingung 1 >
            < Anweisungsblock 1 > 
        CASE < Bedingung 2 >
            < Anweisungsblock 2 >
        ..........
        CASE < Bedingung n >
            <Anweisungsblock n>
    ENDCASE

Es wird höchstens ein Anweisungsblock abgearbeitet, nämlich genau derjenige, dessen Bedingung zuerst erfüllt ist. Danach wird die Programmabarbeitung nach dem ENDCASE fortgesetzt.

Trifft keine der Bedingungen zu, kann mit OTHERWISE ein Anweisungsblock angefügt werden, der dann abgearbeitet wird. Ansonsten wird das Programm direkt hinter ENDCASE fortgesetzt (siehe Abb. 7).

Zusammenfassend kann man sagen, daß man mit diesen 4 Programmstrukturen -dem Anweisungsblock, - der DO WHILE-Schleife,- der IF THEN ELSE- und der DO CASE-Bedingung ein Problem vollständig und eindeutig lösen kann.

Ein- und Ausgabe-Befehle

Abb.6: Konzeptionelle Umsetzung der IF-THEN-ELSE-Struktur DO CASE

ADIMENS bietet eine umfassende Unterstützung bei der Datenein- und ausgabe. Der einfachste Befehl zur Erzeugung einer Ausgabe wird durch ein Fragezeichen (?) eingeleitet. Das Fragezeichen, gefolgt von einem beliebigen Ausdruck oder einer Folge von Ausdrücken, bewirkt, daß der Wert des Ausdrucks auf dem Bildschirm oder dem Drucker ausgegeben wird.

    ? < Ausdruck 1 >

Die Ausgabe erfolgt dabei in der nächsten Zeile. Sollen mehrere Ausdrücke ausgegeben werden, müssen sie durch Kommata voneinander getrennt werden. Soll die Ausgabe direkt in der aktuellen Zeile erfolgen, müssen zwei Fragezeichen als Ausgabebefehl eingegeben werden :

    ?? < Ausdruck 2 >

Für die Eingabe eines einzelnen Zeichens dient der Befehl:

WAIT Information auf dem Bildschirm TO Variablen Namen

WAIT unterbricht einen Programmablauf. Das Programm wird erst dann weiter abgearbeitet, wenn entweder ein beliebiges Zeichen eingegeben oder eine beliebige Taste gedrückt wird. Durch die Erweiterung des WAIT-Befehls mit TO Variablen Name wird die Eingabe als Zeichenkette der angegebenen Variablen zugewiesen. Dabei werden die Returntaste und alle weiteren Sondertasten, als leere Sondertasten als leere Zeichenketten betrachtet. Eine zweite Möglichkeit, den WAIT-Befehl zu erweitern, besteht darin, ihm eine Information anzufügen.

Abb.7: Konzeptionelle Umsetzung der DO CASE-Struktur

Befehle zum Maskenaufbau

Mit TALK ist es möglich, mit den in INIT definierten Masken zu arbeiten, oder sich neue Masken zu erstellen, um sich Datensätze ausgeben zu lassen. Die neuen Masken können entweder Merkmale aus der Datenbank oder Variablen enthalten. Es ist außerdem möglich, eine Maske mit Kommentaren zu versehen. Vor dem Aufbau einer selbstdefinierten Maske sollte der Bildschirm gelöscht werden. Das Löschen erfolgt mit Hilfe des CLEAR- Befehls.

An welcher Stelle ein Kommentar oder eine Merkmalsausprägung in der Maske stehen soll, wird über den @ < Zeile >,< Spalte >-Befehl festgelegt. Die Position in der Maske wird durch zwei Zahlen festgelegt. Die erste Zahl gibt die Zeilennummer, die zweite die Spaltennummer an.

Kommentare werden durch den SAY < Ausdruck > in eine Maske eingefügt. Neben Kommentaren können auch ganze Ausdrücke am Bildschirm ausgegeben werden. Die Ausgabe ist jedoch auf einen Ausdruck beschränkt. Der SAY-Befehl arbeitet also ähnlich wie das doppelte Fragezeichen und kann auch dementsprechend eingesetzt werden. Während der SAY-Befehl dazu dient, eine Maske optisch zu gestalten, lassen sich mit dem GET-Befehl Merkmalsausprägungen oder Variableinhalte einer Maske bearbeiten.

GET < Variablenname >
PICTURE < Kontroll-Anweisung >

Mit PICTURE kann der Inhalt eines Merkmals durch Kommentare oder Ergänzungen erweitert oder nur eine teilweise Bearbeitung zugelassen werden.

Alle GET-Anweisungen innerhalb eines Programmes werden zunächst intern zwischengespeichert. Das Abarbeiten der GET-Anweisungen erfolgt erst über einen gesonderten Befehl READ.

Diskussion des Menüaufbaues

Ein einfacher Menüaufbau könnte folgendermaßen aussehen:

    CLEAR  
    ? “...............”  
    ? “...............”  
    ? “...............”  

usw.

Ein Nachteil ist dabei aber, daß bei später gewünschter Verschiebung der Menüdarstellung sehr viele Leerschritte von Hand eingefügt oder gelöscht werden müssen. Abhilfe ergibt sich bei direkter Adressierung.

    CLEAR
    @ 10,20 SAY “ 0 ... Programmende“
    @ 11,20 SAY “ 1 ... Stammdatenverwaltung “
    @ 12,20 SAY “ 2 .... Organisation “

Hier müßten zwar evtl, nur noch Zahlen geändert werden, aber immer noch mehrere. So müßten z.B. bei einer gewünschten Verschiebung um 10 Spalten nach rechts alle “20“ durch “30“ ersetzt werden. Man kann nun die Tabulatoren durch eine Variable ersetzen. Zum Beispiel durch TAB = 20.

In Abb. 8 oben wurde ein allgemeines Struktogramm für eine Menüsteuerung entworfen. Die Auswahl der Untermenüpunkte erfolgt durch die Zuweisung der Variablen wähl. Sie kann die Werte von 1 bis n annehmen. Dabei ist n die Zahl der möglichen aufzurufenden Module. Es wird dann vereinbart, daß bei der Eingabe der Zahl 0 das Programm beendet werden soll.

Zum Standardumfang eines Menüprogrammes gehört außerdem eine sogenannte Plausibilitätsprüfung (bzw. -kontrolle), d.h. eine Abfrage, die nicht erlaubte Eingaben erkennen und zurückweisen soll. Da dazu eventuell eine mehrfache Wiederholung der Eingabe möglich sein muß, ist im Programm eine zweite (“innere”) Schleife erforderlich. Bei näherer Betrachtung dieses Algorithmus zeigen sich jedoch zwei Fehler:

Abb.8: Entwurfsalternativen beim Menüaufbau

Deshalb wurde folgende Abhilfe geschaffen.

Daraus ergibt sich das Struktogramm in Abb. 8 unten. Dieses Schema wird bei allen weiteren Menüauswahlen weiterverwendet.

Die Feinstruktur des Hauptmenüs eines möglichen Anwendungsprogrammes wird in Abb. 9 gezeigt.

Im Anweisungsblock 1 werden die Schalterstellungen festgelegt. Dabei wird immer am Anfang der Bildschirm gelöscht und die automatische Maskenanzeige unterdrückt. Dies hat den Vorteil, daß, wenn man eine Datenbank mit einer zugehörigen Datei öffnet, die Maske mit der ersten Datei nicht angezeigt wird. Das automatische Löschen des Bildschirmes wird unterdrückt, und die Sonderregelungen für die Funktion FIND werden abgeschaltet.

Im Anweisungsblock 2 werden die globalen Variablen festgelegt. Globale Variablen sind im ganzen Programm gültig. Bei ADIMENS Talk wird dies dadurch geregelt, daß die Variablen in einem Unterprogramm nicht deklariert werden müssen. Beim Übersetzen des Unterprogrammes wird dann diese Variable importiert und als global betrachtet.

Nach diesen Systemeinstellungen wird die DO WHILE-Schleife so lange ausgeführt, bis der Benutzer mit der Eingabe “0” das Programmende selbst definiert. Die Eingabe wird der Variablen “wähl“ zugeordnet, welche auf den Wert “ “ ( 1 Leerzeichen ) oder äquivalent dazu SPACE(1) gesetzt wurde. Innerhalb dieser Schleife wird der Anweisungsblock 3 abgearbeitet, der die Menüausgabe auf dem Bildschirm anzeigt. Er wurde in die DO-WHILE-Schleife gesetzt, damit bei jeder Änderung auch die Uhrzeit und das Datum korrekt angezeigt werden. Aus dem Struktogramm in Abb. 9. wird ersichtlich, daß nun die Variable “wahl” erneut auf den Wert SPACE (1) gesetzt wird, um nicht in eine Endlos-Schleife zu laufen. Die Schleife für die Plausibilitäts-Kontrolle erlaubt nur die Eingaben für die Variable “wahl” von 0 bis 4. Die Masken werden mit den SAY-Kommandos aufgebaut. Mit dem Kommando WAIT wird eine Eingabe von der Tastatur erwartet, und ein Tastendruck wird der Variablen "wahl” zugewiesen.

Abb. 10: Hierarchie-Diagramm der Menüsteuerung

Im Anweisungsblock 4 findet eine DO CASE-Abfrage statt, die bewirkt, daß die Variable “wahl” auf die Werte 0 bis 4 abgefragt wird. Je nachdem, welche Ziffer eingegeben wurde, wird mit DO das entsprechende Untermodul ausgeführt. Die DO CASE-Schleife wird mit END-CASE abgeschlossen. Die DO WHILE-Schleife wird mit ENDDO abgeschlossen. Listing 1 und Listing 2 zeigen das durchgängige Konzept einer Menüsteuerung. Im Listing 2 findet eine differenzierte Menüauswahl statt. Zum Schreiben, Ändern und Speichern des Quelltextes wird unabhängig von der Programmiersprache ADIMENS Talk ein sogenannter Editor benötigt. Dies kann im Prinzip ein beliebiges Textverarbeitungsprogramm sein, jedoch mit folgenden Einschränkungen:

Für die glücklichen Atari-Besitzer mit 1 Megabyte RAM eignet sich eine RAM-DISK. Für die Programmierung der Menüsteuerung müssen daher nur die Programme TALK.PRG, TALK.RSC and ihr “Liebingseditor” in die Ram Disk geladen werden. Die erstellten Quelltexte laben die Kennzeichnung *. TLK und die dann mit ADI Talk übersetzten Programme *.TLP. Wollen Sie nun selbständig eine Menüsteuerung generieren, so empfiehlt es sich, sich ein einheitliches Modulkonzept zurechtzulegen. Das einzige, was sie bei der vorgestellten Menüsteuerung noch ändern müßten, ist der Aufbau der einzelnen Auswahlpunkte.

Abb. 9: Feinstruktur einer Menüauswahl

Schluß, Zusammenfassung und Ausblick

Im 1. Teil der flexiblen Modulprogrammierung haben Sie die wichtigsten Programmstrukturen kennengelemt, die eine Anwendungsprogrammierung mit ADIMENS Talk erlauben. Danach wurde im Quelltext näher auf die Möglichkeiten einer strukturierten Programmierung, den TOP-DOWN-Entwurf und die Bedeutung der Struktogramme und deren konzeptionelle Umsetzung eingegangen. Nach einer Stoffsammlung an Teilaufgaben konnte die hierarchische Gliederung eines beispielhaften Menüaufbaues vorgestellt werden.Mit dieser flexiblen und universell einsetzbaren Menüsteuerung können Sie ihr Anwendungprogramm gestalten.Im Teil2 wird gezeigt werden, wie man mit einem flexiblen Modul Merkmale Ihrer Datenbank, die in verschiedenen Dateien Vorkommen, benutzerfreundlich erfassen, löschen und abspeichern kann.

/1/ Günter Spur, Frank-Lothar Krause, CAD-Technik, Lehr- und Arbeitsbuch für die Rechnerunterstützung in Konstruktion und Arbeitsplanung, Hanser Verlag.

/* PROGRAMM MENUE01 .TLK */

/***************************************************/ 
/* Dies ist ein Beispiel für eine Menüsteuerung */ 
/* (C)  Copyright by Hans-Ulrich Mayer 1988 */
/***************************************************/

/*** 1 ***/
/* FESTLEGUNG DER SCHALTERSTELLUNGEN    *
/* Löschen des Bildschirmes *
CLEAR
/* Unterdrücken der automatischen Maskenanzeige *
SET AUTOSC OFF
/* Die Sonderregelungen für die Funktion FIND sind * 
/* abgeschaltet *
SET DBASE OFF
/*** 1 ***/

/***************************************************/ 
/* DURCHLAUFE die Schleife SOLANGE der Benutzer das */ 
/* Programm durch die Eingabe "0" verlassen will. */ 
DO WHILE ( WAHL <> "0" )
/******************************************************/ 
    /*** 3 ***/
    /* MENÜAUSGABE - Aufbau der Kopfzeile */
    CLEAR
    /* aktuelle Datumsanzeige und der Uhrzeit */
    @ 02    ,00 SAY " Datum "
    @ 03    ,00 SAY DATE ()
    @ 02    ,72 SAY "Uhrzeit"
    @ 03    ,72 SAY TIME()
    @ 01    ,00 SAY BILD1 + BILD1
    @ ROW() ,TAB SAY "  MENÜ STEUERUNG
                *** V 1.01 ***"
    @ ROW()+1,TAB SAY "flexible Anwendungsprogrammierung mit ADIMENS Talk "
    @ ROW()+1,00 SAY BILD2 + BILD2

    /* MENÜAUSGABE - Aufbau d.einzelnen Auswahlpunkte */

    @ ROW()+1,TAB SAY " **** HAUPTMENUE **** "
    @ ROW()+1,TAB SAY "
    @ ROW()+1, 00 SAY BILD1 + BILD1
    @ ROW()+1,TAB SAY "0 .... PROGRAMM ENDE    "
    @ ROW()+1,TAB SAY "                    "
    @ ROW()+1,TAB SAY "                    "
    @ ROW()+1,TAB SAY "1 .... STAMMDATEN       "
    @ ROW()+1,TAB SAY "                    "
    @ ROW()+1,TAB SAY "2 .... EINKAUF          "
    @ ROW()+1,TAB SAY "                    "
    @ ROW()+1,TAB SAY "3 .... ORGANISATION    "
    @ ROW()+1,TAB SAY "                    "
    @ ROW()+1,TAB SAY "4 .... STATISTIK        "
    @ ROW()+1,TAB SAY "                    "
    @ ROW()+1, 00 SAY BILD1 + BILD1
    /*** 3 ***/

/********************************************/

    /*** 4 ***/
    /* LOKALE VARIABLENDEKLARATION - die Variablen */ 
    /* gelten für dieses Programm */
    STORE SPACE(1) TO WAHL 
    STORE ROW()+4 TO ZEILE
    /*** 4 ***/

/********************************************/
/* DURCHLAUFE d.Schleife SOLANGE ein falscher Wert */ 
/* eingegeben wird */
DO WHILE ( (WAHL < "0") OR (WAHL > "4") )
/********************************************/

    /*** 5 ***/
    /* EINGABE WAHL */
    @ ZEILE, 00 WAIT " Bitte wählen Sie .... "TO WAHL
    /*** 5 ***/ 

    /********************************************/

    /* FALLUNTERSCHEIDUNG - Verzw.in Untermoduln */ 
    DO CASE

        /* FALL 0 : Programm beenden und Zurück auf */ 
        /* Betriebssystemebene */
        CASE WAHL = "0"
            /* nichts tun */
        /* FALL 1 : Sprung ins Untermenü STAMMDATEN */ 
        CASE WAHL = "1"
            DO "STAMM"
        /* FALL 2 : Sprung ins Untermenü EINKAUF */
        CASE WAHL = "2"
            DO "LEER"
        /* FALL 3 : Sprung ins Untermenü ORGANISATION*/ 
        CASE WAHL = "3"
            DO "LEER"
        /* FALL 4 : Sprung ins Untermenü STATISTIK */
        CASE WAHL = "4"
            DO "LEER"
        /* ANDERENFFALLS */
        OTHERWISE
        /* Erzeugen einer Falschmeldung m.Warnton */ 
            BELL
            @ 22,19 SAY "Falsche Eingabe !!! Bitte wiederholen ..."

    ENDCASE

/********************************************/

/* Beenden der zweiten Schleife, da ein richtiger */ 
/* Wert eingegeben wurde */

ENDDO
/********************************************/

/* Beenden der ersten Schleife da der Benutzer das */ 
/* Programm verlassen will */

ENDDO

/********************************************/

Listing 1: Hauptmenü

/* PROGRAMM STAMM.  TLK */
/********************************************/
/* Dies ist ein Beispiel für eine Menüsteuerung */ 
/* (C)  Copyright by Hans-Ulrich Mayer 1988 */
/********************************************/


/*** 1 ***/
/* FESTLEGUNG DER SCHALTERSTELLUNGEN */
/* Löschen des Bildschirmes */
CLEAR
/* Unterdrücken der automatischen Maskenanzeige */
SET AUTOSC OFF
/* Die Sonderregelungen für die Funktion FIND sind */ 
/* abgeschaltet */
SET DBASE OFF
/*** 1 ***/

/********************************************/

/*** 2 ***/
/* MENÜAUSGABE - Aufbau der Kopfzeile */
CLEAR
/* aktuelle Datumsanzeige und der Uhrzeit */
@ 02,00 SAY " Datum "
@ 03,00 SAY DATE()
@ 02,72 SAY "Uhrzeit"
@ 03,72 SAY TIME()
@ 01,00 SAY BILD1 + BILD1
@ ROW(),TAB SAY "   MENÜ    STEUERUNG *** V 1.01 *** " 
@ ROW()+1, TAB SAY "flexible Anwendungsprogrammierung mit ADIMENS Talk"
@ ROW()+1,00 SAY BILD2 + BILD2

/* MENÜAUSGABE - Aufbau d.einzelnen Auswahlpunkte */

@ ROW()+1,TAB SAY " **** STAMMDATEN **** "
@ ROW()+1, 00 SAY BILD1 + BILD1
@ ROW()+1,TAB SAY "0 .... ZURÜCK    zum Hauptmenü   "
@ ROW()+1,TAB SAY " "
@ ROW()+1,TAB SAY " "
@ ROW()+1,TAB SAY " LIEFERANTEN
@ ROW()+1,TAB SAY " 1... Erfassen 2... Ändern 3... Suchen "
@ ROW()+1,TAB SAY "  "
@ ROW()+1,TAB SAY "             KUNDEN          "
0 ROW()+1,TAB SAY " 4... Erfassen 5... Ändern 6... Suchen "
@ ROW()+1,TAB SAY " "
@ ROW()+1,TAB SAY " MITARBEITER "
@ ROW()+1,TAB SAY " 7. . . Erfassen 8...Ändern 9...Suchen "
@ ROW()+l,TAB SAY " "
@ ROW()+1, 00 SAY BILD1 + BILD1 
/**** 2 ****/

/********************************************/

/**** 3 **** /
/* LOKALE VARIABLENDEKLARATION - die Variablen */ 
/* gelten für dieses Programm */
STORE SPACE (1) TO WAHL 
STORE ROW()+4 TO ZEILE
/**** 3 ****/

/********************************************/
/* DURCHLAUFE die Schleife SOLANGE ein falscher */ 
/* Wert eingegeben wird */
DO WHILE ( (WAHL < "0") OR (WAHL > "9") )

/********************************************/

/**** 4 ****/
/* EINGABE WAHL */

@ ZEILE, 00 WAIT " Bitte wählen Sie .... " TO WAHL
/**** 4 ****/ 

    /********************************************/
    /* FALLUNTERSCHEIDUNG - Verzw.in Untermoduln */ 
    DO CASE

        /* FALL 0 : Programm beenden und zurück zum */ 
        /*Hauptmenü */
        CASE WAHL = "0"

        /* nichts tun */

        /* FALL 1 : Sprung ins Untermenü LIEFERANTEN */ 
        /* ERFASSEN */
        CASE WAHL = "1"
            DO "LERFASSE"
        /* FALL 1 : Sprung ins Untermenü LIEFERANTEN */ 
        /* ÄNDERN */
        CASE WAHL = "2"
            DO "LEER"
        /* FALL 1 : Sprung ins Untermenü LIEFERANTEN */ 
        /* SUCHEN */
        CASE WAHL = "3"
            DO "LEER"
        /* FALL 1 : Sprung ins Untermenü KUNDEN */
        /* ERFASSEN */
        CASE WAHL = "4"
            DO "LEER"
        /* FALL 1 : Sprung ins  Untermenü KUNDEN */
        /* ÄNDERN */
        CASE WAHL = "5"
            DO "LEER"
        /* FALL 1 : Sprung ins Untermenü KUNDEN */
        /* SUCHEN */
        CASE WAHL = "6"
            DO "LEER"
        /* FALL 1 : Sprung ins Untermenü MITARBEITER */
        /* ERFASSEN */
        CASE WAHL = "7"
            DO "LEER"
        /* FALL 1 : Sprung ins Untermenü MITARBEITER */
        /* ÄNDERN */
        CASE WAHL = "8"
            DO "LEER02"
        /* FALL 1 : Sprung ins Untermenü MITARBEITER */
        /* SUCHEN */
        CASE WAHL = "9"
            DO "LEER"

        /* ANDERENFALLS */
        OTHERWISE
        /* Erzeugen einer Falschmeldung mit Warnton */ 
        BELL
        @ 22,19 SAY "Falsche Eingabe !!! Bitte wiederholen ... "
    ENDCASE
/********************************************/
/* Beenden der zweiten Schleife, da ein richtiger */ 
/* Wert eingegeben wurde */
END DO
/********************************************/

/* Beenden der ersten Schleife, da der Benutzer zum */ 
/* Hauptmenü will. */
ENDDO
/********************************************/

/* Rücksprung ins Hauptmenü */
STORE "1" TO WAHL 
DO "MENUE01"
/********************************************/

Listing 2: Untermenü

/*                  PROGRAMM LEER.TLK                */
/*****************************************************/ 
/*      Dies ist ein Beispiel eines leeren Moduls    */
/*      (C) Copyright by Hans-Ulrich Mayer   1988    */
/*****************************************************/

/**** 1 ****/

/* FESTLEGUNG DER SCHALTERSTELLUNGEN */
/* Löschen des Bildschirmes */
CLEAR
/* Unterdrücken der automatischen Maskenanzeige */
SET AUTOSC OFF
/* Die Sonderregelungen für die Funktion FIND sind */ 
/* abgeschaltet */
SET DBASE OFF
/**** 1 ****/

/****************************************************/

/**** 2 ****/
/* MENÜAUSGABE - Aufbau der Kopfzeile */
CLEAR
/* aktuelle Datumsanzeige und Uhrzeit */

@ 02,00 SAY " DATUM "
@ 03,00 SAY DATE()
@ 02,72 SAY "Uhrzeit"
@ 03,72 SAY TIME()
@ 01,00 SAY BILD1 + BILD1
@ ROW(), TAB SAY " MENÜ STEUERUNG *** V 1.01 *** "
@ ROW()+1, TAB SAY "flexible Anwendungsprogrammierung mit ADIMENS Talk"
@ ROW()+1,00 SAY BILD2 + BILD2

/* BILDSCHIRM ANZEIGE - Meldung auf dem Bildschirm */

@ ROW()+1,TAB SAY " **** Leeres Modul ****          "
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,00 SAY BILD1 + BILD1 
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,TAB SAY " Leider ist dieses Programm noch " 
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,TAB SAY " nicht erstellt worden.          "
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,TAB SAY " Bitte drücken Sie eine beliebige " 
@ ROW()+1,TAB SAY " Taste, um wieder ins vorherige " 
@ ROW()+1,TAB SAY " Menü zurückzukehren             "
@ ROW()+1,TAB SAY "                                 "
@ ROW()+1,00 SAY BILD1 + BILD1 
/**** 2 ****/

/********************************************/

/**** 3 ****/
/* WARTEN bis eine beliebige Taste gedrückt wurde */ 
@ ROW()+4,00 WAIT 
/**** 3 ****/

/********************************************/

/* Rücksprung ins vorherige Menü, von dem aus */
/* verzweigt wurde. */

Listing 3: Leerprogramm
Hans-Ulrich Mayer


Links

Copyright-Bestimmungen: siehe Über diese Seite
Classic Computer Magazines
[ Join Now | Ring Hub | Random | << Prev | Next >> ]