Verbindung zu BASIC
Suche
Index
FAQ
Kontakt
Zurück

7. Verbindung zu BASIC
        Diese Kapitel beschreibt Programme, die die Verbindung zu BASIC-Programmen
        erleichtern. Mit den angegebenen Routinen kann man BASIC-Programme starten,
        BASIC-Variablen und BASIC-Programmzeilen suchen, Fehlermeldungen ausgeben
        und Parameter aus BASIC-Programmen an Maschinenprogramme uebergeben.

        Die verwendeten ROM-Routinen und Speicherplaetze sind :

        Name       2001     3001     8001      Beschreibung

        ARGBYT     $D676    $D678    $C8D4     Argumentausw. Byte-Daten
        ARGINT     $D0A0    $D090    $C2E0     Argumentausw. Integer
        ARGKLA     $CE05    $CDEC    $BEE9     Argument in Klammern auswerten
        ARGREA     $CCA4    $CC8B    $BD84     Argumentausw. real
        ARGUM      $CCB8    $CC9F    $BD98     Aurumentauswertung
        CHRGET     $00C2    $0070    $0070     Zeichen aus BASIC-Text holen
        ERRO       $C36C    $C36A    $B3E0     Ausgabe BASIC-Fehlermeldung
        ERROC      $C359    $C357    $B3CF     Abort Files, Fehlermeldung
        FVAR       $CF7B    $CF6D    $C12B     BASIC-Variable einrichten/suchen
        KLAUF      $CE0E    $CDF5    $BEF2     prueft auf Klammer auf
        KLAZU      $CE0B    $CDF2    $BEEF     prueft auf Klammer zu
        KOMMA      $CE11    $CDF8    $BEF5     prueft auf Komma
        NUMTYP     $CCA7    $CC8E    $BD87     prueft auf num. Argument
        PTRC       $C777    $C787    $B80A     Pointer initialisieren
        PTRW       $C59A    $C5A7    $B622     Pointer setzen
        RDINT      $C863    $C873    $B8F6     Integer-Zahl aus Basic-Text
        RUN        $C6CF    $C6DA    $B75F     RUN BASIC-Programm
        SBAL       $C522    $C52C    $B5A3     BASIC-Zeile suchen
        SBAV       $CFD7    $CFC9    $C187     BASIC-Varible suchen
        STRTYP     $CCA9    $CC90    $BD89     prueft auf Stringargument

        ARGFLG     $5E      $07      $07       Argumentflag String/numerisch
        FAC1       $B0-B6   $5E-64   $5E-64    Floating Akkumulator #1
        LINADR     $AE-AF   $5C-5D   $5C-5D    Adresse einer BASIC-Zeile
        LINUM      $08-09   $11-12   $11-12    Nummer einer BASIC-Zeile
        TYPFLG     $5F      $08      $08       Typflag integer/real
        VARADR     $96-97   $44-45   $44-45    Variablenadresse
        VARNAM     $94-95   $42-43   $42-43    Variblenname

7.1 RUN (Kaltstart)
       Ruecksetzen aller BASIC-Zeiger (loeschen aller Variablen), Kalt-Start :

          JSR PTRC
          JMP RUN

7.2 RUN (Warm-Start)
        Ruecksetzen aller BASIC-Zeiger (Variablen bleiben erhalten), Warm-Start:

         JSR PTRW
         JMP RUN

7.3 Suchen einer BASIC-Variablen
        Die folgende Routine liefert die Adresse zu einer gesuchten BASIC-Variablen.
        Der Name der Variablen wird dabei in VARNAM wie folgt abgelegt:

           a)  VARNAM enthaelt den ASCII-Code des ersten Buchstabens der Variablen.
           b)  VARNAM+1 enthaelt den ASCII-Code des zweiten Zeichens (Buchstabe oder Zahl)
               der Variablen. Besteht die Variable nur aus einem Buchstaben, so wird in
	       VARNAM+1 der Wert 80 geschrieben.
	   c) handelt es sich um eine Integer-Variable (%), wird in beiden Bytes das hoechstwertige
	      Bit gesetzt (OR mit $80).
           d) handelt es sich um eine String-Variable ($), wird in Adresse VARNAM+1 das	hoechstwertige
              Bit gesetzt (OR mit $80).

              Beispiele:  Variable   VARNAM    VARNAM+1
                             X       $58       $00
                             L$      $4C       $80
                             AB      $41       $42
                             D1%     $C4       $B1


              Der Suchvorgang erfolgt mit:

                  JSR SBAV

              Als Ergebnis steht die Adresse der gesuchten Variablen in VARADR.

              Die Variablen sind folgendermassen im Speicher abgelegt:

              integer : low Byte, high Byte
                real  : Speicherformat (5 Bytes)
               string : Laenge (1 Byte), Stringadresse (low Byte, high Byte)

