Autor.............: Jörg Wach
Kurzbeschreibung..: Tiny-Basic-Interpreter in E
Programm Version..: 0.6 (Beta-Release)
Compiler Version..: 2.1B
O.S. ab...........: 2.04


            Dokumentation TinyBasic-Interpreter
            -----------------------------------

Was heißt hier TinyBasic?
-------------------------

    TinyBasic bedeutet, daßdieses Basic einige Einschränkungen gegenüber
    einer Vollversion hat.

    Konkret sei euch gesagt, daß es sich um einen simplen Basic-Interpreter
    mit einigen Einschränkungen handelt. Dazu später mehr.

    Das wunderbare an diesem TinyBasic ist, daß es in E geschrieben ist!
    Das grauenhafte, daß es sich um ein Beta-Release handelt! Also Vorsicht,
    das Basic ist noch nicht "Wanzenfrei".

Was kann TinyBasic?
-------------------

    Nun, zuerst mal die Einschränkungen:

        1. TinyBasic kennt nur 26 Variablen (A-Z), die auch nur numerische
           Werte enthalten dürfen.

        2. Da TinyBasic das FFP-Format benutzt, gibt es bei mathematischen
           Rechnungen evtl. Fehler, da FFP-nur 6-Stellige Zahlen zuläßt!

        3. Das TinyBasic ist nicht berauschend schnell, aber zum arbeiten
           gut.

        4. Momentan ist TinyBasic nur eine Beta-Version. D.h., das sich
           durchaus noch Bugs verstecken können, die sich erst bei euren
           Programmen bemerkbar machen und den Amiga zum Absturz bringen
           können. Deshalb ist also eine gewisse Vorsicht geboten.

        5. Für die Funktionen SIN, COS etc. wird UNBEDINGT die MATHTRANS-
           LIB benötigt. Ich bin mir nicht sicher, ob diese bei allen
           OS-Versionen im ROM enthalten ist. Wer OS 3.0 hat, der hat auch
           automatisch die Mathtranslib im ROM,

    Nun mal zu den positiven Seiten:

        1. TinyBasic ist in E geschreiben und macht viel Gebrauch von den
           FFP-Routinen, also genau da richtige für die, die immer schon
           mal FFP-Routinen nutzen wollten.

        2. Die Sprache kann numerische Werte berechnen und kennt auch
           Strings, allerdings nur für die Ausgabe.

           Alle numerischen Variablen sind Gleitkommazahlen vom Typ FFP.

        3. Eingaben können in Groß- oder Kleinschreibung vorgenommen
           werden, daß macht für TinyBasic keinen Unterschied.

        4. TinyBasic kennt den Interpreter-Modus, d.h. alle Eingaben
           werden sofort ausgeführt, als auch die Ausführung von
           Programmen, die zuvor geladen werden müßen.

        5. Folgende Kommandos kennt TinyBASIC:

            a) CLS

               läuft leider noch nicht Fehlerfrei, da ich in einem CON:-
               Fenster kein löschen vornehmen kann.

            b) GOTO <Label>

               Hiermit können Labels im Programm angesprungen werden. Die
               Labels können dabei wie folgt aussehen:

                    Label1:
                    ichbinaucheinlabel:
                    ichauchlabel:
               D.h. also, daß einem Label immer ein Doppelpunkt folgen
               muß und KEIN anderer Befehl sich in der Zeile befinden darf.


            c) IF <expr> THEN <statement> [ELSE <statement>]

               Die normalen IF-THEN-ELSE Prüfungen.

            d) INPUT <String>,<variable>

               Hiermit können ZAHLENEINGABEN vorgenommen werden, wobei
               vor der entgegennahme noch die Ausgabe eines Strings erfolgen
               kann. Beispiel

                    Input "Gib mir eine Zahl: ",A

            e) LET <variable>=<expr>

               Erlaubt die Zuweisung eines Wertes an eine Variable. LET kann
               auch weggelassen werden.

            f) EDIT

               Oh Gott, das ist ein ganz, ganz simpler Zeileneditor.
               Ihr ruft hiermit die Eingabe von Zeilen auf, wobei die
               Zeilen fortlaufend vergeben werden.

               Es können KEINE geladenen Zeilen korrigiert werden und es
               können keine weiteren Korrekturen, wie Zeilenlöschen, ein-
               fügen etc., erfolgen.

               Wie gesagt, ein ganz, ganz simpler Zeileneditor.

            g) LIST

               Listet ein geladenes Programm auf.

            h) LOAD <string-literal>

               Lädt ein Programm in den Hauptspeicher. Der Name muß
               unbedingt bekannt sein und in "" eingeschlossen werden.

            i) NEW

               Hiermit wird das Programm im Hauptspeicher wieder gelöscht.

            j) PRINT <expr> | <string-literal> [,..]

               Hiermit könnt ihr Strings oder Variablen ausgeben. Die
               Befehle hinter der Ausgabe beschränken sich nur auf das
               Komma für die Tremnung. Wurde kein Trennzeichen angegeben,
               so wird die Ausgabe direkt nach dem letzten ausgegebenen
               Zeichen fortgesetzt.

            k) RUN

               Startet ein geladenes Programm.

            l) SAVE <string-literal>

               Speichert ein zuvor über EDIR eingegebenes Programm wieder
               ab. Der Name muß in "" eingeschlossen sein.

            m) STOP

               Hält ein geladenes Programm an.

        6. Mehrere Kommandos können, wie bekannt, üner ein ":" getrennt
           werden. Beispiel:

                a=10:b=20

        7. Folgende Funktionen werden unterstützt:

           SIN(n)
           COS(n)
           TAN(n)
           LOG(n)
           SQR(n)
           FIX(n)
           RND

           wobei n eine Zahl ist. Fix rundet einen Wert ab.

        8. Operatoren

           Folgende Operatoren werden verarbeitet:


           ^ - * / +
           zusätzlich
           -  = Negation
           und
           = < > <= >= <>.

           Klammern bestimmen die Reihenfolge der zu bearbeiteten
           Operationen (wie in E).

    Sicher, daß alles ist nicht berauschend, aber TiyBasic gibt noch zu-
    sätzlich

        - Laufzeitfehler aus
        und
        - den Fehler "Division bei Null".

    Die Speicherbelegung erfolgt dynamisch, also je nach größe des zu
    ladenden Programmes. Ein kleines Manko: max. 1000 Programmzeilen.

