Erl€uterungen zum B-Toolkit 1.21:
=================================

B-Toolkit 1.21 bindet beim Aufruf ein:
   1. Einen Treiber mit dem Namen 'BToolkit' (Groœ- und Kleinschreibung
      sind hier wichtig!), der Nur die Funktion hat, B-Toolkit einen
      Datenbereich zur Verf‡gung zu stellen,
   2. Eine 'Scheduler'-Routine, die dazu dient auch aus mit EXEC_W ge-
      starteten Programmen bei verfahrenen Situationen ins BASIC zur‡ck-
      kehren zu k„nnen (kein Allheilmittel!!!),
   3. 'Device'-Vorgaben, wie sie auch Toolkit II mit PROG_USE, ... zur
      Verf‡gung stellt (jedoch werden keine bereits vorhandenen Vorgaben)
      ‡berschrieben,
   4. Zwei S€tze von BASIC-Befehlen (Prozeduren und Funktionen),
      von denen der eine Fest eingebunden wird, der andere jedoch
      an- un abschaltbar (letzterer muœ jedoch erst "eingeschaltet"
      werden).

Zur folgenden Kurzbeschreibung:
   '[' ']'           -     das Argument ist optional; es kann (muœ aber
                           nicht) angegeben werden.
   Beispiel:
         WMON [colour-mode] [, screen-type]
   kann bedeuten:
         WMON
         WMON colour-mode
         WMON , screen-type
         WMON colour-mode, screen-type

   '{' '}'           -     Es k„nnen keins, ein oder mehrere Argumente des
                           Typs, der in diesen Klammern eingeschlossen
                           ist, folgen.
   Beispiel:
         CLOSE [#ch] {, #ch}
   kann bedeuten:
         CLOSE
         CLOSE #ch
         CLOSE #ch , #ch
         CLOSE #ch , #ch , #ch
         CLOSE #ch , #ch , #ch , #ch
         ... ,
                           wobei #ch nicht notwendigerweise das selbe
                           Argument bezeichnet.

   In Hochkommata eingeschlossene Argumente bezeichnen Zeichenketten, d.h.
   das ‡bergebene Argument muœ eine Zeichenkette sein. Im Text dienen die
   Hochkommata jedoch nur, um Namen von BASIC-Befehlen, Fremdworte, etc.
   hervorzuheben.

   Ein (R) in der §berschrift zu einem Befehl bedeutet, das dieser abge-
   schaltet werden kann; ein (F) bedeutet, das er Fest ist.

Kurzbeschreibung der Befehle:

Funktion    ALCHP                (F)
====================================
Syntax:
   a = ALCHP (size [, [JobID]])

'ALCHP' reserviert 'size' Bytes im 'common heap'; Wird hinter 'size'
nichts angegeben, dann ist dieser Speicherplatz durch die Toolkit II-
Befehle 'NEW', 'CLEAR', etc. l„schbar; wird jedoch ein ',' hinter 'size'
angegeben, dann ist dieser Platz nur durch 'RECHP' l„schbar; dasselbe
gilt, wenn eine 'JobID' hinter dem Komma folgt, nur wird dann der
Speicherplatz f‡r den Job mit dieser 'JobID' reserviert, d.h. er wird
automatisch freigegeben, wenn dieser Job gel„scht wird (bzw. sich selbst
l„scht).
Ergebnis ist die Anfangsadresse des reservierten Speicherplatzes.
Beispiele:

         a = ALCHP (1000)
         - reserviert 1000 Bytes im 'common heap'. Dieser Bereich wird
           durch die Toolkit II-Befehle 'NEW', 'CLEAR', ... wieder frei-
           gegeben

         bs = ALCHP (3000,)
         - reserviert 3000 Bytes, die durch 'NEW', 'CLEAR', ... nicht
           freigegeben werden k„nnen sondern nur durch 'RECHP bs'.

         add_m = ALCHP (300, 1)
         - reserviert 300 Bytes f‡r den Job mit der Nummer 1; wird Job 1
           beendet, dann wird dieser Platz automatisch mit freigegeben.


Funktion    ASK                  (R)
====================================
Syntax:
   a = ASK ([#ch,] 'prompt')

'ASK' dient zu Ja/Nein-Abfragen von der Tastatur; Hierzu wird im Fenster
'#ch' (Vorgabe: #1) die Meldung 'prompt' ausgegeben. War das letzte
nicht-Leerzeichen von 'prompt' kein '?', dann wird ' ? ' angeh€ngt
(sonst nicht); anschlieœend wird eine Eingabe von der Tastatur erwartet.
War die Eingabe ein 'j' oder ein 'y' (Schreibung egal), dann ist das Er-
gebnis von 'ASK' 1; war es ein 'n' eingegeben, dann ist es 0.
Wird eine andere Taste gedr‡ckt, dann wird ein Warnton eingegeben und
erneut auf eine Tastatureingabe gewartet.
Beispiel:
      ...
      1030 a = FILE_OPEN ('xyz', 2)
      1040 IF a = -8
      1050   IF ASK (#0, '- bereits vorhandene Datei ‡berschreiben')
      1060     a = FILE_OPEN ('xyz', 3)
      1070   ELSE
      1080     REPORT a
      1090   ENDIF
      1100 ELSE
      1110   IF a < 0: REPORT a: STOP
      1120 ENDIF
      1130 ...

(Ausprobieren!)


Funktion    BASE_N               (F)
====================================
Syntax:
   a = BASE_N (num_base, num$)

'BASE_N' faœt die Zeichenkette 'num$' als Zahl zur Basis 'num_base' auf
und wandelt diese in bin€re Form um. 'num_base' muœ zwischen 2 und 36
liegen; 'num$' darf nur die Ziffern '0'...'9' und die Buchstaben 'A'...'Z'
(Schreibweise egal) enthalten, jedoch h„chstens das Zeichen aus diesem
Bereich, das 'num_base-1' entspricht.
Beispiele:

   PRINT #0, BASE_N (36, 'ABC')
   13368

   PRINT #0, BASE_N (36, 'AZ3')
   14223

   PRINT #0, BASE_N (1, 'xxx')
   bad parameter

   PRINT #0, BASE_N (16, 'ABC)')
   bad parameter


Funktion    BASE_N$              (F)
====================================
Syntax:
   a$ = BASE_N$ (num_base, num, num_bits)

'BASE_N$' wandelt die unteren 'num_bits' Stellen der Bin€rzahl 'num' in
eine Darstellung zur Basis 'num_base' um. 'num_base' muœ zwischen 2 und 36
liegen; 'num_bits' muœ zwischen 1 und 32 liegen.
Das Ergebnis von 'BASE_N$' ist eine Zeichenkette.
Beispiele:

   PRINT #0, BASE_N$ (36, 13368, 21)
   00ABC

   PRINT #0, BASE_N$ (16, 2748, 20)
   00ABC

   PRINT #0, BASE_N$ (2, 2748, 12)
   101010111100


Funktion    BASIC                (R)
====================================
Syntax:
   a = BASIC (ptr)
   a = BASIC

'BASIC' ohne Argument liefert die Anfangsadresse von SuperBASIC;
'BASIC' mit Argument liefert die Absolute Adresse eines Teilbereichs
von SuperBASIC auf die die BASIC-Statusvariable 'ptr' zeigt.
Beispiel:
      a = PEEK_L (BASIC (48))
      - liefert die 'channel id' des BASIC-Kanals #0 in a.
        (Besser jedoch, es wird in diesem Fall mit 'CHANID' gearbeitet.)


Funktion    BASIC_B              (R)
====================================
Syntax:
   a = BASIC_B (rel.addr)

'BASIC_B' liefert ein Byte aus dem Bereich von SuperBASIC; 'rel.addr' ist
ein Zeiger auf dieses Byte relativ zur Anfangsadresse von SuperBASIC.


Funktion    BASIC_L              (R)
====================================
Syntax:
   a = BASIC_L (rel.addr)

'BASIC_L' liefert ein Langwort aus dem Bereich von SuperBASIC; 'rel.addr'
hat dieselbe Bedeutung wie bei 'BASIC_B', muœ jedoch gerade sein.


Funktion    BASIC_W              (R)
====================================
Syntax:
   a = BASIC_W (rel.addr)

'BASIC_W' funktioniert genau wie 'BASIC_B' und 'BASIC_L'; jedoch liefert
es ein Wort; 'rel.addr' muœ wieder gerade sein.


Befehl      BCLEAR               (R)
====================================
Syntax:
   BCLEAR

'BCLEAR' l„scht den gerade aktiven Tastaturpuffer. Der Tastaturpuffer
eines 'CON_'-Fensters kann durch IO_PEND% aktiviert werden.


Funktion    BIN                  (F)
====================================
Syntax:
   a = BIN ('binary-digits')

'BIN' faœt eine Zeichenkette 'binary-digits' als Bin€rzahl auf und liefert
den zugeh„rigen Zahlenwert als Ganzzahl. 'binary-digits' darf nur '0' und
'1' enthalten.
Beispiel:

   PRINT #0, BIN ('11000001')
   193


Funktion    BIN$                 (F)
====================================
Syntax:
   a$ = BIN$ (long-int, bit-num)

'BIN$' wandelt die 'bit-num' untersten Bin€rstellen der Zahl 'long-int' in
eine Bin€rzeichenkette um.
Beispiel:

   PRINT #0, BIN$ (231, 8)
   11100111


Befehl      BREAK                (R)
====================================
Syntax:
   BREAK flag
   BREAK ON
   BREAK OFF

'BREAK' schaltet CTRL & SPACE f‡r BASIC-Programme ab ('flag' = 0) oder
ein ('flag' <> 0). Vorsicht!!! Endlosschleifen k„nnen nach 'BREAK OFF'
nicht wieder verlassen werden.


Funktion    BREAK%               (R)
====================================
Syntax:
   a = BREAK%

'BREAK%' liefert 0 bei abgeschaltetem CTRL & SPACE (verg. 'BREAK') und 1,
falls CTRL & SPACE eingeschaltet ist.
Beispiel:

      ...
      130 BREAK OFF: REMark CTRL & SPACE ist nun abgeschaltet
      ...
      ...
      250 PRINT 'CTRL & SPACE ist ';
      260 IF BREAK% = 0: PRINT 'ab';: ELSE PRINT 'ein';
      270 PRINT 'geschaltet'
      ...
      ...
      960 BREAK ON: REMark CTRL & SPACE einschalten
      ...


Befehl      BSAVE                (R)
====================================
Syntax:
   BSAVE filename, address, length [p [dsz]]

   p = , | \ | !

'BSAVE' speichert 'length' Bytes ab 'address' in der Datei 'filename' ab.
Wird 'dsz' angegeben, dann wird eine Programmdatei mit 'dsz' als Gr„œe
des Datenbereichs abgespeichert. Mit den  Trennzeichen ',', '\' und '!'
wird Entschieden, weche Erg€nzung an den Dateinamen angeh€ngt werden soll.
Im Falle das ',' gew€hlt wurde (oder 'TO' oder ';') wird keine Erg€nzung
angeh€ngt. F‡r '\' wird bei vorhandenem 'dsz' '_ex' und sonst '_cde' ange-
h€ngt, f‡r '!' hingegen '_ew' bzw. '_rext'. Wenn bereits eine Datei unter
dem Namen 'filename' (+ extension) existiert, dann wird mit
'already exists' abgebrochen.

Beispiel:

   BSAVE flp2_Clock, a, 1000 \ 512
   - legt 1000 Bytes ab a in der Programmdatei 'Clock_ex' in 'flp2_' ab.
     Der 'Data Size' wird auf 512 Bytes festgelegt.

   BSAVE 'flp2_QUILL', AddrOfQuill, 53092 ! 1280
   - legt 53092 Bytes ab 'AddrOfQuill' in der Programmdatei 'QUILL_ew' in
     'flp2_' ab. Der 'Data Size' wird hierbei auf 1280 Bytes gesetzt.

   BSAVE 'flp2_ARC', AddrOfArc, 32000, 5000
   - legt 32000 Bytes ab 'AddrOfArc' in der Programmdatei 'ARC' in 'flp2_'
     ab. Der 'Data Size' wird auf 5000 Bytes festgelegt.

   BSAVE 'ram2_saturn_scr', 131072, 32768
   - speichert den Inhalt des Bildschirmes in der Datendatei 'saturn_scr'
     in 'ram2_'.

   BSAVE 'flp1_Compress', AddrOfCompress, 1000 \
   - legt 1000 Bytes ab 'AddrOfCompress' in der Datendatei 'Compress_cde'
     in 'flp1_' ab.

   BSAVE 'mdv1_HotII', AddrOfHotII, LenOfHotII !
   - legt 'LenOfHotII' Bytes ab 'AddrOfHotII' in der DatenDatei
     'HotII_rext' in 'mdv1_' ab.


Befehl      BSAVE_O              (R)
====================================
Syntax:
   BSAVE_O filename, address, length [p [dsz]]

   p = , | \ | !

'BSAVE_O' speichert 'length' Bytes ab 'address' in der Datei 'filename' ab.
Wird 'dsz' angegeben, dann wird eine Programmdatei mit 'dsz' als Gr„œe
des Datenbereichs abgespeichert. Mit den  Trennzeichen ',', '\' und '!'
wird Entschieden, weche Erg€nzung an den Dateinamen angeh€ngt werden soll.
Im Falle das ',' gew€hlt wurde (oder 'TO' oder ';') wird keine Erg€nzung
angeh€ngt. F‡r '\' wird bei vorhandenem 'dsz' '_ex' und sonst '_cde' ange-
h€ngt, f‡r '!' hingegen '_ew' bzw. '_rext'. Wenn bereits eine Datei unter
dem Namen 'filename' (+ extension) existiert, dann diese ‡berschrieben.

Beispiel:

   BSAVE_O flp2_Clock, a, 1000 \ 512
   - legt 1000 Bytes ab a in der Programmdatei 'Clock_ex' in 'flp2_' ab.
     Der 'Data Size' wird auf 512 Bytes festgelegt.

   BSAVE_O 'flp2_QUILL', AddrOfQuill, 53092 ! 1280
   - legt 53092 Bytes ab 'AddrOfQuill' in der Programmdatei 'QUILL_ew' in
     'flp2_' ab. Der 'Data Size' wird hierbei auf 1280 Bytes gesetzt.

   BSAVE_O 'flp2_ARC', AddrOfArc, 32000, 5000
   - legt 32000 Bytes ab 'AddrOfArc' in der Programmdatei 'ARC' in 'flp2_'
     ab. Der 'Data Size' wird auf 5000 Bytes festgelegt.

   BSAVE_O 'ram2_saturn_scr', 131072, 32768
   - speichert den Inhalt des Bildschirmes in der Datendatei 'saturn_scr'
     in 'ram2_'.

   BSAVE_O 'flp1_Compress', AddrOfCompress, 1000 \
   - legt 1000 Bytes ab 'AddrOfCompress' in der Datendatei 'Compress_cde'
     in 'flp1_' ab.

   BSAVE_O 'mdv1_HotII', AddrOfHotII, LenOfHotII !
   - legt 'LenOfHotII' Bytes ab 'AddrOfHotII' in der DatenDatei
     'HotII_rext' in 'mdv1_' ab.


Befehl      BTool_EXT            (R)
====================================
Syntax:
   BTool_EXT

'BTool_EXT' schaltet den abschaltbaren Teil von B-Toolkit (das sind alle
in dieser Beschreibung mit (R) versehenen Befehle/Funktionen) ein.


Befehl      BTool_RMV            (R)
====================================
Syntax:
   BTool_RMV

'BTool_RMV' schaltet den abschaltbaren Teil von B-Toolkit (das sind alle
in dieser Beschreibung mit (R) versehenen Befehle/Funktionen) ab. Diese
sind dann bis zum n€chsten 'BTool_EXT' nicht mehr verf‡gbar.


Funktion    CBASE                (R)
====================================
Syntax:
   a = CBASE [(#ch)]

'CBASE' liefert die Adresse der 'channel defninition' eines Kanals '#ch'
(das ist der Datenbereich, mit dem QDOS auf Kanal arbeitet); Vorgabe f‡r
'#ch' ist #1.


Funktion    CHANID               (F)
====================================
Syntax:
   a = CHANID [(#ch)]

'CHANID' liefert die 'channel id' eines Kanals '#ch' (das ist die Nummer,
unter der dieser Kanal QDOS bekannt ist). Vorgabe f‡r '#ch' ist #1.


Befehl      CHANNELS             (R)
====================================
Syntax:
   CHANNELS [channel]

'CHANNELS' listet die f‡r QDOS offenen Kan€le ‡bersichtlich in 'channel'.
'channel' kann hierbei eine Kanalnummer "#ch" oder ein impliziter Kanal
"\device-name" sein. Vorgabe f‡r 'channel' ist #1.


Funktion    CHR$                 (F)
====================================
Syntax:
   a$ = CHR$ (char-range {, char-range})

'CHR$' hat die aus den Argumenten 'char-range' entwickelten Teilzeichen-
ketten in der Reihenfolge des Auftretens verkettet zum Ergebnis.
'char-range' hat hierbei folgende Bedeutung(en):

   char-range           Bedeutung
      num               Ist 'num' in einem Byte darstellbar, dann ergibt
                        sich das Zeichen, das 'num' im Zeichensatz
                        entspricht; falls 'num' nicht durch ein Byte dar-
                        stellbar ist, dann ergeben sich zwei Zeichen.

      str               Die Zeichenkette 'str' wird unver€ndert ‡ber-
                        nommen.

      TO                Es wird eine Zeichenkette erzeugt, die aus s€mt-
                        lichen Zeichen des Zeichensatzes in aufsteigender
                        Reihenfolge besteht.

   num/str TO           Es wird eine Zeichenkette erzeugt, die aus allen
                        Zeichen des Zeichensatzes ab 'num/str' in aufstei-
                        gender Reihenfolge besteht. 'num/str' ist hierbei
                        entweder eine (in einem Byte darstellbare) Zahl,
                        oder eine Zeichenkette, deren erstes Zeichen
                        benutzt wird. Eine leere Zeichenkette entspricht
                        hierbei CHR$ (0).

   TO num/str           Es wird eine Zeichenkette erzeugt, die aus allen
                        Zeichen des Zeichensatzes bis 'num/str' in auf-
                        steigender Reihenfolge besteht. Eine leere
                        Zeichenkette 'num/str' entspricht CHR$ (255).

   num/str1 TO num/str2     Es wird eine Zeichenkette erzeugt, die alle
                        Zeichen des Zeichensatzes im Bereich zwischen
                        'num/str1' und 'num/str2' enth€lt. Ist 'num/str1'
                        leer, dann entspricht das CHR$ (0); ein leeres
                        'num/str2' entspricht CHR$ (255).

Beispiele:

   OPEN #3, 'SER1': PRINT #3, CHR$ (27, 'M', ' ' TO 126, 10, 27, '@');:
   CLOSE #3
   - setzt einen (EPSON-kompatiblen) Drucker an 'SER1' auf 'Elite'-Modus,
     gibt anschlieœend den gesamten sichtbaren Teil des ASCII-Zeichen-
     satzes auf diesem aus und initialisiert den Drucker anschlieœend neu.


Befehl      CLCHP                (F)
====================================
Syntax:
   CLCHP

'CLCHP' l„scht s€mtliche mit 'ALCHP' erzeugten l„schbaren (!!!)
Speicherbereiche; l„schbare Bereiche sind solche, die mit ALCHP ohne
Trennzeichen bzw. zweiten Parameter erzeugt wurden.
Beispiel:

   a = ALCHP (300)
   b = ALCHP (512,)
   c = ALCHP (6030)
   d = ALCHP (512, 1)
   CLCHP
   - Die Speicherfl€chen, auf die 'a' und 'c' zeigen werden freigegeben,
     die, auf die 'b' und 'd' zeigen hingegen nicht.


Befehl      CLOSE                (F)
====================================
Syntax:
   CLOSE [channel] {, channel}

'CLOSE' schlieœt alle angegebenen Kan€le 'channel'. Wird nichts angegeben,
dann werden sogar BASIC-Kan€le bis auf #0, #1 und #2 geschlossen.
'channel' kann eine BASIC-Kananummer #ch sein, aber auch eine System-
Kanalnummer \ch. Systemkan€le lassen sich mit dem 'CHANNELS'-Befehl
listen.
Beispiele:

   CLOSE #3, #4, #15
   - schlieœt #3, #4 und #15

   CLOSE
   - schlieœt alle BASIC-Kan€le auœer #0, #1 und #2

   CLOSE \4
   - schlieœt den Systemkanal mit der Nummer 4

Vorsicht! Das 'Pointer Enviroment' und der MG(G)-'Point Patch' „ffnen ein
Systemfenster. Dieses sorgt daf‡r, daœ der 'MODE'-Befehl auch weiterhin
funktioniert. Wird dieses jedoch geschlossen, kann dies zum Absturz des
QL f‡hren.


Befehl      COMPRESS             (R)
====================================
Syntax:
   COMPRESS filename

'COMPRESS' speichert den Bildschirm des QL in komprimierter Form in der
Datei 'filename' ab. Die Kompression funktioniert jedoch nur, solange
keine zu zuf€lligen Daten im Bidschirmspeicher stehen. Maximal ergibt sich
eine Dateil€nge von 64K.
Das 'data default device' des Toolkit II wird unterst‡tzt.


Befehl      COPY                 (F)
====================================


Befehl      CopySize             (F)
====================================
Syntax:
   CopySize size%

'CopySize' legt die Gr„œe des Speicherplatzes, der f‡r die Befehle
'COPY', 'COPY_N', 'COPY_O' und 'COPY_ON' als Puffer reserviert werden
soll, fest. 'size%' kann bis 32768 Bytes groœ werden.


Befehl      COPY_N               (F)
====================================
Syntax:
   COPY_N [DEVn_]filename [, [DEVn_][filename|dirname_]]

'COPY_N' funktioniert im wesentlichen wie der entsprechende
Tony Tebby-Befehl; jedoch reicht es, beim zweiten Parameter einen
Pfad (mit '_' am Ende) anzugeben; in diesem Fall wird der vollst€ndige
Dateiname 'filename' dahinterkopiert.
Beispiel:

   COPY_N 'flp1_ENTRY_asm' TO 'ram1_'
   WDIR 'ram1_'
   ...
   ENTRY_asm
   ...


Befehl      COPY_O               (F)
====================================
Syntax:
   COPY_O [DEVn_]filename [, [DEVn_][filename|dirname_]]

'COPY_O' funktioniert im wesentlichen wie der entsprechende
Tony Tebby-Befehl; jedoch reicht es, beim zweiten Parameter einen
Pfad (mit '_' am Ende) anzugeben; in diesem Fall wird der vollst€ndige
Dateiname 'filename' dahinterkopiert.
Beispiel:

   COPY_O 'flp1_ENTRY_asm' TO 'ram1_'
   WDIR 'ram1_'
   ...
   ENTRY_asm
   ...


Befehl      COPY_ON              (F)
====================================
Syntax:
   COPY_ON [DEVn_]filename [, [DEVn_][filename|dirname_]]

'COPY_ON' ist eine Kombination von 'COPY_O' und 'COPY_N'. Es kopiert
eine Datei ohne 'header' und ‡berschreibt dabei eine vorhandene alte auf
dem Zielmedium. Wie bei den anderen COPY-Befehlen reicht es, beim
zweiten Parameter einen Pfad (mit '_' am Ende) anzugeben; in diesem Fall
wird der vollst€ndige Dateiname 'filename' dahinterkopiert.
Beispiel:

   COPY_ON 'flp1_ENTRY_asm' TO 'ram1_'
   WDIR 'ram1_'
   ...
   ENTRY_asm
   ...


Funktion    CTAB$                (R)
====================================
Syntax:
   a$ = CTAB (b$ [, tab-size])

'CTAB$' wandelt eine Zeichenkette derart um, das dort, wo dies m„glich war
statt der Leerzeichen ein TAB-Zeichen (CHR$ (9)) steht. M„glich heiœt, daœ
die Kette ab einer Postion bis zur n€chsten Tabulatorposition mindestens
ein Leerzeichen enth€lt. 'tab-size' gibt hierbei die Tabulatorposition an,
n€mlich alle 'tab-size' Zeichen. Die Voreinstellung f‡r 'tab-size' ist 8.
Beispiele:

   PRINT #0, CTAB$ ('START:  MOVEM.L D1-D7/A1-A5,-(SP)')
   START:#MOVEM.L#D1-D7/A1-A5,-(SP)

   PRINT #0, CTAB$ ('Dies  ist ein     Beispiel    f‡r die Verwendung von CTAB$', 6)
   Dies#ist ein#Beispiel#f‡r die Verwendung von CTAB$


Befehl      CURSOR               (F)
====================================
Syntax:
   CURSOR [#ch,] px, py
   CURSOR [#ch,] gx, gy, dx, dy
   CURSOR [#ch,] flag

'CURSOR' mit zwei Argumenten setzt den 'Cursor' auf die Position in
Pixel-Koordinaten 'px', 'py';
'CURSOR' mit vier Argumenten setzt den 'Cursor' auf die Position in
den virtuellen Koordinaten 'gx', 'gy', 'dx', 'dy'.
'CURSOR' mit einem Argument schaltet den Cursor in Fenster '#ch' ein
('flag' <> 0) oder aus ('flag' = 0)
Beispiele:

   CURSOR #1, ON: a$ = INKEY$ (#1, -1): CURSOR #1, OFF

   CURSOR 10, 15: PRINT 'ABCD': CURSOR 0, 0: PRINT 'ABCD'

   (Ausprobieren!)


Funktion    CURSOR%              (R)
====================================
Syntax:
   a = CURSOR% (#ch)

'CURSOR%' liefert den Status des Cursors des Fensters #ch (Vorgabe: #1).
Hierbei ist das Ergebnis:
      0     -     Cursor ist 'disabled'
     -1     -     Cursor ist 'enabled' aber gerade unsichtbar
      1     -     Cursor ist 'enabled' und sichtbar


Funktion    CvCASE$              (R)
====================================
Syntax:
   a$ = CvCASE$ (b$ [, flag])

'CvCASE$' dient dazu, alle Buchstaben einer Zeichenkette 'b$' in Groœ-
('flag' = 0) oder Kleinbuchstaben ('flag' <> 0) umzuwandeln.
Voreinstellung f‡r 'flag' ist 1.
Beispiele:

   PRINT #0, CvCASE$ ('ein neger mit gazelle zagt im regen nie', 0)
   EIN NEGER MIT GAZELLE ZAGT IM REGEN NIE

   PRINT #0, CvCASE$ ('Otto', 1)
   otto

   PRINT #0, CvCASE$ ('Groœ- und Kleinschreibung werden gleichbehandelt')
   groœ- und kleinschreibung werden gleichbehandelt


Funktion    CVF                  (R)
====================================
Syntax:
   a = CVF ('string')

'CVF' liefert die ersten sechs Bytes einer Zeichenkette als Gleitpunkt-
zahl.


Funktion    CVI%                 (R)
====================================
Syntax:
   a% = CVI% ('string')

'CVI' liefert die ersten zwei Bytes einer Zeichenkette als Ganzzahl.


Funktion    CVL                  (R)
====================================
Syntax:
   a = CVL ('string')

'CVL' liefert die ersten vier Bytes einer Zeichenkette als Gleitpunkt-
zahl.


Funktion    CVS$                 (R)
====================================
Syntax:
   a$ = CVS$ ('string')

'CVS$' liefert eine in einer Zeichenkette 'string' enthaltene Zeichen-
kette (also 1 Wort L€nge + den Text).


Befehl      DDEV                 (F)
====================================
Syntax:
   DDEV default-num, devicename

'DDEV' legt den Namen 'devicename' (BASIC-Name oder Zeichenkette) als
Voreinstellung f‡r die Toolkit II-Opreationen 'LOAD', ... usw. an.
'default-num' entscheidet, welche Voreinstellung angelegt wird:

   0     -     Programme; alle Operationen wie 'LOAD', 'EXEC', ...
               benutzen diese Einstellung

   1     -     Daten; Operationen wie 'FILE_OPEN', 'OPEN', ...
               und die 'COPY'-Befehle benutzen diese Einstellung.

   2     -     Ziel; Die 'COPY'-Befehle und der 'SPL'-Befehl benutzen
               diese Voreinstellung.

Beispiele:

   DDEV 0, 'FLP2': EXEC 'editor'
   - startet das Programm 'editor' von 'flp2_'

   DDEV 1, 'ram2_': WDIR
   - listet das Inhaltsverzeichnis von 'ram2_' in Fenster #1


Funktion    DDEV$                (F)
====================================
Syntax:
   a$ = DDEV$ (default-num)

'DDEV$' liefert die mit 'DDEV' angelegte Voreinstellung.
Beispiele: (mit unter 'DDEV' angegebenen Einstellungen)

   PRINT #0, DDEV$ (0)
   FLP1_

   PRINT #0, DDEV$ (1)
   ram2_



Funktion    DEFAULT              (R)
====================================
Syntax:
   a = DEFAULT (parameter, float-expr)

Ist 'parameter' ein Parameter einer in BASIC geschriebenen Prozedur, dann
liefert 'DEFAULT' den Wert dieses Parameters, wenn er beim Aufruf der
Prozedur angegeben wurde (also einen definierten Wert hat); wurde f‡r
'parameter' jedoch beim Aufruf nichts ‡bergeben, dann liefert 'DEFAULT'
den Wert von 'float-expr' (eine Gleitpunktzahl also).


Funktion    DEFAULT$             (R)
====================================
Syntax:
   a$ = DEFAULT$ (parameter, string-expr)

'DEFAULT$' arbeitet wie 'DEFAULT'; jedoch wird im Falle eines undefinier-
ten Parameters die Zeichenkette 'string-expr' geliefert.


Funktion    DEFAULT%             (R)
====================================
Syntax:
   a% = DEFAULT% (parameter, int-expr)

'DEFAULT%' entspricht 'DEFAULT' und 'DEFAULT$'; hier wird jedoch f‡r einen
undefinierten Parameter 'parameter' eine Ganzzahl ('int-expr') zur‡ck-
gegeben.


Funktion    DEFINED              (R)
====================================
Syntax:
   flag = DEFINED (variable)

'DEFINED' liefert 1, wenn 'variable' (eine normale BASIC-Variable)
definiert wurde (z.B. durch Zuweisung), und 0, falls nicht.
Beispiele:

      NEW
      PRINT #0, DEFINED (a)
      0

      a = ALCHP (30)
      PRINT #0, DEFINED (a)
      1


Funktion    DirDefAddr           (R)
====================================
Syntax:
   addr = DirDefAddr (directory-device-name)

'DirDefAddr' liefert die Adresse der Definition eines Plattentreibers
(RAM-Disk, FLoPpy-Disk, MicroDriVe, WINchester, ...). F‡r die Beschreibung
eines Plattentreibers muœ im 'Advanced User Guide' nachgeschlagen werden.
Beispiel:

   PRINT #0, DirDefAddr (FLP)
   177488
   PRINT #0, PEEK$ (177488+60)
   FLP


Befehl      DISCNAME             (R)
====================================
Syntax:
   DISCNAME DEVn_new_name

'DISCNAME' benennt eine Diskette um. Der Disketten-Controller muœ dem
Tony Tebby-Standard gen‡gen, d.h. Disketten m‡ssen sich direkt lesen
und schreiben lassen (OPEN #ch, 'DEVn_*Dxy'). 'DEVn_' ist der Disketten-
Ger€tename und 'new_name' der Name, den die Diskette bekommen soll
(notfalls wird dieser auf die 10 zul€ssigen Zeichen gek‡rzt).


Funktion    EQ$                  (R)
====================================
Syntax:
   flag = EQ$ (comp-type, string1, string2)

'EQ$' vergleicht die beiden Zeichenketten mit dem Vergleichstyp
'comp-type' und liefert 1, falls beide Zeichenketten 'gleich' (nach
'comp-type') waren, sonst 0.
'comp-type' hat folgende Bedeutung:

  -1     -     Die Zeichenketten werden Zeichenweise nach ihrer Reihenfol-
               ge im ASCII-Zeichensatz verglichen.

   0     -     Die Zeichenketten werden Zeichenweise verglichen, wobei
               Groœ- und Kleinschreibung, sowie enthaltene Zahlen, sofern
               sie nicht zeichenweise ‡bereinstimmen unterschieden werden.

   1     -     Die Zeichenketten werden wie nach Typ 1 verglichen, mit dem
               Unterschied, daœ Groœ- und Kleinschreibung nicht (!) unter-
               schieden werden.

   2     -     In den Zeichenketten enthaltene Zahlen werden numerisch,
               d.h. nach ihrem Zahlenwert verglichen; Groœ- und Klein-
               schreibung werden unterschieden.

   3     -     Wie Typ 2; jedoch werden Groœ- und Kleinschreibung nicht
               unterschieden.


Funktion    ERR_DF               (F)
====================================
Syntax:
   a = ERR_DF

'ERR_DF' behebt den entsprechenden Fehler im ROM der QL-Versionen JS und
MG(G).


Funktion    ETAB$                (R)
====================================
Syntax:
   a$ = ETAB$ (b$ [, tab-size])

'ETAB$' wandelt in einer Zeichenkette enthaltene TAB-Zeichen (CHR$(9))
in soviele Leerzeichen um, das die folgenden Zeichen genau auf der sich
aus 'tab-size' berechneten Tabulatorposition befinden, d.h. z.B. f‡r
'tab-size' = 8 die Positionen 1, 9, 17, ...
Die Voreinstellung f‡r 'tab-size' ist 8.
Beispiel:

   PRINT #0, ETAB$ (CHR$ ('START:', 9, 'MOVEM.L', 9, 'D1-D7/A1-A5,-(SP)'), 12)
   START:      MOVEM.L     D1-D7/A1-A5,-(SP)


Befehl      EXPAND               (R)
====================================
Syntax:
   EXPAND filename

'EXPAND' l€dt eine mit 'COMPRESS' abgespeicherte Datei in den Bildschirm-
speicher des QL zur‡ck.
Das 'data default device' des Toolkit II wird unterst‡tzt.


Befehl      EXTRAS               (F)
====================================
Syntax:
   EXTRAS [channel,] ['wild',] [line-size]

'EXTRAS' listet die Namen der Befehle aller verf‡gbaren Toolkits in ‡ber-
sichtlicher Form in 'channel' auf - und zwar spaltenweise. 'wild'
entscheidet dar‡ber, welche Befehle aufgef‡hrt werden sollen; wird z.B.
'a' ‡bergeben, dann werden alle Befehle, die mit einem 'A' beginnen (bei
vorhandenem Toolkit II z.B.: ALTKEY ALARM AJOB ...) gelistet. Die Ausgabe
erfolgt in Spalten zu (Vielfachen von) 12 Zeichen. 'line-size' entscheidet
‡ber die maximale L€nge einer Ausgabezeile.
In dem Falle, daœ 'line-size' nicht angegeben wird, gilt:
Wird ein BASIC-Kanal #ch f‡r 'channel' verwendet, dann dient die
'WIDTH'-Einstellung dieses Kanals als 'line-size'. Sonst wird 85 Zeichen
Ausgabebreite angenommen. Zu beachten ist jedoch, daœ die Grenzen eines
Bildschirmfensters Vorrang vor 'line-size' haben; ist 'line-size' n€mlich
gr„œer als die maximale Ausgabebreite eines Bildschirmfensters (in
Zeichen), dann wird es auf diese gek‡rzt. Wird z.B. 80 angegeben, das
Fenster hat aber nur 32 Zeichen Platz in einer Zeile, dann wird auch nur
mit maximal 32 Zeichen pro Zeile ausgegeben.
F‡r 'channel' kann schlieœlich noch eine BASIC-Kanalnummer stehen - oder
auch ein impliziter Kanal '\device'.
Beispiele:

   EXTRAS

   EXTRAS #2, 'AL'
   - bei vorhandenem Toolkit II werden ALARM, ALTKEY und ALCHP ausgegeben

   EXTRAS  \'SER1', 'C', 120
   - Alle Befehle, die mit einem 'C' beginnen, werden in Zeilen zu je 120
     Zeichen ‡ber die serielle Schnittstelle ausgegeben

   OPEN #3, 'SER1': WIDTH #3, 120: EXTRAS #3, 'C': CLOSE #3
   - bewirkt dasselbe, wie das 2. Beispiel.


Funktion    FDAT                 (F)
====================================
Syntax:
   a = FDAT [(channel)]

Wenn 'channel' (BASIC-Kanalnummer '#ch' oder impliziter Kanal '\device')
eine Datei bezeichnet, die normalerweise durch 'EXEC'/'EXEC_W' als
Programm aufgerufen wird, dann liefert 'FDAT' die Gr„œe des f‡r Daten
dieses Programmes zu reservierenden Speicherpatzes.


Funktion    FGETB                (R)
====================================
Syntax:
   a = FGETB [(#ch)]

'FGETB' liefert ein vom Kanal '#ch' gelesenes Byte als Zahl zwischen
0 und 255 ab.


Funktion    FGETF                (R)
====================================
Syntax:
   a = FGETF [(#ch)]

'FGETF' faœt die n€chsten sechs von dem Kanal gelesenen Bytes als
Gleitpunktzahl auf und liefert letztere als Funktionsergebnis ab.


Funktion    FGETH$               (R)
====================================
Syntax:
   a$ = FGETH$ [(#ch)]

'FGETH$' liefert den 'file-header' der Datei '#ch' als 64 Bytes lange
Zeichenkette.


Funktion    FGETL                (R)
====================================
Syntax:
   a = FGETL [(#ch)]

'FGETL' faœt die n€chsten vier vom Kanal '#ch' kommenden Bytes als
Langwort; dieses ist (in eine Gleitpunktzahl umgewandelt) das Funktions-
ergebnis.


Funktion    FGET$                (R)
====================================
Syntax:
   a$ = FGET$ [(#ch)]

'FGET$' liest eine Zeichenkette vom Kanal '#ch'. Es werden genausoviele
Bytes gelesen, wie die ersten zwei gelesenen Bytes plus zwei angeben.


Funktion    FGET%                (R)
====================================
Syntax:
   a% = FGET% [(#ch)]

'FGET%' liest zwei Bytes von '#ch' und liefert diese als Ganzzahl ab.


Funktion    FILE_OPEN            (F)
====================================
Syntax:
   ch_or_err = FILE_OPEN ([#ch,] devicename [, open-mode])

'FILE_OPEN' dient zum er„ffnen eines 'devices'. Ergebnis ist, bei
fehlendem ersten Argument '#ch' die BASIC-Kanalnummer, mit der er„ffnet
wurde, oder eine (negative) QDOS-Fehlernummer; wurde '#ch' angegeben,
dann ergibt sich f‡r erfolgreiches Er„ffnen 0. 'open-mode' ist f‡r
Dateien die Art, in der Er„ffnet werden soll und f‡r 'PIPE's die
QDOS-'channel id' der 'output pipe', die mit der zu er„ffnenden
'input pipe' verbunden werden soll. Diese kann f‡r BASIC-Kan€le mittels
'CHANID' (siehe weiter oben) ermittelt werden.
Beispiele:

      con_ch = FILE_OPEN (#3, 'CON')

      scr_ch = FILE_OPEN ('SCR')

      100 out_pipe = FILE_OPEN ('PIPE_5000')
      110 in_pipe = FILE_OPEN ('PIPE', CHANID (#out_pipe))
      120 DIR #out_pipe, 'MDV1_': CLOSE #out_pipe
      125 f = 0
      130 REPeat get_dir
      140   IF EOF (#in_pipe): EXIT get_dir
      150   INPUT #in_pipe, a$
      160   PRINT a$; TO 37;: IF f: PRINT
      165   f = NOT f
      170 END REPeat get_dir
      180 CLOSE #in_pipe


Funktion    FIND                 (R)
====================================
Syntax:
   a = FIND ('procedure-name')

'FIND' liefert die erste Zeilennummer der Definiton einer in BASIC ge-
schriebenen Prozedur/Funktion bzw. die (absolute) Adresse eines in
Maschinensprache geschriebenen Befehls (einer Funktion).
Beispiel:

      MONQL FIND ('BASE_N$')
      - setzt den MONQL-Monitor/Debugger auf die Startadresse von
        'BASE_N$'.


Funktion    FLEN                 (F)
====================================
Syntax:
   a = FLEN [(channel)]

'FLEN' liefert die L€nge der mit 'channel' angesprochenen Datei.
'channel' ist eine BASIC-Kanalnummer oder ein impliziter Kanal '\device'.


Funktion    FNAME$               (F)
====================================
Syntax:
   a$ = FNAME$ [(channel)]

'FNAME$' liefert den Namen der mit 'channel' angesprochenen Datei.
'channel' ist eine BASIC-Kanalnummer oder ein impliziter Kanal '\device'.


Funktion    FPOS                 (F)
====================================
Syntax:
   a = FPOS [(#ch)]

'FPOS' liefert den aktuellen Stand des Dateizeigers von '#ch', d.h. die
Position von der bei der n€chsten Lese-Operation gelesen / an die bei der
n€chsten Schreiboperation geschrieben wird. '#ch' ist auf #1 voreinge-
stellt.


Befehl      FPOS_A               (R)
====================================
Syntax:
   FPOS_A [#ch,] position

'FPOS_A' bringt den Dateizeiger von '#ch' an die Position 'position'
(Langwort). '#ch' ist auf #1 voreingestellt.


Befehl      FPOS_R               (R)
====================================
Syntax:
   FPOS_R [#ch,] offset

'FPOS_R' verschiebt den Dateizeiger von '#ch' um 'offset' Bytes nach
vorn ('offset' < 0) oder nach hinten ('offset' > 0).
Die Voreinstellung f‡r '#ch' ist #1.


Befehl      FPUTF                (R)
====================================
Syntax:
   FPUTF [#ch,] fexpr {, fexpr}

'FPUTF' schreibt die Gleitpunktzahlen 'fexpr' nach '#ch' (Voreinstellung:
#1).


Befehl      FPUTL                (R)
====================================
Syntax:
   FPUTL [#ch,] longword {, longword}

'FPUTL' schreibt seine Argumente 'longword' als Langworte (vier Bytes)
nach '#ch' (#1).


Befehl      FPUT$                (R)
====================================
Syntax:
   FPUT$ [#ch,] string {,string}

'FPUT$' schreibt seine Argumente 'string' als Zeichenketten (zwei Bytes
L€nge gefolgt von dem eigentlichen Text) nach '#ch' (#1).


Befehl      FPUT%                (R)
====================================
Syntax:
   FPUT% [#ch,] iexpr {, iexpr}

'FPUT%' schreibt seine Argumente 'iexpr' als (2 Byte-) Ganzzahlen nach
'#ch' (#1).


Funktion    FREAD$               (R)
====================================
Syntax:
   a$ = FREAD$ (#ch, length)

'FREAD$' liest (maximal) 'length' Bytes vom Kanal '#ch' und gibt diese als
Zeichenkette zur‡ck. Wird ein Dateiende erreicht, dann werden dement-
sprechend auch weniger Zeichen zur‡ckgegeben.
Vorsicht! 'FREAD$' liefert bei auftretenden Lesefehlern keine
Fehlermeldung. Daher sollte das Funktionsergebnis nicht in Ausdr‡cken
weiterverwendet werden. Ein sich ergebender Fehler kann mittels
'ERNUM' (JS/MG(G)) bzw. 'Q_ERR' (QLib_ext(ensions)) abgefragt und weiter-
verarbeitet werden. (inzuzuf‡gen ist, daœ ein Dateiende nicht als Fehler
angesehen wird und demzufolge auch nicht durch 'ERNUM' zu bestimmen ist,
sondern durch vergleich der L€nge des Ergebnisses mit 'length'.
Beispiel:

   ...
   9340 a$ = FREAD$ (#4, 600)
   9350 fails = Q_ERR
   9360 IF (fails = 0) AND (LEN (a$) < 600): end_file = 1
   9370 IF fails
   ...

(Ausprobieren!)


Befehl      FREEZE               (R)
====================================
Syntax:
   FREEZE flag

'FREEZE' schaltet den Bildschirm-Freeze (CTRL & F5) f‡r 'flag' = 0 ab
und f‡r 'flag' <> 0 wieder ein.
Beispiel:

   FREEZE OFF: WDIR: FREEZE ON
   (Ausprobieren!)


Funktion    FREEZE%              (R)
====================================
Syntax:
   flag = FREEZE%

'FREEZE' liefert 1 bei eingeschaltetem und 0 bei abgeschaltetem CTRL & F5.


Funktion    FREE_MEM             (F)
====================================
Syntax:
   free_area = FREE_MEM

'FREE_MEM' liefert die Gr„œe des Bereichs zwischen dem Ende des
'common heap' und dem Anfang des BASIC-Programmbereichs in Bytes zur‡ck.


Funktion    FSETH$               (R)
====================================
Syntax:
   FSETH$ [#ch,] string

'FSETH$' setzt die ersten 14 Bytes des 'file headers' der Datei '#ch'
neu. Die Zeichenkette 'string' sollte vorher mit 'FGETH$' eingelesen
worden sein; im ‡brigen werden auch nur Zeichenketten der L€ngen 14 oder
64 akzeptiert.


Funktion    FTYP                 (F)
====================================
Syntax:
   a = FTYP [(channel)]

'FTYP' liefert den Typ der Datei 'channel'. Dieser ist:

   0     -     f‡r BASIC-Programme, MC-Befehle, Daten usw.
   1     -     f‡r mit 'EXEC'/'EXEC_W' ausf‡hrbare Dateien
   2     -     f‡r die von (unter anderem) von 'Prospero - PASCAL'
               erzeugten '_REL' - Dateien sowie f‡r die Prozedurbibliothek
               dieses (und anderer) Compilers.
   n     -     irgendein anderer Dateityp (n = 3, ..., 255).


Funktion    FUPDT                (F)
====================================
Syntax:
   a = FUPDT [(channel)]

'FUPDT' liefert das 'update date', d.h. das Datum der letzten  nderung der
Datei 'channel' in interner Form. Das Datum als Zeichenkette erh€lt man,
indem man auf das Ergebnis von 'FUPDT' die Funktion 'DATE$' anwendet, z.B.

   PRINT DATE$ (FUPDT (\flp1_GENQL_bin))


Funktion    FXTRA                (F)
====================================
Syntax:
   a = FXTRA [(channel)]

'FXTRA' liefert den Inhalt der bislang unbenutzten vier Bytes des
'file headers' der Datei 'channel', die hinter denen von 'FDAT' gelesenen
in diesem liegen.


Funktion    GE$                  (R)
====================================
Syntax:
   flag = GE$ (comp-type, a$, b$)

'GE$' vergleicht 'a$' und 'b$' mit dem Vergleichstyp 'comp-type' (siehe
hierf‡r: 'EQ$') und liefert 1, wenn 'a$' entspr. 'comp-type' gr„œer oder
gleich 'b$' ist, sonst 0.


Funktion    GT$                  (R)
====================================
Syntax:
   flag = GT$ (comp-type, a$, b$)

'GT$' vergleicht 'a$' und 'b$' mit dem Vergleichstyp 'comp-type' (siehe
hierf‡r: 'EQ$') und liefert 1, wenn 'a$' entspr. 'comp-type' gr„œer als
'b$' ist, sonst 0.


Funktion    HeapFree             (R)
====================================
Syntax:
   a = HeapFree

'HeapFree' liefert die L€nge des gr„œten zusammenh€ngenden Speicher-
platzes im 'common heap' bzw., die L€nge des Bereichs zwischen dem Ende
des 'common heap' und dem SuperBASIC-Programmbereich (sofern dieser gr„œer
als alle Speicherfl€chen im 'common heap' ist).


Funktion    HEX                  (F)
====================================
Syntax:
   a = HEX ('hex-string')

'HEX' faœt die Zeichenkette 'hex-string' als hexadezimalzahl auf und
gibt das maschineninterne  quivalent zu dieser zur‡ck.
Beispiel:

   PRINT #0, HEX ('C0')
   192


Funktion    HEX$                 (F)
====================================
Syntax:
   a$ = HEX$ (long-int, bit-num)

'HEX$' wandelt 'bit-num' Bin€rstellen von 'long-int' in eine hexadezimale
Zeichenkette um und gibt diese zur‡ck.
Beispiel:

   PRINT #0, HEX$ (223, 16)
   00DF


Befehl      INITTURTLE           (R)
====================================
Syntax:
   INITTURTLE [#ch]

'INITTURTLE' setzt die Werte des Graphik-Cursors eines BASIC-Fensters auf
ihre Standarderte zur‡ck. Es entspricht der Befehlsfolge:
PENUP: MOVETO 0, 0: TURNTO 0


Funktion    INPUT$               (R)
====================================
Syntax:
   a$ = INPUT$ ([#ch,] length)

'INPUT$' liest aus '#ch' 'length' Bytes maximal jedoch bis zum n€chsten
'line feed' (einschl. diesem) von '#ch'. Falls bei einer Datei das
Dateiende w€rend des Lesens ‡berschritten wird, dann werden dement-
sprechend nur die Bytes bis zu diesem eingelesen.
Vorsicht! 'INPUT$' liefert bei fehlerhaften Dateioperationen keine
Fehlermeldung. Daher solte es nicht in Ausdr‡cken, sondern nur in
Zuweisungen verwendet werden. Der Fehler kann direkt danach durch
'ERNUM' (JS/MG(G)) bzw. 'Q_ERR' (QLib_ext(ensions)) abgefragt werden.
Beispiel:

   ...
   1320 a$ = INPUT$ (#3, 30)
   1330 fails = ERNUM
   ...


Funktion    IO_PEND%             (R)
====================================
Syntax:
   a = IO_PEND% [(#ch)]

'IO_PEND%' testet einen Kanal. Ergebnis ist eine QDOS-Fehlernummer oder 0.
Bei Bildschirmfenstern kann dies dazu verwendet werden, den Tastaturpuffer
eines solchen in den Vordergrund zu holen, d.h. daœ alle folgenden
Eingaben von diesem erfolgen.


Funktion    JobCBS               (R)
====================================
Syntax:
   a = JobCBS (job-id)

'JobCBS' liefert die Basisadresse des Kontrollbereichs eines Jobs, das ist
die Adresse, wo bei einem Task-Wechsel die Register hin gerettet werden
bzw. wo Informattionen wie die Priorit€t des Jobs usw. stehen.


Befehl      KillCmd              (F)
====================================
Syntax:
   KillCmd 'ext_name'

'KillCmd' entfernt ein mit 'MakeCmd' resident gemachtes Programm
(und nur ein solches!) wieder aus dem Speicher.
'KillCmd' pr‡ft, ob ein Job mit diesem Programmcode l€uft. In diesem
Fall bricht der Befehl mit 'in use' ab. Jobs mit Kopien des Programmcodes
f‡hren bei 'KillCmd' jedoch nich zum Abbruch.
Beispiel:

      - Wurde der 'Digital Precision'-Editor mit 'MakeCmd' (siehe dort)
        unter dem Namen 'DP_Edit' resident gemacht, dann entfernt
      KillCmd 'DP_Edit'
      - diesen wieder aus dem Speicher.


Befehl      KJOB                 (F)
====================================
Syntax:
   KJOB job-id

'KJOB' entfernt einen Job aus dem System.


Befehl      KJOBS                (F)
====================================
Syntax:
   KJOBS

'KJOBS' entfernt alle Jobs auœer Job 0 (SuperBASIC) aus dem System; dieser
Befehl ist mit Vorsicht anzuwenden, da z.B Jobs die durch den Aufruf des
'Eddi Young'-Editors entstanden sind, nur mit diesem auch wieder entfernt
werden d‡rfen (sonst st‡rtzt der QL ab).


Befehl      LBYTES               (F)
====================================
Syntax:
   LBYTES filename, address

'LBYTES' l€dt den Inhalt der Datei 'filename' ab 'address' vollst€ndig in
den Speicher. Wird 'filename' nicht gefunden, dann wird nacheinander mit
den Erg€nzungen '_cde', '_rext' und '_rom' weitergesucht. Wird auch
'filename'&'ext' ('ext' = '_cde', '_rext', '_rom') nicht gefunden, dann
wird mit 'not found' abgebrochen. Das 'Data Default' wird unterst‡tzt.

Beispiel:

   LBYTES 'flp2_saturn_scr', 131072
   - l€dt die Datei 'saturn_scr' von 'flp2_' in den Bildschirmspeicher.


Funktion    LE$                  (R)
====================================
Syntax:
   a = LE$ (comp-type, a$, b$)

'LE$' vergleicht die Zeichenketten 'a$' und 'b$'  mit dem Vergleichstyp
'comp-type'. Ergebnis ist 1, wenn a$ vor b$ (nach 'comp-type') ist, bzw.
wenn a$ = b$ ist, und 0 in jedem anderen Fall. F‡r 'comp-type' muœ unter
'EQ$' nachgesehen werden.


Funktion    LOAD_FILE            (R)
====================================
Syntax:
   a = LOAD_FILE ([#ch,] buffer-address, buffer-size)

'LOAD_FILE' l€dt den Inhalt der Datei #ch (Voreinstellung: #1) in den
Speicher ab der Adresse 'buffer-address'. Maximal werden 'buffer-size'
Bytes geladen. Ergebnis ist die Zahl der tats€chlich geladenen Bytes.
Vorsicht! Im Fehlerfall ist das Ergebnis von LOAD_FILE -1. Der Fehler
kann dann mit 'ERNUM' (JS/MG(G)) bzw. 'Q_ERR' (QLib_ext(ensions))
abgefragt werden.


Befehl      LRESPR               (F)
====================================
Syntax:
   LRESPR   filename

'LRESPR' l€dt eine Maschinensprache-Datei 'filename' in ein eigens hierf‡r
reserviertes Speicherareal; dieses wird im 'common heap' reserviert, wenn
irgend ein Job im Speicher ist und sonst im 'resident procedure area'.
Steht am Anfang des eingeladenen Codes ein ROM-header, dann wird eine
ROM-initialiserung durchgef‡hrt; sonst wird ein Unterprogrammansprung
(CALL) auf den Anfang des Codes ausgef‡hrt.


Funktion    LT$                  (R)
====================================
Syntax:
   a = LT$ (comp-type, a$, b$)

'LT$' vergleicht die Zeichenketten 'a$' und 'b$'  mit dem Vergleichstyp
'comp-type'. Ergebnis ist 1, wenn a$ vor b$ (nach 'comp-type') ist und 0
in jedem anderen Fall. F‡r 'comp-type' muœ unter 'EQ$' nachgesehen werden.



Befehl      MakeCmd              (F)
====================================
Syntax:
   MakeCmd 'filename' [, '[:]extension-name'] [, priority]

'MakeCmd' macht ein Programm (kein SuperBASIC!) resident. Ben„tigt wird
nur der Dateiname; jedoch k„nnen der Name, unter dem das residente
Programm aufgerufen werden soll und die Job-Priorit€t, mit der dies
geschehen soll zus€tzlich angegeben werden. Fehlt 'extension-name',
dann wird der Dateiname ohne 'Device'-Vorsatz verwendet. Fehlt 'priority',
dann wird 'priority' = 32 angenommen.
Das Programm wird durch

   ext_name [wa][! | \][prio] [, 'command' {, channel}]

aktiviert. 'ext_name' ist hierbei der Name unter dem das Programm resident
gemacht wurde ('filename' oder 'extension-name').
Mit 'wa' und 'prio' k„nnen die Gr„œe des 'data area' bzw. die Priorit€t
des Jobs zus€tzlich noch einmal eingestellt werden (bei nicht-Angabe werden
'priority' f‡r 'prio' bzw. der im 'file header' des Programms gefundene
Wert f‡r 'wa' angenommen). '!' bedeutet, daœ der 'owner', das ist der Job,
der 'ext_name' aufruft, warten soll, bis der neue Job beendet ist (EXEC_W);
bei '\' wartet der 'owner' nicht.
F‡r 'command' muœ eine Zeichenkette ‡bergeben werden.
F‡r die Parameter 'channel' ist zu beachten:
   - §bergeben werden k„nnen eine BASIC-Kanalnummer (#n)
     oder ein Dateiname bzw. 'Device'-Name (also z.B. 'FLP1_ed', 'SER1');
     Kan€le auf 'Device'-Namen bzw. Dateinamen werden intern f‡r den neuen
     Job er„ffnet.
   - Der erste 'channel'-Parameter fungiert als Eingabe-Kanal (wird mit
     'OPEN_IN' er„ffnet, falls ein 'Device'-Name bzw. Dateiname angegeben
     wurde).
   - Der zweite 'channel'-Parameter fungiert als Ausgabe-Kanal (wird also
     mit 'OPEN_OVER' er„ffnet, falls ein 'Device'- bzw. Dateiname angegeben
     wurde).
Zur ':'-Option im 'extension-name'-Parameter bei 'MakeCmd' ist noch folgendes
zu sagen:
   Es gibt Programme (wie z.B. alle 'TURBO'-kompilierten), die ihren
   Arbeitsbereich 'wa' PC-relativ adressieren und solche, die sich selbst
   auf eine bestimmte Adresse umschreiben (relokieren)
   (z.B. die 'Prospero'-Compiler bzw. mit diesen erzeugte Programme).
   Damit solche Software als residentes Programm einwandfrei l€uft, muœ
   der Programmk„rper beim Aufruf kopiert werden. Die ':'-Option sorgt nun
   daf‡r, das beim Aufruf von 'ext_name' genau dies geschieht.

Beispiele:

   MakeCmd 'flp1_DISCED', 127
   - macht das Programm 'DISCED' auf 'flp1_' unter dem Namen 'DISCED'
     resident.
   - Der Aufruf erfolgt mit:
   DISCED

   MakeCmd 'QUILL'
   - macht das Textprogramm 'QUILL' auf dem 'program default device'
     unter dem Namen 'QUILL' resident.
     Aufruf:
   QUILL!

   MakeCmd 'flp2_EDT_bin', ':DP_Edit'
   - macht den 'Digital Precision'-Editor unter dem Namen 'DP_Edit'
     resident. Aufruf erfolgt mit:
   DP_Edit

(Ausprobieren!)


Befehl      MCOPY                (R)
====================================
Syntax:
   MCOPY source-addr, dest-addr, length
   MCOPY source-addr, length TO dest-addr

'MCOPY' kopiert 'length' Bytes von 'source-addr' nach 'dest-addr'.
Hierbei ist es gleich, ob 'source-addr' kleiner als 'dest-addr' ist
oder nicht.
Beispiel:

   MCOPY 0, 16384 TO 131072
   - bzw.
   MCOPY 0, 131072, 16384
   - kopieren die untersten 16K des Betriebssystem-ROMs in den
     Bildschirm; das Ergebnis durfte ziemlich wirr aussehen.
   (Ausprobieren!)


Funktion    MKF$                 (R)
====================================
Syntax:
   a$ = MKF$ (float-num)

'MKF$' liefert die interne Form der Gleitpunktzahl 'float-num' als genau
sechs Bytes lange Zeichenkette.


Funktion    MKI$                 (R)
====================================
Syntax:
   a$ = MKI$ (int-num)

'MKI$' liefert die interne Form der Ganzzahl 'int-num' als genau zwei
Bytes lange Zeichenkette.


Funktion    MKL$                 (R)
====================================
Syntax:
   a$ = MKL$ (long-int)

'MKL$' liefert die interne Form der Ganzzahl 'long-int' als genau vier
Bytes lange Zeichenkette.


Funktion    MKS$                 (R)
====================================
Syntax:
   a$ = MKS$ ('string')

'MKS$' liefert die interne Form der Zeichenkette (2 Bytes L€nge, gefolgt
von dem eigentlichen Inhalt) als Zeichenkette zur‡ck. Das Ergebnis ist
genau zwei Bytes l€nger als 'string'; darum darf 'string' auch nur maximal
32763 Zeichen lang sein.


Befehl      MOVETO               (R)
====================================
Syntax:
   MOVETO [#ch,] x, y

'MOVETO' setzt den Graphik-Cursor eines BASIC-Fensters auf die Position
<x, y> (Graphikkoordinaten). Ist PENDOWN #ch eingestellt, dann wird eine
Linie von der letzten Position des Graphik-Cursors nach <x, y> gezeichnet.


Funktion    NE$                  (R)
====================================
Syntax:
   a = NE$ (comp-type, a$, b$)

'NE$' vergleicht die Zeichenketten 'a$' und 'b$'  mit dem Vergleichstyp
'comp-type'. Ergebnis ist 1, wenn a$ = b$ ist, sonst 0. F‡r 'comp-type'
siehe unter 'EQ$'.


Funktion    ODD                  (R)
====================================
Syntax:
   a = ODD (num)

'ODD' liefert 1, falls 'num' ungerade ist, sonst 0.


Funktion    OFF                  (R)
====================================
Syntax:
   a = OFF

Das Ergebnis von 'OFF' ist 0.


Funktion    ON                   (R)
====================================
Syntax:
   a = ON

Das Ergebnis von 'ON' ist 1.


Funktion    PEEK_F               (R)
====================================
Syntax:
   a = PEEK_F (address)

Ergebnis von 'PEEK_F' ist die an der (geraden) Adresse 'address' stehende
Gleitpunktzahl.


Funktion    PEEK$                (R)
====================================
Syntax:
   a$ = PEEK$ (address[, length])

Wird 'length' angegeben, dann liefert 'PEEK$' die 'length' Zeichen ab
der (auch ungeraden) Adresse 'address' als Zeichenkette zur‡ck.
Wird 'length' nicht angegeben, dann liefert 'PEEK$' die an der (geraden)
Adresse 'address' stehende Zeichenkette.


Befehl      POKE_F               (R)
====================================
Syntax:
   POKE_F address, float-num

'POKE_F' schreibt die Gleitpunktzahl 'float-num' an die (gerade) Adresse
'address'.


Befehl      POKE$                (R)
====================================
Syntax:
   POKE$ address, 'string' [, length]

Wird 'length' angegeben, dann schreibt 'POKE$' 'length' (maximal jedoch
die L€nge von 'string') Zeichen von 'string' ab der (auch ungeraden)
Adresse 'address' in den Speicher.
Wird 'length' nicht angegeben, dann wird die Zeichenkette 'string' an
die (gerade) Adresse 'address' in den Speicher gebracht.


Funktion    QDOS$                (R)
====================================
Syntax:
   a$ = QDOS$

'QDOS$' liefert die Versionsnummer des Betriebssystems als vier Zeichen
lange Zeichenkette.
Beispiel:
   - f‡r MG(G)
   PRINT #0, QDOS$
   1G13


Funktion    QRAM$                (R)
====================================
Syntax:
   a$ = QRAM$ [(#ch)]

'QRAM$' liefert die Versionsnummer des aktivierten 'pointer interface' als
Zeichenkette oder '', falls kein 'pointer interface' aktiv ist.


Befehl      RECHP                (F)
====================================
Syntax:
   RECHP address {, address}

'RECHP' gibt mit 'ALCHP' reservierte Speicherfl€chen wieder ans Betriebs-
system zur‡ck. 'address' m‡ssen genau die Adressen sein, die 'ALCHP' ge-
liefert hat. 'RECHP' ist in der Lage auf beliebige Art mit 'ALCHP' reser-
vierte Speicherfl€chen freizugeben.


Befehl      RELJOB               (F)
====================================
Syntax:
   RELJOB job-id

'RELJOB' gibt einen Suspendierten Job frei.
Vorsicht! 'RELJOB' sollte niemals auf Jobs angewendet werden, die suspen-
diert sind, weil sie auf die Beendigung einer Ein- oder Ausgabeoperation
warten.


Funktion    REPLY                (R)
====================================
Syntax:
   a = REPLY ([#ch,] ['valid' [, lettercase-flag]])

'REPLY' erm„glicht eine gezielte Auswahl bei Ein-Zeichen-Eingaben.
Nachdem im Fenster #ch der Cursor aktiviert wurde, wird auf eine Eingabe
von der Tastatur gewartet. Wird diese in 'valid' nicht gefunden, dann
wird ein Warnton ausgegeben und anschlieœend erneut auf eine Eingabe
gewartet. Dies geschieht solange, bis eine g‡ltige Eingabe gemacht wurde.
Ergebnis ist die Position des Zeichens innerhalb von 'valid'.
'lettercase-flag' entscheidet, ob bei Buchstabeneingaben zwischen Klein-
und Groœschreibung unterschieden werden soll (lettercase-flag = 0)
oder nicht (lettercase-flag = 1).
Mit 'REPLY' lassen sich auch ALT-Tastenkombinationen abfragen. In diesem
Fall muœ die Kombination CHR$(255)&CHR$(Taste) in 'valid' enthalten sein;
das Ergebnis ist dann die Position des direkt vor CHR$(Taste) stehenden
CHR$(255) innerhalb von 'valid'.

Es ist auch m„glich 'valid' nicht anzugeben. Es gilt:
  Wird 'valid' nicht angegeben oder ist leer, dann ist das Ergebnis
  f‡r einfache Tastendr‡cke der ASCII-Code der gedr‡ckten Taste und
  f‡r ALT-Tastendr‡cke der ASCII-Code der Taste weniger 256.

Die Voreinstellungen sind #1 f‡r '#ch' und 0 f‡r 'lettercase-flag'.



Befehl      REPORT               (F)
====================================
Syntax:
   REPORT [#ch,] qdos-errnum

'REPORT' gibt die der Fehlernummer 'qdos-errnum' entsprechende Meldung
in Kanal '#ch' (Voreingestellt ist #0) aus. Existiert keine solche
Meldung, dann wird 'undefined error' ausgegeben.


Befehl      RESET                (F)
====================================
Syntax:
   RESET ram-size

'RESET' f‡hrt eine Neuinitialisierung des QL mit der Speicherkonfiguration
'ram-size' durch. 'ram-size' muœ in 64K-Schritten zwischen 128 und 640
liegen.


Funktion    RESPR                (F)
====================================
Syntax:
   a = RESPR (mem-size)

'RESPR' reserviert minimal 'mem-size' Bytes im Speicher und gibt die
Anfangsadresse der reservierten Speicherfl€che zur‡ck.
'RESPR' reserviert normalerweise Platz im 'resident procedure area'.
Funktioniert dies jedoch nicht, weil ein Job l€uft, dann wird stattdessen
Platz im 'common heap' reserviert.


Befehl      RJOB                 (F)
====================================
Syntax:
   RJOB job-id, qdos-errnum

'RJOB' l„scht den Job 'job-id' und gibt die Fehlernummer 'qdos-errnum' an
dessen 'owner' zur‡ck.


Befehl      RPT$                 (R)
====================================
Syntax:
   a$ = RPT$ (str/num, n)

'RPT$' gibt das 'n'-mal vervielf€ltigte Argument 'str/num' als Zeichen-
kette zur‡ck.
'str/num' kann sein sein:
   1. eine Zeichenkette; dann wird diese entsprechend oft vervielf€ltigt.
   2. eine Zahl im Bereich 0...255; In diesem Fall wird
      CHR$(str/num) vervielf€ltigt.
   3. eine Ganzzahl > 255 bzw. < 0; In diesem Fall wird
      CHR$(str/num DIV 255) & CHR$(str/num MOD 255) vervielf€ltigt.


Befehl      SBYTES               (F)
====================================
Syntax:
   SBYTES filename, address, length

'SBYTES' speichert 'length' Bytes ab der Adresse 'address' in der Datei
'filename'. Wenn eine Datei mit dem Namen 'filename' bereits existiert,
dann wird mit 'already exists' abgebrochen.
Das 'Data Default' wird unterst‡tzt.

Beispiel:

   SBYTES flp2_saturn_scr, 131072, 32768
   - speichert den Bildschirminhalt unter dem Namen 'saturn_scr' auf
     'flp2_'


Befehl      SBYTES_O             (F)
====================================
Syntax:
   SBYTES_O filename, address, length

'SBYTES_O' speichert 'length' Bytes ab der Adresse 'address' in der Datei
'filename'. Wenn eine Datei mit dem Namen 'filename' bereits existiert,
dann wird sie ‡berschrieben.
Das 'Data Default' wird unterst‡tzt.

Beispiel:

   SBYTES_O flp2_saturn_scr, 131072, 32768
   - speichert den Bildschirminhalt unter dem Namen 'saturn_scr' auf
     'flp2_' und ‡berschreibt eine evtl. bereits existierende dieses
     Namens.


Funktion    SEARCH               (R)
====================================
Syntax:
   addr = SEARCH (start-address, end-address, 'pattern' [, upper-flag])

'SEARCH' sucht im Bereich zwischen 'start-address' und 'end-address' nach
der Zeichenkette 'pattern'. Im Falle eines Erfolgs wird die Adresse des
ersten Zeichens von Pattern zur‡ckgegeben; bei einem Miœerfolg 0. Wird
f‡r 'upper-flag' 1 ‡bergeben, dann wird zwischen Groœ- und Kleinschreibung
bei der Suche nicht unterschieden; Voreinstellung ist 0.


Befehl      SETMON               (F)
====================================
Syntax:
   SETMON #x, bw, bc, ww, wh, wx, wy  (#x = #0, #1, #2)
oder:
   SETMON bw0,bc0,ww0,wh0,wx0,wy0, bw1,bc1,ww1,wh1,wx1,wy1, bw2,bc2,ww2,
          wh2,wx2,wy2

'SETMON' legt die Einstellungen der Fenster #0, #1, #2 f‡r den Befehl
'WMON n, -1' fest. Es geschieht jedoch noch nichts auf dem Bildschirm.


Befehl      SETTV                (F)
====================================
Syntax:
   SETTV #x, bw, bc, ww, wh, wx, wy  (#x = #0, #1, #2)
oder:
   SETTV bw0,bc0,ww0,wh0,wx0,wy0, bw1,bc1,ww1,wh1,wx1,wy1, bw2,bc2,ww2,
          wh2,wx2,wy2

'SETTV' legt die Einstellungen der Fenster #0, #1, #2 f‡r den Befehl
'WTV n, -1' fest. Es geschieht jedoch noch nichts auf dem Bildschirm.


Befehl      SEXEC                (F)
====================================
Syntax:
   SEXEC filename, address, length, datasize

'SEXEC' speichert 'length' Bytes ab 'address' als Programmdatei 'filename'
mit einem Datenbereich der Gr„œe 'datasize'. Wenn eine Datei des Namens
'filename' bereits existiert, dann wird mit 'already exists' abgebrochen.

Beispiel:

   SEXEC 'flp2_Clock', a, 1000, 512
   - speichert 1000 Bytes ab a als mit 'EX' aufrufbare Datei 'Clock' auf
     'flp2_' mit dem 'data size' 512 Bytes.


Befehl      SEXEC_O                (F)
====================================
Syntax:
   SEXEC_O filename, address, length, datasize

'SEXEC_O' speichert 'length' Bytes ab 'address' als Programmdatei
'filename' mit einem Datenbereich der Gr„œe 'datasize'. Wenn eine Datei
des Namens 'filename' bereits existiert, dann wird diese ‡berschrieben.

Beispiel:

   SEXEC_O 'flp2_Clock', a, 1000, 512
   - speichert 1000 Bytes ab a als mit 'EX' aufrufbare Datei 'Clock' auf
     'flp2_' mit dem 'data size' 512 Bytes. Eine bereits existierende
     Datei 'Clock' wird hierbei ‡berschrieben.


Funktion    SIGN                 (F)
====================================
Syntax:
   a = SIGN (x)

Ergebnis von 'SIGN' ist das Vorzeichen der Zahl 'x', d.h. 1 f‡r positives
'x', -1 f‡r negatives 'x', und 0, wenn 'x' gleich 0 ist.


Funktion    SINT                 (R)
====================================
Syntax:
   a = SINT (unsigned-integer)

'SINT' wandelt eine Zahl im Bereich zwischen 0 und 65535 in eine Zahl im
Bereich -32768...+32767 um.


Befehl      SPJOB                (F)
====================================
Syntax:
   SPJOB job-id, priority

'SPJOB' setzt die Priorit€t eines Jobs auf den Wert 'priority'.


Befehl      SUSJOB               (F)
====================================
Syntax:
   SUSJOB job-id, timeout

'SUSJOB' suspendiert einen Job f‡r die angegebene Zeit 'timeout'.
'timeout' z€hlt hierbei in 'frames'; dies sind in der BRD 20ms-Zeiteinhei-
ten (die Frequenz des Strahr‡cklaufs eines Fernsehers oder Monitors).


Funktion    TPAFree              (F)
====================================
Syntax:
   free_space = TPAFree

'TPAFree' gibt die l€nge des gr„œten f‡r Jobs zur Verf‡gung stehenden
zusammenh€ngenden Speicherbereichs zur‡ck. Intern ist 'TPAFree' mit
'MT.FREE' (TRAP #1; D0 = $06) identisch.


Funktion    TURTLE               (R)
====================================
Syntax:
   tst = TURTLE ([#ch,] stat-num)

'TURTLE' gibt den Status des Graphik-Cursors eines BASIC-Fensters zur‡ck.
F‡r stat-num wird zur‡ckgegeben:
        0         y-Koordinate des Graphik-Cursors
        1         x-Koordinate des Graphik-Cursors
        2         Winkel ('heading') des Graphik-Cursors
        3         0 f‡r PENUP, 1 f‡r PENDOWN


Funktion    TYPE                 (R)
====================================
Syntax:
   use = TYPE ('basic_name')

'TYPE' gibt den Verwendungstyp eines BASIC-Namens 'basic_name' zur‡ck.
F‡r BASIC-Prozeduren ist dies 1026, f‡r BASIC-Funktionen 1282 (Gleitpunkt-),
1283 (Ganzahl-) bzw. 1281 (Zeichenkettenfunktionen).
F‡r MC-Prozeduren ergibt sich 2048, f‡r MC-Funktionen 2304.


Befehl      TYPE_IN              (R)
====================================
Syntax:
   TYPE_IN 'input-line'

'TYPE_IN' schreibt die Zeichenkette 'input-line' in den gerade aktiven
Tastaturpuffer.
Beispiel:

   ...
   2310 xx = IO_PEND% (#1): REMark aktiviere Tastaturpuffer von #1
   2320 TYPE_IN 'FLP1_'
   2330 INPUT 'Type filename:' ! fnm$


Funktion    UINT                 (R)
====================================
Syntax:
   unsigned_int = UINT (signed_int)

'UINT' wandelt eine Ganzzahl im Bereich -32768...32767 in eine Ganzzahl
zwischen 0 und 65535 um.
Beispiele:

   PRINT #0, UINT (-32768)
   32768

   PRINT #0, UINT (-1)
   65535

   PRINT #0, UINT (16240)
   16240


Befehl      VIEW                 (F)
====================================
Syntax:
   VIEW [channel,] filename [\]

'VIEW' listet den Inhalt der Datei 'filename' in dem Kanal 'channel'.
'channel' kann eine BASIC-Kanalnummer oder ein 'impliziter' Kanal
'\device' sein. Wird 'channel' gar nicht angegeben, dann wird #1
angenommen. Wird '\' zus€tzlich angegeben, dann wird der Rest einer Zeile
bei Ausgabe in einem Bildschirmfenster 'verschluckt', sondern in den
folgenden Zeilen des Fensters bis zum n€chsten 'line feed' vollst€ndig
ausgegeben.


Funktion    WinCTRL              (R)
====================================
Syntax:
   addr = WinCTRL ([channel,] offset)

'WinCTRL' liefert einen Zeiger auf eine Speicherstelle im Standard-Teil
der 'window definition' und zwar unabh€ngig davon, ob das 'pointer enviroment'
aktiv ist oder nicht. 'offset' gibt die Adresse der Speicherstelle relativ
zum Anfang der 'standard window definition' an.


Befehl      WinLOAD              (R)
====================================
Syntax:
   WinLOAD address

'WinLOAD' l€dt ein mit 'WinSAVE' abgespeichertes Bildschirmfenster wieder
in den Bildschirm zur‡ck. 'address' muœ die von 'WinSAVE' gelieferte Adresse
des Speicherfeldes sein. Das Speicherfeld wird hinterher an das System zu-
r‡ckgegeben.


Funktion    WinSAVE              (R)
====================================
Syntax:
   addr = WinSAVE [(#ch)]

'WinSAVE' speichert den Inhalt des Fensters #ch (Voreinstellung: #1) in
einen eigens hierf‡r reservierten Seicherbereich ab. Ergebnis ist die
Anfangsadresse des reservierten Bereichs.


Befehl      WinSHOW              (R)
====================================
Syntax:
   WinSHOW address

'WinSHOW' arbeitet wie 'WinLOAD'; jedoch wird der reservierte Bereich
hinterher nicht freigegeben sondern bleibt erhalten.


Funktion    WMAN$                (R)
====================================
Syntax:
   a$ = WMAN$ [(channel)]

'WMAN$' liefert die Versionsnummer des 'window managers' als vier Zeichen
lange Zeichenkette - oder '', falls kein 'window manager' aktiv ist.
'channel' kann eine BASIC- (#n) oder eine Systemkanalnummer (\n) sein.
Voreingestellt ist #1.


Befehl      WMON                 (F)
====================================
Syntax:
   WMON [colour-mode][, screen-config]

'WMON' setzt die drei Standardfenster (#0, #1, #2) auf einen definierten Wert
'screen-config' und f‡hrt hinterher einen 'MODE'-Befehl mit 'colour-mode'
als Parameter aus. 'screen-config' ist entweder -1 oder ein Wert zwischen
0 und (momentan) 2. WIrd -1 angegeben, dann wird die durch 'SETMON' ein-
gestellte Konfiguration genommen. Alle anderen sind fest vorgegeben.
Voreinstellung sind immer die Parameter, die zuletzt angegeben wurden.
Wurde 'WMON' jedoch noch nicht aufgerufen, dann ist 'WMON 4, 0' voreinge-
stelt.


Befehl      WTV                  (F)
====================================
Syntax:
   WTV [colour-mode][, screen-config]

'WTV' funktoniert im Prinzip genau wie 'WMON'; jedoch werden andere
Fensterkonfigurationen verwendet. F‡r 'WTV , -1' muœ der 'SETTV'-Befehl
zur Einstellung der Fenster verwendet werden. Wurde 'WTV' noch nicht mit
Parametern aufgerufen, dann gilt 'WTV 8, 0' als Voreinstellung.
