
                               .m.A.C.R.O.s.

                                  FED 2.2

<---------------------------------------------------------------------------->

                               ALLGEMEINES:


Der Fulled besitzt seit der Version 2.0 eine koplexe Macro-Sprache, die der
des "Installers" sehr aehnlich ist. Sie basiert auf einer ersten Version des
Programms "YAX" von Wouter van Oortmerssen, wurde jedoch im Laufe der Zeit
stark verbessert und erweitert. Wer bereits mit dem Installer vertaut ist,
wird keine grossen Probleme haben, diese Sprache zu erlernen.

<---------------------------------------------------------------------------->

                                 ZU LOGIK:

Diese Macro-Sprache arbeitet streng nach der RPN (Reverse Polish Notation)
Regel, da dies zum Einen eine hoehere Abarbeitungsgeschwindigkeit erlaubt und
zum Anderen auch in der Anwendung eine Grosszahl von moeglichen Fehlern von
vorneherein ausschliesst. Wer sich einmal an diese Notationsweise gewoehnt
hat, wird sehr schnell damit arbeiten koennen.

Es gibt folgende verschiedene Arten von Variablen:

[term]      : ein ganz beliebiger Term
[int]       : eine Zahl
[str]       : ein String
[var]       : eine Variable (kein konkreter Wert!)
[svar]      : eine String-Variable (kein konkreter Wert!)
[func]      : eine Funktion
[bool]      : ein Wahrheitswert
...         : bezeichnet eine beliebige Anzahl von Variablen des zuvor ge-
              nannten Typs

<---------------------------------------------------------------------------->

                                UEBERSICHT:



                 (write [term] ...)                                 +
                   (add [int] ...)                                  +
                    (eq [int] ..)
                  (uneq [int] [int])
                   (sub [int] ...)
                   (mul [int] ...)
                   (div [int] ...)
                   (and [int] ...)
                    (or [int] ...)
                   (not [int] ...)
                    (if [bool] [term] [term])                       +
                    (do [term] ...)                                 +
                (select [int] [term] ...)                           +
                   (set [var] [term])                               +
             (for [var] [int] [int] [term] ...)                     +
                 (while [term] [term] ...)                          +
                 (until [term] [term] ...)                          +
                 (defun [var] ([var] ...) [term] ...)               +
               (readint)
                 (array [var] [int] [int] ...)
               (greater [int] [int])
               (smaller [int] [int])
                   (cls)
                  (dump)
                (string [var])                                      +
                  (read [svar])
                   (abs [int])
                   (mod [int] [int])
                   (eor [int] ...)
                  (swap [var] [var])
                 (power [int] [int])
                   (inc [var])
                   (dec [var])
                   (rnd [int])
                  (rndq [int])
                  (kick [int])
                  (when [int] [term] ... else [term] ...)
                   (hex [int])
               (goright)
                (goleft)
                  (goup)
                (godown)
                 (gotop)
              (gobottom)
               (gobegin)
                 (goend)
                 (delch)
               (erasech)
                (output [int])
                (getval)
               (isfirst)
                (islast)
               (putchar [int])
               (getcpos)
               (getlpos)
                (dialog [int])
                  (exit)

(+): Bereits dokumentiert!

<---------------------------------------------------------------------------->

                        AUSFUEHRLICHE BESCHREIBUNG:



Zu der Kommando-Beschreibung:

Im folgenden Abschnitt werden die Kommandos erklaert.
Hierbei wird als erstes die SYNTAX angegeben, mit der der Befehl zu benutzen
ist. Als zweites erfolgt eine kurze BESCHREIBUNG des Befehls, gefolgt von
dem ERGEBNIS, welches dieser liefert. Dieses Ergebnis kann dann mit hilfe
von (set) einer Variablen zugewiesen oder durch andere Funktionen ausge-
wertet werden. Als letzes folgt dann noch ein BEISPIEL-Macro in dem dieser
Befehl benutzt wird.


1.KAPITEL: PROGRAMMSTRUKTUR / EINLEITUNG


In diesem ersten Teil wird die eigentliche Programmstruktur der Macro-Sprache
erklaert. Mit dieser Sprache ist es moeglich, komplexe Programme zu
erstellen, die sich ganz wesentlich von Batch-Dateien unterscheiden. Sie ist
von der Maechtigkeit in etwa vergleichbar mit AREXX oder der Installer-
Sprache. Zum besseren Verstaendnis fuer die leute, die programmieren sei
gesagt: Diese Sprache besteht zu 100% aus Listen und rekursiven Aufrufen!
Was heisst: Alles kann verkettet werden und jede Funktion kann (bis auf
weniga Ausnahmen) in jede andere eingesetzt werden. <- Und genau SO funk-
tioniert das Programmieren in dieser Spache auch.


Weitere Dinge, die wichtig zu wissen sind:

1.: Funktionen muessen immer deklariert sein, BEVOR sie aufgerufen werden
    (Pascal-Like..).

2.: Mit (set) werden Variablen in der Regel als LONG-Definiert. Soll die
    Variable als String behandelt werden, so sollte dies vorher mit (string)
    angemeldet werden. Wird dies nicht getan, kann irgendwann der Stack
    ueberlaufen und das Programm zum Abbruch zwingen. Wenn ihr das Programm
    also verlassen wollt, deklariert bitte KEINEN String von 25kb, sondern
    benutzt die Funktion (exit), das geht einfacher...