Aufruf, Übergabeparameter
-------------------------

    Entweder aus durch doppelklichk von der Werkbank oder durch Eingabe
    von "Tinybasic" in der Shell.

    Keine Übergabeparameter.

Einbindung in eigene Programme
------------------------------

    Im besonderen kann ich euch die FFP-Routinen empfehlen, da

        1. diese ausgetestet sind
        und
        2. der Bug, der im E-Compiler ist (siehe auch "Dies_und_das" auf der
           EPD#5), hierbei beachtet wird.

Erklärung des Source-Codes
--------------------------

    Ich habe an vielen Stellen den Source-Code erläutert. Ich hoffe
    das reicht allen aus.

Sonstiges
---------

    Mehr oder weniger durch Zufall bin ich auf diesen Basic-Interpreter
    gestoßen, da ich Basic im OS3.0 vermiße.

    Was waren daß doch für Zeiten, als man mall schnell ein Programm
    mit ein paar Rechenoperationen fertiggestellt hat.

    Tja, und dann habe ich mich eben rangesetzt und das Teil geschrieben.

    Sicher gibt es andere Möglichkeiten, um sich die Zeit zu vertreiben,
    aber gerade bei meinem Wirtschaftsinformatik-Studium ist das Teil
    von unschätzbaren Wert.

Copyrights
----------

    Copyright © 1994 by Jörg Wach (= JCL POWER)

    Dieses von mir geschriebene Programm ist Freeware. Es darf nur als
    GESAMTPACKET, also mit ALLEN Dateien, weitergegeben werden.

Dateiverzeichnis
----------------

        Tinybasic     ---> Das Programm
        Tinybasic.e   ---> Source.Code in Amiga_E (Yeah)
        Tinybasic.Doc ---> Na, was wohl ?

        Zufall.bas, Vergleich.bas ---> zwei kleine Programmbeispiele.

        und natürlich die entsprechenden Infofiles dazu.

Historie
--------

    Version 0.1: 13.01.1994
                 Lockere Übersetzung.

    Version 0.2: 21.01.94
                 - Ausbau des Gurus bei zwei Variablen
                 - Änderungen aller Variablen auf FFP

    Version 0.3: 24.01.94
                 - EDIT-Mode
                 - LIST-Befehl überarbeitet
                 - RUN -Befehl überarbeitet
                 - Save-Befehl überarbeitet
                 - Load-Befehl überarbeitet
                 - LABEL's für GOTO
                 - LET Befehl auch ohne LET

    Version 0.4: 24.01.1994
                 - SAVE - Befehl neu geschrieben.
                 - LOAD - Befehl neu geschrieben.
                 - PRINT- Befehl überarbeitet.
                 - Vergleiche auf FFP umgestellt.
                 - Stringliterale überarbeitet.

    Version 0.5: 28.01.1994
                 - INPUT-Befehl für begleitende Strings eingerichtet
                 - PRINT Befehl erweitert um ?, ","
                 - FFP-Routinen für Wandlung angepasst.
                 - Tuning vorgenommen.

    Version 0.6: 29.01.1994
                 - Zuweisungen für negative Zahlen korrigiert.


Habt Spaß damit



      !!                             !!!!! !!!!! !   ! !!!!! !!!!!
      !!                             !! !! !! !! !   ! !!    !! !!
      !!                             !!!!! !! !! !   ! !!!!! !!!!!
     !!!                             !!    !! !! ! ! ! !!    !!!
   !!!!                              !!    !!!!! !!!!! !!!!! !! !!

           !!!!
           !!                        Jörg Wach
           !!                        Waitzstr. 75
           !!
           !!!!                      24105 Kiel

                  !!                 Tel.: 0431/57 84 85
                  !!
                  !!                 Westdeutschland
                  !!
                  !!!!!              15.02.1994