7.4 Suchen einer BASIC-Zeile
        Die Nummer der gesuchten Zeile muss zunaechst in LINUM abgelegt werden (low
        Byte, high Byte). Die gesuchte Zeile wurde gefunden, wenn nach Rueckkehr das
        Carry-Flag gesetzt ist. Die Anfangsadresse der gesuchten Zeile steht dann in
        LINADR. Der Suchvorgang beginnt mit :

                  JSR SBAL

7.5 Ausgabe einer BASIC-Fehlermeldung
        Die folgende Routine gibt eine Meldung aus dem Speicherbereich ab $C190/$C192/$B20D aus.
        Das X-Register wird mit dem Abstand der Textbeginns der auszugebenden Meldung zum Beginn
        des Textblocks (s.o.) geladen.

                  JSR ERRO

        Sollen gleichzeitig alle offenen Files unzugaenglich gemacht werden (kein CLOSE!) und ausserdem
        ein eventuelles CMD-Kommandos aufgehoben werden, so ist statt ERRO die Routine ERROC aufzurufen.

                  JSR ERRORC

7.6 Eingabe Integer-Zahl aus BASIC-Text
        Eine ganze Zahl aus dem BASIC-Programm wird im ASCII-Code gelesen und
        umgewandelt. Pointen in den BASIC-Text befinden sich in der CHRGET-Routine
        (CHRGET+7). Das Ergebnis steht im Adressenformat (low Byte, high Byte) in
        LINNUM.

                  JSR RDINT

7.7 Auswertung von Ausdruecken
        Eine ungemein nuetzliche ROM-Routine, die es gestattet, Parameter aus einem
        BASIC-Programm in ein Maschinenprogramm zu uebernehmen. Jede erdenkliche
        Parameterstruktur ist moeglich. Den Aufruf der auswertenden Maschinenroutine
        kann ueber einen SYS-Aufruf oder aber Spracherweiterungen (mit eigenen Befehlsworten -
        aehnlich z.B. TOOLKIT) erfolgen.

        Beispiele:      SYS (826) 20
                        SYS 826 K
                        SYS 826,K,I
                        SYS 826 (K)
                        INSTRING (A$,B$,J)
                        SYS 826 (K+J,LEFT$(A$,2))
                        SYSIN,D

        Die Parameter unterliegen den ueblichen Regeln der BASIC-Syntax. Danach sind
        zulaessig: numerische Konstanten, Strings, numerische Variablen (integer oder
        real), String-Arrays, numerische Ausdruecke, String-Ausdruecke.

        Die Parameter-Uebengabestruktur kann beliebig gewaehlt wenden: Variable direkt
        hinter der Adresse, numerische Konstante direkt hinter den Adresse (die
        Adresse muss dann in Klammern stehen, s.o.) , Variablen oder Feldelemente in
        Klammern eingeschlossen oder durch ein Komma vom Befehlswort oder SYS-Aufruf
        getrennt.

        Aus Gruenden einer uebersichtlichen ('sauberen') Parameteruebergabe empfiehlt
        sich immer die Verwendung der eingeklammerten oder durch ein Komma abgetrennten Parameter.

        Der Aufruf von mit Parametern ausgestatteten Routinen kann beliebig erfolgen, d.h. im
        direkten Modus oder aus einem Programm. Leerzeichen sind beliebig einfugbar. Der Aufruf
        kann an beliebiger Stelle einer Programmzeile stehen.

        Da diese Routine wohl zu den wichtigsten des Interpreters gehoeren duerfte, ist sie auch
        entsprechend komfortabel ausgestattet. Es existiert daher eine Reihe von Entry-Points zur
        Auswertung der unterschiedlichsten Parameter.