3.: KEINE Fnktion ausser (set) VERAENDERT den Wert einer Variablen, die neuen
    Werte, die z.B. durch mathematische Funktionen errechnet werden, werden
    als ERGEBNIS zurueckgeliefert. Beispiel:
    (+ 10 10) tut DEFINITIV nichts!
    (set i (+ 10 10)) weist der Variablen i den wert 10+10=20 zu.




>>> SET

    SYNTAX: (set [var] [term])

    BESCHR: Diese Funktion gibt einer Variablen einen neuen Wert. WICHTIG: Nur
            hiermit kann man den Wert einer Variablen veraendern! Ist die
            Variable bisher noch nicht deklariert, so geschieht dies hiermit
            automatisch.

    ERGEBN: (keins)

    BEISP.: <MACRO02>


>>> DEFUN

    SYNTAX: (defun [var] ([var] ...) [term] ...)

    BESCHR: Hiermit koennen neue Funktionen geschrieben werden, hinterher
            wie die eingebauten aufgerufen werden koennen.

    ERGEBN: Das der zuletzt benutzten Operation.

    BEISP.: <MACRO03>, <MACRO04>


>>> STRING

    SYNTAX: (string [var])

    BESCHR: Deklariert eine Variable als String-Variable, dieser Befehl
            sollte VOR dem eigentlichen Set-Befehl aufgerufen werden. Er
            intialisiert diese Variable auf Dauer und muss daher nur einmal
            aufgerufen werden.

    ERGEBN: (keins)

    BEISP.: <MACRO05>


>>> ARRAY

    SYNTAX: (array [var] [int] [int] ...)

    BESCHR: Hiermit wird ein FELD von Zahlen (LONG's) deklariert, auf dessen
            einzelne Komponenten man zugreifen kann, wie auf Variablen.

    ERGEBN: (keins)

    BEISP.: <MACRO06>


>>> IF

    SYNTAX: (if [bool] [term] [term])

    BESCHR: If ist eine Bedingte Programm-Verzweigung nach dem Prinzip: "Wenn
            [bool] zutrifft dann erledige Term1, sonst Term2".
            WICHTIG: Es darf immer nur EIN Term folgen! Sollen z.B. bei er-
            folgreichem IF mehere Befehle erledigt werden, so muessen diese
            Befehle mit (do ...) eingeklammert werden!

    ERGEBN: (keins)

    BEISP.: <MACRO04>, <MACRO03>


>>> DO

    SYNTAX: (do [term] ...)

    BESCHR: Mit diesem Befehl koennen mehrere Terme zu einem Block zusammen-
            gefasst werden, der dann als einer betrachtet wird. IF z.B. er-
            laubt bei Erfolg oder Misserfolg jeweils nur EINEN Term. Sollen
            hier jedoch MEHERE Terme folgen, so muessen sie mit (do ...)
            eingeklammert werden.

    ERGEBN: (keins)

    BEISP.: <MACRO03>


>>> SELECT

    SYNTAX: (select [int] [term] ...)

    BESCHR: Dies ist ein direktes Aequivalent zu einer CASE-Schleife in
            Hochsprachen. Sie ermoeglicht, abhaengig vom Wert einer Integer-
            zahl in verschiedene Terme zu verzweigen.

    ERGEBN: (keins)

    BEISP.: <MACRO07>


>>> FOR

    SYNTAX: (for [var] [int] [int] [term] ...)

    BESCHR: Diese Funktion stellt eine Hachsprachen-typische FOR-Schleife
            dar. Hierbei ist der erste Parameter die hochzuzaehlende Variable,
            die beiden folgenden geben den Zaehlerbereich an. Danach koennen
            beliebig viele Terme folgen, die ausgefuehrt werden sollen.

    ERGEBN: (keins)

    BEISP.: <MACRO08>


>>> WHILE

    SYNTAX: (while [term] [term] ...)

    BESCHR: While ist eine Schleife, die solange immer wieder durchlaeuft, wie
            die erste Bedingung erfuellt ist.

    ERGEBN: (keins)

    BEISP.: <MACRO09>, <MACRO03>


>>> UNTIL

    SYNTAX: (until [term] [term] ...)

    BESCHR: Until ist eine Schleife, genau wie While, mit dem Unterschied,
            dass sie ausgefuehrt wird, solange die erste Bedingung NICHT er-
            fuellt ist.
            ACHTUNG: Until wird MINDESTENS einmal durchlaufen!!

    ERGEBN: (keins)

    BEISP.: <MACRO10>


2.KAPITEL: MATHEMATISCHE FUNKTIONEN


>>> ADD

    SYNTAX: (add [int] ...) oder: (+ [int] ...)

    BESCHR: Fuegt zu einer Zahl andere hinzu.

    BEISP.: <MACRO02>




3.KAPITEL: AUSGABE

>>> WRITE

    SYNTAX: (write [term] ...)

    BESCHR: Schreibt eine beliebige Annzahl von Strings / Zahlen auf den
            Bildschirm.

    BEISP.: <MACRO01>




<<< ACHTUNG BAUSTELLE !!! >>>
<----------------------------------EOF--------------------------------------->
