Commodore 128 - Das große BASIC-Buch

Aus C64-Wiki
Zur Navigation springenZur Suche springen


Commodore 128 - Das große BASIC-Buch
Cover/Buchdeckel
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 2
Genre Programmieren / Hardware
Information Mehrere Auflagen erschienen




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 Programmabiaufplä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
 
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
 
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 RIGHTS ......................................... 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 

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 

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
 
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 

6. Musik und Grafik .................................. 286 
6.1 Musik ............................................ 286 
6.2 Grafik ........................................... 291 
6.2.1 Analoguhr ...................................... 295 

7. BASIC Intern ...................................... 300 
7.1 Der Monitor ...................................... 300 
7.2 Der Variablenzeiger .............................. 303
  
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 

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!

Fehler[Bearbeiten | Quelltext bearbeiten]

Meinung[Bearbeiten | Quelltext bearbeiten]

Weblinks[Bearbeiten | Quelltext bearbeiten]