7.7.1 Syntax-Pruefung
        Diese Routinen ermoeglichen auf einfachste Art die Pruefung der gewaehlten Syntax.

                  JSR KLAUF ;KLAMMER AUF VORHANDEN ?

        Das naechste Zeichen (ungleich Leerzeichen) des BASIC-Textes wird geholt. Ist es nicht
        das Zeichen "(",  so erfolgt ein Fehlerabbruch mit der Meldung:
        "SYNTAX ERROR" bzw. "SYNTAX ERROR IN xxx".

                  JSR KOMMA ;KOMMA VORHANDEN ?

        Das naechste Zeichen (ungleich Leerzeichen) des BASIC-Textes wird geholt. Ist
        es nicht das Zeichen ",", so erfolgt ein Fehlerabbruch mit der Meldung:
        "SYNTAX ERROR" bzw. "SYNTAX ERROR IN xxx".

                  JSR KLAZU ;KLAMMER ZU VORHANDEN

        Das naechste Zeichen (ungleich Leerzeichen) des BASIC-Textes wird geholt. Ist es nicht
        das Zeichen ")", so erfolgt ein Fehlerabbruch mit der Meldung:
        "SYNTAX ERROR" bzw. "SYNTAX ERROR IN xxx".


7.7.2 Parameterdarstellung
        Konstante und Variable werden direkt verarbeitet, Ausdruecke werden zunaechst
        entsprechend den BASIC-Regeln ausgewertet. Das Ergebnis jeder Parameter-Auswertung
        wird im Fioating Akku #1 (FAC1) abgelegt.

        Numerische Konstante und konstante Ausdruecke werden als reelle Zahl in den
        FAC1 geschrieben.

        Bei numerischen Variablen, Feidelementen oder Ausdruecken daraus (integer oder real) wird
        der Wert der Variablen, des Feldelementes oder das Ergebnis des arithmetischen Ausdruckes
        in den FAC1 geschrieben.

        Bei String-Argumenten (Konstante, Variable, Feldelement, Ausdruck) wird ab FAC1+3
        ($B3-B4/$61-62/$61-62) ein Pointer (low Byte, high Byte) auf den String-Descriptor abgelegt.
        Der Stringdescriptor enthaelt an erster Stelle die Stninglaenge, gefolgt von der Stningadresse
        (low Byte, high Byte).

        Beispiele:       Real-Variable:         A=4:SYS 826(A)
                         Der FAC1 enthaelt:   $ 83 80 00 00 00 00 00

                         Integer-Variable:      B%=4:SYS 826(B%)
                         Der FAC1 enthaelt:   $ 83 80 00 00 00 00 00

                         String-Vaniable:        CLR:A$='**' :SYS 826(A$)
                         Der FAC1 enthaelt:   $ 8A 00 00 05 04 00 00
                         Pointer auf String-Descniptor:	$0405
                         Stning-Descriptor (32 K RAM) :	$ 02 FE 7F
                         Das bedeutet: Stninglaenge 2, Stningadresse $7FFE
                         Ab Adresse $7FFE steht der Stning "**".

7.7.3 Parametertyp
        Bei der Uebernahme eines Parametens werden zwei Flags gesetzt, die seinen Typ
        kennzeichnen: ARGFLG und TYPFLG.

        ARGFLG gibt an, ob der ausgewertete Parameter vom Typ "numerisch"  oder String ist.

             ARGFLG = $00   :   Argument numerisch
             ARGFLG = $FF   :   Argument Str ing

        Bei numenischem Argument (ARGFLG =$00) gibt TYPFLG an, ob der ausgewertete
        Parameter vom Typ "integer" oder "real" ist.

         TYPFLG = $00   :   Argument real
         TYPFLG = $80   :   Argument integer (%)

        Diese Flags koennen vom Programm untersucht werden. Im Fehlerfall (Parameter
        von anderem Typ als erwartet) koennen entsprechende Meldungen ausgegeben werden.
        Die im ROM enthaltene Meldung "TYPE MISMAICH ERROR" kann auf einfachste Weise ausgegeben werden:

	     LDX #$A3 (#$A8 beim 2001-Computer)
             JMP ERRORC

        Da entsprechende Routinen zur Typenueberpruefung natuerlich in den ROM's enthalten
        sind, ist folgende Vereinfachung moeglich:

        Pruefen auf Stringargument ("TYPE MISMATCH ERROR" bei numenischem Argument):

                  JSR STRTYP


       Pruefen auf numerisches Argument ("TYPE MISMATCH ERROR" bei Stningargument) :

                  JSR NUMTVP

