home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Power-Programmierung
/
CD1.mdf
/
xbase
/
tools
/
dbt
/
dbt.doc
next >
Wrap
Text File
|
1993-07-28
|
77KB
|
1,429 lines
U1EG
┌─────────────────────────────────────────────────────────────────────────┐
│ IF DO CASE │
│ ELSE CASE │
│ DO WHILE DO WHILE │
│ EXIT RETURN │
│ ENDIF CASE │
│ ENDDO ENDDO │
│ ENDDO │
│ │
│ Chaos ERROR Fehler Nichts geht mehr ! WARUM ??? WO ??? │
└─────────────────────────────────────────────────────────────────────────┘
╔═════════════╗ ╔═════════════╗ ╔═══════════════╗
║ ╔═════════╗ ╚═╗ ║ ╔═════════╗ ╚╗ ╚══════╗ ╔══════╝
║ ║ ╚═╗ ║ ║ ║ ╚╗ ║ ║ ║
║ ║ ║ ║ ║ ║ ║ ║ ║ ║
║ ║ ║ ║ ║ ║ ╔╝ ║ ║ ║
║ ║ ║ ║ ║ ║ ╔═╝ ╔╝ ║ ║
║ ║ ║ ║ ║ ╚═══════╝ ╔═╝ ║ ║
║ ║ ║ ║ ║ ╔═══════╗ ╚═╗ ║ ║
║ ║ ║ ║ ║ ║ ╚═╗ ╚╗ ║ ║
║ ║ ║ ║ ║ ║ ╚╗ ║ ║ ║
║ ║ ║ ║ ║ ║ ║ ║ ║ ║
║ ║ ╔═╝ ║ ║ ║ ╔╝ ║ ║ ║
║ ╚═════════╝ ╔═╝ ║ ╚═════════╝ ╔╝ ║ ║
╚═════════════╝ ╚═════════════╝ ╚═╝
┌─────────────────────────────────────────────────────────────────────────┐
│ │
│ ┌─IF ┌─DO CASE ┌─DO WHILE ┌─PROCEDURE ┌─FUNCTION │
│ ├──ELSE ├───CASE ├──LOOP ┼───RETURN │ │
│ └─ENDIF ├──OTHERWISE ┼──EXIT └─RETURN └─RETURN │
│ └─ENDCASE └─ENDDO │
│ │
│ │
│ ┌─DO WHILE HAUPT──┬──STADAVER─┬──KUNMOD │
│ │ ┌─DO CASE │ ├──ARTMOD │
│ │ ├─CASE │ ├──TEXMOD │
│ │ │ ┌─IF │ ├──PARMOD │
│ │ │ ├──ELSE │ └──OPOMOD │
│ │ │ └─ENDIF ├──STADAANZ─┬──KUNANZ │
│ │ ├─CASE │ ├──ARTANZ │
│ │ │ ┌─IF │ ├──TEXANZ │
│ │ │ ├──ELSE │ └──PARANZ │
│ ┼──┼──┼──EXIT ├──FAKTURA──┬──ERFASS───┬──SUCHEN │
│ │ │ └─ENDIF │ │ ├──SUCHEN │
│ │ ├─OTHERWISE │ │ └──SUCHEN │
│ │ │ ┌─IF │ ├──DRUCK │
│ ├──┼──┼──LOOP │ └──AKTUAL │
│ │ │ └─ENDIF ├──OFFPOS │
│ ┼──┼──────RETURN ├ LAGER │
│ │ └─ENDCASE └──SICHERN │
│ └─ENDDO │
└─────────────────────────────────────────────────────────────────────────┘
╔═════════════════════════════════════════════════════════════════════════╗
║ ╔═══════════════════════════════════════════════════════════════════╗ ║
║ ║ d B a s e I I I / C L I P P E R - P r o g r a m m - ║ ║
║ ║ S t r u k t u r - T e s t e r ║ ║
║ ║ + D o k u m e n t a t i o n s - P r o g r a m m ║ ║
║ ╚═══════════════════════════════════════════════════════════════════╝ ║
║ DBT-Version 3.0 Copyright 1989- VoG ║
║ DBT-Small-Version ║
╚═════════════════════════════════════════════════════════════════════════╝
╔═════════════════════════════════════════════════════════════════════════╗
║ G ╔═══════════════════════════════════════════════════════════════════╗ H ║
║ G ║ d B a s e I I I / C L I P P E R - P r o g r a m m - ║ H ║
║ G ║ S t r u k t u r - T e s t e r ║ H ║
║ G ║ + D o k u m e n t a t i o n s - P r o g r a m m ║ H ║
║ G ╚═══════════════════════════════════════════════════════════════════╝ H ║
║ DBT-Version 3.0 Copyright 1989- VoG ║
║ G DBT-Small-Version H ║
╠═════════════════════════════════════════════════════════════════════════╣
║ ║
║ GDBTH untersucht Ihr GdBase/Clipper-ProgrammH auf GStruktur-Fehler.H ║
║ ║
║ Jeder GStruktur-BlockH beginnt mit einer GStruktur-EröffnendenH ║
║ Anweisung und GmussH mit der entsprechenden GStruktur-SchließendenH ║
║ Anweisung enden. GInnerhalb eines Struktur-BlockesH sind nur die ║
║ zu Gdiesem Struktur-Block gehörenden AnweisungH und Gneue Struktur-H ║
║ GEröffnende und Struktur-Schließende AnweisungenH zulässig. ║
║ ║
║ Die in Klammern stehenden Struktur-Anweisungen sind wahlweise: ║
║ ║
║ G ┌─IF ┌─DO WHILE ┌─DO CASE ┌─PROCEDURE ┌─FUNCTION H ║
║ G ├──(ELSE) ├──(LOOP) ├───CASE ┼───RETURN │ H ║
║ G └─ENDIF ┼──(EXIT) ├──(OTHERWISE) └─RETURN └─RETURN H ║
║ G └─ENDDO └─ENDCASE H ║
║ ║
║ GFehlerH in einer Struktur werden mit der GStruktur-EröffnendenH ║
║ Anweisung und Gder AnweisungH ausgewiesen, bei der der GStruktur-H ║
║ GverstoßH erkannt wurde. ║
║ ║
║ Aufruf DBT ║
║ ║
║ GDBT (name.ext) (/param) H ║
║ ║
║ Gname.ext:H Name des zu testenden Programms. ║
║ wildcard's (* / ?) in name führt zum Test aller ║
║ zutreffenden Programme. ║
║ ║
║ G/param :H über Parameter kann der Struktur-Test und die weitere ║
║ Verarbeitung beeinflusst werden. ║
║ ║
║ G R H = RETURN innerhalb von Strukturen werden nicht ausgewertet. ║
║ Ein RETURN führt sonst zur Überprüfung von offenen ║
║ Strukturen. ║
║ ║
║ ║
║ ║
║ G P H = Struktuierte Druckausgabe (CTRL-P oder >filename) ║
║ N = ohne Ausgabe der Satznummer ║
║ ║
║ G C H = Ausgabe nur der Struktur-Blöcke ║
║ ║
║ G E H = Ausgabe der Verarbeitungs-Zeiten ║
║ ║
║ G T H = T ist der 1. Parameter des Autoren gewesen, weil er ║
║ nicht glaubte, daß sein Struktur-Analyse-Programm ║
║ so schnell ist. ║
║ ║
║ ║
║ ║
║ ║
╠═════════════════════════════════════════════════════════════════════════╣
║ ║
║ G DBT benötigt zur Analyse von 1.000 Zeilen 5 Sekunden. H ║
║ G ( 200 Zeilen pro Sekunde auf einem IBM/XT) H ║
║ ║
╚═════════════════════════════════════════════════════════════════════════╝
EG Inhaltsverzeichnis:
-------------------
Struktuierte Programmiermethode 1
DBT, die kleine schnelle Hilfe 3
DBT als Struktur-Tester 5
* DBT als Dokumentations-System 6
* Erläuterunge zu den Ausgaben 7
* Test- und Dokumentations-Lauf 9
* Die XREF - Funktionen sind nur in der
erweiterten DBT-Version erhalten.
Informationen über die DBT-full-Version können beim
Autoren angefordert werden.
dBase und Clipper sind geschützte Produktnamen.
DBT ist ein Produkt von VoG
DBT ist unter DOS > Version 2.0 ablauffähig und mit
Sourcen der dBase IV Plus und Clipper 86 getestet.
U1A
──────────────────────────────────────────────────────
──────────────────────────────────────────────────────
──────────────────────────────────────────────────────
┌─────────────────────────────────────────────────────
U1A
│ GV.Gülke, Gieseckenkamp 6a, D-3012 Langenhagen 1 H
U1A └─────────────────────────────────────────────────────
U1A
U1
H
1.
EGStruktuierte Programmier-Methoden.
EG----------------------------------H
Die Struktuierten Programmier-Methoden bieten Sprachelemente, mit denen
ein Programmierer sein Programm in Funktions-Blöcke aufteilen kann.
In den Sprachelementen für logische Entscheidungen oder Fall-
unterscheidungen werden per Funktionsaufruf oder Verzweigung mit
Rückkehr hinter die Verzweigung der Funktions-Block aufgerufen.
Weitere Sprachelemente erlauben eine Wiederholung von Funktionsaufrufen
begrenzt durch eine Anzahl oder durch eine logische Entscheidung.
Der Beginn eines Funktions-Blocks ist immer durch einen eindeutigen
Namen gekennzeichenet. Der Funktions-Block kann ein Programm, eine
Procedure oder eine Function sein. Das Ende eines Funktions-Blocks ist
durch ein Return, eine andere Procedure oder Funktion, oder durch das
Ende des Programms gekennzeichenet.
Bei den logischen Entscheidungen, Fallunterscheidungen, Wiederholungen
wird der Beginn der Struktur durch Struktur-eröffnende Sprachelemente
und das Ende der Struktur durch Struktur-schließende Sprachelemente
eindeutig gekennzeichenet und ergibt einen Struktur-Block.
G
┌─────────────────────────────────────────────────────────────────────┐
│ │
│ ┌─IF ┌─DO CASE ┌─DO WHILE ┌─PROCEDURE ┌─FUNCTION │
│ ├──ELSE ├──CASE ├──LOOP ┼───RETURN │ │
│ └─ENDIF ├──OTHERWISE ┼──EXIT └─RETURN └─RETURN │
│ └─ENDCASE └─ENDDO │
└─────────────────────────────────────────────────────────────────────┘
Tabelle der in dBase / Clipper geltenden Sprachelemente
für Struktur-Blöcke. H
Innerhalb von logischen Entscheidungen oder Fallunterscheidungen gibt
es noch den Gültigkeitsbereich der Entscheidung.
Beim IF-Struktur-Block (logische Entscheidung) liegt der Gültigkeits-
bereich für die WAHR-Entscheidung zwischen IF und ELSE, die FALSCH-
Entscheidung zwischen ELSE und ENDIF. Beim DO CASE-Struktur-Block
(Fallunterscheidung) liegt der Gültigkeitsbereich zwischen dem
zutreffenden CASE und dem nächsten CASE oder OTHERWISE oder ENDCASE,
oder dem zutreffenden OTHERWISE und dem ENDCASE. Bei der DO
CASE-Struktur ist noch zu berücksichtigen, daß immer nur der 1.
zutreffende CASE ausgeführt wird.
2.
Beim DO WHILE-Struktur-Block führt die ENDDO-und LOOP-Anweisung zum
Beginn der Struktur, der DO WHILE-Anweisung. Der DO WHILE-Struktur-
Block wird sooft durchlaufen, bis die DO WHILE-Bedingung erfüllt ist,
oder die DO WHILE-Schleife durch eine EXIT-Anweisung beendet wird.
Der RETURN innerhalb von Struktur-Blöcken beendet immer rigoros den
Funktions-Block.
Innerhalb der Struktur-Blöcke und Gültigkeitsbereiche können weiter
Struktur-Blöcke aufgerufen werden. So kann z.B. innerhalb des
WAHR-Zweiges einer IF-Struktur ein weiterer IF-Struktur-Block,
innerhalb eines OTHERWISE-Falls ein weiterer DO CASE-Struktur-Block
aufgerufen werden.
Eine Verschachtelung aller Struktur-Blöcke untereinander ist somit
möglich.
Nun ergibt sich allerdings das Problem, daß bei verschachtelten
Struktur- Blöcken zwar der Beginn eines Struktur-Blocks eindeutig ist,
daß aber oft das dazugehörende Ende des Struktur-Blocks nicht so
eindeutig zu identifizieren ist. Bei verschachtelten IF-Strukturen ist
oft das dazugehörende ELSE und ENDIF nicht so leicht zu bestimmen. Ein
an einer falschen Stelle gesetztes ELSE verändert sofort die gesamte
logische Struktur. Ebenso führen fehlende oder doppelte
Struktur-Ende-Anweisungen zur Veränderung der logischen Struktur. Oft
erkennen die programmausführenden Produkte diese Struktur-Verstöße
nicht oder melden sie nicht bei der Programmausführung. Solche Fehler
werden meistens erst nach langwierigen Testen aufgedeckt oder nach
zeitaufwendigen Kompilierungen gemeldet.
Die optimale Lösung wäre ein Editor, der solche einfachen
Struktur-Teste durchführen kann und die Struktur-Verstöße sofort
anzeigt.
3.
EG
EGD B T , die kleine schnelle Hilfe !
EG-----------------------------------H
DBT ist als Hilfsmittel für die Programmierung als schneller
Struktur-Tester entwickelt worden.
Sie schreiben oder ändern ihr Programm mit einem herkömmlichen Editor.
Vor dem Struktur-Test schreiben Sie Ihr Programm zurück und rufen DBT
über die DOS-Schnittstelle oder direkt im DOS auf. DBT untersucht
jetzt Ihr Programm blitzartig nach Struktur-Fehlern und meldet jeden
Verstoß mit der Struktur-Eröffnenden Zeile/Zeilen-Nr. und der
Zeile/Zeilen-Nr., bei dem der Struktur-Verstoß erkannt wurde.
Gleichfalls können aber auch Hinweise auf unlogische Anwendungen in
Struktur-Blöcken gemeldet werden.
┌────────────────────────────────────────────────────────────────────────────┐
│ Source filename: dbterr.prg │
│ │
│ Line: 8 Struktur-Beginn. │
│ do case Auswahl │
│ Line: 9 >> OTHERWISE nach DO CASE │
│ otherwise │
│ Line: 8 Struktur-Beginn. │
│ do case Auswahl │
│ Line: 11 >> ENDCASE ohne CASE │
│ endcase │
│ Line: 14 Struktur-Beginn. │
│ If │
│ Line: 17 >> ELSE doppelt │
│ else │
│ Line: 14 Struktur-Beginn. │
│ If │
│ Line: 18 >> ELSE doppelt │
│ else │
│ Line: 7 Struktur-Beginn. │
│ do while │
│ Line: 21 >> ENDDO fehlt │
│ │
│Source filename: dbterr.prg 5 Struktur-Fehler erkannt !!! │
└────────────────────────────────────────────────────────────────────────────┘
GBeispiel: Struktur-Analyse:H
---------------------------
Der Struktur-Fehler kann somit aufgrund der Zeilen-Nr. sofort nach
Rückkehr in den Editor behoben werden.
Die Ausgabe des Fehlerprotokolls kann per CTL-P auf den Drucker
geleitet oder per DOS-Umleitung > in eine Datei geschrieben werden.
Weiter bietet DBT die Möglichkeit die Struktur-Blöcke oder das ganze
Programm struktuiert aufbereitet auszugeben.
4.
╔══════════════════════════════════════════════════════╦══VoG═════════════════╗
║ dbterr.prg 1990.07.22 - 19:47 ║ Datum: 1990.07.22 ║
╟──────────────────────────────────────────────────────╢ Zeit : 16:47:47 ║
║ dbterr.prg ║ ║
╚══════════════════════════════════════════════════════╩══D-B-T══(C)-VoG═1989═╝
dbterr.prg Seite: 1
1 ***********************************************************************
2 * Programm : DBTERR.PRG
3 * Titel : DBT-Test- und Demo-Programm
4 * Version : 2.1
5 * : ein paar alltägliche Probleme
6 ***********************************************************************
7 ┌─do while
8 │ ┌─do case Auswahl
9 │ ├─otherwise
>> OTHERWISE nach DO CASE
10 ┼─│─exit
11 │ └─endcase
>> ENDCASE ohne CASE
12 │ ┌─do while
13 │ │ ┌─if
14 │ │ │ ┌─If
15 │ │ │ ├─else
16 │ │ │ │ lf
17 │ │ │ ├─else
>> ELSE doppelt
18 │ │ │ ├─else
>> ELSE doppelt
19 │ │ │ └─endif
20 │ │ └─endif
21 │ └─enddo
>> ENDDO fehlt
└────────────────────────────────────────────────────────────────────────────┘
GBeispiel: Struktur-Analyse mit struktuierter Ausgabe:H
-----------------------------------------------------
┌────────────────────────────────────────────────────────────────────────────┐
│>> THEN / ELSE / ENDIF ohne IF >> CASE / OTHERWISE / ENDCASE ohne DO CASE │
│>> THEN doppelt >> CASE nach OTHERWISE │
│>> THEN nach ELSE >> CASE nach ENDCASE │
│>> THEN nach ENDIF >> OTHERWISE nach DO CASE │
│>> ELSE nach IF >> OTHERWISE doppelt │
│>> ELSE doppelt >> OTHERWISE nach ENDCASE │
│>> ELSE nach ENDIF >> ENDCASE ohne CASE │
│>> ENDIF ohne THEN >> ENDCASE doppelt │
│>> ENDIF fehlt >> ENDCASE fehlt │
│>> ENDDO ohne DO WHILE │
│>> LOOP / EXIT ohne DO WHILE │
│>> ENDDO doppelt │
│>> ENDDO fehlt │
│ │
│>> Mehr als 128 Struktur-Ebenen eroeffnet. │
│>> PROCEDURE und noch offnene Strukturen │
│>> PARAMETER und noch offnene Strukturen │
│>> FUNCTION/RETURN und noch offnene Strukturen │
│>> RETURN und noch offnene Strukturen │
│>> Ende Programm und noch offnene Strukturen │
└────────────────────────────────────────────────────────────────────────────┘
GMeldungen des Struktur-Tester DBT: H
----------------------------------
Der erfolgreiche Test wird mit:G K e i n e Struktur-Fehler erkannt !!H
gemeldet.
5.
EGDBT als Struktur-Tester.
EG------------------------H
DBT wird mit dem Namen des zu testenden Programms aufgerufen. Über
Zusatz-Parameter, die mit einem / beginnen und hinter dem Programmnamen
stehen müssen, können gesonderte Programmfunktionen ausgewählt werden.
Hinter den Parametern können weiter die DOS-Umleitungs- Symbole <name,
>name verwendet werden.
Format des Aufrufes:
GDBT (name.ext) (/parameter) (<name >name)H
Gname.extH Der Name des Programms wird vollqualifiziert mit .ext
angegeben.
Wildcard's (* oder ?) im Namen führt zum Testen aller
zutreffenden Programme.
G/parameterH über Parameter kann der Struktur-Test beeinflußt werden.
GRH = der RETURN innerhalb von Strukturen führt zur Fehler-
meldung: RETURN und noch offene Strukturen. Mit R wird
der Test auf offene Strukturen bei RETURN ausgeschaltet.
Unabhängig von RETURN wird immer bei Programm-Ende, neuer
Funktion und neuer Procedure immer ein Test auf noch
offene Strukturen durchgeführt.
GPH = Struktuierte Ausgabe des Programms.
Die struktuierte Ausgabe des Programms dient dem besseren
und schnelleren Erkennen von Strukturen und
Struktur-Ebenen. Logische Fehler können somit erheblich
schneller gefunden werden. Die Ausgabe kann per CTL-P
oder >filename umgeleitet werden.
N = Ausgabe ohne Satznummer.
GCH = Ausgabe nur der Struktur-Blöcke.
Die Ausgabe nur der Struktur-Anweisungen macht ein großes
Programm mit vielen logischen Entscheidungen zu einem
kleinen übersichtlichen Struktogramm.
GEH = Ausgabe der Zeit-Statistik.
die Zeitstatistik beinhaltet 3 Messpunkte.
1. Beginn Laden des Programms.
2. Beginn Struktur-Test
3. Ende Struktur-Test
Die Zeitstatistik weist alle 3 Messzeiten in der Form
Stunde/Minuten/Sekunde/1/100-Sekunde aus.
Die 2.Zeile weist die jeweiligen Differenzen zwischen
1 + 2 und 2 + 3 aus.
GTH = T ist der 1. Parameter des Autoren gewesen, weil er
nicht glaubte, daß sein Programm wirklich so schnell ist.
6.
EGDBT als Dokumentations-System.
EG------------------------------H
DBT ist, aufgrund der hohen Verarbeitungsgeschwindigkeit, zu einem
Programm-Dokumentations-System erweitert worden.
Über Parameter beim Aufruf von DBT können verschiedene Dokumentations-
Funktionen aufgerufen werden.
1. Test und Dokumentation eines gesamten Programm-Systems.
Beim Aufruf wird nur der Name des Haupt-Programmes angegeben.
2. Cross-reference über die in einem Programm verwendeten Namen
mit Ausgabe in sortierter Reihenfolge.
3. Cross-reference über alle Programme, DO-Aufrufe und Proceduren.
sowohl vorwärts:
in Programm abc wird per DO die Procedure xyz aufgerufen.
als auch rückwärts:
Procedure xyz wird aus Programm abc per DO aufgerufen.
4. Cross-reference über alle Datenbank-Aufruf und SET INDEX-Aufrufe.
5. Graphische Aufbereitung der Programm-Struktur über die DO-Aufrufe.
6. Ausgabe der Datenbank-Definitionen.
Format des Aufrufes:
GDBT (name.ext) (/parameter) (<name >name)H
Gname.extH Vollqualifizierter Programm-Name vom Hauptprogramm
des zu dokumentierenden Programm-Systems.
G/parameterH über Parameter kann die Dokumentation beeinflußt werden.
GDH = automatisches Dokumentieren aller Programme, die über
DO, SET KEY oder SET PROCEDURE TO aufgerufen werden.
GFH = Ausgabe der XREF über die im Programm verwendeten
Namen. Über die DBTELIM.TAB können Namen von der XREF
ausgeschlossen werden. Hauptsächlich sollten die dBase-
Befehle und Anweisungen eliminiert werden.
L = ausschalten des Vergleiches: Upper = Lower
U = die Feld-XREF erfolgt unsortiert.
GBH = Ausgabe der XREF über die im Programm-System verwendeten
USE databases INDEX. Gleichzeitig werden auch in der
Programm-XREF die SET INDEX TO mitgezeichent
Bei der Feld-XREF werden zusätzlich auch die Datenbank-
Definitionen ausgedruckt.
GOH = Ausgabe der gesamten Dokumentation in eine File.
Der Filename der Dokumetations-Datei wird angefordert.
GO=H = Die Ausgabedatei wird mit name.DBT gebildet.
GXH = Ausgabe nur der XREF / ZREF / GREF.
GGH = Ausgabe nur der GREF.
GAH = Ausgabe der Source struktuiert.
Das Programm wird vorher unter name.SAV gesichert.
7.
EGErläuterungen zu den Ausgaben:H
EG------------------------------H
: % &