Das große BASIC-Buch zum Commodore 128
| Das große BASIC-Buch zum Commodore 128 | |||
|---|---|---|---|
 |
Sprache | deutsch | |
| Autor(en) | Frank Kampow | ||
| Verlag | Data Becker | ||
| Jahr | 1985 | ||
| ISBN | ISBN 3-89011-114-9 | ||
| Neupreis | DM39,00 | ||
| Datenträger | |||
| Seitenzahl | 452 | ||
| letzte Auflage | 3. unveränderte Auflage, 1988 | ||
| Genre | Programmieren / Hardware | ||
| Information | Mehrere Auflagen erschienen; aka "Commodore 128 - Das große BASIC-Buch" | ||
Buchrückseite[Bearbeiten | Quelltext bearbeiten]
DAS STEHT DRIN:
Das Große BASIC-BUCH zum Commodore 128 ist eine ausführliche, didaktisch gut geschriebene Einführung in das CBM BASIC 7.0. Von den BASIC-Befehlen über die Problemanalyse bis zum fertigen Algorithmus lernt man schnell und sicher das Programmieren. Übungsaufgaben helfen, das Gelernte zu vertiefen. Gleichzeitig erhält der BASIC-Programmierer ein praxisbezogenes Nachschlagewerk.
Aus dem Inhalt:
- Datenfluß- und Programmablaufpläne
- Fortgeschrittene Programmiertechniken
- Menueerstellung
- Grafikprogrammierung
- Mehrdimensionale Felder
- Sortierroutinen
- Dateiverwaltung
- Windowprogrammierung
- BASIC intern
- Tokentabelle
- Der Monitor
und viele nützliche Utilities
UND GESCHRIEBEN HAT DIESES BUCH:
Frank Kampow ist Programmierer in der DATA BECKER Softwareabteilung. Seine vielfältigen Erfahrungen als Seminarleiter zu verschiedensten EDV-Themen einerseits und die jahrelange Programmierpraxis andererseits, machen dieses Buch zu einer nützlichen Hilfe für jeden C-128 Anwender.
Inhaltsverzeichnis[Bearbeiten | Quelltext bearbeiten]
Einleitung ........................................ 11
Kapitel 1:
1. Grundlagen des Programmierens .................. 17
1.1 Algorithmus und Programm ...................... 17
1.2 Die Computersprache BASIC ..................... 17
1.3 Datenfluß- und Programmablaufpläne ............ 20
1.3.1 Datenflußpläne .............................. 22
1.3.2 Programmablaufpläne ......................... 25
1.4 ASCII-Codes ................................... 31
1.5 Zahlensysteme ................................. 32
1.5.1 Das Dualsystem .............................. 33
1.5.2 Bit und Byte ................................ 34
1.5.3 Das Hexadezimalsystem ....................... 36
1.6 Die logischen Operatoren ...................... 39
1.6.1 NOT ......................................... 41
1.6.2 AND ......................................... 42
1.6.3 OR .......................................... 43
1.6.4 XOR ......................................... 45
Aufgaben .................................... 47
Kapitel 2:
2. Einführung in das Programmieren mit BASIC ...... 50
2.1 Das erste BASIC-Programm ...................... 50
2.1.1 Eingabe von Werten mit INPUT ................ 54
2.1.2 Wertzuweisung mit LET ....................... 55
2.1.3 Ausgabe mit PRINT ........................... 56
2.1.3.1 PRINT USING ............................... 61
2.1.3.2 PUDEF beeinflußt PRINT USING .............. 67
2.1.4 Kommentare mit REM .......................... 69
2.2 Variablen und deren Verwendung ................ 70
2.2.1 Rechenoperationen mit Variablen ............. 72
Aufgaben .................................... 74
2.3 Numerische Funktionen ......................... 75
2.3.1 Funktionen mit DEF FN ....................... 80
2.3.2 Zufallszahlen ............................... 81
2.3.3 Noch mehr Befehle für Variablen ............. 82
2.3.4 ASC(X$) und CHR$(X) ......................... 85
Aufgaben .................................... 89
2.4 TAB( und SPC( ................................. 90
2.5 Strings ....................................... 91
2.5.1 LEFT$ ....................................... 93
2.5.2 RIGHT$ ...................................... 94
2.5.3 MID$ ........................................ 95
2.5.4 LEN(X$) ..................................... 97
2.5.5 VAL(X$) ..................................... 97
2.5.6 STR$(X) ..................................... 99
2.5.7 INSTR ....................................... 100
2.5.8 TI$ ......................................... 101
Aufgaben .................................... 103
2.6 Editieren von Programmen ...................... 105
Kapitel 3:
3. Erweiterte Programmstrukturen .................. 112
3.1 Unbedingte Programmsprünge .................... 112
3.2 Bedingte Programmsprünge ...................... 116
3.2.1 IF...THEN...ELSE ............................ 116
3.2.2 BEGIN...BEND ................................ 121
Aufgaben .................................... 123
3.2.3 FOR...TO...NEXT ............................. 124
3.2.4 Schleifen mit DO...LOOP ..................... 132
3.2.4.1 DO...LOOP mit UNTIL und
WHILE ..................................... 133
3.3 Berechnete Sprungbefehle ...................... 139
3.3.1 Beispielprogramm "Rechenlehrgang" ........... 143
3.3.2 Programmsprünge mit TRAP .................... 153
Aufgaben .................................... 158
3.4 Programmablaufsteuerung mit GET ............... 159
3.4.1 Eingabe von Daten mit GET ................... 159
3.4.2 Tastaturabfrage mit GETKEY .................. 163
3.4.3 Die Belegung der Funktionstasten ............ 167
3.4.4 Funktionstastenabfrage mit GET .............. 168
3.5 FRE, POS, SYS, USR(X), WAIT ................... 171
3.6 PEEK und POKE ................................. 174
3.7 READ, DATA und RESTORE ........................ 177
Kapitel 4:
4. Komplexere BASIC-Anwendungen ................... 188
4.1 Felder ........................................ 188
4.1.1 Eindimensionale Felder ...................... 188
4.1.2 Beispiele zu eindimensionalen Feldern ....... 197
Aufgaben .................................... 205
4.1.3 Mehrdimensionale Felder ..................... 206
4.2 Unterprogramme ................................ 216
4.3 Menütechniken ................................. 238
4.3.1 Verwendung von GET-Routinen im
Menü ........................................ 244
4.3.2 Cursorpositionierung mit CHAR ............... 254
4.3.3 Cursorsteuerung mit CHR$-Codes .............. 255
4.4 WINDOW-Techniken .............................. 265
4.5 Sortierverfahren .............................. 269
Kapitel 5:
5. Das Prinzip der Dateiverwaltung ................ 274
5.1 Allgemeines zur Datenspeicherung .............. 274
5.2 Verschiedene Dateitypen ....................... 275
5.3 Die Datei ..................................... 276
5.4 Relative Dateiverwaltung ...................... 282
Kapitel 6:
6. Musik und Grafik ............................... 286
6.1 Musik ......................................... 286
6.2 Grafik ........................................ 291
6.2.1 Analoguhr ................................... 295
Kapitel 7:
7. BASIC Intern ................................... 300
7.1 Der Monitor ................................... 300
7.2 Der Variablenzeiger ........................... 303
Kapitel 8:
8. Utilities ...................................... 306
8.1 Hardcopy Text ................................. 306
8.2 Binärumwandlung ............................... 307
8.3 Ausgabe mit führenden Nullen .................. 307
8.4 Oszillierendes Flag ........................... 308
8.5 Programmlisting auf Diskette .................. 308
8.6 Auslesen einer sequentiellen Datei ............ 308
Kapitel 9:
9. Lösungen ....................................... 310
Anhang
A Befehlsübersicht ................................ 328
B Reservierte Wörter .............................. 426
C Die Tokentabelle ................................ 430
D Dezimal-, Hexadezimal- und Binärtabelle ......... 433
E Fehlermeldungen ................................. 437
F Die Zeichensätze ................................ 439
G Stichwortregister ............................... 452
Leseprobe[Bearbeiten | Quelltext bearbeiten]
(1. Auflage - Seite 139ff: Kapitel "3. Erweiterte Programmstrukturen"; Unterkapitel "3.3.2 Programmsprünge mit TRAP")
Diese spezielle Art des ON...GOTO-Befehls wird eingesetzt, um innerhalb eines Programms auftretende Fehler selbst per Programm zu behandeln bzw. zu verwalten. Dazu wird meistens die TRAP-Funktion am Anfang eines Programms untergebracht. Der Rechner ’merkt’ sıch die Stelle, an der der Befehl zum ersten Mal auftritt. Alle Fehler bzw. Fehlermeldungen, die nach diesem Befehl auftreten, veranlassen das Programm, zu der Zeilennummer zu springen, die der TRAP-Funktion folgt. Sie können hier allerdings immer nur eine Zeilennummer angeben und nicht mehrere, wie Sie es vom ON...GOTO-Befehl her kennen. Ab dieser Zeilennummer kann dann ein kleines Programm (Fehlerroutine) stehen, das auf den aufgetretenen Fehler entsprechend reagiert. Woher wissen wir aber, welcher Fehler in welcher Zeilennummer entstanden ist?
Auch hierfür gibt es im BASIC 7.0 des Commodore 128 zwei Variablen (sogenannte Systemvariablen), die daraufhin abgefragt werden können. Es handelt sich dabei um die Variablen
ER
und
EL.
Geben Sie z.B. statt PRINT
PRILT
in den Rechner und betätigen die RETURN-Taste, so erhalten Sie die Fehlermeldung
?SYNTAX ERROR.
Geben Sie jetzt
PRINT ER
ein, so wird die Fehlernummer des Fehlers angezeigt. In unserem Falle wäre das die Fehlernummer Il. Im Anhang finden Sie sämtliche Fehlernummern sowie die entsprechenden Fehlerbeschreibungen aufgelistet. In Ihren Programmen können Sie dann gemäß dem Wert von ’ER’ eine eigene Fehlermeldung ausgeben, ohne daß das Programm ungewollt abbricht. Mit der Variablen ’EL’ haben Sie zusätzlich noch die Möglichkeit, die Zeilennummer abzufragen, in der der Fehler auftrat.
Diese Art der eigenen Fehlerbehandlung hat den Vorteil, daß innerhalb des Programms erst bestimmte Schritte unternommen werden können, bevor man das Programm dann endgültig beendet. Somit können, z.B. in der Dateiverwaltung, beim Auftreten eines Fehlers erst alle Dateien geschlossen werden (kein Datenverlust), bevor das Programm dann die eigene Fehlermeldung ausgibt und danach beendet wird.
Oft ist es jedoch gar nicht notwendig, das Programm zu beenden. Es reicht dann volkommen aus, eine Fehlermeldung für den Anwender auszugeben und dann mit dem Programm fortzufahren. Für solch eine Fall existiert die Anweisung
RESUME.
Mit
RESUME ( Zeilennummer )
bestimmen Sie, in welcher Programmzeile das Programm nach der Fehlermeldung fortfahren soll. Ein einfaches Beispiel soll dies wiederum verdeutlichen. Geben Sıe das nachfolgende Programm in den Computer und starten Sie es.
10 TRAP 1000 20 FOR I=-1 TO 3 30 ON I GOTO 200,300 40 NEXT I 100 END 200 SCNCLR 210 PRINT "ZEILE 210" 220 SLEEP 3 230 GOTO 40 300 SCNCLR 310 PRINT "ZEILE 310" 320 SLEEP 3 330 GOTO 40 1000 REM FEHLERBEHANDLUNG 1010 SCNCLR 1020 PRINT "FEHLER";ER;" IN ZEILE";EL 1030 SLEEP 3 1030 RESUME 40
In diesem Programm steckt ein Fehler in Zeile 30. Die Laufvariable ’I’ hat als ersten Wert -1. Nun soll in Zeile 30 über ’’ mit ON...GOTO in bestimmte Zeilen verzweigt werden. Wie wir aber wissen, funktioniert dies nicht mit negativen Werten. Daher springt dieses Programm beim ersten Durchlauf in die Fehlerroutine ab Zeile 1000 und gibt dort eine entsprechende Meldung aus. Jetzt veranlaßt die RESUME-Anweisung, daß das Programm in Zeile 40 mit der Programmausführung fortfährt. Es werden nun noch die beiden Zeilen 200 und 300 abgearbeitet und dann wird das Programm in Zeile 100 ordnungsgemäß beendet. Wie Sie an diesem Beispiel gesehen haben, ist der Gebrauch dieser Funktionen doch recht einfach. Sie können in Ihren Programmen selbstverständliich den Fehler noch genauer beschreiben, indem Sıe entsprechend dem Wert von ’ER’ zusätzlich einen beschreibenden Text mit ausgeben lassen.
Sie haben aber auch die Möglichkeit, innerhalb eines Programms die ’Originalfehlermeldung’ des Commodore 128 ausgeben zu lassen. Die Funktion
ERR$(X)
gibt Ihnen gemäß dem Wert von ’X’ die dazugehörige Originalmeldung aus. Da Ihnen insgesamt 41 Meldungen zur Verfügung stehen, müssen die Werte von X im Bereich zwischen l und 41 liegen. Das folgende kleine Programm gibt Ihnen alle zur Verfügung stehenden Fehlerstrings aus:
10 FOR I=1 TO 41 20 PRINT ERR$(I) 30 NEXTI 40 END
Im vorletzen Programm können Sie ja einmal die Zeile 1020 gegen die nachfolgende Zeile austauschen.
1020 PRINT "?";ERR$(ER);" ERROR IN ZEILE";EL
Wirkt doch täuschend echt, oder?
Auf der nächsten Seite habe ich nun wieder einige Aufgaben für Sie zusammengestellt, deren Lösungen Sie dann am Ende des Buches finden können. Berücksichtigen Sie auch diesmal wieder die am Anfang des Buches aufgeführten fünf Punkte der Programmierung. Und nun wie gehabt viel Erfolg beim Lösen der Aufgaben!