7.7.4 Parameterubernahme
        Je nach Problemstellung koennen unterschiedliche Routinen aufgerufen werden.
        Damit koennen Argumentauswertung, Syntax-Pruefung, Typumwandlung, Bereichsueberpruefungen
        zu einem einzelnen JSR-Befehl zusammengefasst werden.


         a) Generell kann jeder Parameter mit der Routine ARGUM ausgewertet werden.
            Art und Typ des Parametens koennen aus ARGFLG und TYPFLG (s.o.) entnommen
            werden. Das Ergebnis der Argumentauswertung steht im Floating Akku #1 (FAC1),
            s. 7.7.2 .

                  JSR ARGUM


         b) Ein einzelner, in Klammer eingeschlossener Parameter kann ueber die Befehlsfolge
            "KLAUF, ARGUM, KLAZU" ausgewertet werden, zusammengefasst mit:

                  JSR ARGKLA


         c) Liegt der Parameter im Wertebereich -32767 bis +32767 (integer), so kann mit der folgenden
            Routine eine Argumentauswertung, Typenueberpruefung, Real-Integer-Umwandlung und
            Grenzenueberpruefung fuer den Wertebereich.
            Das Ergebnis steht als ganze Zahl ab FAC1+3 ($B3-B4/$61-62/$61-62) im Zahlenformat (high
            Byte, low Byte). Bei Verlassen des Wertebereiches erfolgt ein Fehlerabbruch mit der Meldung
            "ILLEGAL QUANTITY ERROR".

                  JSR ARGINT

        d)  Liegt der Parameter im Wertebereich 0 bis 255 (Byte), so uebernimmt die folgende Routine die
            Argumentauswertung, Typueberpruefung, Real-Integer-Umwandlung und Grenzenueberpruefung fuer
            den Wertebereich. Das Ergebnis steht in FAC1+4 ($B4/$62/$62) und im X-Register. Bei Verlassen des
            Wertebereiches erfolgt ein Fehlerabbruch mit der Meldung "ILLEGAL QUANTITY ERROR".

                  JSR ARGBYT

        e)  Wird als Parameter eine reelle Zahl (Variable, Ausdruck) erwartet, so koennen Argumentauswertung
            und Typueberpruefung zusammengefasst werden:

                  JSR ARGREA

7.7.5 Hinweise zur Auswertung
        Es ist bei mehreren Parametern nicht notwendig, diese aööe beim Eintritt in die Routine
        sofort auszuwerten. Diese Auswertungen koennen auch nach und nach im Verlauf der Berechnung
        erfolgen. Nach Auswertung eines Parameters ist dessen Wert entsprechend zu verarbeiten, d.h.
        der Wert muss vor der Berarbeitung des naechsten Parameters aus dem FAC1 "gerettet" werden.

        Bei vorzeitigem Verlassen der Routine muss - falls der Programmverlauf fortgesetzt werden soll -
        dafuer gesorgt werden, das die noch nicht ausgewerteten Parameter ueberlesen werden. Der Text-
        Pointer der CHRGET-Routine muss daher entsprechend korrigiert werden.

        Wird in eine SYS-Adresse statt einer Konstante eine einfache Variable eingesetzt, so muss diese
        in Klammern gesetzt werden, wenn ein geklammerter Parameter folgt.

          Richtig : SYS  826 (A)
                    SYS  (826) (A)
                    SYS 826, A
                    SYS PA ,A
                    SYS (PA) (A)

           Falsch : SYS PA (A)


        Hier wuerde nicht die Routine ab Adresse PA sondern ab Adresse PA(A) aufgerufen !

        Sind fuer ein Parameter numerische und String-Werte zulaessig (s: 7.7.6), so ist stets
        mit der Routine ARGUM zu arbeiten. Abhaengig vom Flag ARGFLAG kann dann die weitere Verarbeitung
        erfolgen.

7.7.6 Beispiele fuer Parameterauswertung
        Das auswertende Maschinenprogramm beginne bei Adresse "PA". Fuer jedes Beispiel folgt eine Reihe
        von Maschinenbefehlen zur Auswertung des (der) Parameter.

                  SYS PA (I+J)        JSR ARGKLA

                  SYS PA (300)        JSR KLAUF
                                      JSR ARGINT
                                      JSR KLAZU

                  SYS PA (A$,10)      JSR KLAUF
                                      JSR ARGUM
                                      JSR KOMMA
                                      JSR ARGBYT
                                      JSR KLAZU

                  SYS PA (EXP(2))     JSR KLAUF
                                      JSR ARGREA
                                      JSR KLAZU

              SYS PA, RIGHT$(A$,5)    JSR KOMMA
                                      JSR ARGUM

                  SYS PA (Z$)         JSR ARGKLA

                  SYS PA ('033A')     JSR KLAUF
                  SYS PA (826)        JSR ARGUM
                                      BIT ARGFLG
                                      BMI HEX
                                      BPL DEZ

              SYS PA, I%(J+1)         JSR KOMMA
                                      JSR ARGINT

7.8 Ermittlung einer Parameter-Adresse
        Dieses Programm ist dann nuetzlich, wenn es darum geht, an Parameter des
        BASIC-Programms Werte zu uebergeben.

        Beispiel : SYS xxx,EIN,AUS

        Der Wert der Variablen EIN soll an das Maschinenprogramm uebergeben werden,
        die Variable AUS soll das Ergebnis erhalten. Den Wert von EIN erhaelt man
        einfach durch Aufruf der Routine ARGUM (s. Kap. 7.7). Die Adresse von AUS
        kann mit der folgenden Routine gefunden werden :

                  JSR FVAR

        Der Variablenname (im Beispiel: AUS) wird aus der Programmzeile entnommen und
        in VARNAM abgelegt (Format s. Kap. 7.3). Gleichzeitig werden die Flags TYPFLG
        ($00=real, $80=integer) und VARFLG ($00=numerisch, $ff=String) gesetzt.
        Die Variable wird dann mit der Routine SBAV (s. Kap. 7.3) gesucht. Wird sie
        nicht gefunden, so wird sie neu eingerichtet. Als Ergebnis wird die Startadresse
        der Variablen im X-Register (low Byte) und Y-Register (high Byte) uebergeben.

        Beispiel : Addition der Werte zweier Parameter , Zuweisung des Ergebnisses an den
        dritten Parameter und Ausgabe auf dem Bildschirm. Die Angaben in Klammern verweisen
        auf das Kapitel mit der ausfuehrlichen Beschreibung der jeweiligen Befehle.

          SYS AD, S1, S2, SU : REM SU = S1 + S2 & PRINT SU

          JSR KOMMA    ; Komma vorhanden ?                 (Kap. 7.7.1)
          JSR ARGREA   ; Reelles Argument auswerten (S1)   (Kap. 7.7.4)
          JSR FAC12    ; FAC1 in FAC2 kopieren             (Kap. 5.5)

          JSR KOMMA    ; Komma vorhanden
          JSR ARGREA   ; Reelles Argument auswerten (S2)
          LDA FAC1+5   ; Vorzeichenvergleich
          EOR FAC2+5   ; von FAC1 und FAC2
          STA FAC2+6
          LDA FAC1     ; Exponent FAC1
          JSR ADD      ; FAC1=FAC2+FAC1
          JSR KOMMA    ; Komma vorhanden ?
          JSR FVAR     ; Variable finden
          JSR FAC1MEM  ; Ergebnis ablegen (SU)
          JSR FPOUT    ; Ausgeben und Return

 

Letzte Änderung: 2019-01-04 10:06:25
  Rubrik:  CBM PET
Rubriken-Übersicht
 9 Besucher online 

Valid XHTML 1.0 Transitional Valid CSS!