* F6 * pre(!)-79-standard experimental fig-forth * glossary * by .hpr'8/1995 *
* F6 * experimentelles Forth-System nach dem f.i.g.-Modell * von .hpr'8/1995 *

* >>   English explanations can be found by searching for the marker ">>".   *

This text is about 6700 lines of up to 80 chars, each, of plain QL-ascii
characters with no ctrl's other than lines terminating <lf>s - ASCII 10.

Characters above code 127 are
 "€" ae = 128 & 160     "„" oe = 132 & 164      "‡" ue = 135 & 167
 "œ" sz = 156           "±" pi = 177            "¶" section symbol = 182
 "°" my = 176           "Ÿ" backquote = 159     "»" division symbol = 187
 "¿" arrow down = 191   "¾" arrow up = 190

Der Text enth€lt als Steuerzeichen nur <lf> - Code 10 - am Zeilenende und um-
faœt ca. 6700 Zeilen zu max. 80 Zeichen Breite. Textende mit » eof » markiert.


              F6, Ausgabe 8.18, April 1998 - "final beta"
                Copyright (C) 1997 H.-Peter Recktenwald
                 Albestr. 21, D-12159 Berlin-Friedenau
                         Tel.: ++49 30 8520413
                     Inet: phpr@mail.geocities.com


                              1 - EINF§HRUNG
                     ->  Teil 2 - GLOSSAR
                              3 - Referenzlisten


* "F6GLS_txt" - Glossar

* Bezeichnungen, Angaben zur Notation:

4th             abgek‡rzt fur "FORTH"
ans             man weiœ ja nie...
             >> (most unlikely) some adaptation to the ANSI-standard proposal.
C1 lmi          Anpassung an das C1-LMI-Typ Forth.
             >> the lmi-style forth for the QL by "Computer One"
F6              Hinweis auf nicht in den bekannten Standardbeschreibungen ent-
                haltene Einrichtungen im F6-System; teils eigene Entwicklungen
                und hierdurch zur Diskussion gestellte Vorschl€ge des Autors.
             >> F6 special.
F6S             f‡r zus€tzlich vom Screenfile "forth_scr" compilierbare Worte.
             >> additional forth words may be compiled from "forth_scr".
F79             Dem ersten als solchem formulierten Standard entlehnt.
F83             Hinweis auf Herkunft aus verschiedenen F83-€hnlichen Systemen.
             >> for 83-standard compliance, or taken from f83, 83-standard etc.
FIF             Einem "fifth"-System zum ibm-PC entlehnt,
                das unter der Autorenschaft "Click-Software" geht.
             >> "fifth", by Click Software.
H4              Ein Multitasking-System der "Skyvawe"-Software, H&H Husband,
                zum ZX81, dem u.a. einige Funktionsprinzipien entlehnt wurden.
             >> H & H Husband's multitasking Forth for the ZX81.
LR              nach der von L.Reeves eingerichteten f.i.g.-Standardinstallation
                f‡r den QL, insbes. die qdos-Kanal-Tabellen betreffend.

* Wort-Typen
integer         jeder 16-Bit-Wert, als Zahl im bin€ren Zweiercomplement notiert,
                Wertebereich -32767 bis 32767, -32768 als "negative Null".
             >> 16-bit-value, signed magnitude two's complement number
double          32-Bit-Wert entspr. 'integer',
                Wertebereich -2^31+1 bis 2^31-1, entspr. +/- 2147.483687.
             >> 32-bit integer value
quad            64/63-bit-Integer, max. Bereich -2^63+1 bis 2^63-1,
                entspr. rund +/- 10^19, genau: +/- 9.223372.036854.775807.
fp              dezimale QL/QDOS-Flieœkommazahl,
                Bereich ca. +/- 10^614 bei neunstelliger Genauigkeit.
             >> decimal QL/QDOS-format (44-bit) floating point number
cons            Constante allgemein
vari            Variable
qdos-string     String mit f‡hrendem Z€hler-Wort, muœ nur dann an geradzahliger
                Adresse stehen, wenn eine qdos-Operation daran vorgenommen wird.
             >> word counted string, at even address if qdos-operands involved.
4th-string      String mit f‡hrendem Z€hler-Byte, dem "countbyte".
             >> byte counted string

   Notierung f‡r den Datenstack, ggf. mit Returnstack
        ( datenparameter rp: returnstackparm -- datenparm rp: retstackparm )
   Alternativposten werden durch "|" getrennt angegeben.
        ( sys: ... )
   Compilerdaten liegen gemeinsam mit anderen Posten im Datenstack.

* Art und Bezeichnungsweise der Datenposten
Zahl            ein Posten im Stack oder im Speicher
Festwert        in ein Forth-Wort compilierte nicht €nderbare Zahl, die w€hrend
                dessen Ausf‡hrung zum Stack gelangt - s. auch "literal".
Wert            Bestand einer beliebigen Dateneinheit.
String          l‡ckenlose Gruppe als Schriftzeichen interpretierbarer Bytes.
                Die meist vorzufindende Umschreibung "Zeichenkette" trifft nicht
                zu, da die Zeichen in keinerlei Zusammenhang miteinander stehen,
                "Zeichen-Strang" w€re akzeptabel, ist aber ungebr€uchlich.
                Darum wird in diesem Text der "String" als Begriff beibehalten.
Byte            je Adresse spezifizerte Gruppe 8 aufeinanderfolgender Bits.
Zelle           beliebiger Ort zweier aufeianderfolgend adressierbarer Bytes.
Adresse         des Forth heiœt anderswo oft "Pointer". Die Speicheradressierung
                im Forth erfolgt ‡blich ‡ber solche auf die Referenzadresse des
                Systems bezogenen Verweise auf die eigentlichen Datenposten und
                erspart damit viele unn„tige Speicheroperationen.
                Der Klarheit halber wird in diesem Text zwischen "Pointern" als
                "4th-Adressen" und "wirklichen (32-Bit-)Adressen" unterschieden.
+ve             f‡r einen Wert ab Null,
-ve             f‡r einen Wert unter Null.
negative Null   Zahl, bei der nur das (h„chstwertige) Vorzeichenbit gesetzt ist.
-ve zero     >> integer with only the sign bit (m.s.b.) set.
dadr1           wirkliche Speicheradresse als 'double'
             >> double true memory address (32-bit)
disp            "displacement", Abstand zu einem festliegenden Ort.
c1              8-Bit-Wert, wie 'integer'
             >> charcter value, in the range of 0 to 255, or -128 to 127.
{ccc}           Beliebige Folge (im F6) zul€ssiger Schriftzeichen
             >> Any number of consecutive characters.
n1              Integer-Posten im Stack, das Standardformat des F6-Systems
             >> standard F6 single cell content, signed single integer, 16-bit.
Cc              Integer mit Vorzeichenwert als Sprung-Bedingung
             >> condition code
d1              "double": Doppeltgenaue Integer (32 Bit)
q1              "quad": Vierfachgenaue Integer (63/64 Bit)
un1 ud1 uq1     vorzeichenlos bewertete Integer der entsprechenden Formate
             >> unsigned
f1              fp-Posten im Stack
             >> qdos-style floating point item
er              Fehlernummer
d.er            'double' Fehlernummer
ptr1            vorzeichenbehafteter 16-Bit-ptr relativ zur Adressierungsbasis.
             >> ptr into the forth addres space, single integer (signed 16-bit)
stg1            4th-Adresse eines 4th-Strings, stg1 zeigt auf sein Countbyte.
             >> ptr to a (byte counted) 4th-string
flg             Flagwert tf oder ff, auf andere Codierung wird hingewiesen.
ff              "false flag" mit dem Wert 0.
tf              "true flag" mit dem Wert 1 (nicht -1 der sp€teren Standards!)
             >> "true flag" is 1, not -1 of the more recent standards!

* Worteigenschaften
(I)             'immediate' word
(C)             compilierendes immediate-Wort; Compile-Stack danach notiert.
(D)             'deferred' word, gebildet mit {defer}.
(P)             benutzt {pad} als Hilfsspeicher
(iP)            (P) nur im interpretierenden Zustand oder bei Programmeingabe.
hi-level        Ebene reiner Forth-Definitionen, im Unterschied zu
lo-level        Ebene direkt ausf‡hrbarer Processorcodes.
primitive       Wort, das sofort in direkt ausf‡hrbaren Processorcode m‡ndet.
runtime      1. Zeitpunkt der Ausf‡hrung eines Wortes, rsp.
             2. Kurz f‡r "runtime executive", die beim Aufruf eines Wortes aus-
                gef‡hrte WA, von einer ‡bergeordneten Definition compiliert.
          >> 1. moment of actually executing a word in a program.
          >> 2. "runtime executive", code executing a compiled word at runtime;
                the execution behaviour determining part of a defining word.
state sensitiv  ist ein Wort, das abh€ngig vom in {state} notierten Systemzu-
                stand (compilierend/interpretierend) unterschiedlich arbeitet.
AQ              Hinweis auf den Atari-QL, es gilt dasselbe wie bei QX.
QX              speziell f‡r QXL/SMSQ. Anwendung im SMSQ/E wegen immer wieder
                neuer und nicht st€ndig ‡berpr‡fbarer Versionen u.U. unsicher.
                Gewissenhafte Pr‡fung bei zumutbarem Aufwand war nur in der
                Version 2.76 des mit der QXL gelieferten SMSQ m„glich.
             >> for QXL/SMSQ; thoroughly tested as all the F6 system, never-
                theless not necessarily safe with any versions of SMSQ/E.
IO2             Die betr. Aufrufe liefern brauchbare Ergebnisse nur, wenn das
                MEM-Device der IO2-Sammlung (vom Autor des F6) vorhanden ist.
             >> needs the MEM-device which may be loaded from "dvs_byt".
PC              "program counter" - Programmz€hler, oder "personal computer".
PeZe            die garnichtmal so schlechte Kiste der "big blue", verdorben
                durch vorsteinzeitliche "Programmier"-Versuche...
PiQ             "Programmieren in QDOS", Beschreibung des Betriebssystems des
                (schwarzen!) QL, Systemdaten und Beispiele. Kann u.a. aus dem
                Internet oder gegen Freimschlag und zwei formatierte Disketten
                vom Autor bezogen werden.
PIF             Pointer Interface, Basisteil des "Extended Environment";
PEX             eine besonders f‡r MINERVA (und SMSQ) eingerichtete Erg€nzung
                dazu f‡r die automatische Auffrischung des Fensterinhalts.
SBasic          weist auf das SuperBASIC des QL hin (und nichts anderes!).
TK2             Hinweis auf Aktionen, die nur im TK2-erweiterten System zum
                Erfolg f‡hren, gilt zugleich f‡r Trump-/Gold-Card u. QXL/SMSQ.

* Systematische Begriffe
t.o.s.          "top of stack" - zuerst errreichbarer Stackposten.
sys             Compiler-Kontrolldaten, vor‡bergehend im Datenstack.
             >> control data on stack while compiling.
dictionary      der durch Worte besetzte und zum Aufbau neuer Worte freie Be-
                reich. Er teilt sich nach dem letzten compilierten Wort in die
                fl‡chtigen Arbeitsbereiche ab {here}, wohin der Interpreter die
                aus dem Eingabestrom isolierten Worte holt, und {pad} zur An-
                wender-Nutzung und einige wenige Stringoperationen auf, sowie
                dazwischen den Bereich zur Umwandlung von Zahlen in Ziffernfol-
                gen, und beherbergt zum Ende hin noch den Datenstack mit ggf.
                den Localen Variablen. - Im eigentlichen Sinne nur der bereits
                besetzte Teil des Forth-Speichers, der jedoch erweiterbar ist.
             >> space of 4th-words, free compiling memory and workspace.
screenfile      Klartextfile ohne Steuerzeichen von ohne Rest durch Seitengr„œe
                (c/l * b/scr) teilbarer L€nge - Standardm€œig 1024 Bytes/Seite;
                der Name deutet auf die Darstellungsweise in Bildschirmseiten.
block           Die "screen" besteht aus Bl„cken mit einer systemabh€ngigen
                Anzahl Bytes, die einer Zweierpotenz entspricht.
                Im F6 hat eine "screen" 16 "block"s zu 64 Bytes L€nge.
             >> One screen is 16 blocks of 64 bytes - re below.

* Wortgestalt
{name}          Forth-Worte erscheinen im Text zwischen geringelten Klammern.
                Die Namen d‡rfen im F6 alle Schriftzeichen bis zum   enthalten,
                entsprechend den (QL-)ASCII-Codes 33 bis 160, worin auch die
                kleingeschriebenen Umlaute enthalten sind, und das " ". Inner-
                halb dieses Bereichs sind Groœ- oder Kleinschreibung belanglos.
                Die anderen Zeichen werden zwar fehlerfrei verarbeitet und damit
                gebildete Worte sp€ter auch erkannt, jedoch k„nnen mehrdeutige
                Namen entstehen: Das System pr€pariert sie so, daœ die g‡ltigen
                Schriftzeichen mit gel„schtem Bit 7 in die Wortheader ‡bernom-
                men werden. Dadurch erhalten die Zeichen 128 bis 160 einen Code
                im Bereich 0 bis 32. Beim Lesen werden sie wieder restauriert.
                Die Zeichen ab 161 kommen dabei mit den g‡ltigen Codes ab 33 zur
                Deckung und k„nnen nicht als ver€ndert erkannt werden, sodaœ die
                damit gebildeten Namen sp€ter verf€lscht erscheinen und sie u.U.
                nicht eindeutig sind:
                        : ± also fp pi previous ;
                wird angenommen, jedoch sind dann
                        ±      und     1
                identisch. Was zeigt, daœ ein neues Wort {±} die Constante {1}
                ‡berdefiniert und je nach Vokabular unzug€nglich machen kann.
             >> forth words in a description appear within curly brackets. Names
                may consist of any chars in the range of (QL-)ASCII 33 to 160,
                wherein whether being upper or lower cases doesn't matter. Any
                other chars might result to ambiguous names.

* Vorzugs-Verwendung f‡hrender rsp abschlieœender Zeichen bei 4th-Namen {...}
- ...           f‡hrendes "-" deutet an, daœ das Wort eine Aktion Flag-abh€ngig
                ausf‡hrt, oder selber eine Flag liefert.
" ...           Variante der Operation {ccc} f‡r eine Folge von Schriftzeichen.
? ...           zumeist eine Pr‡foperation mit {abort} im Fehlerfalle.
2 ...           Stackoperation an allgemeinen doppelt-groœen Posten
4 ...           dto., vierfache Postengr„œe.
d ...           vorwiegend f‡r vorzeichenbehaftete 32-Bit-Zahlen; Arithmetik.
q ...           dto., vierfachgenaue Zahlen.
 ... "          Wort erwartet oder holt eine Folge von Schriftzeichen.
 ... .          Schreibt eine Zahl rsp ein Textst‡ck (auch bei f‡hrendem ".").
 ... :          Definitionswort.
 ... ?          Liest Daten und schreibt davon abgeleitete Zahl oder Text.
 ... ]          Wort mit §bergang in den Compile-Zustand.
   Diese Namensmarkierungen sind standardm€œig nicht immer konsequent benutzt,
   geben aber meist zuverl€ssige Hinweise auf die Funktionen der betr Worte.

   Begrenzungszeichen zwischen Worten ist das Leerzeichen, auœerdem gilt die
   ascii-<nul> (chr$ 0) als unbedingte Begrenzung, die dazu noch eigene Akti-
   vit€ten ausl„st, da sie zugleich Name eines (wichtigen!) Forth-Wortes ist.
   Gleiche Bedeutung hat das Zeilenende, unabh€ngig von der Eingabequelle.

   Zahlenangabe ist in verschiedener Form unabh€ngig von {base} m„glich:
        %101    bin€r           !123    quatern€r
        &123    oktal           #123    dezimal
        ¶123    duodezimal      $123    sedezimal
        {A      ein Zeichen-Code (ersetzt z.B. das ASCII des F83-Forth),
                gilt mit Ausnahme der L€nge 2 f‡r beliebig lange Strings.
        {AB     "AB" in den beiden Bytes einer Integer-Zahl
        \123    als fp-Zahl     \123%   Hundertstel einer fp-Zahl
   Negative Zahlen werden durch das Vorzeichen NACH dem Basis-Praefix markiert:
        $-123                   \-123%
   Dezimalbruchmarke in allen Zahlentypen (auch fp!) "." und "," gleichrangig.


* Der Wortaufbau entspricht dem f.i.g.-Modell:

* >> Wortheader allgemein
   [ 1 p s ccccc ][ name ][ link ][ doword ][ parameter ][ wa ][ wa ] ...
   ¾nfa                   ¾lfa    ¾cfa      ¾pfa
        Darin:
nfa     "namefield address" mit gesetztem h„chstwertigem Bit (7),
  p     precedence-Bit (6), das den "immediate"-Status bestimmt,
  s     smudge-Bit (5), das den Wortheader f‡r {-find} sperrt oder freigibt
  c     und den f‡nf niederwertigen Bits als Z€hler f‡r die L€nge des Namen.
name    bis zu 31 Schriftzeichen, gesetztes Bit 7 markiert das Ende.
        Die h„chstwertigen Bits der Codes von 128 bis 160 werden vor Eintragen
        der Grenzenmarken gel„scht und durch {id.} restauriert.
        Die nfa kann an ungerader Adresse liegen  - s. {create} - der Compiler
        justiert sie so, daœ die lfa geradzahlig unmittelbar anschlieœt.
lfa     "linkfield address"
        mit einem ptr, der auf den Vorg€nger im selben Vocabular zeigt.
cfa     "codefield address" (auch: compilefield)
        weist auf direkt ausf‡hrbaren Processorcode, der die Art des Wortes
        bestimmt, und die Verwendung der ggf. folgenden Parameterliste.
pfa     "parameterfield address"
        Liste mit Daten entsprechend den Erfordernissen des Wortes
wa      "word address"
        Synonym f‡r cfa, bezeichnet eine Eintragung in der Parameterliste.

* frei definierte Worte

Die Standardform entsteht mittels <BUILDS .. .. DOES> und erzeugt den Aufbau
wie anschlieœend am Beispiel der Vocabulare dargestellt. Alternativ kann auch
die in den sp€teren Forth-Typen eingef‡hrte Methode benutzt werden. Dazu dient
die Kombination CREATE .. .. ;DOES>, die das <dodoes> in das Definitionswort
‡bernimmt und stattdessen die CFA damit gebildeter Worte dorthin lenkt. Damit
unterscheidet sich deren Aufbau im Gegensatz zu o.a. Form insbes. bez‡glich
ihrer PFA nicht mehr von den Colon-Definitionen:

Mit <BUILDS .. DOES> aufgebaute Definitionsworte erzeugen:
                [name][lfa][dodoes][doword][wa...]

CREATE .. ;DOES> sorgt f‡r einen dem Standardaufbau entsprechenden Kopf:
                [name][lfa][doword][wa....]
                ¾ nfa      ¾ cfa   ¾ pfa

* Vocabulare

Die Definition ist Standard-vertr€glich (insofern, als deren Auswertung rein
systemspezifisch ist, und innerhalb compilierter Programme bedeutungslos) um
zwei Posten erweitert.
                                                      ¿       ¿
   [name][lfa][dodoes][dovoc][vocnfa][voctop][voclink][search][ff]
                      ¾ pfa   $81A0  {latest}
    standard:
dovoc   {vocabulary} ist ein mit <BUILDS..DOES> erzeugtes Definitionswort.
vocnfa  das 1. Wort im Vocabular als Platzhalter mit dem Pseudo-Namen $81A0,
        der dem Leerzeichen entspricht und als Wort nicht vorkommen kann.
voctop  dessen "linkfield" h€lt die nfa des j‡ngsten Wortes des Vocabulars.
        Der Ptr auf diese Position gelangt beim Aufruf in den Vocabularstack.
voclink sein "codefield" verkettet ein Vocabular mit dem bis dahin j‡ngsten,
        indem es auf dessen [voclink]-Position gerichtet wird und die eigene
        Adresse bei der Vocabulardefinition in die User-Vari {voc-link} gelangt.
    zus€tzlich:
search  die eingepr€gte secund€re Suchfolge, initial mit {current} besetzt.
ff      das niederwertige Byte dient als Flag f‡r fp-compilierende Vocabulare,
        das h„herwertige Byte sperrt bei den {-find}-Varianten ein bereits
        durchsuchtes Vocabular f‡r die erneute Suche, sodaœ mehrmaliges Vor-
        kommen in der Suchfolge keinen Einfluœ auf die Compilezeit hat, und
        Endlosschleifen durch das Secund€rvocabular ausgeschlossen werden.

        Dank dieser Struktur ist es recht einfach, wie z.B. in {forget}, die
        gesamte Vocabularkette Wort f‡r Wort durchzugehen - und anzuzeigen:

             voc-link
             begin @ dup -0 -
             while dup 4- dup 2- nfa cr cr id. cr
              begin dup id. pfa lfa @ dup @ $81a0 = over -0= or until
             drop repeat drop

        Das Beispiel {vwords} in "forth_scr" ist auf diese Weise aufgebaut.
        Die Folge { pfa lfa } holt zun€chst aus der Vocabulardefinition die
        nfa des j‡ngsten Wortes, von wo ausgehend mit denselben Aufrufen
        die Kette dann zur‡ck bis nach [vocnfa] f‡hrt. Gleichheit mit dem
        dort hilfsweise eingetragenen Ur-Namen ist Abbruchkriterium f‡r die
        Wortkette, w€hrend die Vocabularverkettung im F6 mit $8000 endet.
        $8000 ist auœerdem Inhalt der ersten lfa des Systems im Wort {root}
        und muœ darum in die Abfrage der inneren Schleife einbezogen werden.

        Das eingepr€gte Secund€rvocabular entspringt dem Versuch, ohne einen
        seiner Natur nach notwendig begrenzten Vocabularstack auszukommen, und
        die m„gliche Suchfolge auf eine beliebig groœe Anzahl Vocabulare auszu-
        dehnen. Obwohl das auch genau so der Fall ist, wurde die Stackstruktur
        zus€tzlich ‡bernommen, da sie sich als sehr handlich erwiesen hat.
        N‡tzlicher Nebeneffekt ist die f‡r die OOP erforderliche und hierdurch
        leicht m„gliche fix eingepr€gte Aufruf-Hierarchie.

        Mit beispielsweise nur CURRENT und beiden CONTEXT-Posten besetzt, etwa
                only forth definitions
                2nd-voc on
                hidden minerva
        sieht die eingepr€gte Suchfolge mit den Vorgabedaten folgendermaœen aus:
                hidden forth minerva fp qdos pif forth
        denn {hidden} hat das Secund€rvocabular {forth}, das seinerseits kein
        weiteres Vocabular angibt, und {minerva} weist nach {fp}, dieses nach
        {qdos}, welches {pif} zum Secund€rvocabular hat. Da {pif} auch wieder
        nach {forth} ‡bergeht, endet die Kette damit.

Hinweis:
        Da im F6 die besonders schnelle, aber vorzeichenbehaftete 16-Bit-
        Offset-Adressierung f‡r den Processor benutzt wird, ist der Umgang
        mit der "Null" ein wenig heikel. In allen F€llen, die die Suche in
        Vocabularen betreffen, wird die wertm€œige Null durch die "negative
        Null" vorzeichenbehafteter 16-Bit-Zahlen ersetzt. D.h., wo sonst
        ‡blicherweise etwa als Abbruchmarke eine Null steht, findet sich im
        F6 die $-8000, beispielsweise auch im Ur-"voclink", das den Ursprung
        aller im System vorhandenen Vocbulare (und Worte) kennzeichnet.
        Die in fr‡heren Versionen auftretenden Probleme bei Worten nahe der
        4th-Adresse Null konnten damit nun auch restlos gel„st werden.

* GLOSSAR

Im Systemkern sind etwa 1000 Worte definiert, die nun in alphabetischer
Folge und geordnet nach Vocabularen beschrieben werden.

Es gibt im Kern folgende Vocabulare:
        ROOT    FORTH   HIDDEN  QDOS    FP      EDITOR  PIF     ASM68
Mit nach Hinzuladen von L-LOAD und WORDS der jeweiligen Anzahl Worte:
        21      678     79      125     64      4       21      10

FORTH und ASM68 sind in ROOT definiert und k„nnen darum immer aktiviert werden.
HIDDEN, QDOS, FP und EDITOR sind Untervocabulare von FORTH, das darum zu deren
Aufruf in der CONTEXT-Suchfolge vorhanden sein muœ.
PIF als Untervocabular von QDOS ist nur zug€nglich, wenn auch QDOS dort einge-
reiht ist.
Alle Vocabulare, auch das Deferred-Wort {assembler}, sind "immediate" angelegt.

* Das FORTH-Vocabular:

Wenn bei Zahlen im Stack Integer- und Flieœkommaposten angegeben werden, so
existiert dasselbe Wort auch im {fp}-Vocabular oder einem seiner Nachfolger,
wo es dann mit den bezeichneten fp-Posten arbeitet. Hier wird auf die beiden
Vocabularen gemeinsamen Worte hingewiesen, um Fehler vermeiden zu helfen.

!               ( n1 ptr -- ) ( f1 ptr -- )
                Zahl n1 an der Stelle ptr im 4th-Speicher eintragen.
!a              ( n1 ptr2 -- )                          F6      "store aligned"
                Integer n1 an GERADzahliger 4th-Adresse ptr2 ablegen.
             >> store integer n2 to even aligned ptr2
!csp            ( -- )
                aktuellen Stackptr in der User-Variablen {csp} sichern.
                Dient der Fehlerkontrolle beim Compilieren, darf nur im nicht-
                compilierenden Zustand f‡r andere Zwecke eingesetzt werden.
             >> save the current stackptr
!name           ( ptr1 n2 ptr3 -- )
                max. n2 Bytes Text mit 16-Bit-Z€hler von ptr3 nach ptr1 bringen.
             >> store word counted text of up to n2 bytes from ptr3 to ptr1
!l              ( n1 adr2 -- )                          F6 / lmi
                Integer n1 an wirklicher Speicheradresse adr2 ablegen
             >> store integer n1 to true memory address dadr2
#               ( d1 -- d2 )                                    "sharp"
                teilt d1 durch die aktuelle Zahlenbasis, stellt die aus dem
                Rest gebildete Ziffer in {hld} dem im Aufbau begriffenen Zif-
                fernstring voran und bel€œt den Divisionsrest d2 im Stack.
                Anwendung zwischen <# und #>. Mit {#} lassen sich beliebig
                formatierte Ziffernstrings definierter L€nge zusammenstellen,
                und mit {hold} darin auch andere Schriftzeichen unterbringen.
                        ( dn ) <# # # # # #> type
                schreibt die vier niederwertigen Ziffern der Zahl (dn) hin.
                Dieselbe Operation an quad-Zahlen wird mit {q#} ausgef‡hrt, die
                weiteren Operationen zur Ziffern-Umwandlung sind mit {l-load}
                aus "forth_scr" mit Hilfe des Suchwortes {q.} compilierbar.
#case           ( -- n1 )               compiled code   F6
                Index, mit dem ein Wort aus case: aufgerufen wurde; muœ darin
                als erstes stehen, liefert sonst keine zuverl€ssigen Werte. Es
                wird der unver€nderte Index angegeben, auch, wenn er ‡ber eine
                der Grenzen hinausweist. Das erste oder letzte Wort einer Liste
                kann auf diese Weise ‡berlaufende Werte geb‡ndelt ‡bernehmen
                und sie dann einzeln weiterbearbeiten. Innerhalb einer Worte
                ausf‡hrenden {case:}-Liste kann {#case} z.B. den Austausch von
                Stackposten vereinfachen:
                    case: char bl bl bl bl bl bl bl bl bl bl bl bl bl bl bl
                               bl bl bl bl bl bl bl bl bl bl bl bl bl bl bl
                               #case ;
                ersetzt die Steuercodes bis 31 durch Leerzeichen (Code 32) und
                l€œt den Rest unver€ndert.
             >> re-reads the case index when called 1st in a case:-indexed word
#tib            ( -- n1 )                               f83
                User-Vari, Anzahl der in der t.i.b.-Eingabe empfangenen Zeichen.
                Unterscheidet sich von {span} dadurch, daœ z.B. {query} zwar
                beide besetzt, {expect} sich aber nur auf {span} auswirkt.
             >> no. of chars fetched from the t.i.b.
#vocs           ( -- n1 )                               f83
                gr„œtm„gliche Anzahl Posten im Vocabularstack.
             >> max. no. of vocs which may be stacked in the search order.
#.              ( un1 -- )
                Zahl un1 vorzeichenlos dezimal ausgeben (hinschreiben).
             >> write the unsigned value of un1 to standard output {out-cons}
#>              ( ud1 -- ptr1 n2 )
                Ende der Umwandlung einer Zahl in einen Ziffernstring mit R‡ck-
                gabe der L€nge und des Ortes, wo der String zu finden ist. Der
                Ablagebereich wird durch jede Form der Zifferndarstellung (auœer
                FP) sofort wieder ‡berschrieben, darum ist u.U. Transport an ei-
                ne anderweitig nicht benutzte Stelle erforderlich:
                        ( dn ) <# #s #> pad 80 + 2dup c! 1+ swap cmove
                sichert den String f‡r die weitere Bearbeitung.
                Mit Hilfe local anzulegenden Speichers kann der Zahlenstring
                auch local erzeugt werden, wodurch dann jegliche Kollision mit
                den Zuweisungen des Systems ausgeschlossen ist - mehr s. {<#}.
#s              ( ud1 -- 0. )
                ud1 vollst€ndig in Ziffern umwandeln und die Zeichen an ggf.
                bereits ermittelte Zeichen anh€ngen - zwischen {<#} und {#>}.
                Immer wird mindestens eine Ziffer geschrieben, so lassen sich
                z.B. auch Zahlen einer gewissen Mindestl€nge erzeugen:
                        ( dn ) <# # # # #s #> type
                schreibt eine wenigstens vierstellige Zahl hin, l€ngere Zahlen
                werden vollst€ndig ausgegeben, k‡rzere auf vier Stellen mit
                f‡hrenden Nullen aufgef‡llt.
$>f             ( ptr1 -- f2 )                          F6 QDOS
                qdos-String von 4th-Adresse ptr1 als Flieœkommazahl zum Stack.
                Setzt als fp-Signal {dpl} auf -2 und sichert den h„chstwertigen
                Stackposten f‡r QDOS-Operationen gegen Exponentenfehler.
             >> convert the word counted string at ptr1 to a floating-pt-number
$.              ( un1 -- )
                Integer un1 vorzeichenlos sedezimal ausgeben.
             >> print un1 with {base} set to 16
%.              ( un1 -- )                              F6
                Integer un1 vorzeichenlos bin€r ausgeben.
             >> print un1 with {base} set to 2
&.              ( un1 -- )                              F6
                Integer un1 vorzeichenlos octal ausgeben.
             >> print un1 with {base} set to 8
(boot)          ( -- ptr )                              F6
                ptr auf einen Filenamen, der u.a. bei {s-load} benutzt wird,
                wenn dort ein Filename nicht zus€tzlich angegeben wurde.
             >> ptr to a filename used by {s-load}
(d#)            ( dn1 n2 -- ptr3 n4 )                   F6      8.16 => hidden
                Zahl dn1 abh€ngig vom Vorzeichenflag n2 in String der L€nge n4
                auf Position ptr3 umwandeln.
(dir)           ( -- ptr )                              F6
                ptr to a filename used by {s-load}
(ert)           ( -- ptr )                             (LR)     8.16 => hidden
                flag to dis-/enable error trapping
(exper)         ( -- )(D)                               F6
                Fehleraktion von {expect} und {query} zum Schutz gegen Verlust
                des Eingabekanals. Bei einem Fehler anders als err.bo(-5) werden
                in-cons und out-cons auf den Fensterkanal vom Jobstart gestellt.
                Revectorisierbar z.B. f‡r {chain} u.€. Worte.
(file)          ( -- ptr )                              F6
             >> filename used by the editor and when {dr1} active.
(joker)         ( -- n1 )                               F6
                Constante, deren Wert einen Zeichencode repr€sentiert, der
                bei den Stringvergleichsoperationen stets als gefunden gilt.
             >> constant determining a char. value which will be always found
                when comparing strings, defaulted to disabled by -1.
(line)          ( n1 n2 -- n3 n4 )
                Liefert Stringptr n3 und L€nge n4 der Zeile n1 in Seite n2
                des gerade g‡ltigen Screenfile.
(prompt)        ( -- ptr ) User-Vari                    F6      8.16 => hidden
                Eingabeanforderung und entpr. Meldungen freigeben/unterbinden
(prt)           ( -- ptr )                              F6
                (File-)Name der Drucker-Ausgabe
             >> filename used for printer output
(r)             ( -- ptr )                              F6
                User-Vari, ptr auf den Code des F‡llzeichens f‡r {.r} u. dgl.
(screen)        ( -- ptr )                              F6
                filename used by the editor, and when {dr0} active.
(update)        ( -- ptr )
                Schreibfreigabe f‡r {r/w}
(upper)         ( -- n1 )                               F6
                Maskierung f‡r die Aufrufe mit Zeichenvergleich bestimmt die
                Abh€ngigkeit von der Schreibweise: -33 nicht -1 beachten.
                Fehler, die durch diese einfache Maskierung entstehen k„nnen,
                betreffen (fast) nur Codes auœerhalb des f‡r Schriftzeichen
                g‡ltigen bereichs, welche darum zugunsten h„herer Ausf‡hrungs-
                geschwindigkeit in Kauf genommen wurden.
(wcard)         ( -- n1 )                               F6 (vorl€ufig)
                Code f‡r ein "wildcard"-Zeichen, das bei {t=} und {tl=} eine
                Gruppe von Zeichen beliebiger L€nge ab 1 in dem zu suchenden
                String ersetzen kann. -1 als Vorgabe inaktiviert den Code.
                Mit (joker) und (wcard) steht eine vereinfachte Form des Text-
                vergleichs im UNIX-Typ zur Verf‡gung, wobei aber beide Einsatz-
                zeichen nicht auf die ‡blichen "?" und "*" festgelgt sind, son-
                dern je nach Erfordernis beliebig codiert werden k„nnen.
             >> This, and {(joker)}, facilitates a simplyfied unix-like string
                search mode of {t=} and {tl=} where the char of {(wcard)} de-
                termines the unlimited groups of characters representing code
                which, rather than being just an "*" may be redefined to any
                other character to suit.
*               ( n1 n2 -- n3 ) ( f1 f2 -- f3 )
*/              ( n1 n2 n3 -- n4 )
                Wie {*/mod}, ohne Rest. Einziger hi-level-Arithmetikaufruf, wird
                in der Form { */mod sdrop } geringf‡gig schneller ausgef‡hrt.
*/mod           ( n1 n2 n3 -- n4 n5 )
                Multiplikation n1 mit n2 und Division des doppeltgenauen
                Produkts durch n1 liefert Rest n4 und den Quotienten n5.
+               ( n1 n2 -- n3 )(C)  ( f1 f2 -- f3 )
                {+} des Forth-Vocabulars ist immediate und optimiert im Compile-
                betrieb nach einem einfachem Festwert (Literal) auf {LIT+}.
+!a             ( n1 ptr2 -- )                          F6
                n1 zum 16-Bit-Inhalt an geradzahliger 4th-Adresse ptr2 addieren.
+!l             ( n1 adr2 -- )                          F6
                n1 zum 16-Bit-Inhalt an Speicheradresse adr2 addieren.
+!              ( n1 ptr2 -- )
                n1 zum 16-Bit-Inhalt an 4th-Adresse ptr2 addieren
++              ( n1 n2 n3 -- n4 )                      F6
                Zusammenfassung zweier Additionen.
+-              ( n1 n2 -- n3 ) ( f1 n2 -- f2 )
                n1 rsp. f1 mit dem Vorzeichenwert von n2 multiplizieren.
+buf            ( ptr1 -- ptr2 n1 )
                Flag n1 = 0, wenn der in {prev} verzeichnete Blockpuffer mit dem
                durch den auf ptr1 folgenden mit ptr2 bezeichneten identisch ist.
+continue       ( n1 -- )(I)                            F6
                §berspringt die n€chsten n1 Zeilen beim Lesen eines Screenfile,
                Bei negativem n1 z€hlt die Zeile des {+continue} mit.
+loop           ( n1 -- )(C)
                Abschluœ einer Z€hlschleife mit Angabe der Z€hlstufung n1.
                Endlosschleifen z.B. durch 0 +LOOP werden abgefangen.
+nul            ( -- ptr )                              F6
                Adresse einer Speicherstelle, die den Wert 0 enth€lt.
+origin         ( n1 -- ptr )
                liefert mit einem Index lt. f.i.g.-Modell einige Initiierungs-
                Daten f‡r den Systemstart und die Wiederherstellung bei {cold}
                und {warm}. Zun€chst die Verwendungsdefinition f‡r F6-Kan€le:
                        -7      gerade benutzter i/o-Kanal, vom System besetzt.
                        -6   14 dr0-Kanal,              {screen}
                        -5   15 dr1-Kanal,              {file}
                        -4    0 Standard-Eingabe,       {in-cons}
                        -3    1 Standard-Ausgabe,       {out-cons}
                        -2    2 user-i/o, Druckerausgabe, {prt}
                        -1    3 qdos-Arbeitskanal,      {work}
                f.i.g.-Modell Standard-Initiierungstabelle:
                         0      cold-Einsprung als ausf‡hrbarer Processorcode.
                         4      warm-Einsprung, dto.
                         8      .cpu Systemidentifikation
                        12      {last}-Initiierung
                        14      <bs> Zeichencode
                Bedingt durch die u.a. zum F6-Multitasking notwendige 32-Bit-
                Initiierung weichen die n€chsten Posten von der f.i.g.-Vorgabe
                ab. Die ‡blichen User-Vari k„nnen in gewohnter Weise verwandt
                werden, sie m‡ssen jedoch bei Ver€nderungen, die nicht durch
                das System selbst gesteuert werden, auf Offset -2 die 32-Bit-
                Werte (ggf. vorzeichenerweitert) erhalten:
                        16      {up 2-}
                        20      {s0 2-}
                        24      {r0 2-}
                Standardm€œige 16-Bit Initiierungswerte
                        28      {tib}
                        30      {width}
                        32      {warning}
                        34      {fence}
                        36 32-Bit {dp 2-}
                        40      {voc-link}
                        42      {up} User-Vari Laufptr
                Zus€tzlich schlieœen sich die 32-Bit-Posten an:
                        44      CON-Handler-Adresse
                        48      Original-CON-Handler, ggf. vor PIF-§bernahme
                        52      Abstand der CON-Parametertabelle vom Anfang des
                                Kanal-Definitionsblocks, br‡cksichtigt das PIF.
                cdtque  56      Abstand cdt (A0 in extop) zur i/o-queue
                pifque  60      Adresse der PIF dummy-queue
                        64      th-entry, Einsprungadresse in das Thing-System
                        68      hk-thg, Aufrufadresse f‡r das "hotkey-thing"
                und als 16-Bit-Variablenwerte:
                        72      (quit) erste cfa f‡r den Systemstart
                        74      {ert}-Aktivierung/-Sperrung
                        76      Maus-Code f‡r {break} bei §bernahme durch PIF
                        78      Abbruchcode von {break}
            >>> re [jdt] for more sytem related information
+text           ( ptr1 ptr2 -- )                        (F6) f.i.g.-Editor
                qdos-String von ptr2 an qdos-String auf ptr1 anh€ngen,
                beide Strings k„nnen auch an ungeraden Adressen stehen.
-               ( n1 n2 -- n3 ) ( f1 f2 -- f3 )
-->             ( -- ) (I)
                Beim Laden n€chste Seite im Screenfile aufsuchen. Dies wird bei
                zug€nglichem {in-cons}-Fenster dort mit einem Punkt angezeigt.
                Auch innerhalb von Worten oder Listen ohne besondere Maœnahmen
                im Compilezustand zur Fortsetzung einer Definition verwendbar.
                Falls beim Seitenwechsel der Stack eine andere Anzahl Posten
                enth€lt, als beim Eintritt, werden zur Kontrolle und ggf. leich-
                teren Fehleranalyse Seitennummer und Differenz hingeschrieben.
                Darf nicht am Schluœ eines Screenfile stehen, denn dann w‡rde
                der Ladevorgang endlos fortgesetzt, weil EOF bei Screenfiles
                nicht als Fehler gilt, also auch nicht zum Abbruch f‡hrt. Das
                Signal zum Beenden des Ladevorganges ist bei diesem Filetyp mit
                {;s} immer explizite anzugeben - f‡r {chain} s. {end}.
-cache          ( flg -- er )                           F6 QX IO2
                Cache-Zustand entsprechend flg 1 ein- oder 0 ausschalten. Z.B.
                nach {cache}, um den damit gelesenen Zustand wiederherzustellen.
             >> Cache on (n1=true) or off (n1=0)
-compile        ( -- ) (C)                              F6 "state sensitive"
                "state"-abh€ngig Compilieren rsp. Ausf‡hren einer cfa., ersetzt
                        ... state @ IF compile ENDIF {forthword} ...
             >> compile "state sensitive", if state is set, else noop.
-count          (ptr1 -- ptr2 count)                    F6
                Liefert Countbyte und Anfangsadresse des Strings ab ptr1,
                unabh€ngig vom Typen als 4th- oder qdos-String, wobei beide
                max. 255 Zeichen lang sein d‡rfen. Ersetzt
                        ( ptr1 ) count -dup 0= IF count ENDIF ( ptr2 count )
-cr             ( flg -- )                              F6
                Bei flg =/= 0 ein <cr> senden.
-dup            ( n1 -- n1 n1 | 0 -- 0 )
                {dup} nur bei n1 =/= 0, entspricht dem ?dup sp€terer Standards.
-exit           ( flg --) (C)                           F6
                Bedingtes Verlassen eines Wortes, steht f‡r
                        ... IF ;s ENDIF ...
                Optimiert zu {0=exit}, wenn {0=} vorangestellt ist; darf ohne
                zus€tzliche Vorkehrungen nicht auf {local}-Deklarationen folgen.
-find           ( -FIND name -- pfa cbyte flg | 0 )
                flg =/= 0 wenn {name} gefunden wurde, cbyte ist dann das Count-
                byte einschlieœlich der Flags zum Worttypen. Ist dem {find}
                sp€terer Standards insofern ‡berlegen, als es neben dem Prece-
                dence-Bit (f‡r den "immediate"-Status) auch die anderen Kopf-
                daten verf‡gbar macht:
                        -find {name}    0= 0 ?error     \ pr‡ft Vorhandensein
                                        dup $40 and .   \ Precedence-Bit
                                        dup $20 and .   \ Smudge-Bit (Null)
                                            $1f and .   \ L€nge des Namen
                Bei geeignetem Header-Aufbau und entsprechendem Verfahren zur
                Wortsuche ist auch das h„chstwertige Bit als Flag verwendbar.
-forget         ( -FORGET name -- )                     F6
                {forget} ohne Fehlerabbruch bei nicht vorhandenm Wort {name}.
                Das Wort wird nur im CONTEXT-Vocabular gesucht.
-leave          ( flg -- ) (C)
                NUR innerhalb DO.. ..LOOP / DO.. ..+LOOP zum Verlassen der
                Schleife bei flg =/= 0 mit n€chstem Erreichen des Endpunktes.
-loc            ( -LOC name -- ptr ) (I)                F6
                Liefert den ptr einer Localen Variablen, welche mit einem
                einzelnen Buchstaben {name} zu bezeichnen ist.
-lword          ( -LWORD name -- flg )                  F6S
                flg =/= 0 wenn {name} das mit L-LOAD zu compilierende Wort ist.
-off            ( ptr -- )                              F6      "minus off"
                Schreibt eine "negative Null" nach ptr. Die $-8000 stellt im F6
                die niedrigste 4th-Adresse dar und ist bei der Suche in Vocabu-
                laren die Abbruchmarke.
-print          ( ptr --)                               F6
                Ersetzt
                        ( ptr ) count -dup 0= IF count ENDIF type ( -- )
-rot            ( n1 n2 n3 -- n3 n1 n2 )                F79
-scan           ( ptr1 n2 c3 -- ptr1 n4 )
                Im Bereich ab ptr1 der L€nge n2 vom Ende her nach demm Byte c3
                suchen, n4 als Bytenummer des gefundenen Zeichens zur‡ckgeben:
                n4 z€hlt ab 1, ist 0, wenn c3 nicht gefunden wurde.
-trailing       ( ptr count1 -- ptr count2 )
                <bl>s des String der L€nge count1 bei ptr vom Ende her kappen.
                Hierdurch wird nur der Z€hler im Stack ver€ndert - was f‡r die
                Ausgabe gen‡gt; die Ursprungsdaten bleiben unber‡hrt.
-window         ( c1 -- flg )                           F6
                flg = 1 bei eigenem Fensterkanal ohne PIF, flg = 49 mit PIF.
-0              ( -- $8000 )                            F6
                Cons, "negative Null", f‡r alle vocabularbezogenen Aktionen,
                oder wo sonst der niedrigst m„gliche Forth-Ptr ben„tigt wird.
-1              ( -- -1 )
                Integer- rsp. fp-Constante
-2              ( -- fp: -2 )
                NUR fp-Constante, darum Vorsicht bei {fp} in der Suchordnung!
                Eine andersartige Zahl compiliert man dann sicherheitshalber
                z.B. mit dem entsprechenden Basis-Paefix.
.(r)            ( count1 count2 -- count1 )             F6
                Justiert eine zu erwartende Stringausgabe der L€nge count1
                rechtsb‡ndig in einem Feld der L€nge MAX( count1,count2 ),
                gez€hlt ab der aktuellen Ausgabe-Position. Der Code f‡r das
                ggf. zum Auff‡llen benutzte Zeichen steht in {(r)}, kann also
                frei gew€hlt werden - er gilt auch f‡r {.r} etc.
             >> Right-adjust to MAX( count1,count2 ) fieldwidth for an expected
                string output of count1 chars taken from {(r)}.
.cpu            ( -- )          4th-Systemkennung
.line           ( n1 n2 -- ptr count )
                ptr und l€nge der Zeile n1 in Seite n2 des gerade benutzten
                Screenfile, holt die Daten ggf. zuerst in den Blockpuffer.
."              ." text"        (I)
                Durch " oder Zeilenende begrenzten Text f‡r die Ausgabe com-
                pilieren oder sofort nach {out-cons} senden.
.(              .( text)        (I)
                Durch ) oder Zeilenende begrenzten Text sofort hinschreiben,
                d.h. nach {out-cons} senden, auch w€hrend des Compilierens.
.r              ( n1 n2 -- )
                n1 rechtsb‡ndig in ein Feld mindestens der Gr„œe n2 schreiben.
.s              ( -- )                                  F6S
                Zahlenbasis & Anzahl Datenposten im Stack dezimal, und davon
                bis zu 31 Posten mit ihrem Wert zur aktuellen Basis anzeigen.
/mod            ( n1 n2 -- q3 r4 )
0=/=            ( n1 -- 1 | 0 )                         F6
                Wandelt einen Wert =/= 0 in den definierten Flagwert 1 um.
0max            ( n1 -- +n2 )                           F6
                Gibt bei positivem Wert n1 zur‡ck, sonst Null.
0,              ( -- )
                integer 0 compilieren, entpricht { 0 , }.
0.              ( -- 0 0 )
                Doppeltgenaue Integer-Constante
0<              ( n1 -- flg ) ( f1 -- flg )
0=              ( n1 -- flg ) ( f1 -- flg )
0>              ( n1 -- flg ) ( f1 -- flg )
0 1 2 3 -1      ( -- cons ) ( -- fp-cons )
10*             ( n1 -- n1*10 )                         F6
16*             ( n1 -- n1*16 )                         F6
1abs            ( n1 -- n1 | ~n1 )                      F6
                Betrag einer als Einercomplement interpretierten Zahl.
                Dient auch der Pr‡fung einer 32-Bit-Zahl auf 16-Bit-Wert:
                        : d->s 1abs abort" Betrag > 32K" ;
                        ( dn )  d->s  ( nn | abort )
1off            ( ptr -- )                              F6
                Byte an der Stelle ptr auf 0 setzen.
1on             ( ptr -- )                              F6
                Bit 0 des Byte an der Stelle ptr auf 1 setzen.
                Kann einen {defer}red-Vector deaktivieren; und mit
                        ( ptr ) 1+ dup 1on 1 toggle ( -- )
                l€œt er sich unabh€ngig vom alten Zustand freigeben.
1+              ( n1 -- n1+1 )
1-              ( n1 -- n1-1 )
2!a             ( dn1 ptr -- )                          F6
                Dopelte Integer an geradzahlige Adresse bringen.
             >> Store double to even aligned address.
2!l             ( dn1 dadr -- )                         F6
                Doppelte Integer an wirkliche Speicheradresse.
             >> Store double integer to true memory address.
2+!l            ( dn dadr -- )                          F6
                Doppelte Integer in den Speicher an Adresse dadr addieren.
2+!             ( dn ptr -- )                           F6
                Doppelte Integer in den Forth-Speicher bei ptr addieren.
2>rr            ( dn -- dn , rp: dn )                   F6 LR
                Doppelte Integer in den Returnstack copieren.
2>r             ( dn -- , rp: dn )
                Doppelte Integer in den Returnstack verlagern.
2@a             ( ptr -- dn )                           F6
                Doppelte Integer von geradzahliger Forth-Adresse ptr holen.
             >> Fetch double from even aligned 4th-ptr.
2@l             ( dadr -- dn )
                Doppelte Integer von wirklicher Speicheradresse
             >> Double from true memory address.
2and            ( dn1 dn2 -- dn1&dn2 )                  F6
2base+          ( dptr -- daddr )                       F6
                Doppelte Integer als Forth-Ptr wird wirkliche Speicheradresse.
2cons+          use: ( dn ) 2CONS+ name                 8.18
                exec: ( d1 -- d2 ) : d2:=d1+dn
2constant       use: ( dn ) 2CONSTANT name
                 nderbar mit:
                        ( dn ) IS twoconsname
2drop           ( n1 n2 -- )
2dup            ( n1 n2 -- n1 n2 n1 n2 )
2off            ( ptr -- )                              F6
                32-Bit-Feld bei ptr l„schen
2over           ( n1 n2 n3 n4 -- n1 n2 n3 n4 n1 n2 )
2over-          ( d1 d2 -- d1 d3 )                      F6 LR
                Zusammenziehung von { 2over d- }, liefert d3 = d2 - d1#
2pick           ( d1.. dm .. dn nm -- d1 .. dm .. dn dm )
                nm-ten Posten zum t.o.s. copieren.
2roll           ( d1.. dm .. dn +nm -- d1 .. dm+1 .. dn dm )
                nm-ten Posten zum t.o.s. und nm Posten eins hochr‡cken.
                ( d1.. dm .. dn -nm -- d1 .. dn dm .. dn-1 dm )
                Posten dn abheben und an Position nm einf‡gen.
2rot            ( n1 n2 n3 n4 n5 n6 -- n3 n4 n5 n6 n1 n2 )
2r>             ( rp: dn -- dn )
                Doppelte Integer vom Returnstack abheben.
2sdrop          ( n1 n2 n3 n4 -- n2 n4 )                F6
2sgn            ( dn1 -- 1 | 0 | -1 )                   F6
2swap           ( n1 n2 n3 n4 -- n3 n4 n1 n2 ) ( f1 f2 f3 f4 -- f3 f4 f1 f2 )
2variable       ( dn 2VARIABLE name )
2within         ( d1 d2 d3 -- d4 )                      F6
                d4 als d1, auf den Bereich d2 bis d3 begrenzt.
             >> Adjust dn1 to d4 such that d4 fits in the interval [d2,d3].
2within?        ( d1 d2 d3 -- flg )                     F83
                flg = 1 wenn d2 <= d1 < d3 (obere Grenze z€hlt nicht mit).
2!              ( dn ptr -- )
2*              ( n1 -- n1*2 ) signed ( f1 -- f1*2 )
                vorzeichenbehaftete schnelle Verdopplung, fp mit -2 in {dpl}.
2+              ( n1 -- n1+2 )                          F6
2-              ( n1 -- n1-2 )                          F6
2/              ( n1 -- n1/2 ) signed ( f1 -- f1*2 )
                vorzeichenbehaftete schnelle Halbierung, fp mit -2 in {dpl}.
2@              ( ptr -- dn )
2@!             ( ptr1 ptr2 -- )                        F6
                32-Bit-Inhalt von ptr1 nach ptr2 ‡bertragen.
2r              ( -- dn )
                Zwei Returnstackposten in den Datenstack copieren.
3*              ( n1 -- n1*3 )                          F6
3+              ( n1 -- n1+3 )                          F6
3-              ( n1 -- n1-3 )                          F6
4!l             ( qn dadr -- )                          F6
                Vierfachgenaue Integer an wirklicher Speicheradresse ablegen.
             >> Store quad integer to true memory address.
4@              ( ptr -- q1 )                           F6
                Vierfache Integer von ptr holen.
4@!             ( ptr1 ptr2 -- )                        F6
                Vier Zellen Inhalt von ptr1 nach ptr2 ‡bertragen.
             >> Move quad contents from ptr1 to ptr2.
4@l             ( dadr -- qn )                          F6
4drop           ( n1 n2 n3 n4 -- )
4dup            ( n1 n2 n3 n4 -- n1 n2 n3 n4 n1 n2 n3 n4 )       F6
4pick           ( q1 .. qm .. qn nm -- q1 .. qm .. qn qm )       F6
                Damit z.B. ersatzweise:
                        : 4over 1 4pick ;
4roll           ( q1 .. qm .. qn +nm -- q1 .. qm+1 .. qn qm )    F6
                ( q1 .. qm .. qn -nm -- q1 .. qn qm .. qn-1 )
                Hiermit auch:
                        : -4rot -2 4roll ;
4rot            ( q1 q2 q3 -- q2 q3 q1 )                F6
4swap           ( q1 q2 -- q2 q1 )                      F6
4th-err         ( -- flg )                              F6
4th-id          ( -- did )                              F6
                QDOS-Job-ID des aufrufenden F6-Jobs
4!              ( q1 ptr -- )                           F6
4*              ( n1 -- n1*4 ) schnelle Multiplikation  F6
4+              ( n1 -- n1+4 ) schnelle Addition        F6
4-              ( n1 -- n1-4 ) schnelle Subtraktion     F6
4/              ( n1 -- n1/4 ) signed                   F6
5*              ( n1 -- n1*5 ) schnelle Multiplikation  F6
5+              ( n1 -- n1+5 )          Addition        F6
5-              ( n1 -- n1-5 )                          F6
6*              ( n1 -- n1*6 ) schnelle Multiplikation  F6
6+              ( n1 -- n1+6 )          Addition        F6
6-              ( n1 -- n1-6 )                          F6
7+              ( n1 -- n1+7 )                          F6
7-              ( n1 -- n1-7 )                          F6
8+              ( n1 -- n1+8 )                          F6
8-              ( n1 -- n1-8 )                          F6
:               ( -- ) ( : name -- )
                Der "Colon-Compiler" leitet eine Wortdefinition ein, legt den
                entsprechenden Header an, tr€gt ihn in das {current}-Vocabular
                ein und sperrt ihn zun€chst f‡r die Wortsuche. {context} wird
                auf das {current}-Vocabular gesetzt, das bisherige zweite Voca-
                bular f€llt aus der Suchfolge, falls es nicht mit {also} vorher
                in den sicheren Bereich des Vocabularstacks geschoben wurde.
;               ( -- ) oder ( sys: ptr 9 -- ) mit {local}s  (C)
                Abschluœ einer Colondefinition mit Kontrolle der Stackbilanz
                und anschlieœender Freigabe des Wortes f‡r die Vocabularsuche.
                Compiliert {;s} und ggf. davor die {local}-Freigabe.
                Optimierung durch
                {drop;} statt {;s}, falls dem {;} ein {drop} vorangestellt ist.
                Automatische Optimierung durch Compilieren eines Sprunges direkt
                in das letzte Wort, falls dies eine Colon-Definition ist.
                8.18: Zus€tzlich Zusammenfassung von
                { rdrop ; }             zu      {r;}    (dummy-namen)
                { rdrop rdrop ; }               {rr;}
                { 2drop ; }                     {dd;}
;code           ( -- ptr ) (C) ( -- )
                Abschluœ der Bildungsvorschrift eines Definitionswortes und
                §bergang in den lo-level-codierten Ausf‡hrungsteil. Beendet
                den Compilezustand, gibt den Wortheader f‡r {-find} frei und
                stellt {context} auf das Assemblervocabular ein. Einsetzbar
                wie {;does>} mit dem einzigen Unterschied, daœ die Ausf‡hrungs-
                vorschrift in lo-level-Code folgen muœ. Da es keine weiteren
                Schutzmaœnahmen gibt, ist strikt auf ordentlichen Wortabschluœ
                zu achten, z.B. durch Sprung nach [next].
;does>          ( -- ptr ) (C)(D) ( -- )                F6 C1 lmi F83+
                Das DOES> des F83 etc., nach CREATE zu verwenden. Mit {create}
                erzeugte Definitionen werden etwas schneller ausgef‡hrt und um
                eine Speicherzelle k‡rzer angelegt. Jene wird vom DOES> des F83
                nicht mehr ben„tigt, da der Aufrufteil in die Rumtime-Definition
                selbst verlagert wurde, und die modifizierte cfa dorthin weist.
                {;does>} kann konfliktfrei mit jedem Wort gepaart werden, das
                einen Wortheader anlegt, sodaœ einmal definierte Bildungsvor-
                schriften in darauf aufbauende neue Definitionsworte ‡bernommen
                werden k„nnen. Man konstruiert mit {;does>} also allgemein
                        : eigenerName
                                CREATE Bildungsanweisung
                                ;DOES> ausf‡hrungsanweisung ;
                Wie auch bei der Konstruktion aus <BUILDS .. DOES> l€œt sich so
                ein Definitionswort als namensgebendes Wort, hier statt CREATE,
                in neuen Definitionsworten verwenden.
                Der cfa-Inhalt eines mit einer {;does>}-Definition erzeugten
                Wortes ist f‡r die sp€tere Wortanalyse bestimmbar:
                        0 constant n-cfa
                        : name CREATE ... ;DOES> [ here 4- is n-cfa ] ... ;
                Eine Besonderheit im F6 - die aber auch anderen Systemen nach-
                tr€glich mitgegeben werden kann - ist die "Vererbbarkeit" auch
                der Ausf‡hrungsanweisung. Dazu bedarf es zus€tzlicher Maœnahmen
                mit z.B. dem Wort {<with}, wie sie dort beschrieben sind.
                {;does>} ist ein deferred Wort, das vom System bedient wird,
                es sollte von Programmen auf keinen Fall ver€ndert werden.
                Worte, die mit {;does>} gebildet wurden, k„nnen von {c-load} nur
                wie 'normale' 4th-Worte behandelt werden, die Anpassung innerer
                Aufrufe an ver€nderte Adressenlage ist im Gegensatz zu den Defi-
                nitionen mit dem standardm€œigen {does>} dort nicht m„glich.
                {;does} enth€lt auch einen {unsmudge}-Aufruf, sodaœ danach das
                gerade im Aufbau befindliche Wort bereits gefunden werden kann.
;cdoes>         ( -- n1 ) (C) ( -- )                    F6
                wie ;DOES> jedoch bereits mit dem in ptr gelesenen Integerwert;
                auch hiernach ist das neue Definitionswort bereits auffindbar.
;s              ( -- )
                Zum Verlassen eines hi-level-Wortes (einer Colon-Definition)
                und in Screenfiles zum (vorzeitigen) Beenden des Ladevorganges.
                Darf ohne zus€tzliche Vorkehrungen nicht nach einer {local}-
                Deklaration stehen.
<               ( n1 n2 -- flg ) ( f1 f2 -- flg )
<builds         ( -- ) (C)
                Leitet den definierenden Teil eines Definitionswortes ein.
                An einem einfachen Beispiel aus dem SBasic erkl€rt:
                        LET cons% = 123
                Das Bildungsgesetz legt hier fest, daœ ein Name eingerichtet
                und irgendwie auffindbar gespeichert wird, sodaœ daraus sp€ter
                die ebenfalls eingerichtete Speicherstelle eindeutig auffind-
                bar wird. Die Ausf‡hrungsvorschrift legt fest, was mit dem
                Inhalt der identifizierten Speicherstelle geschehen soll, hier
                in einer Form, die die dort liegende Zahl verf‡gbar macht.
                Dasselbe sieht im Forth ganz €hnlich aus:
                        123 CONSTANT cons%
                CONSTANT ist eine elementare Procedur, die im Processorcode
                definiert ist, und etwa so nachgebildet werden kann:
                        : CONSTANT <builds , does> @ ;
                Darin erzeugt <BUILDS den auffindbaren Namen, das Komma legt
                die Speicherstelle an und tr€gt den Wert ein; sp€ter beim Auf-
                ruf holt @ die gespeicherte Zahl und bringt sie in den Stack.
<#              ( dn -- dn )
                Vorbereitung zur Umwandlung einer Zahl in Zifferndarstellung.
                Das System stellt die Ziffernstrings von { hld @ } ausgehend zu
                niedrigen Adressen hin zusammen. {hld} wird dabei anfangs durch
                {<#} auf {pad} eingestellt. Setzt man {hld 2-} als lange Integer
                unmittelbar danach auf eine andere 4th-Adresse um, sowie den
                ebenfalls doppeltgroœen Posten {hld 2+} auf denselben Wert,
                so ergibt sich eine M„glichkeit, die Ziffern ohne Umspeichern
                sofort an einem sicheren Ort abzulegen.
                In "forth_scr" ist dazu mit {t.} ein Beispiel angegeben.
=               ( n1 n2 -- flg ) ( f1 f2 -- flg )
=/=             ( n1 n2 -- flg )                        F6      "not equal"
                Erzeugt Flagwert 0 oder 1; wird einfach nur ein von Null ver-
                schiedener Wert ben„tigt, gen‡gt das etwas schnellere {-}.
>               ( n1 n2 -- flg ) ( f1 f2 -- flg )
>chan<          ( c1 c2 -- )                            F6
                Vertauschen der Tabellenpl€tze zweier offener(!) Kan€le
>fount          ( n1 c2 -- )                            F6 ben„tigt dvs/IO2
                F6-Fensterkanal c1 den mit n1 codierten Zeichensatz zuweisen.
                Codie f‡r n1 s. {atne}, {bblu}, {hisc}, {losc}, u. -23: latin-1.
>loc            ( n1 -- )                               F6 (vorl€ufig)
                n1 Zellen "dynamische" Zuweisung eines localen Speicherblocks;
                richtet einen localen Speicherbereich von n1 Zellen ein, dessen
                Gr„œe auch erst w€hrend der Programmausf‡hrung festgelegt werden
                mag, da die betr. Zahl im Stack ‡bergeben wird. Der Aufruf kann
                mehrmals innerhalb eines Wortes stehen. Dabei dann zu beachten,
                daœ die Indexadressierung "mitwandert", alte Indices also um die
                entsprechende Postengr„œe weitergez€hlt gelten. Zum Compilieren
                der Local-Constanten-Adressierung muœ w€hrend des Compilevor-
                ganges wenigstens irgendein Datenposten in den Stack gebracht
                und am Wortende wieder fortgenommen werden. Eigene oder Locale
                Variable ‡bergeordneter Worte bleiben unver€ndert adressierbar,
                allein die Indices sind daf‡r entsprechend weiterzuz€hlen:
                    \ a  c  e  g  i  k  m  o  q  s  u  w  y
                    \ 0  4  8  12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72
                    \ A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S
                Das Verfahren ist beim Stichwort {local} n€her beschrieben.
>resolve        ( sys1 -- )                             C1
                Aufl„sen einer Vorw€rtsreferenz nach aktuellem {here}.
>rr             ( n1 -- n1 rp: n1 )                     LR
                n1 in den Returnstack copieren.
>|<             ( n1 -- n2 n3 )                         F6
                n1 in Byte-Werte n2 (lsb) und n3 (msb) aufteilen. Ersetzt:
                        ( n1 ) 256 /mod ( n2 n3 )
><              ( n1 -- n2 )                            C1 lmi
                Bytes vertauschen
             >> swap bytes
>r              ( n1 -- rp: n1 ) ( f1 -- rp: f1 )
?comp           ( -- )
                abort, wenn nicht Compilezustand.
?csp            ( -- )
                abort, wenn die Stackbilanz nicht stimmt, d.h. der Wert in {csp}
                nicht mit dem aktuellen t.o.s. z.b. aus {sp@} ‡bereinstimmt.
?error          ( flg n1 -- )
                Bei flg =/= 0 abort und die mit n1 codierte Fehlermeldung.
?esc            ( -- flg )                              F6
                flg = 1, wenn <esc> bet€tigt wurde, wartet nach Bet€tigen der
                <space>-Taste auf erneuten Tastendruck, sonst ohne Wartezeit.
?exec           ( -- )
                abort, wenn im Compilezustand.
?key            ( -- 0 | $8000 | +code | -code )        (F6)
                Wird standardgem€œ ausgef‡hrt, liefert jedoch zus€tzlich bei
                ALT-Tasten den negativen Code, und $8000 bei {in-cons}-Fehler.
?loading        ( -- )
                abort, wenn nicht gerade von einem File geladen wird,
                Fehlersituation signalisiert durch 0 oder -ve Werte in {blk}.
?locals         ( -- n1 n2 )                            8.18
                n1 Anzahl Bytes und n2 Anzahl Bl„cke Localer Speicherbereiche.
?pairs          ( n1 n2 -- )
                abort, wenn n1 =/= n2.
?stack          ( -- )
                abort bei Grenzen‡berlauf des Datenstacks.
?terminal       ( -- flg )
                flg =/= 0 wenn ein Zeichen in der Eingabe bereitliegt.
@               ( ptr -- n1 ) ( ptr -- f1 )
                Inhalt der Speicherzelle ptr zum Stack holen.
@!              ( ptr1 ptr2 -- )        auch fp         F6
                Posten von ptr1 am Ort ptr2 eintragen.
                Austausch zweier Variabler:
                        ( ptr1 ptr2 ) 2dup @ >r >r @! 2r> ! ( -- )
@a              ( ptr -- n1 )                           F6
                n1 von geradzahliger 4th-Adresse lesen.
@l              ( dadr -- n1 ) ( dadr -- f1 )           F6
                Integer rsp. fp-Zahl von wirklicher Speicheradresse holen.
             >> Fetch single integer/fp from true memory address.
* A
a/drv           ( -- d1 )                               F6
                2Cons, Anzahl Zuweisungseinheiten im Datentr€ger
a/fre           ( -- d1 )                               F6
                2Cons, Anzahl freie Zuweisungseinheiten
a>h             ( c1 -- c2 )                            H4
                Einen Buchstaben als Ziffer interpretiert, sofern m„glich,
                in seinen sedezimalen Zahlenwert umwandeln, liefert sonst -1.
abort"          ( flg ABORT" text" -- )
                abort und Ausgabe des mit " begrenzten Textes wenn flg =/= 0.
abort           ( -- )
abs             ( n1 -- +n2 )
                Betrag bilden, gibt n2 = 0 bei n1 = $8000 zur‡ck.
accept          ( ptr n1 -- n2 )                        8.18 ANS
                Wie EXPECT, jedoch mit R‡ckgbe der empfangenen Anzahl Zeichen
                einschlieœlich der abschlieœenden <nul>.
acl             ( -- ptr ) user-Vari                    8.18
acp             ( -- ptr ) user-vari                    8.18
again           ( -- ) (C) ( sys: ptr 1 -- )
                Abschluœ einer endlosen Schleife.
align           ( n1 n2 -- n3 )                         F6
                Anzahl n2 niederwertige bits in n1 l„schen.
             >> Clear n2 l.s. bits of n1
allot           ( n1 -- )
                n1 Bytes ab {here} im Dictionary reservieren.
and             ( n1 n2 -- n3 )
                Bktweise n1 && n2.
and!            ( n1 ptr -- )                           F6
                and-Verkn‡pfung n1 mit dem Speicherinhalt bei ptr. Z.B. wird
                mit { -2 ptr and! } die Zelle bei ptr geradzahlig justiert.
anew            use: ANEW name                          8.18
                FORGET {name} und danach Anlegen eines NOOP-Wortes {name}.
ascii           ( -- c1 ) (I)                           (F83) F6S
                im F6 durch das pseudo-Zahlenpr€fix "{" ausgef‡hrt; im Screen-
                file angegeben, um Compatibilit€tsprobeleme mit F83 zu umgehen.
associative:    (I)                                     F6 (F83)
                Verwendung eigenst€ndig als Forth-Wort:
                        associative: {name} n1 n2 n3 .. nn ;
                oder innerhalb einer Colon-Definition:
                        ... associative: n1 n2 n3 .. nn ; ... ;
                Compiliert die Zahlenwerte n1... oder, falls 4th-Worte in die
                Liste eingetragen wurden, deren pfa (wie ' sie liefert). {;}
                beendet die Liste, andere immediate Worte werden ausgef‡hrt.
                So kann mit Hilfe von {-->} eine solche Liste auf den folgenden
                Screens mit insgesamt bis zu 16383 Posten fortgesetzt werden.
                Zahlen, von denen nicht sicher bekannt ist, ob sie im System als
                Constante definiert sind, werden zweckm€œig mit Basis-Praefix
                hingeschrieben. Es werden stets einfache Integer eingetragen,
                auch, wenn gerade das fp-Vocabular {context} sein sollte, darauf
                muœ also keine R‡cksicht genommen werden. In die derzeitige De-
                finition lassen sich Werte von auœen ‡bergeben durch:
                        : I, 3 roll , ; immediate
                        ( zahl )
                        associative: name erstezahl .. I, .. letztezahl ;
                Ausf‡hrung:
                        (nn -- associtative:-liste -- index)
                wo index die ab Null z€hlende Nummer des Posten ist, der mit
                dem ‡bergebenen Wert nn ‡bereinstimmt, andernfalls geht die
                Anzahl Posten zur‡ck, dem h„chsten Index + 1 entsprechend.
                 ndern einer Eintragung:
                        ( index nn ) IS asssociativename
atne            ( -- n1 )                               F6 & IO2
                Cons, Index f‡r einen mit {>fount} installierbaren Zeichensatz.
                QX/AQ: in den SMSQ-Varianten kann zu Fehlern kommen, insbes. bei
                der Bilddarstellung im Acht-Farben-Modus. Die IO2-Zeichens€tze
                sind wegen ihrer 8-Bit-Breite nur in den Minerva-Systemen v„llig
                problemlos, anderswo sollten sie vorher ausprobiert werden.
* B
b/alc           ( -- n1 )                               F6
                Cons, Bytes pro Zuweisungseinheit als ganzes Vielfaches der
                Anzahl Bytes pro Sector
b/buf           ( -- n1 )
                Cons, Daten-Bytes pro Blockpuffer.
                Konventionell muœ die Anzahl einer Zweierpotenz entsprechen.
b/hed           ( -- n1 )                               F6
                Cons, Bytes L€nge der Fileheader
b/scr           ( -- n1 )
                Cons, Bl„cke pro (Editor-)Screen.
                Konventionell muœ die Anzahl einer Zweierpotenz entsprechen.
b/sec           ( -- n1 )                               F6
                Cons, Bytes pro (Disketten-)Sector.
                Konventionell muœ die Anzahl einer Zweierpotenz entsprechen.
base!           ( n1 -- )                               F6
                {base} mit n1 besetzen
base+           ( ptr -- dadr )                         F6
                Forth-ptr in doppeltgenaue wirkliche Speicheradresse umrechnen
base@           ( -- n1 )                               F6
                {base} lesen
base            ( -- ptr )
                User-Vari f‡r die Zahlenbasis im Forth-System
basic           ( ptr -- flg )                          F6
                ptr zeigt auf das count-Wort eines im SBasic (Job 0) bekannten
                Namen. Repr€sentiert der eine residente Procedur, die ohne
                Parameter benutzt werden kann, so wird diese ausgef‡hrt. In
                allen anderen F€llen kann mit {a1l@} der Wertepointer, falls
                ein Variablenname angegeben war, sonst die Ausf‡hrungsadresse
                einer residenten Funktion oder die Zeilennummer einer SBasic-
                Definition gelesen werden. Stets liefert {a1l@} eine auf die
                Referenzadresse des F6 bezogene Zahl, die wirkliche Adresse
                erh€lt man daraus mit {2base+}.
basicv"         ( BASICV" variname" -- dadr 0 | 0. tf ) F6S
                Holt den Werte-Pointer einer nicht DIMensionierten, sonst
                aber beliebigen SBasic-Variablen (des Jobs 0). Z.B:
                        basicv" e$"
                        0= IF 1 m+ count-l type-l
                           ELSE 2drop ENDIF
                Die n„tige Vorsicht vorausgesetzt, k„nnen die SBasic-Variablen
                vom F6 auch ver€ndert werden - bei Strings muœ die L€nge im
                SBasic erhalten bleiben!:
                        basicv" e$" dup ?error
                                1 m+ count-l
                                " .hpr l€œt gr‡œen" count-w
                                rot min swap base+ rot cmove-l
bblu            ( -- n1 )                               F6
                Cons, Codierung f‡r einen Zeichensatz - s. {>fount}.
bclr            ( dn1 n2 -- dn3 )                       F6
                Mit n2 angegebene Bitnummer in dn1 l„schen.
begin           ( -- ) (C) ( -- sys: ptr 1 )
                leitet eine einfache Wiederhol-Schleife ein.
bell            ( -- )                                  F6
                Bimmelt
bfclr           ( dadr1 ud2 -- )                        F6
                Mit ud angegebene Bitnummer in Bit-Feld ab dadr l„schen.
                {L<I} liefert ggf. den bis dahin dort g‡ltigen Bitwert.
bfset           ( dadr1 ud2 -- dn3 )
                Mit ud2 angegebene Bitnummer im Bitfeld ab dadr setzen.
                {L<I} liefert ggf. den bis dahin dort g‡ltigen Bitwert.
bftst           ( dadr ud -- flg )                      F6
                Test Bit#(ud) im Feld ab Adresse dadr. flg = Bit-Wert 0 oder 1;
                dadr und ud vorzeichenlose doppelte Integer (2^31).
            >>> Test bit#(ud) in the bit field beginning in memory
blanks          ( ptr n1 -- )
                Anzahl n1 <bl>s nach ptr in den 4th-Speicher eintragen.
blk@            ( -- n1 )
                Inhalt der User-Variablen {blk}
block           ( n1 -- ptr ) (D)
blk             ( -- ptr ) User-Vari
                Aktuelle Screenfile-Blocknummer, Null zur t.i.b.-Eingabe.
bounds          ( n1 n2 -- n3 n1 )
                Legt n3 so an, daœ eine DO..LOOP von n1 ausgehend bis n3-1
                die Anzahl n2 Durchg€nge z€hlt, entspricht der Sequenz
                        over + swap
break           ( c1 -- )                               H4
                Erwartet den Tastencode zum bedingungslosen Programm-Abbruch.
                Dieselbe Taste zusammen mit ALT l„st den Kaltstart aus - {cold}.
buffer          ( n1 -- ptr )
                Puffer f‡r den Block n1 zur Verf‡gung stellen.
bl              ( -- c1 )
                Cons, Zeichencode f‡r Leerzeichen
bs              ( -- )
                Position im Ausgabefenster um ein Zeichen zur‡cksetzen.
* C
c!l             ( n1 dadr -- )                          C1
                Byte n1 an wirklicher Speicheradresse dadr ablegen.
c->s            ( c1 -- n2 )
                Byte c1 vorzeichenbehaftet in Integer n2 erweitern.
c-find          ( ptr1 -- ptr2 c1 tf | ff )
                Wie {-find}, durchsucht jedoch nur die Wortkette, deren j‡ngste
                nfa an der Stelle ptr1 eingetragen ist.
c/scr           ( -- n1 )
                Cons, Bytes pro (Editor-)Screen
c/l             ( -- n1 )
                Cons, L€nge einer (Editor-)Zeile
c@l             ( dadr -- n1 )                          C1
                Byte n1 von wirklicher Speicheradresse dadr holen.
cache-off       ( -- flg )                              QX IO2
                Ruft die SMSQ-Trap sms.cach zum Abschalten der Cache auf.
cache-on        ( -- flg )                              QX
                Entspr. cache-off, Cache Einschalten.
cache           ( -- flg )                              QX
                Liefert den aktuellen Einschalt-Zustand der Processorcache.
case:           (I)                                     H4
                Verwendung wie {associative:} eigenst€ndig oder innerhalb eines
                Hi-Level-Wortes. Compiliert cfa-s der angegebenen Forth-Worte
                solange, bis ein {;} angetroffen wird. Zahlen werden mit ihrem
                wirklichen Wert eingetragen.
             >> compiles:
                the 4th-words cfa or the number values if the word wasn't found
                in context and successfully was converted to a single integer.
                executes:
                        (index -- executing | nn)
                the indexed cfa will be executed if the list was built of all
                4th-words. If there was at least one number given when defining
                it will be handled as a list of integers to be pushed to the
                datastack corresponding to the indexed position, instead. Case
                numbers will then be returned by their true value and 4th-words
                by their cfa, ready to {execute}.
case?           ( n1 n2 -- | n1 ) (C)                  (!)
                        ... case? ... else case? ... endif endif ...
cc-4th          ( c1 -- n1 | exec )                     F83     8.16 => hidden
                case:-Liste zur Ausf‡hrung von Steuer-Codes.
cc4th           ( -- ptr j)                             (F83)   8.16 => hidden
                User-Vari mit ptr zur aktuellen case:-Liste f‡r die Ausf‡hrung
                von Control-Codes durch {ctrl}, initial mit {cc-4th} besetzt.
cfa             ( n1 -- n2 )
                Liefert in n2 die cfa, wenn n1 die pfa eines Wortes ist.
ch-id           ( c1 -- did | -1. )                     (LR)
                Liefert die QDOS-Kanal-ID did, wenn mit c1 die Nummer eines
                im F6 offenen Kanals ‡bergeben wurde, sonst -1.
ch-num          ( did -- c1 | -1 )
                Liefert die h„chste F6-Kanalnummer, in der der im F6 offene
                QDOS-Kanal did verzeichnet ist, sonst -1.
chp             ( c1 -- ptr )                           LR
                Speicherplatz der zu c1 geh„rigen Kanalnummer, c1 von 0 bis 15,
clone-4th       ( -- )
                Aktive eigenst€ndige Copie des aufrufenden-F6-Jobs erzeugen.
close           ( c1 -- )                               LR
                Kanal c1 schlieœen, keine Fehleraktion.
cls             ( -- )
                Mit {out-cons} bezeichnetes Bildschirmfenster l„schen.
cmove-l         ( dadr1 dadr2 n3 -- )                   C1
cmove           ( ptr1 ptr2 n3 -- )
                Speicherbereich der Gr„œe +n3 von Forth-ptr1 nach ptr2 nicht-
                ‡berschreibend ‡bertragen.
cmc             ( -- ptr )
                Cons, als Wort-Z€hler bei der Code-Optimierung.
code+           ( n1 -- dn2 )
                wandelt den Abstand n1 zur Codebasis des F6-Jobs in wirkliche
                Speicheradresse um.
cold            ( -- )
                Nach {empty}.
compile         ( -- )
cons+           ( n1 CONS+ name )         => (  n2 name -- n1+n2 )
                Wert mit IS €nderbar.   (8.18)
consm+          ( n1 CONS+ name )         => ( dn2 name -- n1+dn2 )
                Wet mit IS €nderbar.    (8.18)
constant        ( n1 | f1 CONSTANT name ) => ( name -- n1 | f1 )
                fp-Constante setzen beim Aufruf {dpl} auf -2.
                 nderung m„glich mit:
                        ( nn | fn ) IS constantname
context         ( -- ptr )
                User-Vari, ptr zum ersten Such-Vocabular.
                Wird durch Nennung eines Vocabularnamen besetzt.
count-l         ( adr1 -- adr2 n3 )
                liefert den Inhalt der Zelle adr1 und die um eins weitergez€hlte
                Adresse adr2.
count-w         ( ptr1 -- ptr2 n3 )
                z.b. 16-Bit-Z€hler eines QDOS-String, ersetzt die Folge
                        2+ dup 2- @
count           ( ptr1 -- ptr2 c3 )
                liefert z.B. das Z€hlerbyte von Forth-Strings; steht f‡r
                        1+ dup 1- c@
create          ( -- ) ( CREATE name )
                Legt einen Primitive-Wortheader an und leitet Definitionsworte
                im F79/F83-Stil ein, wozu es im F6 mit {;does>} gepaart wird.
csp!            ( -- )
                Restauriert den Stackpointer aus der Variablen {csp}.
csp             ( -- ptr )
                User-Vari zur Stack-Kontrolle beim Compilieren.
ctrl            ( n1...nx -- m1...mx flg | exec 0 )     / F83
                Ausf‡hrung eines Steuercodes mit unterschiedlichen Parametern.
current         ( -- ptr )
                User-Vari, enth€lt den ptr zum aktuellen Definitionsvocabular.
c!              ( n1 ptr -- )
                Byte n1 an Forth-Adresse ptr eintragen.
c,              ( n1 -- )
                Byte n1 ins Dictionary eintragen, Dictionary-Ptr eins weiter.
c@              ( ptr -- n1 )
                Byte von Forth-Adresse lesen.
cr              ( -- ) (D)
                N€chsten Zeilenanfang aufsuchen.
* D
d$.             ( dn -- )                               F6
                Doppelte Integer sedezimal hinschreiben.
d+-             ( dn1 n2 -- dn3 )
                dn1 mit dem der Multiplikation dn1*n2 entsprechenden Vorzeichen
                versehen, d.h. dn1 negieren, wenn n2 negativ ist.
d->q            ( dn -- qn )  signed                    F6
                Vorzeichenbehaftetet Doppelte in Vierfache Integer wandeln.
d.r             ( dn1 n2 -- )
                dn1 in ein Feld der l€nge n2 rechtsb‡ndig hinschreiben.
d->s            ( d1 -- n1 | abort )                   (F6S)
                l€œt sich einschlieœlich §berlaufkontrolle z.B. nachbilden:
                        : d->s 1abs -18 ?error ;
                sonst gen‡gt einfach nur {drop}.
d/num           ( -- n1 )                               F6
                Cons, Devicenummer. Wie alle auf die Massenspeicher bezogenen
                Constanten wird sie nicht durch das System aktualisiert. Dies
                muœ bei Bedarf z.B. nach dem Aufruf {xinf} mit Eintragung der
                daraus gewonnenen Daten geschehen (s. Beispiel in "fig_scr").
d/wpt           ( -- n1 )                               F6
                Cons, f‡r =/= 0 bei geschaltetem Schreibschutz.
d0<             ( dn -- flg )
d0=             ( dn -- flg )
d1+             ( dn -- dn+1 )
d2+     d4+                     wie d1+                 F6
d1-             ( dn -- dn+1 )
d2-     d4-                     wie d1-                 F6
                Mit Hilfe der CFA k„nnen weitere gleichartige Operatoren nach
                folgendem Muster definiert werden:
                        create d16- -2 allot ' d2+ cfa @ , -16 , unsmudge
d2*             ( ud -- ud*2 )
d2/             ( dn -- dn/2 )
d4*             ( ud -- ud*4 )                          F6
d4/             ( dn -- dn/4 )                          F6
d>f             ( dn -- fp )                            F6
dabs            ( dn -- +dn )
                Betrag bilden; gibt $8000.0000 als 0 zur‡ck.
date$           ( -- ptr count )                        F6 QDOS
                Legt den Datumsstring zur weiteren Bearbeitung rsp. f‡r die
                Ausgabe mit {type} bereit.
             >> SBasic's DATE$ ready to {type}
day$            ( -- ptr count )                        F6 QDOS
db-on           ( -- n1 )                               F6
                Cons, Flag f‡r die debug- und Einzelschritt-Einrichtung, deren
                aktive Teile aus "forth_scr" geladen werden, z.B. durch
                        L-LOAD debugger flp1_forth_scr
                Mit einem Wert =/= 0 vor dem Compilieren wird der Einzelschritt-
                betrieb f‡r neue Worte oder den fl‡chtigen Compilezustand vorbe-
                reitet. Nachdem die erg€nzenden Debugger-Worte geladen wurden,
                k„nnen mit Werten von 1 bis 4 in {db-on} die pr€parierten Worte
                entsprechend abgearbeitet werden. Man ruft sie wie gewohnt auf
                und hat folgende zus€tzliche Tastenfunktionen:
                 <cursor hoch>
                        ‡berspringt einen Schritt,
                 <cursor runter>
                        entfernt den oberen Stackposten,
                 <ctrl/esc>
                        schaltet zwischen Normal- und Debug-Betrieb um,
                 <esc>
                        suspendiert den Debugger und bricht ab; ggf. §bergang
                        nach {quit}, wenn der Processor im Supervisor-Modus war.
                 <jede andere taste>
                        l„st den n€chsten Schritt aus.
                Negative Werte in {db-on} suspendieren den Debug-Betrieb, nicht
                aber das entsprechende Compilieren, und belassen die Tastatur-
                abfrage aktiv. F‡r Worte wie {r+}, die auf die folgende WA zu-
                greifen, muœ {db-on} zumindest befristet Null gesetzt werden,
                wie folgendes Beispiel klarmacht:
                        : name1 ... r+ execute ... ;
                        : name2 ... name1 bell ... ;
                Ruft man nun {name2} auf, f‡hrt dies u.a. auch {name1} aus, in
                dessen Rahmen die n€chste WA ausgef‡hrt wird. Dies ist oft recht
                n‡tzlich, wenn ein allgemeiner Aufruf f‡r verschiedene Zwecke
                eingesetzt werden soll. Dem Debugger bleibt dies jedoch verbor-
                gen, und er f‡gt nach {name1} seine Arbeits-WA ein, die dann
                von {r+} f€lschlich gelesen wird, was zu Sch€den f‡hren kann.
                        : name2 ... [ db-on 0 is db-on ] name1 bell [ is db-on ]
                vermeidet solche Irrl€ufer. Mehr in "F6CHG_txt" u. "FORTH_txt".
dds             ( -- ptr )                              F6
                User-Vari, ptr zum hi-level-Einsprung in den Ausf‡hrungsteil des
                j‡ngsten mit {;does>} gebauten Definitionswortes. Dient der
                Weitergabe der Ausf‡hrungsvorschrift neuer Definitionsworte.
ddup            ( n1 -- n1 n1 n1 )                      F6
decimal         ( -- )
default-is      ( name | -- )                           F6
                Einen Vector auf die Vorgabe-Aktion zur‡ckstellen; ist auf
                weitere Worte anwendbar, die mit IS besetzt werden k„nnen
                und einen 16-Bit Datenposten beliebiger Art verarbeiten.
                N‡tzlich auch, wenn ein Wort innerhalb eines Programms nur
                beim ersten Aufruf ausgef‡hrt werden soll, wie z.B. f‡r die
                Zuweisung einer Command-Line-History:
                        : (his) 80 swap history ;
                        defer   his
                        ' (his) is his          \ aktion beim ersten aufruf
                        ' drop cfa ' his !      \ ruhezustand des wortes
                und damit
                        ... 0 his default-is his ...
                womit nur beim ersten Aufruf eine History neu eingerichtet
                wird, und sie bei jedem neuen Aufruf unver€ndert bleibt.
             >> Re-assign a vector to it's default action.
defer           ( exec ) (C) ( DEFER name -- )          F83
                Vorw€rtsreferenz einrichten, {name} kann sp€ter mit {is} die
                gew‡nschte Aktion zugewiesen werden. Bis dahin, im Urzustand,
                f‡hrt {name} ein {noop} aus - welches zugleich auch "default"
                dieses Wortes ist (s.o.):
                        ' forthwort1 IS name            \ aufruf eintragen
                        ' forthwort2 cfa ' name 2+ !    \ default evtl. auch
                        ' forthwort  cfa dup ' name 2!  \ beide zugleich
                {defer}red-Definitionen sind abgesichert gegen Verlust der
                Codebasis durch {forget}. In einem solchen Fall wird die
                Vorgabe ausgef‡hrt, deren cfa auf ' name 2+ eingetragen ist.
                Liegt auch diese auœerhalb des sicheren Bereichs, wird mit
                Fehlermeldung abgebrochen. Ungerade ptr deaktivieren einen
                {defer}red Aufruf und gelten nicht als Fehler, sodaœ er mit
                {1on} und {toggle} stillgelegt rsp. freigegeben werden kann.
                Diese Form der Deaktivierung ist der Revectorisierung nicht
                nur deshalb vorzuziehen, weil die urspr‡ngliche Aktion leicht
                zur‡ckgewonnen werden kann, sondern auch, weil sie selbst
                gegen‡ber dem sehr schnellen {noop} noch einen deutlichen
                Zeitgewinn bringt. Im Vergleich wurden in einer Schleife mit
                1.000.000 Durchg€ngen im SMSQ/E mit QXL gemessen:
                        leere Schleife                   4,1 °s je Durchgang
                        Schleife mit {noop}              6,6
                        auf {noop} {defer}red Wort      11,2
                        Vector mit 1+ deaktiviert        8,1
depth           ( -- n1 )
                n1 gibt die Anzhl gerade vorhandener Stackposten an.
del             ( -- )                                  F6
                Im Ausgabefenster ein Zeichen zur‡ckgehen und es l„schen.
del-defb        ( --er )                                IO2/dvs_byt 8.18
                Aufruf der SBasic-Procedur aus TK2/GC/SMSQ.
digit           ( n1 -- n1 tf | ff )
                Liefert zus€tzlich den Flagwert 1, wenn n1 als Ziffer zur
                aktuellen Basis aus {base} g‡ltig ist, ersetzt sonst n1 durch
                den Flagwert 0.
dliteral        ( -- dn )  (C)( dn -- )         - "state sensitive" -
                doppeltgenauer Festwert. N€heres s. {literal}.
dminus          ( dn1 -- -dn1 )
                Negation
dm*             ( ud1 ud2 -- uq3 )                      F6
                Multiplikation zweier Doppelter zu einer Vierfachen Integer.
do              ( n1 n2 -- ) (C) ( -- sys: ptr 3 )
                Leitet eine Schleife ein, die (n1-n2)-mal ausgef‡hrt rsp. bei
                (n1-n2) < 1 nur einmal durchlaufen wird.
                Der mit {i} lesbare Laufindex beginnt bei n2.
                                DO.. ..LOOP oder DO.. ..+LOOP
does>           ( -- ) (C)
                Leitet in einem Definitionswort den von den damit definierten
                neuen Worten auzuf‡hrenden Teil ein. Darf nur bei Worten ein-
                gesetzt werden, die mit {<builds} aufgebaut werden. F‡r die im
                F83 mit {create} ‡bliche Paarung ist {;does>} zu verwenden.
                Nach {does>} ist das im Aufbau begriffene Wort f‡r {-find} noch
                nicht erkennbar.
dp              ( -- ptr ) User-Vari
                Dictionary-Pointer, wird beim Compilieren weitergez€hlt.
                Die niedrigste 4th-Adresse ist $-8000, die h„chste $7fff.
                Vorsicht:
                Wird der Inhalt von {dp} direkt durch ein Programm ver€ndert,
                und besteht dabei die M„glichkeit der Vorzeichen€nderung, muœ
                dem Dictionary-Ptr auf der Langwortadresse { dp 2- } die vor-
                zeichenerweiterte doppeltgenaue 4th-Adresse zugewiesen werden.
                Widrigenfalls verkehren sich die Maœnahmen zur Adressierungs-
                sicherheit in ihr Gegenteil, und das System bricht zusammen.
dpl@            ( -- n1 )                               F6
                Liefert den Inhalt der User-Variablen {dpl}
dpl             ( -- ptr )                              ( F6 f‡r fp-Zahlen )
                User-Vari, nach der Umwandlung eines Ziffernstring in eine Zahl
                wird hier die Position des (letzten) Dezimal-Kommas (-Punktes)
                verzeichent, gez€hlt von der letzten Ziffer an. Steht das Zei-
                chen an letzter Position, enth€lt {dpl} Null, fehlt es, steht
                dort -1. Flieœkommazahlen werden mit -2 in {dpl} gemeldet.
dr0ch           ( -- c1 )                               F6
                Byte-Cons, F6-Kanalnummer des {screen}-Kanals.
dr1ch           ( -- c1 )                               F6
                Byte-Cons, F6-Kanalnummer des {file}-Kanals.
drop            ( n1 -- ) ( f1 -- )
drop;           ( n1 -- )                               F6
                Verbindung aus {drop} und {;s} wird ggf. durch {;} compiliert.
                Auch geeignet zum auœerordentlichen Verlassen eines Wortes.
dr0             ( -- )                                  LR
                Erstes Massenspeicherger€t aktivieren, i/o durch {screen}.
                Setzt {offset} auf Null. G‡ltige Screens von 0 bis 16383;
                Screen Null kann nicht in den Interpreter geladen werden!
dr1             ( -- )                                  LR
                Zweites Massenspeicherger€t aktivieren, i/o durch {file}.
                Setzt {offset} auf 16384.
du<             ( ud1 ud2 -- flg )
dup             ( n1 -- n1 n1 ) ( f1 -- f1 f1 )
d*              ( d1 d2 -- d3 )                         F6
d+              ( d1 d2 -- d3 )
d-              ( d1 d2 -- d3 )
d.              ( d1 -- )
                Doppelte Integer hinschreiben.
d/              ( d1 d2 -- d3 )
d<              ( d1 d2 -- flg )
d=              ( d1 d2 -- flg )
* E
echo            ( ptr count -- )                        F6
                {type} in den {in-cons}-Kanal, wenn {prompt} =/= 0 ist. Ist c1
                nicht offen, geht die Ausgabe in das Ur-Fenster vom Job-Start.
editor          ( -- )  Vocabular
edif            ( -- c1 )                               F6
                Zum Editieren gerade g‡ltige Kanalnummer, {screen} oder {file}.
edit            ( -- )                                  F6
                Wenn der Editor noch nicht geladen ist, wird versucht, ihn aus
                dem namentlich bei {(screen)} eingetragenen File zu compilieren.
                Danach, oder wenn er bereits vorhanden ist, erfolgt Aufruf des
                F6-Screen-Editors - Erl€uterungen dazu in "ed_gls".
else            ( -- ) (C) ( sys: ptr 2 -- ptr -2 )
emit-m          ( n1 c2 -- )                            F6
                'emit multiply' - Ausgabe der Anzahl n1 Zeichen c2.
emit            ( c1 -- )
                Zeichen c1 nach {out-cons} ausgeben.
empty-buffers   ( -- )
                Alle Blockpuffer mit <nul>-Bytes l„schen.
empty           ( -- )                                  F6 F83
                Alle Definitionen jenseits der Grenze aus {fence} l„schen.
enclose         ( ptr c1 -- ptr n1 n2 n3 )
                Eine von dem Zeichen c1 umschlossene Gruppe Zeichen eingrenzen.
                Dies ist der zentrale Aufruf aller Worte im F6-Kern, die ein
                Textst‡ck holen. Anfangs ist c1 nicht erforderlich, es m‡ssen
                ab der Stelle ptr jedoch wenigstens zwei unterschiedliche Zei-
                chen vorhanden sein, deren letztes mit dem Code c1. F‡hrende
                Begrenzungszeichen werden ‡bersprungen, erst nach einem davon
                unterschiedlichen Zeichen gilt es als Begrenzung. Leerstrings
                kommen also nicht vor. Vielfach als st„rend empfunden ist das
                zum einen f‡r {word} erforderlich, zum andern aber auch zur
                optisch g‡nstigeren Schreibweise etwa bei einer derartigen De-
                finition mit Vorteil nutzbar:
                        : string create 0 c, here [compile] " ...
                womit man dann schreiben kann:
                        string {name} "die Begrenzung umfaœt alle Zeichen"
                was sehr viel plausibler aussieht, als die (eigentlich korrekte)
                Schreibweise f‡r denselben Text:
                        string {name} die Begrenzung umfaœt alle Zeichen"
                Zur‡ckgegeben wird der unver€nderte ptr, der Abstand n1 zum
                ersten Zeichen =/= c1, der Abstand n2 zum danach ersten Zei-
                chen = c1 und in n3 der Abstand zu der Stelle, wo ein neues
                {enclose} angesetzt werden kann.
                n2-n1 ist die L€nge der eingegrenzten Zeichengruppe.
endif           ( -- ) (C) ( sys: ptr 2 -- )
enter           ( -- ) (C) ( -- sys: here 5 )           F6(!)
                Die Kombination {enter} mit {entry} bildet eine Struktur-
                Variante besonderer Effizienz:
                {enter} ist Startpunkt f‡r den unbedingten Einsprung in eine
                BEGIN-Schleifenstruktur an den mit {entry} bezeichneten Ort.
                Dies macht den unbedingten R‡cksprung der Strukturen der Art
                BEGIN..WHILE..REPEAT ‡berfl‡ssig und erlaubt bei schnellerer
                Ausf‡hrung vielseitigere Gestaltung durch Abschluœ wahlweise
                mit WHILE..REPEAT, UNTIL oder AGAIN. Z.B.
                        BEGIN dup WHILE 1+ REPEAT
                wird ersetzt durch
                        ENTER BEGIN 1+ ENTRY dup 0= UNTIL
                Die Operation 0= zieht der Compiler des F6 mit UNTIL zu einem
                Sprung mit umgekehrter Bedingung zusammen, wodurch der zus€tz-
                liche Operator ohne Wirkung auf die Ausf‡hrungszeit bleibt.
             >> This is a new modification to the BEGIN..-loop structure of
                improved efficiency as it dispenses with the uncondional branch
                back to the loop entry. It also enables more flexibility as
                the loops may be terminated with any one of REPEAT (after an
                additional WHILE), nn UNTIL, or AGAIN, respectively.
entry           ( -- ) (C) ( sys: ptr 5 n1 n2 -- n1 n2 )  F6(!)
                Zielpunkt eines {entry}-Einsprunges:
                        ENTER BEGIN ... ENTRY .. WHILE .. REPEAT
                        ENTER BEGIN ... ENTRY .. cc UNTIL
                        ENTER BEGIN ... ENTRY .. .. AGAIN
                Einsprung mit einer Stackmanipulation auch hinter WHILE:
                        ENTER BEGIN ... WHILE .. [ 2rot 2swap ] ENTRY .. REPEAT
                Ein wenig verr‡ckt:
                        cc IF n1 n2 2>r ENTER [ 2swap ] ENDIF
                                 n3 n4 DO ... [ 2swap ] ENTRY ... LOOP
                Es ist also lediglich darauf zu achten, daœ f‡r {entry} irgend-
                welche zwei Stackposten und die eigenen Parameter vorliegen.
                Der Einsprung kann damit an beliebiger Stelle stehen.
erase           ( ptr n1 -- )
                Im Forth-Speicher ab ptr Anzahl n1 <nul>-Bytes eintragen.
ernum           ( -- dn )                               F6
                Fehlercode nach einem der Aufrufe aus dem qdos-Vocabular -
                das sind die, die nicht in den Standardfenstern arbeiten.
                Wird nach den Lesen sofort wieder auf Null zur‡ckgestellt.
                Zerst„rungsfreies Lesen ist m„glich mit:
                        ' ernum cfa @ 2+ base+ @l 2+ 2@
error           ( n1 -- )
                Schreibt die Fehlermeldung zum Code n1 und f‡hrt {warm} aus.
                Im Verlauf der Fehlerbehandlung wird vor dem Erreichen von
                {quit} eine Kette teils revectorisierbarer Worte ausgef‡hrt,
                die bedarfsweise auch auf andere Worte eingestellt werden
                k„nnen. Insbes. {(quit)} dient dabei dem automatischen Start
                und sp€teren stetigen Wiedereintritt in z.B. ein Programm.
                error (D)       f‡hrt [error] aus,
                [error]         bei warning > oder = 0 endet es
                                        in der Ausf‡hrung der cfa aus (quit).
                        (quit)          f‡hrt in den  uœeren Interpreter.
                                bei warning < 0 wird abort ausgef‡hrt
                        abort           ruft (abort) und (quit) auf:
                        (abort) (D)     ist initial mit einem headerlosen Wort
                                        zur Teil-Initiierung besetzt,
                        (quit)          schlieœt mit Ausf‡hrung der cfa ab,
                        quit            ist der  uœere Interpreter, und seine
                                        cfa steht initial in (quit).
ert             ( dn -- )                               LR
                Warmstart bei dn =/= 0.
even            ( n1 -- n2 )                            F6
                Gibt n1 geradzahlig abgerundet als n2 zur‡ck.
             >> align n1 to n2 = n1 - (n1 mod 2)
even+           ( n1 -- n2 )                            F6
                Rundet geradzahlig auf.
             >> align n1 to n2 = n1 + (n1 mod 2)
execute         ( cfa -- )
                Der Aufruf eines Wortes ist gleichbedeutend mit
                        ' name cfa execute
expect          ( ptr n1 -- )(D)
                Erwartet Tastatureingabe in {in-cons} bis zum n€chsten <enter>
                oder der maximalen L€nge n1 und bringt sie nach ptr.
                Die empfangene L€nge ist unmittelbar danach in {span} lesbar.
                Fehler werden durch {(exper)} so abgefangen, daœ bei Verlust
                des Eingabekanals die Fenstervorgabe vom Systemstart sowohl
                f‡r in-cons als auch f‡r out-cons eingetragen wird. Eingabe
                ist sowohl aus Dateien als auch aus Fensterkan€len m„glich.
* F
f/n             ( -- n1 )                               F6
                Cons, Maximall€nge f‡r einen Filenamen.
f>$             ( f1 -- ptr count )                     F6 QDOS
                fp-Zahl in Zifferntext umwandeln und zur weiteren Bearbeitung
                rsp f‡r {type} bereitlegen.
f>d             ( f1 -- d1 )                            F6
                Wandelt f1 in doppeltgenaue Intger um, liefert bei Bereichs-
                ‡berschreitung entsprechende §berlaufwerte ( $7fff.ffff oder
                $8000.0001 = $-7fff.ffff ) in den Stack.
f>q             ( f1 -- q1 )                            F6
                Umwandlung einer fp-Zahl f1 in eine Vierfache Integer,
                §berlaufwerte entsprechend {f>d}.
fdelete         ( name -- ) (I) (iP)                    F6 LR
                L„scht das File name. Kann, wie auch die {fop-..}-Varianten,
                compiliert werden mit fest in das Wort eingabutem Filenamen
                        : wortname ...  ... fdelete filename ... ;
                mit Anforderung des Namen durch das neue Wort
                        : wortname ... ... [compile] fdelete ... ;
                oder in ein neues Compiler-Wort
                        : name ... compile [compile] fdelete ... ; immediate
                das seinerseits in den beiden ersten Varianten verwendbar ist.
fence           ( -- ptr )
                User-Vari, enth€lt die absolute Untergrenze f‡r {forget}, die
                zur einwandfreien Funktion von {empty} und {cold} unbedingt
                eine lfa sein sollte, z.B.:
                        ' task lfa fence !
                Wurde {empty} mit ge€ndertem {fence} oder {forget} unterhalb
                der zuvor g‡ltigen Grenze aufgerufen, sind danach mit {safe!}
                die Initiierungsdaten f‡r {cold} und {warm} zu aktualisieren.
file            ( -- c1 )                               F6
                Position des ersten Editor- rsp. Load-Filekanals.
fill            ( ptr1 n2 c3 -- )
                Anzahl n2 Zeichen c3 nach Forthadresse ptr1 brigen.
first           ( -- ptr )
                Cons, ptr zum ersten Blockpuffer, beim Systemstart besetzt.
fld             ( -- ptr )
                User-Vari, frei verwendbar
fname"          ( ptr FNAME" filename" -- )             F6S
                Bringt einen mit " begrenzten String der maximalen L€nge aus
                {f/n} mit Z€hler-Wort ("integer") nach ptr.
fop-dir         ( FOP-DIR name -- d.er ) (I) (iP)       F6 LR
                ¤ffnet name als Directory-File.
                Weist die QDOS-ID bei Erfolg dem aktuellen {work}-Kanal zu.
fop-in          ( FOP-IN name -- d.er ) (I)  (iP)       F6 LR
                ¤ffnet name als File zum Lesen.
                Weist die QDOS-ID bei Erfolg dem aktuellen {work}-Kanal zu.
fop-link        ( did FOP-LINK name -- d.er ) (I) (iP)  F6
                zur Verkn‡pfung eines PIPE-Kanals (oder HIS der History von
                'oktagon') mit einem neuen Kanal.
                Weist die QDOS-ID bei Erfolg dem aktuellen {work}-Kanal zu.
                Eine interessante Nebenwirkung dieser Kanalverkettung ist
                auch die M„glichkeit, damit eine automatisch verwaltete Teilung
                von Prompt-/Eingabe- und Ausgabe-Fenster einzurichten:
                        " con_448x40a20x200" 0 ch-id 0 open-link
                er„ffnet ein nur f‡r die Eingabe zust€ndiges Fenster, das
                zugleich als "prompt"-Kanal dient, und lenkt die Standard-
                Ausgabe in den f6-Kanal 0, der nun nur die Ausgabe aufnimmt.
                F‡r eine den SBasic-Fenstern €hnliche Aufteilung lassen sich
                die Fenster dann z.B. mit {wmov} anordnen:
                        0 wmov ... <enter>   richtet Gesamtbereich ein
                        1 wmov ... <enter>   postiert darin das Eingabefenster
                        0 wmov ... <ESC>     justiert schlieœlich das Ausgabe-
                                             fenster so, daœ es sich mit dem
                                             Eingabebereich nicht ‡berschneidet.
                Danach hat man einen von der eigentlichen Bildausgabe klar ge-
                trennten Eingabe- und Prompt-Bereich, der ohne jeden Programm-
                aufwand - und damit auch ohne Zeitverlust - betreut wird.
fop-new         ( FOP-NEW name -- d.er ) (I) (iP)       F6 LR
                ¤ffnet einen Kanal zum hiermit neu eingerichteten File name.
                Weist die QDOS-ID bei Erfolg dem aktuellen {work}-Kanal zu.
fop-over        ( FOP-OVER name -- ) (I) (iP)           F6 LR
                L„scht ggf. das File name und f‡hrt dann {fop-new} aus,
                ist darum von TK2 oder Minerva unabh€ngig ‡berall verwendbar.
                Weist die QDOS-ID bei Erfolg dem aktuellen {work}-Kanal zu.
fopen           ( FOPEN name -- d.er ) (I) (iP)         F6 LR
                ¤ffnet einen Schreib-/Lese-Kanal nach name.
                F‡r alle {fop..}-Varianten gilt:
                Falls {work} vor dem open-Versuch einen offenen Kanal repr€sen-
                tiert, der nur dort verzeichnet ist, wird jener geschlossen.
                Dies geschieht der Ordnung halber, da dessen ID durch die neue
                Nummer ‡berschrieben wird und danach nicht mehr greifbar ist.
                Bei Erfolg wird die neue QDOS-ID dem {work}-Kanal zugewiesen.
                Am Schluœ der Aufrufe folgt ein { 0 paper }. Das ist stets un-
                sch€dlich, hat bei Fenstern aber zur Folge, daœ der Kanal ggf.
                sofort in die Verwaltung durch das PIF ‡bernommen wird, was die
                andernfalls oft recht ‡blen Fehlererscheinungen vermeidet. Diese
                Extratour ist Teil der Vorgabedefinition des vectorisierten Wor-
                tes {[fop]}, das den eigentlichen open-Aufruf enth€lt, und wo
                sie bei Neudefinition ggf. auch fortgelassen werden kann.
forget-lk       ( -- ptr )
                User-Vari, im System zur Verkettung von {forget}-Aktionen.
forget          ( FORGET name -- | abort )
                Alles ab der Definition name aus dem Dictionary l„schen und
                den betr. Bereich freigeben. {abort} wenn name nicht existiert.
                {forget} ist von der Vocabularordnung beim Aufruf unabh€ngig
                und arbeitet durch alle Vocabulare hindurch. Falls das betrof-
                fene Wort nicht im Context-Vocabular steht, kehrt der Aufruf
                zur Sicherheit stets mit {forth} als Context zur‡ck; Vocabulare
                k„nnen problemlos mit {forget} ebenfalls entfernt werden.
                        fence @ top-nfa id.
                zeigt den Namen des letzten vor {forget} gesch‡tzten Wortes an.
                In {forget} liegt die einzige Stelle des F6-Systems, an der die
                Caches der Processoren ab 68020 geschaltet werden. Dies dient
                f‡r sp€tere z.B. {defer}red oder lo-level-Aufrufe der sicheren
                Erkennung der Ver€nderungen durch den Processor. Nach auœen hin
                tritt die vor‡bergehende Abschaltung nur mehr oder weniger zu-
                f€llig in Erscheinung, wenn der mit {break} erzwungene Abbruch
                gerade in die Ausf‡hrung der entsprechenden {forget}-Passage
                f€llt. Sch€dliche Folgen entstehen nicht, man kann die Caches
                aus jedem beliebigen Programm heraus sofort wieder aktivieren.
format          ( FORMAT name -- n1 n2 0 | er )         F6 LR
                Gibt die Anzahl formatierter und brauchbarer Sectoren zur‡ck,
                bei einem Fehler nur den Fehlercode er.
fp-err          ( -- er )                               F6
                Fehlercode nach fp-Operationen, nach dem Lesen auf Null gesetzt.
ftest           ( FTEST name -- er )                    F6
                Pr‡ft, ob mit name ein lesbarer Kanal eingerichtet werden kann.
fp              ( -- ) (I)                              F6
                Vocabular f‡r Flieœkomma-Operationen. Ist {fp} current, werden
                Zahlen stets im fp-Format ermittelt und ggf. compiliert, sofern
                sie nicht mit einem Zahlenpraefix versehen sind.
                In {fp} definierte neue Vocabulare - bei {fp} als context -
                'erben' die fp-compilierende Eigenschaft.
             >> Vocabulary compiling and operating on fp-numbers, as newly
                defined {fp}-sub-vocabularies also do.
* H
h>a             ( n1 -- c1 )                            H4
                liefert das sedezimale Ziffernzeichen entsprechend der Zahl n1
here            ( -- ptr )
                ptr ist der aktuelle Dictionary-Ptr, gelesen aus {dp}.
hex             ( -- )
                Stellt die sedezimale Zahlenbasis ein.
hidden          ( -- ) (I)                              F6 C1 F83
                Vocabular f‡r die eher heiklen Operationen zum Schutz gegen
                versehentlichen Aufruf, und f‡r Hilfsdefinitionen, die kaum
                allgemeine Anwendung haben, um die Wortsuche in den anderen
                Vocabularen nicht unn„tig zu verlangsamen.
hld?            ( -- flg )                               F6
                flg = 1 bei Erreichen der Bereichsgrenze zur Zifferndarstellung.
                Insbes. zur Kontrolle bei der quad-Umwandlung. Es bleibt stets
                noch gen‡gend Platz, um ggf. durch einen voranzustellenden L€n-
                genz€hler einen 4th- oder qdos-String zu erzeugen. Die Kontrolle
                wirkt nur bei Standardbesetzung von {hld} auf {pad} mit nach
                {here} wachsenden Strings, wie sie z.B. durch {<#} automatisch
                eingestellt wird. Wurden die Referenzposten ab { hld 2- } auf
                einen anderen Wert umgestellt, ist ggf. im Programm gesondert
                f‡r Einhaltung der Grenzen zu sorgen. Es wird Platz f‡r maximal
                66 Zeichen einschlieœlich evtl. des L€ngenwortes ben„tigt.
hld             ( -- ptr )
                User-Vari, nach Umwandlung einer Zahl in die Ziffernschreibweise
                mit ptr zum Anfang des Ziffernstrings, der bis vor {pad} reicht.
                Der Posten { hld 2- } enth€lt den vorzeichenerweiterten Wert.
                Bei Ver€nderung des Ptr von auœen, z.B. durch ein Programm, ist
                stets der doppeltgenaue Wert einzutragen, zugleich muœ dieselbe
                Zahl auch an die Stelle { hld 2+ } ‡bergeben werden. Z.B.
                        ( d.zahl ) <# pad 100 + s->d 2dup hld 2- 4! #s #> type
                wodurch der Ziffernstring von { pad 100 + } an "abw€rts" aufge-
                baut wird. Wird ein mit {>loc} reservierter Localer Speicherbe-
                reich hierzu benutzt, lassen dadurch sich jegliche Konflikte bei
                der Zahlenausgabe vollst€ndig ausschlieœen.
hold            ( c1 -- )
                F‡gt das Zeichen mit dem Code c1 in den im Aufbau befindlichen
                Ziffernstring an der aktuellen Position aus {hld} ein.
                Wird allgemein nur zwischen <# und #> benutzt.
* I
i               ( -- n1 ) (C) ( -- )
                Schleifenindex innerhalb einer DO..LOOP, identisch {r}.
i/o             ( -- c1 )                               F6
                Nummer des mit der j‡ngsten Operation benutzten i/o-Kanals.
id.             ( nfa -- )
                Schreibt den zur angegebenen nfa geh„renden Namen eines Wortes
                hin. Immediate-Worte werden durch vertauschte Hintergrund- und
                Schriftfarbe hervorgehoben.
if              ( flg -- ) (C) ( -- sys: 2 )
                {if} wird vom Compiler optimiert, wenn ihm einer oder eine
                Kombination der Vergleichsoperatoren {0< 0= 0>} vorausgeht.
                Dies erspart neben dem oft erheblichen Zeitgewinn auœerdem
                die Definition einer Unzahl spezieller Operatoren f‡r jeden
                der m„glichen Vergleichszust€nde und Postentypen, denn z.B.
                        ist     0< 0= IF        identisch mit  0>= IF
                und wird im F6 direkt als bedingter Sprung compiliert. Auch
                        hat        0= IF        kein k‡rzeres  quivalent, wird
                aber als besondere IF-Variante ebenfalls optimierend compiliert.
if-found        ( IF-FOUND name -- ) (I)                F6 (F83)
                Hilfe z.B. f‡r bedingte Aktionen beim Laden aus Screenfiles.
                Wurde {name} nicht gefunden, bleibt der Rest der Eingabezeile
                unbeachtet.
if-nfound       ( IF-NFOUND name ) (I)                  F6 (F83)
                Der Rest der betr. Eingabezeile rsp. des Blockes im Screenfile
                bleibt unbeachtet, wenn das Wort name bereits vorhanden ist.
if-true         ( flg IF-TRUE ) (I)                     F6
                Der rest der Zeile bleibt unbeachtet, wenn flg = 0 ist.
immediate       ( -- )
                Macht das j‡ngste current-Wort zum Compiler-Wort, d.h. es
                wird "immediate" erkl€rt und damit stets sofort ausgef‡hrt.
in-cons         ( -- c1 )                               F6
                Nummer des Kanals der Standard-Tastatureingabe.
interpret       ( -- )
                Der Text in {source} wird Interpretiert ab der Stelle
                        source drop in @ +
                Das Textende l€œt sich u.a. ermitteln aus
                        source sdrop in @ 1- <
io-err          ( -- n1 )                               F6
                Fehlernummer bei einem i/o-Fehler der Standardfenster oder
                in den File-Operationen
io-time         ( -- ptr )                              F6
                User-Vari mit der Wartezeit f‡r i/o-Operationen. Wird im System
                benutzt, sollte sonst stets auf -1 belassen bleiben - s. {key}.
is-chan         ( c1 -- )                               F6
                QDOS-ID des aktuellen {work}-Kanals an F6-Kanal c1 ‡bergeben.
is-his          ( c1 -- flg )                           F6
                flg=0 wenn der Fensterkanal c1 keine Command-Line-History hat,
                flg=1 bei gew„hnlichen Fenstern, flg=-1 bei untauglichem Kanal.
is-ochan        ( c1 -- flg )                           F6
                flg = 1 wenn c1 einen eigenen Kanal des F6-Jobs repr€sentiert.
is-open         ( c1 -- flg )                           F6
                flg = 1 wenn c1 einen offenen Kanal repr€sentiert.
in              ( -- ptr ) User-Vari
                Enth€lt den Interpreter-Laufptr als Abstand zum Text-Anfang.
inkey           ( +n1 | -1 -- c1 )                      F6
                unterscheidet sich von {key} nur durch Wartezeitangabe +n1 und
                Nutzung des {work}-Kanals, wenn der ein Fenster repr€sentiert.
is              ( xx IS name ) (I)                      F6 F83 H4
                Werte-Zuweisung an verschiedenerlei Datenposten:
                       Wert        IS   Typ             {default-is}
                        pfa             defer           anwendbar
                      index pfa         case:
                         n1             variable        anwendbar
                         n1             user
                     n1 rsp. f1         constant        anwendbar
                      index n1          case:
                      index n1          associative:
                      index n1          range:
                        dn1             2variable
                        dn1             2constant
                Bei Variablen und Constanten ist die konventionelle Zuweisung
                mit Hilfe der zugeh„rigen Adresse und einem {!}-Operator sehr
                viel schneller, IS dagegen ist transportabel in andere Forth-
                Systeme, da dessen Definition dort leicht erg€nzt werden kann,
                nicht aber die des {'}. Das hier benutzte IS kann problemlos
                identisch mit anderem Namen eingerichtet werden:
                        defer TO                immediate
                        ' is IS to  ' is cfa ' to 2+ !
                oder (geringf‡gig langsamer compilierend)
                        : TO [compile] IS ;     immediate
* J
j               ( -- n1 )
                Schleifenindex einer umgebenden zweiten DO..LOOP.
* K
keyrow          ( n1 -- n2 )                            F6 QDOS
                Gibt den Spalten-Code der QL-Tastatur der Reihe n1 zur‡ck.
key             ( -- n1 )                               ( F6 erweitert )
                Wartet auf Tastenbet€tigung und gibt den zugeh„rigen Zeichen-
                code zur‡ck. Zusammen mit ALT ist der Wert negativ, war kein
                Tatstaturkanal zug€nglich, kommt $8000 ( 32768 ).
                Die Wartezeit wird von {io-time} bestimmt und kann damit ge€n-
                dert werden, ist sp€ter aber unbedingt wieder zur‡ckzustellen.
* L
lit+            ( -- ) (C)                              F6
                Mit gr„œter Vorsicht zu verwenden, da v„llig ungesch‡tzt:
                Darf nur compiliert werden, keinesfalls direkt aufgerufen!
                Vor einer Zahl compiliert modifiziert die Literal-Optimierung
                diese dann so, daœ sie sofort in den Stack addiert wird, also
                die Sequenz {n1 n2 +} durch diese gut 40% schnellere (und zwei
                Bytes Platz einsparende) Variante ersetzt. Man schreibt dazu
                        : name ... lit+ zahl ...
                was dem "normalen" Text gleichkommt
                        : name ... zahl + ...
                In der Optimierung wird durch den {+}-Compiler ein {lit} automa-
                tisch durch {lit+} ersetzt, wenn vor dem {+} ein Festwert steht.
l-load          (I) <= 8.16             (P)             F6 und F6S
                init: ( L-LOAD filename )               oder
                      ( 0 L-LOAD drop )
                load: ( L-LOAD forthwort )              oder
                      ( L-LOAD forthwort filename )
                "Library Load" zum Compilieren einzelner Worte aus Screenfiles.
                Die zweite Initiierungsvariante ist Beispiel f‡r den Aufruf,
                wenn ungewiss ist, ob die Initiierung schon vorher erfolgte.
                Da relativ aufwendig, und f‡r fertige Programme kaum je vonn„-
                ten, wurde dieser Aufruf in das Screenfile ausgelagert, als zu-
                grundeliegende Definition ist S-LOAD (s.dort) im Kern vorhanden.
                Zum Auffinden des Wortes muœ in der ersten Zeile der Seite, an
                der die gesuchte Definition beginnt, der Name mit f‡hrendem und
                abschlieœendem Leerzeichen bei vorangestelltem Doppelpunkt ste-
                hen, ggf. auch als Kommentar:
                        ( : name1 : name2 und ggf. weiterer text )
                Bleibt er unver€ndert, kann der Filename fortgelassen werden.
                Bedingtes Compilieren wird zus€tzlich dadurch unterst‡tzt,
                daœ {-lword} den gesuchten mit einem angegebenen Namen ver-
                gleicht und bei Erfolg als Flag 1 zur‡ckgibt, sonst Null.
                Zur Kontrolle gibt der {l-load}-Aufruf zuerst seinen Filenamen
                aus, und am Ende den Namen des zuletzt compilierten Wortes.
                Die Files werden nur zum Lesen ge„ffnet, sodaœ auch Aufrufe im
                selben Quellenfile mit {l-load} m„glich sind, oder mehrere F6-
                Jobs zur selben Zeit auf dieselbe Quelle zugreifen k„nnen.
                L-LOAD kann in ca. 30 Stufen geschachtelt aufgerufen werden:
                Es belegt im Returnstack die der Namensl€nge des Aufruf-File
                zuz‡glich 11 entsprechende Anzahl Bytes, geradzahlig abgerundet.
           FEHLER: Regul€re Fehlermeldung bei nicht gefundenem Wort ist err.ro,
                "Schreibschutz", weil intern ein Versuch zum normalen OPEN am
                bereits OPEN_IN-ge„ffneten File scheitert, der standardm€œig
                als Hilfe dient, einen fehlerhaften Text zu editieren. Fehl-
                schlag gilt NICHT als Fehler, wenn {l-load} aus einem File auf-
                gerufen wurde, was das allein durch Vorhandensein (oder nicht)
                irgendwelcher Teile steuerbare Compilieren erlaubt, aber auch
                die Fehlerm„glichkeit unvollst€ndiger Programme birgt.
                Einige Beispiele zu L-LOAD finden sich u.a. in "fig_scr".
           HINWEIS: Mitunter gibt es Fehler beim Laden aus "WIN" bei den SMSQ-
                Varianten. Falls L-LOAD abbricht, gelingt es u.U. fortan nicht
                mehr, von "WIN" ‡berhaupt noch einen Ladevorgang durchzuf‡hren,
                selbst mit neu gestarteten Jobs blieb das oftmals aussichtslos.
                Dem hat in Version 2.57 gelegentlich DEL_DEFB abgeholfen.
                In {l-load} sind inzwischen weitgehende Vorkehrungen dagegen
                getroffen, die jedoch nicht immer helfen m‡ssen.
l-mrg           ( -- ptr ) User-Vari                    F6
                Linker Rand bei der Bildausgabe, z.B. im Debugger.
l<i             ( -- dn1 )                              F6
                Gibt den j‡ngsten Wert des Processor-Registers D0 zur‡ck.
                Liefert nur compiliert sinnvolle Werte, die benutzt werden
                k„nnen, um z.B. das regul€re Ende einer DO..LOOP vom Ende
                durch Verlassen mit LEAVE zu unterscheiden. Dieses Wort ist
                ganz und garnicht standardgem€œ und d‡rfte kaum ‡bertragbar
                sein. Es sollte darum nur in Ausnahmef€llen benutzt werden.
                N€heres hierzu in "FORTH_txt" rsp. hier am Schluœ.
last            ( -- ptr )                              F79+
                User-Vari, enth€lt die nfa der j‡ngsten Definition im Sytem.
                Gegen‡ber {latest} bietet dieses Wort die Sicherheit, daœ z.B.
                ein Verweis auf die gerade im Aufbau befindliche Definition
                auch wirklich die richtige Stelle trifft - wenngleich {current}-
                Wechsel w€hrend der Definitionsphase ein h„chst unkonventionel-
                les (und sinnloses!) Vorgehen ist, so wird {latest} dann auf ein
                anderes Wort zeigen und die Referenz kann zu Fehlern f‡hren.
                        : name ... IF [ last @ pfa cfa , ] ENDIF ... ;
                beispielsweise f‡r eine "handgefertigte" Recursion.
latest          ( -- nfa )
                ist nfa des j‡ngsten Wortes im {current}-Vocabular, entspricht
                        current @ @
                {latest} kann { last @ } sicher ersetzen, wenn es in ein Defi-
                nitionswort eingebaut wird, oder allgemein, wenn es einem Aufruf
                von {create} oder von Worten, die damit gebildet werden, folgt,
                und Referenz auf das gerade erzeugte neue Wort beabsichtigt ist.
leave           ( -- )
                Abbruch einer DO..LOOP am Ende des laufenden Durchganges. Dies
                wird durch §berschreiben des Grenzwertes mit dem aktuellen Index
                erreicht; die Worte nach {leave} werden darum noch abgearbeitet.
lfa             ( pfa -- lfa )
limit           ( -- ptr )
                Cons, Obergrenze des Blockpuffer-Bereichs.
literal         ( -- n1 ) (C) ( n1 -- )         - "state sensitive" -
                Einfacher Festwert, compiliert {lit} und eine Zahl vom Daten-
                stack, im interpretierenden Betrieb ist das Wort inaktiv.
                Optimierung:
                Zwei aufeinanderfolgende Festwerte ordnet der Compiler als
                {dlit} mit quasi-doppeltem Festwert an. Damit ist z.B.
                        : dr? $40 $40 offset c@ and = ;
                deutlich schneller, als
                        : dr? $40 dup offset c@ and = ;
                und auœerdem noch k‡rzer, als
                        : dr? offset c@ $40 and $40 = ;
                F‡r alle {literal}-Varianten gilt:
                Beim Compilieren wird die zugeh„rige Zahl sofort vom Stack
                genommen und in das gerade zu definierende Wort compiliert.
                Kam sie also von "auœen" in das Wort hinein, muœ sie zum Aus-
                gleich der Stackbilanz dupliziert werden. Man entfernt die
                Zahl dann nach erfolgtem Wortaufbau. Beim Aufruf liefert das
                compilierte {lit} die Zahl in den Datenstack. Z.B.:
                        here
                        : wodenn [ dup ] literal $. ;
                        drop
                {literal}s werden mit geringerem Zeitaufwand ausgef‡hrt, als die
                entsprechenden {constant}-Definitionen. Das Compilieren dauert
                etwas l€nger, da Zahlen immer erst nach erfolgloser Wortsuche
                ermittelt werden. Sie bieten sich dort an, wo eine Zahl nach dem
                Compilieren nicht mehr ge€ndert wird, sie nur selten vorkommt,
                und nicht von mehreren Stellen auf einen identischen Wert zuge-
                griffen werden muœ.
lngbad          ( -- er )                               F6 IO2 Lightning
                Versucht den SBasic-Aufruf _lngBAD. Keine Fehleraktion, gibt
                stets den QDOS-Fehlercode zur‡ck, 0 im Erfolgsfalle. Fehler-
                code 0 kann auch als zuverl€ssiger Hinweis auf Vorhandensein
                der "lightning"-Erweiterung ausgewertet werden.
l-ro            ( -- n1 )                               F6
                Cons, 1 f‡r {l-load} mit nur zum Lesen offenen Files, sonst 0.
load            ( +n1 -- ) (D)
                Beginnt das Compilieren vom offenen Screenfile ab Seite n1 mit
                n1 > 0, da vom Block 0 nicht geladen werden kann (tib-Eingabe).
                Beginn des Ladevorganges wird mit einem Doppelpunkt im Stan-
                dard-Eingabefenster {in-cons} - sofern zug€nglich - angezeigt.
                LOAD belegt jeweils drei Posten im Returnstack, womit mehr als
                250 Stufen geschachtelter Ladevorg€nge sicher aufrufbar sind.
                F‡r aufeinander folgende Aufrufe oder Anzahl unterschiedlicher
                Files gibt es bei keiner der Lade-Varianten eine Begrenzung.
                Durch Re-Vectorisierung von {load} l€œt sich aus {l-load} mit
                einfachsten Mitteln ein VIEW-Aufruf als Hilfsfunktion zum An-
                sehen der aus Screenfiles compilierten Wortdefinitionen einrich-
                ten. Dieses {view} ist zum Nachladen in "forth_scr" definiert.
                Sollte der Vector einmal verdorben worden und nicht wiederher-
                stellbar sein, kann er notfalls mit der Vorgabe besetzt werden:
                        ' load 4+ dup ' load 2!
                Der Lade-Vorgang wird ‡blicherweise mit {;s} ausdr‡cklich been-
                det, bricht aber auch selbst€tig ab, sofern in der zuletzt gele-
                senen Seite weder {-->} steht, noch ein neues {load}-Kommando.
loc>            ( n1 -- )                                       F6
                Gibt den n1 Zellen groœen Local-Bereich frei. Der Aufruf kann
                mehrmals innerhalb eines Wortes stehen. Auch gibt es keine Kon-
                flikte mit dem System, falls die Freigabe nicht alle reservier-
                ten Posten umfaœt. Einziger Schaden besteht u.U. darin, daœ der
                "vergessene" Bereich nur dann zuverl€ssig zur‡ckzugewinnen ist,
                wenn die Anzahl verbliebener Local-Bytes bekannt ist. Gegen die
                Freigbe zu groœer Bereiche sind Maœnahmen getroffen, die jedoch
                nur als letzte Rettung zum Schutz des Systems wirksam werden.
                 ltere locale Bereiche und evtl. auch regul€r im Datenstack ab-
                gelegte Posten k„nnen in solchen F€llen verlorengehen.
loc>stk         ( n1 ... nn -- {a|A} {b|B} ... {z|Z} n1 .. nn )
                Auœerordentlich schnelle Form der §bergabe in den Stack bei
                gleichzeitiger Freigabe der eigenen Local-Gruppe. Holt alle
                Locals zum Stack; dort bereits vorhandene Posten bleiben an
                unver€nderter Position, die Locals werden danach angeordnet.
local           ( n1..nn LOCAL liste| -- ) (C) ( -- sys: ptr 9 ) F6
                ( LOCAL buchstabe -- n1 )(C)( -- )               F6
        Definition:
                Eine mit jedem Forth-System v„llig konfliktfreie Form von bis zu
                26 mit einem einzelnen Buchstaben bezeichneten Localen Variablen
                je Colon-Definition. Sie werden angelegt durch z.B.
                        : name .. LOCAL abcd| ...
                f‡r einfache Integer, oder
                        : name .. LOCAL ABCD| ...
                f‡r Doppelte. Gemischte Schreibweise gilt als Kleinschreibung.
                Bei der Deklaration muœ die Buchstaben-Liste mit einem "|" abge-
                schlossen werden, widrigenfalls k„nnen unkontrollierbare Fehler
                auftreten. Mehrere Listen im selben Wort sind nicht zul€ssig.
                Zwischen den Buchstaben und vor dem "|" k„nnen Leerzeichen ste-
                hen, sofern nur die Definition in derselben Zeile endet.
                Die Deklaration kann an beliebigem Ort erfolgen, es ist v„llig
                belanglos, welche Operationen m„glicherweise davor in den Stacks
                oder sonstwo im System vorgenommen wurden. Allein zum ordnungs-
                gem€œen Compilieren d‡rfen in der Compilephase keine hierdurch
                hinterlassenen Daten im Stack vorhanden sein, da diese Tatsache
                als Hinweis zum Compilieren eines Leseaufrufs ausgewertet wird,
                und, weil die Deklaration selbst Steuerdaten zum Compilieren der
                Bereichsfreigabe am Wortende im Stack hinterl€œt. Man ordnet die
                Deklaration also an einer Stelle an, wo bis zum Wortende keine
                §berschneidung mit einer IF-ENDIF-Struktur oder einer Schleife
                vorkommt; weiterer Vorkehrungen bedarf es nicht. Bedingtes Ein-
                richten ist wegen der Art der Freigabe problematisch, es wird
                darum durch diese einzige Beschr€nkung (weitgehend) unterbunden.
                In gewisser Weise bedingt ist es jedoch problemlos nach dem
                hier beschriebenen Muster m„glich, wenn sich evtl. vorzeitig zu
                verlassende Aufrufteile vor der Deklaration abspalten lassen.
                Danach eingerichtete Locale Variable gelten nur im verbleibenden
                Teil des Wortes, und sie werden immer ordentlich aufgel„st, da
                dann das {;} am Schluœ stets regul€r erreicht wird.
                        : name .. .. IF .. LOCAL a| ..
                ist zur Deklaration ungeeignet (es wird ein fehlerhafter Lese-
                aufruf erzeugt), dagegen ist sie in der Form
                        : name .. -EXIT .. IF .. ENDIF .. LOCAL a| ..
                an BELIEBIGER Stelle zul€ssig; d.h. sie muœ auœerhalb jeglicher
                in Forth-Worten abgefaœter Sprungstruktur stehen.
        Ausf‡hrung:
                F‡r die Ausf‡hrung gibt es weder Einschr€nkungen noch Abweichun-
                gen gegen‡ber gew„hnlichen Constanten und bei Adressierung mit
                Hilfe des Wortes {-loc} auch nicht gegen‡ber Variablen. So wer-
                den insbes. weder DO-LOOP-Konstruktionen noch irgendwelche Ope-
                rationen in beiden(!) Stacks beeinfluœt. Gerade diese Eigenheit
                kann innerhalb von Schleifen zu enormem Zeitgewinn f‡hren, der
                die weiter unten beschriebene und zun€chst eher umst€ndlich an-
                mutende Initiierungsweise mehr als nur rechtfertigt.
                Die Parameter werden vom t.o.s. angefangen den Localen Variab-
                len in Reihenfolge ihrer Deklaration zugewiesen:
                        : test local abc| local a . local b . local c . ;
                        1 2 3  3 ndup  . . .  test
                schreibt
                        3 2 1 3 2 1
                Neben den eigenen Local-Posten sind auch die Localen Variablen
                ‡bergeordneter Worte erreichbar. Sie werden um die Anzahl eige-
                ner Indices erh„ht adressiert, wodurch sich mit u.U. groœem
                Laufzeitgewinn locale Parameterbl„cke an untergeordnete Aufrufe
                weitergeben lassen. Stehen beim Compilieren nicht schon irgend-
                welche Compilerdaten im Stack, muœ das betr. Wort wenigstens
                durch eine leere Deklaration pr€pariert werden:
                        : name ... IF ... local A ...
                        : name [ 0 ] ... local A ... ... [ drop ] ;
                erzeugen Leseaufrufe. Stets sicher, aber weniger schnell in der
                Ausf‡hrung, schreibt man
                        : name ... LOCAL | ... IF ...
                Anwendungsbeispiele in den Label-Sortierfunktionen "f6z80_scr".
        Installation:
                Grundlage bilden einem Wort durch die Local-Deklaration in un-
                gebrochener Reihenfolge zugewiesene geschlossene Speicherbl„cke.
                Die Localen Variablen sind lediglich eine spezialisierte Form
                dieser Zuweisung, erg€nzt um besondere Hilfsfunktionen. Darum,
                und wegen der Lage in einem Bereich, wo sie mit anderen System-
                erfordernissen nicht kollidieren, k„nnen s€mtliche Operationen,
                die etwa an einem mit {allot} reservierten Ort zul€ssig sind,
                auch 'local' vorgenommen werden. Alleinige Einschr€nkung ist
                deren Localit€t. Jede fixe Verkettung mit dem umgebenden System
                verbietet sich daher, alles andere ist frei nutzbar.
                Die localen Daten werden "oberhalb" des Stacks eingeordnet und
                dort vor dem System in einer ausnahmlos mit allen Forth-Opera-
                tionen vertr€glichen Form verborgen. Dazu wird der Datenstack
                mit jeder {local}-Deklaration um die entsprechende Anzahl Pos-
                ten in Richtung niedrigerer Adressen verlagert. Die user-Vari
                {s0} ‡bernimmt die neue Adresse f‡r den Stackanfang und bleibt
                damit weiterhin Ptr f‡r den leeren Datenstack, ist zugleich nun
                aber auch Basis des {local}-Bereichs im betr. Wort.  hnlich den
                vom SBasic des QL her bekannten Localen Variablen k„nnen sie
                darum auch hier an untergeordnete Worte weitergereicht werden.
                Zuweisung und Freigabe werden mit Hilfe der in das Wort hinein-
                compilierten Festwerte verwaltet, sodaœ keine zus€tzlich ord-
                nenden Daten n„tig sind; dies erm„glicht die Geschlossenheit des
                {local}-Bereichs und formatfreie mit z.B. den {user}-Variablen
                consistente durchgehende Adressierbarkeit aller {local}-Posten.
                Damit er„ffnet sich die sonst in Forth-Systemen unbekannte und
                nur mit hohem Aufwand nachzusetzende M„glichkeit der §bergabe
                von (localen) Parametern unabh€ngig von der Stackverwendung und
                in gleichbleibender Form an die verschiedensten Unteraufrufe.
                Bestes Beispiel sind die Label-Definitionen des F6-Assemblers,
                wo dank geeigneter - und wenig komplizierter - Schutzvorkehrun-
                gen dort selbst tempor€re Forth-Worte angelegt werden k„nnen.
        Anwendung:
                Zum Reservieren rsp. Freigeben localen Speichers sind die Worte
                {ini-loc} und {end-loc} im hidden-Vocabular vorhanden - s.dort.
                Diese m‡ssen insbes. bei vorzeitigem Verlassen eines Wortes mit
                {;s} etc. zur Bereichsfreigabe aufgerufen werden:
                        : name .. LOCAL ab| ..
                               .. IF .. [ 4 ] end-loc ;s ENDIF ..
                               .. restliche Worte ..    ;
                Die Vorteile der besonderen Installationsform im F6 erlauben
                €uœerst vielf€ltigen Einatz von Local-Posten:
                        : name LOCAL abcd| .. local A local a local b d= ..
                erzeugt den Flagwert 1, da doppeltgenaue Posten auch in ein-
                facher Gr„œe gelesen werden k„nnen, und umgekehrt. Identisch:
                        : name LOCAL AB| .. -loc A 2@ -loc a @ -loc b @ d= ..
                {-loc} liefert den einer {variable}n entsprechenden 4th-ptr.
                Sollen einzelne Zellen von Doppelposten gelesen werden, ist
                daf‡r der Index zu verdoppeln; die z.B. in C abgelegten zwei
                einfachen Integer liest man mit { local e } und { local f }.
                Da die Variablen in einem kontinuierlichen Speicherbereich
                angelegt werden, kann dort ohne weiteres auch mit Strings oder
                Flieœkommazahlen gearbeitet werden. Entsprechende Platzreser-
                vierung ist erforderlich und auch ohne Parameter u.a. dadurch
                m„glich, daœ das Wort selbst vor der Deklaration die n„tigen
                Platzhalter liefert:
                        : name ..worte.. 0. 0. 0. local ABC| ..
                ‡bernimmt vom Datenstack nur die im Wort enthaltenen Zahlen.
                FP-Zahlen lassen sich z.B. eintragen und lesen:
                        : name                          also fp
                                pi 180 local ABC|
                                -loc a @
                                -loc d @        *
                                -loc a !                previous ;
                Es ist bei beliebigem Datenformat lediglich darauf zu achten,
                daœ eine ausreichende Anzahl Posten im Stack bereitliegt.
                In der Ausf‡hrungsphase sind Aufl„sen und (insbes.) Einrichten
                des localen Bereichs mit merklichem Zeitaufwand verbunden, der
                mit der Anzahl "normaler" Daten im Stack zunimmt - die Anzahl
                evtl. schon vorhandener Loacal-Gruppen bleibt ohne Einfluœ.
                Die zum Lesen ben„tigte Zeit ist mit {constant}en vergleichbar.
                Zugegebenermaœen hat der Autor Locale Variable im 4th schlicht
                f‡r Quatsch gehalten (mit all den "standardgem€œen" Einschr€n-
                kungen sind sie das in der Tat), doch zeigte sich, daœ neben
                dem bequemen Umgang damit die hier eingerichtete Form auœerdem
                zu erheblichem Zeitgewinn f‡hren kann. Damit wird der Einsatz
                Localer Variabler unabh€ngig von allen grunds€tzlichen Erw€gun-
                gen durchaus sinnvoll, besonders, wenn wiederholt umfangreiche
                Stackoperationen erforderlich w€ren, um die Daten zurechtzule-
                gen, oder wo die Lesbarkeit ‡bergeordneter Posten von Nutzen
                ist. Selbst eine so kurze Passage, wie
                   LOCAL ABCD| .. DO .. local D ... LOCAL D .. LOOP ..
                ist bereits schneller, als
                   LOCAL ABCD| .. DO .. local D 2dup .. 2swap .. LOOP ..
                vorausgesetzt, daœ vor der Local-Deklaration nicht allzuviele
                zus€tzliche Datenposten im Stack vorhanden sind.
                §bergeordnete Locale Variable indiziert man mit ihrem Index der
                Deklaration, erh„ht um dem gr„œten Index im eigenen Bereich:
                        : name1 local | ... local A d$. ... ;
                        : name2 $9abc.def0 local A| .. local A d$. local B d$. ..
                        : name3 ... $1234.5678 local A| ... name1 .. name2 .. ;
                womit {name3} hinschreibt:
                        12345678 9abcdef0 12345678
                Die durch den Indexbuchstaben gegebene Adressierungs-Obergrenze
                bei {z} oder {Z} gilt einschlieœlich evtl. eigener Local-Posten.
                F‡r eine nur mit ‡bergeordnetet Localen Werten arbeitende Defi-
                nition wie {name1} ist die zeitraubende Verwaltung des eigenen
                Speicherbereichs (der Gr„œe Null) unn„tig. Mit einem Eingriff
                in den Compiler l€œt sich deren Einbau unterdr‡cken:
                        : name1 ... [ 0 ] .. local A d$. ... [ drop ] ;
                Hier noch ein eher abartiges Beispiel, um auf die Folgen mehr-
                facher Eintragung gleicher Indices aufmerksam zu machen:
                        : name LOCAL ABCABC| ..
                legt dieselbe Dreiergruppe zweimal ab, deren "obere" Werte dann
                mit den Buchstaben D, E, F adressierbar sind. Es werden jedoch
                stets soviele Posten vom Stack entnommen, wie Local-Posten an-
                gegeben sind, auch bei gleichen Buchstaben. Das obige Beispiel
                erwartet also sechs doppelte Integer im Stack, wovon aber nur
                die oberen drei en bloc dupliziert und als Sechsergruppe dann
                in den Local-Bereich ‡bertragen werden, die restlichen drei
                Posten im Stack werden anschlieœend verworfen. Auf diese Weise
                kann die Local-Deklaration mit einer {drop}-Funktion vereinigt
                werden - was aus Laufzeitgr‡nden wohl weniger zu empfehlen ist.
                Sollte aufgrund eines Fehlers einmal die selbst€tige Freigabe
                versagt haben, l€œt sich der Local-Bereich durch Reinitiierung
                radikal freigeben, entweder mit {cold}
                                safe!           ( ggf. bisherige Worte sch‡tzen
                                cold
                oder direkt aus den Initiierungsdaten
                                28 +origin @ s->d s0 2- 2!
                bei intaktem System entsprechend
                                tib@ s->d s0 2- 2!
             >> Local variables may be defined up to 26 within each colon
                definition by (consecutive) letters, lower case (or mixed) de-
                noting single integer items, upper case for double integers.
                        : name LOCAL abc| .. local a . local A d. ..
                or      : name LOCAL  a b   c d   | ...
                i.e. any number of blanks acceptable if the definition doesnt't
                exceed the input line. The declaration is delimited by a "|"
                char and may not be placed in between of any branching words
                (like IF...ENDIF) or within a loop structure, which otherwise
                would lead to LOCAL compiling a false reading operation.
                Re "FORTH_txt" for a more elaborate description.
loop            ( -- ) (C) ( sys: ptr 3 -- )
losc            ( -- n1 )                               F6
                Kennzahl f‡r einen Zeichensatz - s. {>fount}.
* M
m>r             ( ptr1 n1 -- rp: n1*bytes )             F6
                holt die ggf. geradzahlig aufgerundete Anzahl n1 Bytes aus dem
                Forth-Speicher ab ptr1 in gleicher Anordnung zum Returnstack.
m>s             ( ptr1 n1 -- n1*bytes )                 8.18
                analog {m>r}.
max             ( n1 n2 -- n3 )
message         ( n1 -- )
                Gibt eigene (+n1) und QDOS-Systemmeldungen (-n1) aus.
mem             ( -- un1 )                              H4
                Freier dictionary-Bereich (vorzeichenlose 16-Bit-Zahl).
minerva         ( -- )                                  F6
                Vocabular, kann z.B. die besonderen Arithmetikaufrufe aufnehmen.
                ! Ab Version 8.08 entf€llt dieses - ohnehin leere - Vocabular
                ! wegen der beschriebenen Probleme mit dem GST-Assembler
            >>> ! removed with vers. 8.08 due to GST-assembler problems.
minus           ( n1 -- -n1 )   negation
min             ( n1 n2 -- n3 )
move-mem        ( dadr1 dadr2 +n3 +n4 - dadr5 dadr6 )   F6     (‡berschreibend)
                Blocktransfer im Speicher von dadr1 nach dadr2 einer Anzahl n3
                Bl„cke der L€nge n4, gibt die weitergez€hlten Adressen zur‡ck.
mod             ( n1 n2 -- n3 )
                Divisionsrest
mt-inf          ( -- d1 d2 d3 )                         F6
                d1 Basis der Systemvariablen, d2 QDOS-Version, d3 eigener Job.
m*              ( n1 n2 -- d3 )                         (F6)
m+              ( d1 n2 -- d3 )
                Addiert einfache Integer n2 vorzeichenerweitert zu d1.
m+!             ( n1 ptr2 -- )                          F6
                Addiert einfache Integer n2 vorzeichenerweitert in doppelten
                Posten an der Stelle ptr2.
m/              ( d1 n2 -- n3 n4 )
                Double d1 durch single n2 mit single Rest n3 & Quotient n4.
m/mod           (d1 n2 -- n3 d4 )
                Teilt Doppelte Integer d1 durch einfache Integer n2, gibt
                einfachen Quotienten n3 und doppeltgenauen Rest d4 zur‡ck.
* N
n>r             ( nn n1..nx m1 -- nn | rp: n1..nx )     F6
                Anzahl m1 Posten zum Returnstack ‡bertragen.
name            ( NAME name -- ptr ) (I) (iP)           F6
                Bringt mit <bl> begrenzten String samt 16-Bit-Z€hler nach ptr.
                ptr liegt im Compilezustand beim aktuellen HERE, ist sonst PAD.
ndrop           ( nn n1 .. nx m1 -- nn )                F6
                Anzah m1 Posten vom Stack entfernen oder -m1 Posten zuf‡gen.
ndup            ( nn n1 .. nx m1 -- nn n1 .. nx n1 .. nx ) F6
                Gruppe von +m1 Posten duplizieren, -ve m1 wirkungslos.
new-chan        ( -- c1 | -1 )                          LR
                niedrigste freie F6-Kanalnummer oder -1
nfa             ( pfa -- nfa )
noop            ( -- )
nopdf           ( -- | 0. )                             F6
                Leere {defer}red Definition, f‡hrt {noop} aus, wird durch Auf-
                ruf { default-is nopdf } auf {0.} gestellt. Das Wort dient der
                Vectorisierbarkeit von Assembler-codierten und mit {c-save} zu
                sichernden Codepassagen. Mehr s.u. beim Assembler-Vocabular.
not             ( n1 -- n2 )
                Einercomplement, entspricht der Negation mit anschlieœender Ver-
                minderung um Eins und kann oftmals auch zeitsparend eine solche
                Folge ersetzen. F‡r quad-Integer definiert man z.B.:
                        : qnot qminus -1 qm+ ;  ( q1 -- ~q1 )
nr>             ( nn m1 rp: n1..nx -- nn n1..nx )       F6
                Anzahl m1 Posten vom Returnstack holen
nswap           ( nn n1 n2 .. nx-1 nx nm -- nn nx n2 .. nx-1 n1 ) F6
                Mit m1 bezeichneten und oberen Posten im Stack vertauschen.
number          ( ptr -- d1 | f1 | abort ) (D)          (F6)
                F‡hrt {[number]} aus, bei Fehler anschlieœend {?numerr}.
ni              ( n1 -- n2 )                            H4
                Holt den Schleifenindex der n1-ten n€chst€uœeren DO..LOOP.
* O
offset          ( -- ptr )
                User-Vari, hilfsweise zur Festlegung des aktuellen Screenfile.
off             ( ptr -- )                              F83
                Setzt den Integerposten am Ort ptr auf Null.
ok              ( -- )(D)                               79
                Tastatur-Bereitschaftsmeldung, re-vectorisierbar.
open-link       ( ptr did c1 -- d.er )                  F6
                - s. FOP-LINK -
open            ( ptr n1 c1 -- d.er )                   LR
                Kanal „ffnen mit dem Namen auf ptr, open-Typ n1, ID an F6-Kanal
                c1 ‡bergeben. F‡r den open-Typ gelten die Codes der Qdos-Trap:
                        0       zum Lesen und Schreiben
                        1       nur Lesen, mehrfache Nutzung m„glich
                        2       noch unbekanntes File neu einrichten
                        3       File neu einrichten (nur Minerva, TK2 u.dgl.)
                        4       Directory-File „ffnen (nur TK2 u.dgl.)
                Wenn der Kanal c1 vorher bereits einen offenen Kanal repr€sen-
                tiert, so wird dieser vor der neuen Zuweisung geschlossen.
                Hinweis: {fop-over} ben„tigt die erweiterte open-Codierung des
                TK2 o.dgl. nicht, da es das File durch die Verbindung {delet}
                mit folgendem {fop-new} erst nach L„schen desselben „ffnet.
opt             ( -- ptr )                              F6
                Vari f‡r globale Freigabe und Sperrung der hi-level-Optimierung,
                jeder von Null verschiedene Wert bewirkt Freigabe.
os              ( -- ptr )                              F6
                User-Vari, vorbereitet f‡r die Code-Segmentierung
out-cons        ( -- c1 )                               F6
                F6-Kanalnummer des Standard-Ausgabekanals.
out             ( -- ptr ) User-Vari
                ptr auf Z€hler der in den Standard-Ausgabekanal geschriebenen
                Zeichen, wird durch {cr} auf Null gesetzt, durch {bs} und {del}
                zur‡ckgez€hlt.
over-           ( n1 n2 -- n1 n3 )                      LR
                Zusammenziehung von { over - }, liefert n3 = n2 - n1
over            ( n1 n2 -- n1 n2 n1 )
on              ( ptr -- )                              (F83)
                Setzt den Integerposten am Ort ptr auf 1.
or              ( n1 n2 -- n3 )
                Bitweise OR
or!             ( n1 ptr -- )                           F6
                or-Verkn‡pfung n1 mit dem Speicherinhalt bei ptr.
* P
pad             ( -- ptr )
perform         ( ptr -- exec )                         F6/F79+
                ptr zeigt auf eine cfa, die durch {perform} ausf‡hrt wird.
pfa             ( nfa -- pfa )
pick-4th        ( -- )                                  F6
                aufrufenden F6-Job aktivieren - PIF erforderlich.
pick            ( nn n1 .. nx m1 -- nn n1 .. nx n1 )    F79
                Copiert den m1-ten Posten zum t.o.s., ab Null z€hlend.
prev            ( -- ptr )
prompt          ( c1 -- )                               F6
                emit in den {in-cons}-Kanal, sofern {(prompt)} =/= 0 ist. Ist c1
                nicht offen, geht die Ausgabe in das Ur-Fenster vom Job-Start.
* Q
q#              ( uq1 -- uq2 )                          F6
                Niederwertige Ziffer aus uq1 dem im Aufbau befindlichen Zahlen-
                string bei {hld} voranstellen, Rest als uq2 im Stack. Diese
                quad-Operation entspricht dem standardm€œigen "sharp", als zeit-
                bestimmender elementarer Aufruf zur Bildung eines Zahlenstring
                im Kern definiert; die restlichen Worte k„nnen mit { l-load q. }
                aus "forth_scr" geladen werden.
q+-             ( q1 n1 -- q2 )                         F6
                Vorzeichen von n2 auf q1 anwenden
q<              ( q1 -- flg )                           F6
qu<             ( q1 -- flg )                           F6
q0=             ( q1 -- flg )                           F6
q0<             ( q1 -- flg )                           F6
q>f             ( q1 -- f1 )                            F6
qabs            ( q1 -- q2 )                            F6
                Betrag von q1 bilden, die "negative Null" geht als 0 zur‡ck.
q->d            ( q1 -- d1 | abort )                    F6
                kann z.B. definiert werden
                        : q->d 1abs swap 1abs or -18 ?error ;
q->s            ( q1 -- n1 | abort )                    F6
                kann z.B. definiert werden
                        : q->s q->d d->s ;
qdos            Vocabular                               F6
qm/mod          ( +q1 d2 -- q3 d4 )                     F6
                quad q1 durch double d2, liefert quad Rest q3, double Quotient
                d4. Die Ergebnisse sind "floored", werden nach negativ unendlich
                gerundet, wobei f‡r die Rechnung gilt:
                dividend   /  divisor   =   quotient * divisor + rest
                +ve             +ve             +ve             +ve
                +ve             -ve             -ve             -ve floor
                -ve             -ve             +ve             -ve
                -ve             +ve             -ve             +ve floor
                Bei negativem Quotienten entstehen durch die Rundung nach nega-
                tiv Unendlich f‡r den Rest gegen‡ber der 'normalen' Rechenweise
                ungewohnte Resultate, die ggf. sich an ein paar Beispielen zu
                veranschaulichen empfohlen wird.
qminus          ( q1 -- -q1 ) negation                  F6
qm+             ( q1 n2 -- q3 )                         F6
                Addition n2 vorzeichenbehaftet zu q1.
qs*             ( q1 n1 -- q2 )                         F6
                quad mit single multiplizieren.
                Basisaufruf zur Umwandlung von Ziffernstrings in quad-Zahlen.
quad            (I) ( -- )                              F6
                Veranlaœt, daœ die n€chste Zahl im quad-Typen geholt rsp. com-
                piliert wird. Dies ist unabh€ngig von einer Dezimalmarke und
                gilt nur f‡r die n€chste in Eingabestrom gelesene Zahl. Wurde
                eine der elementaren Proceduren zur Umwandlung von Strings in
                Zahlen aufgerufen, muœ dieser Zustand explizit durch {no-quad}
                abgeschaltet werden, im Standardaufruf {[convert]} geschieht
                dies automatisch mit Ausf‡hrung der {qlit}-Runtime.
                Schreibt man z.B.
                        quad 1000 10 qs*
                entsteht die quad-Zahl
                             10000
                die Deklaration wirkt sich also nur auf die erste Zahl aus.
                Da der Wert f‡r {dpl} in keinem Falle gr„œer als 64 werden
                kann, wurden neben der Angabe der (Dezimal-)Bruchmarkierung in
                den niederwertigen 8 Bits s€mtlich gesetzte Bits des h„herwerti-
                gen Byte bei stets ungesetztem Bit 7 als quad-Signal gew€hlt.
                {dpl@} kann daf‡r dann Werte von $ff00 bis $ff40 annehmen, die
                von den anderen M„glichkeiten unterscheidbar sind:
                  | dpl@ range: $ff00 $ff41 $ff7f #-2 #-1 #0 33 ;
                        1 CASE? ." quad "    ELSE
                        3 CASE? ." quad ohne punkt & komma " ELSE
                        4 CASE? ." fp-Zahl " ELSE
                        5 CASE? ." Integer " ELSE
                        6 CASE? ." double  " ELSE
                          drop  ." M‡ll "    ENDIF ENDIF ENDIF ENDIF ENDIF  |
query           ( n1 -- )(D)
                Text aus der Standardeingabe bis <enter> oder max Anzahl n1
                nach t.i.b. holen, unmittelbar danach Anzahl Zeichen in {span}.
                Fehleraktion ist {(exper)} wie f‡r {expect}, s.dort.
quit            ( -- )
                Der €uœere Interpreter - sicherer R‡ckkehrpunkt bei Fehlern.
qxl             (D) ( -- flg )                          8.18
qxl?            ( --  tf | ff )                         8.18
                Vorgabe-Aktion von QXL, Flag = 1 in QXL/SMS-Systemen.
q+              ( q1 q2 -- q3 )                         F6
q-              ( q1 q2 -- q3 )                         F6
q=              ( q1 q2 -- flg )                        F6
* R
r               ( -- n1 ) ( -- f1 )
                Copie des j‡ngsten Posten im Returnstack zum Datenstack.
                Im Forth-Vocabular ist {r} immediate und optimierend.
r/w             ( ptr n1 flg -- )
                bei flg = 0 Anzahl {b/buf} Bytes des Blocks Nummer n1 von ptr
                zum Screenfile schreiben, sonst lesen; eof ist kein Fehler.
r>m             ( ptr m1 rp: nn n1 .. nx -- rp: nn )    F6
                Anzahl m1 Bytes aus dem Returnstack in den Speicher nach ptr
                ‡bertragen, geradzahlig aufgerundete Anzahl vom Returnstack
                entfernen.
range:          ( RANGE: n1 n2 ... nn ; )               F6(!)
                ( RANGE: name n1 n2 ... nn ;
                ( nx RANGE: n1 n2 .. nn ; -- index(nm) mit nm <= nx < nm+1 )
                Definition und Aufrufformen wie {associative:}.
                Aufruf liefert den Listenindex der Position der Zahl, die klei-
                ner oder gleich der ‡bergebenen Zahl ist, sofern die n€chste
                Zahl der Liste wenigstens um eins gr„œer ist als jene, oder
                kein weiterer Listenposten folgt. Liegt die Zahl unterhalb des
                niedrigsten Listenposten, geht Null zur‡ck, regul€re Indices
                z€hlen ab eins:
                        range: rtab 10 20 30 40 ;
                        9    rtab  ( => 0
                        10   rtab  ( => 1
                        39   rtab  ( => 3
                        1234 rtab  ( => 4
             >> executes much the like associative, giving the index of the
                range from the number below or equal to the parameter passed
                till the next higer list item which at least is one greater:
                        index(nn) where lower bound <= nn < next bound
                Returns zero on underflow, and the number of items on ovf.
rdrop           (I) ( -- rp: n1 n2 -- rp: n1 )          F6 & 8.18
                Einen Posten vom Returnstack entfernen.
                { rdrop rdrop } optimierend zum headerlosen Wort {2rdrop}.
recurse         ( -- ) (C)                              (F6)
                Selbstaufruf des in Definition befindlichen Wortes. Compiliert
                zur Sicherheit noch ein {?stack} vor die eigentliche Recursion.
                Ist dies entbehrlich, kann die Recursion leicht auch "von Hand"
                compiliert werden:
                        ... [ latest pfa cfa , ] ...
repeat          ( -- ) (C) ( sys: ptr 1 -- )
roll            ( nn n1 .. nx +m1 -- nn n1+1 .. nx n1 ) - auch fp, dabei m1
                ( nn n1 .. nx -m1 -- nn nx n1 .. nx-1 ) - immer als integer!
                m1-ten posten im Stack zum t.o.s. und alle Posten bis dahin
                eins hochlegen, bei m1 < 0 umgekehrt; Gesamtanzahl unver€ndert.
                VORSICHT bei FP: Der Posten m1 muœ stets als Integer angegeben
                werden, im FP-Format kann es wegen Interpretation des Exponenten
                als Z€hler durch Bereichs‡berschreitung zu ‡blen Fehlern kommen.
root            ( -- )                                  F83
                Vocabular, enth€lt nur das Minimum an Worten, das vorhanden
                sein muœ, um das System in Betrieb zu nehmen. Neue Definitionen
                sollten hier nur sparsam und ‡berlegt eingef‡gt werden. Zum ei-
                nen ist {root} quasi der Schl‡ssel zum System, zum andern wird
                es bei erfolgloser Wortsuche zum Schluœ unabh€ngig von der ein-
                gestellten Vocabularordnung immer auch durchsucht. Die im Kern
                vorhandenen 17 Worte fallen nicht merklich ins Gewicht, werden
                aber viele weitere Worte aufgenommen, kann sich die Compilezeit
                deutlich erh„hen.
rot             ( n1 n2 n3 -- n2 n3 n1 ) ( f1 f2 f3 -- f2 f3 f1 )
row             ( -- ptr )                              F6
                User-Vari, Zeilenz€hler bei der Ausgabe
rp!             ( -- )
                Returnstack mit dem Inhalt von {r0} re-initiieren.
rp@             ( -- ptr )
                Forth-Adresse des Returnstack-Ptr.
r#              ( -- ptr )
                User-Vari, im Editor Cursorposition in der aktuellen Screen.
r+              ( rp: ptr1 -- n1 rp: ptr2 )             F6
                Holt den Integerwert der Stelle, auf die der ptr im Returnstack
                zeigt und z€hlt ihn zwei Bytes weiter. Ersetzt:
                        r> dup 2+ >r @
                Hiermit lassen sich Rahmenaufrufe zusammenstellen, hinter denen
                eine Parameterliste compiliert wird, die dann unterschiedliche
                Aktionen innerhalb dieses Rahmens erm„glicht.
                Einige Anwendungen finden sich z.B. bei PRINTER in "forth_scr".
                Aufrufe eines ein {r+} enthaltenden Wortes d‡rfen d‡rfen NICHT
                mit aktiviertem DEBUGGER compiliert werden. Zumindest f‡r den
                Aufruf selbst und die mit ihm zu ‡bergebenden Daten, die durch
                {r+} gelesen werden sollen, muœ {db-on} auf Null gestellt sein.
r0              ( -- ptr )
                User-Vari, Initiierungswert f‡r den Returnstackptr.
r>              ( rp: nn n1 -- n1 rp: nn ) ( rp: nn f1 -- f1 rp: nn )
* S
s->d            ( n1 -- d2 )
                vorzeichenbehaftete Erweiterung
s->q            ( n1 -- q1 )                            nicht vorhanden
                kann leicht gebildet werden aus
                        ( n1 )  s->d ddup  ( q1 )
s-load          ( +n1 S-LOAD filename -- ) (P)          F6
                ( +n1 S-LOAD -- )
                Laden ab Screen n1, n1 > 0, des Screenfile {filename}.
                Das File wird zum mehrfach-Zugriff nur lesend ge„ffnet und bei
                ordentlichem Abschluœ geschlossen. Die zweite Variante (ohne
                Filenamen) arbeitet mit dem zuvor benutzten Screenfile, oder
                einem anderen nach (boot) gebrachten Namen. Dies kann zu einer
                der TK2-Devicevorgabe €hnlichen Namensvorgabe benutzt werden:
                        ftest flp1_f6asm_scr
                        dup if-true drop ftest flp2_f6asm_scr
                        dup 0= if-true drop (boot) f/n pad !name 1 s-load
                        dup if-true message ;s
                        drop
                Sind diese Zeilen z.B. in scr 1 eines Screenfile eingetragen,
                wird der F6-Assembler entweder von flp1 oder von flp2 geladen.
                War nicht zu finden, bricht das Laden mit Fehlermeldung ab.
            HINWEIS: Falls es Fehler in SMSQ/QXL beim Laden von "win" gibt,
                helfen evtl die bei L-LOAD genannten Maœnahmen.
s>f             ( n1 -- f1 )                            F6
                Einfache Integer n1 nach fp-Zahl f1
s>m             ( ..nn n1..nx ptr mx -- ..nn )          8.18
                Anzahl mx Bytes vom Stack nach ptr ‡bertragen, anschlieœend
                Stackptr ggf. geradzahlig aufgerundet justieren.
safe!           ( -- )                                  F6
                lfa des Wortes am Dictionary-Ende in Fence eintragen, womit
                der gesamte aktuelle Systemaufbau gegen Verlust durch {cold}
                oder {forget} gesichert ist.
scan            ( ptr1 n1 c1 -- ptr2 n2 )               F83
                n1 Bytes langen Text ab ptr1 nach Zeichen c1 absuchen und die
                erste Position ptr2 sowie verbleibende L€nge n2 zur‡ckgeben,
                an der das Zeichen c1 gefunden wurde. Das n€chste Vorkommen
                desselben Zeichens findet mann dann z.B. mit
                        $ffff.0001 d+ ( c1 ) scan
                worin die double-Addition eine verk‡rtzte Form der Sequenz zum
                Weiterr‡cken auf das n€chste Zeichen darstellt:
                        swap 1+ swap 1-
                Die zweite Stelle, die mit einem Zeichen ( c1 ) beginnt, findet
                man dagegen z.B. mit
                        ( ptr1 n1 c1 ) >rr scan r skip r> scan
screen          ( -- c1 )                               F6
                Standard-Kanalnummer f‡r (das erste) Screenfile.
scr             ( -- ptr )
                User-Vari, lfd. Screenfile-Seite
sdrop           ( n1 n2 -- n2 )                         F6
                F83/ANS auch: nip (oder schluck oder babybrei...)
sdup            ( n1 n2 -- n2 n1 n1 )                   F6
set-baud        ( n1 -- n2 )                            F6
                Setzt die Baud-Rate auf n1 und gibt den bis dahin g‡ltigen
                Wert in n2 zur‡ck, oder nur letzteres bei n1 = -1.
set-cal         ( -- )                                  F6
                Systemeigenen Zeit-Z€hler (20ms je Einheit) calibrieren.
set-chan        ( did c1 -- )                           F6
                F6-Kanal c1 mit QDOS-ID did besetzen
set-work        ( did -- )                              F6
                {work}-Kanal mit did  besetzen
sgn             ( n1 -- -1 | 0 | 1 ) ( f1 -- flg )
shift           ( n1 n2 -- n3 n4 )                      (F6)
                n1 um Anzahl +n2 Bits nach links schieben, rsp -n2 Bits nach
                rechts. Resultat in n3 und aus n1 ‡berlaufende Bits in n4;
                auch als vorzeichenlose Multiplikation mit einer Zweierpotenz
                bei Formaterweiterung single nach double interpretierbar.
                Beim Linksschieben kann ( n3 n4 ) als ( dn3 ) als doppeltge-
                naues Ergebnis der vorzeichenlosen Multiplikation der einfachen
                Integer n1 mit der n2-ten Zweierpotenz interpretiert werden.
                Ist n1 mit 1 angegeben, liefert {shift} die Zweierpotenz:
                        : d2^ 1 swap shift ;    ( n1 -- dn2 ( dn2 := 2^n1
sign            ( n1 d2 -- d2 )
                stellt das Vorzeichen entsprechend dem Wert n1 an den Anfang
                des gerade im Aufbau begriffenen Zifferstrings der Zahl d2;
                wird zwischen <# und #> benutzt. Der ausgewertete Integerposten
                n1 wird unabh€ngig vom bearbeiteten Zahlentyp der dritten Stel-
                le im Stack entnommen und entfernt. Die entsprechende hi-level-
                Definition lautet:
                        : sign rot 0< IF {- hold ENDIF ;
                {sign} ist darum auch f‡r quad-Zahlen geeignet, sofern nur der
                Flagposten davor an die richtige Stelle gebracht wurde:
                        >rr qabs <q# ... r> -rot sign ... q#>
skip            ( ptr1 n1 c1 -- ptr2 n2 )               F83
                n1 Bytes langen Text ab ptr1 nach Zeichen c1 absuchen und die
                erste Position ptr2 sowie verbleibende L€nge n2 zur‡ckgeben,
                an der das gefundene Zeichen vom Code c1 abweicht - s. {scan}.
sltext          ( c1 -- ) (D)                           F6
                Holt einen mit dem Zeichen c1 begrenzten Text nach {pad}.
                Hilfsweise f‡r S-LOAD - und damit auch L-LOAD, um die Re-
                Vectorisierung f‡r letztgenannten Aufruf zu erm„glichen.
                Initial mit {\name} besetzt.
smudge          ( -- )
                Freigabezustand der j‡ngsten Definition im current-Vocabular
                umschalten. Nach {create} erforderlich, wenn das Wort auffind-
                bar (und ausf‡hrbar) gemacht werden soll, oder z.B. bei Fehler-
                abbruch w€hrend des Compilierens, um {forget} auf das j‡ngste,
                wegen des Fehlers unvollst€ndige Wort anwenden zu k„nnen.
source          ( -- ptr n1 )                           F83 & 8.18
                Ort und verf‡gbare L€nge der aktuell geltenden Eingabe. ptr
                ist t.i.b. bei direkter Eingabe (blk null), ein Blockpuffer im
                Lade-Zustand, rsp die Werte aus {acp} und {acl} bei blk = -1.
sover           ( n1 n2 -- n2 n1 n2 )                   F6
                F83/ANS auch: tuck (doppelt wird dann bonni's ranch daraus(?)
spaces          ( n1 -- )
                Anzahl n1 <bl>s in das Ausgabefenster schreiben.
space           ( -- )
                Ein <bl> in das Ausgabefenster schreiben.
span            ( -- ptr )                              F79/F83
                User-Vari, hat die L€nge des j‡ngsten von {expect} oder {query}
                aufgenommenen String.
sp!             ( -- )
                Datenstack auf den wert aus {s0} re-initiieren.
sp@             ( -- ptr )
                aktueller Stackpointer.
stack           ( STACK abc|aabbcc )( n1 n2 n3 -- n1 n1 n2 n2 n3 n3 ) F6 & FIF
                ( STACK ABC|CBAABC )( d1 d2 d3 -- d3 d2 d1 d1 d2 d3 )
                Anwendung in "f6chg_txt" ausf‡hrlich beschrieben, hier kurz:
                Universeller Stackoperator f‡r mit kleinen Buchstaben bezeich-
                nete einfache oder mit Groœbuchstaben bezeichnete doppelte
                Integerposten; gemischte Listen gelten wie Kleingeschriebene.
                Die Posten werden in der vor dem "|" angegebenen Reihenfolge
                und Position (der letztgenannte Buchstabe entspricht dem t.o.s)
                dem Stack entnommen und in der danach angegebenen Folge dort
                wieder abgelegt. Die Darstellung entspricht damit genau der in
                der Beschreibung von Forth-Worten (diesem Text) ‡blichen Form.
                Bis zu 26 verschiedene Posten k„nnen benannt werden, die Listen
                d‡rfen insgesamt 62 Posten enthalten. Dient allein der besseren
                §bersicht, konventionell hingeschriebene Stackoperationen werden
                mit wenigen Ausnahmen stets schneller abgearbeitet.
stack:          ( STACK: name srclist|dstlist )         F6 (FIF)
                Frei definierbarer Stackoperator nach dem Muster von {stack},
                mit dem innerhalb der dort genannten Grenzen jede beliebige
                Ablage-Ordnung als besonderer Operator definiert werden kann.
                Z.B., in bestem F83-Stil,
                        stack: nuck abc|cac
                wonach {nuck} dann die F83-Sequenz { nip tuck } ausf‡hrt, rsp.
                in Standard-Worten { swap drop swap over }.
state@          ( -- flg )                              F6
                Inhalt der Variablen {state}
state           ( -- ptr )                              (F6)
                User-Vari, bestimmt den Systemzustand compilierend oder
                interpretierend, im F6 auœerdem den fl‡chtigen compilieren-
                den Zustand zwischen "|"-Zeichen bei der direkten Eingabe.
stk>loc         ( n1 ... nn -- ) ( sys: -- ptr 9 )      F6S
                Auœerordentlich schnell ausgef‡hrte Altternative zum Einrichten
                Localer Variabler bei §bergabe s€mtlicher Daten vom Stack in
                den Local-Bereich.
swap            ( n1 n2 -- n2 n1 )
sysflg          ( -- d1 )                               F6 AQ QX
                Die Zahl d1 liefert in 4 Bytes einige System-Angaben:
                msw msbyte      -1 bei Processoren ab 68010, sonst 0
                    lsbyte      -2 SMSQ, -1 Atari-QL, 1 QDOS vor JS, 0 sonst
                lsw msbyte      Nationalit€ten-Kennbuchstabe des QDOS
                    lsbyte      -1 Minerva-System, 0 sonst
                Auœerdem lassen sich mit Hilfe von {qsys+} einige Eigenheiten
                j‡ngerer qdos-Abk„mmlinge ermitteln, u.a.:
                    $a1 qsys+ c@l mit dem Processortypen
                       $0x       68000
                        1x       68010
                        2x       68020
                        3x       68030
                        4x       68040
                     $a7 csys+ c@l gibt Bildschirm- und Rechnertypen an:
                       %xxxxxxx1 Atari mit Blitter oder QL mit Hermes
                        001xxxxx Atari Monochrom
                        010xxxxx Atari E-4 Emulator
                        100xxxxx QVME Emulator-Karte
                        110xxxxx VGA-Bildschirm
                        xxx0000x Atari-ST
                        xxx0001x Atari-ST mit Uhr
                        xxx0011x Atari STE
                        xxx0100x Mega STE
                        xxx0101x GoldCard
                        xxx0110x Super-GC
                        xxx1100x Atari TT
                        xxx1110x QXL
s#              ( -- ) (P)                              F6
                Erwartet die mit <bl> oder <enter> begrenzte Eingabe einer Zahl.
s*              ( d1 n2 -- d3 | ovf )                   F6
s0              ( -- ptr )
                User-Vari mit dem Initiierungswert f‡r den Datenstackptr.
                Zugleich ggf. Basis der Localen Variablen.
s@              ( c1 -- ) (P)                           H4
                Erwartet einen mit dem Zeichen c1 oder <enter> begrenzten
                String und bringt ihn mit Byte-Count nach {pad}.
* T
task            ( -- )
                Leeres Wort, Colondefinition, markiert das Ende des F6-Kerns.
text            ( c1 -- ptr ) (I) (iP)                  f.i.g.-Editor
                Holt einen mit dem Zeichen c1 oder <enter> begrenzten String
                und gibt die Adresse seines Count-Word zur‡ck. In direkter
                Eingabe wird daf‡r {pad} benutzt, sonst der Bereich ab {here}.
ti-cal          ( -- d1 )                               F6
                gibt den Kalibrierungswert des F6-Zeitz€hlers zur‡ck. Dieser
                entspricht der Anzahl Durchg€nge einer im F6-System verankerten
                Z€hlroutine innerhalb 50 20ms-Intervallen. Sie ist so aufgebaut,
                daœ der Processor ggf. nicht in den "loop"-Modus geht, l€œt aber
                die evtl. vorhandene Cache-Speicherung unber‡hrt und unbeachtet.
                Die unterschiedliche Ausf‡hrungstaktung der 68008- gegen‡ber den
                anderen Processorvarianten ist bereits ber‡cksichtigt, die beim
                Atari-QL m„glichen besonderen Interruptintervalle jedoch nicht.
                Das Ergebnis ist die effektive Rechnertaktung/sec/10, die Zahl
                dient der Synchronisierung zeitabh€ngiger Vorg€nge; wieweit die
                Taktung tats€chlich damit ‡bereinstimmt, hat demgegen‡ber keine
                sonderliche Bedeutung, dieser Wert soll lediglich einen qualita-
                tiven §berblick geben. Wegen der Vorg€nge beim Jobaufbau des
                SMSQ/E wird die Startmeldung um eine Sekunde verz„gert, damit
                sofort der wirkliche Wert zur Verf‡gung steht.
                Die Anzeige erscheint mit folgenden Faktoren in MHz umgerechnet:
                        ti-cal ( dn ) d* ( - zyklen/sek )
                1.      18.     Standard-QL
                                bei Werten, die nach 3. unter 8 MHz liegen.
                2.       8.     Atari-QL mit 68000, QXL und ab 68010,
                                alle, wo Pos. 3 einen Wert ab 23 MHz erg€be.
                3.      10.     Gold-Card-QL
                                bei Werten ab 8 MHz bis < 23 MHz.
tib             ( -- ptr )
                User-Vari, enth€lt den ptr zum "terminal input buffer" - t.i.b.
                Nicht zu verwechseln mit tib des F83 etc. - s. Vergleichsliste.
tib-max         ( -- n1 )                               F6
                Maximal im t.i.b. erlaubte Eingabel€nge. Wird nach der ersten
                Eingabe auf 171 reduziert, kann bei Beachtung der Grenze von
                1080 Bytes f‡r den gemeinsamen Bereich von Returnstack und
                t.i.b. erh„ht werden durch
                        ( zahl ) ' tib-max 2+ !
                Oder einmalig f‡r die unmittelbar folgende Eingabe (und damit
                nur im Programmverlauf nutzbar):
                        ( zahl ) is tib-max
                Jeder 4th-Aufruf belegt im Returnstack 2 Bytes, damit ist im
                allgemeinen, insbes. zu Testzwecken mit dem Debugger, der t.i.b
                risikolos auf das Doppelte, meist auch auf das Vierfache erwei-
                terbar, was die Eingabe sehr langer Testsequenzen erm„glicht.
tib@            ( -- ptr )                              F6
                Inhalt von {tib}, Anfang des t.i.b.
tick            ( -- d1 )                               F6
                Augenblicklicher Stand des F6-Zeitz€hlers in 20ms-Einheiten.
                Mit einem einfachen allgemeinen Aufrufrahmen l€œt {tick} sich
                sehr gut zur Ermittlung des Zeitbedarfs von Worten verwenden:
                   defer test
                   0. 2variable tnul
                   : ti-test !csp tick 2>r
                                       1000. DO 1000. DO test csp! LOOP LOOP
                                  tick 2r> d- tnul 2@ d-
                                  2dup 20 s* d. ' test @ 2+ nfa id. ;
                Zuerst den Zeitaufwand f‡r die leere Schleife eintragen:
                   ' noop is test       \ Wort f‡r die Null-Referenz, oder
                   ' task is test       \ um den hi-level-Kopf auszugleichen
                   ti-test  tnul 2+!    \ Leerdurchgang calibrieren
                Dann ein einfaches Beispiel:
                    : t1 2over 2over ;  \ hi-level f‡r {4dup}
                    ' t1 is test
                    ti-test
                    ' 4dup is test
                    ti-test
                Nach dem Durchgang erscheint die Zeit in Mikrosekunden f‡r den
                einzelnen Aufruf und es verbleibt die Anzahl 20ms-Einheiten
                f‡r den gesamten Test im Stack, z.B. f‡r die Ermittlung der
                Zeitdifferenz zweier Tests oder zur Ausgabe mit {time$}. Als
                Ged€chtnisst‡tze wird auœerdem das aufgerufene Wort angezeigt.
tl=             ( dadr1 count1 dadr2 count2 -- flg )    F6
                Stringvergleich mit flg = 0 bei Gleichheit, -1 wenn der String
                bei dadr1 kleiner ist als der bei dadr2, andernfalls 1.
                Beachtung der Schreibweise kann durch Eintragen von -33 in die
                Constante {(upper)} abgeschaltet werden, -1 schaltet sie ein:
                Die Zeichencodes werden mit dem Wert and-verkn‡pft. Da die so
                m„glichen Fehler auœerhalb der 7-Bit-Schriftzeichenbereiche
                liegen, wurde dieses einfache aber schnelle Verfahren gew€hlt.
                Ein Code in {(joker)} gilt f‡r ein Zeichen im Vergleichsstring,
                das immer als gefunden z€hlt, also f‡r den Vergleich nicht von
                Belang ist. Der ggf. in {(wcard)} eingetragene Code repr€sen-
                tiert in gleicher Weise ein Zeichen, das eine ab 1 beliebig
                groœe Gruppe beliebiger Zeichen repr€sentiert (versuchshalber).
                Der im Sinne dieser Angaben "Vergleichsstring" steht bei dadr2.
                        {+ IS (wcard)
                        " 012345678" pad 100 + over 2+ cmove
                        pad 100 + -count " 01+5+8" -count t=
                gibt 0 f‡r Gleichheit beider Strings zur‡ck.
to-chan         ( c1 c2 -- )                            F6
                QDOS-ID des F6-Kanals c1 dem F6-Kanal c2 zuweisen.
to-work         ( c1 -- )                               F6
                QDOS-ID des F6-Kanals c1 dem F6-Kanal {work} zuweisen.
toggle          ( ptr c1 -- )
                mit dem Byte c1 an der Stelle ptr eine eOR-Operation ausf‡hren.
top-nfa         ( ptr -- nfa | 0 )                      F6
                Hilfswort zur Ermittlung der j‡ngsten nfa, die ungeachtet der
                Suchordnung noch im Dictionary-Bereich bis ptr liegt. Liefert
                z.B. in {forget} den Wert f‡r {last}, und wird neben {safe!}
                u.a. auch in {c-save} und {c-load} ben„tigt.
                        fence @ top-nfa id.
                zeigt den Namen des letzten vor {forget} gesch‡tzten Wortes an.
traverse        ( ptr1 n1 -- ptr2 )
                Tastet den Speicher ab ptr1 bis zu einem Byte mit gesetztem
                h„chstwertigem Bit ab. Richtung und Schrittweite werden mit n1
                dadurch bestimmt, daœ dieser Wert vor jedem Schritt zu ptr1
                addiert wird. n1 wird ‡blicherweise mit 1 oder -1 angegeben.
type-l          ( dadr count -- )                       F6
                Gibt den count Bytes langen String ab der wirklichen Speicher-
                adresse dadr im Kanal {out-cons} aus. Es gilt 0 < count < 32K.
type            ( ptr count -- )
                Gibt den count Bytes langen String ab der Forth-Adresse ptr
                im Kanal {out-cons} aus. Es gilt 0 < count < 32K.
t=              ( ptr1 count1 ptr2 count2 -- flg )      F6
                Stringvergleich mit Forth-Adressen, sonst wie {tl=}.
* U
u+              ( dn1 un2 -- dn3 )                      c-load mit "f6a80_4th"
                Integer vorzeichenlos zu Double addieren. Ersetzt z.B.
                        : u+ -compile 0 -compile d+ ;   immediate
u/              ( un1 un2 -- un3 )
u/mod           ( un1 un2 -- un3 un4 )
                Division un1 durch un2 mit Rest un3 und Quotient un4
uc<             ( n1 n2 -- flg )                        F6
                Vorzeichenloser Vergleich nur der jeweils niederwertigen Bytes,
                entspricht z.b.
                        ( n1 n2 ) $00ff.00ff 2and <
ud*/mod         ( d1 d2 d3 -- d4 d5 )                   F6
                Multiplikation d1 mit d2 und Division des vierfachgenauen
                Zwischenergebnisses durch d3 liefert Rest d4 und Quotienten d5.
ud.r            ( ud1 n1 -- )
                Zahl ud1 rechtsb‡ndig in Feld der L€nge n1 schreiben.
udm*            ( ud1 ud2 -- uq3 )                      F6
ud*             ( ud1 ud2 -- ud3 )
ud.             ( ud1 -- )
                Dopeltgenaue vorzeichenlose Zahl ud1 hinschreiben.
uq.             ( uq1 -- )                              F6S
                Vierfachgenaue vorzeichenlose Zahl uq1 hinschreiben.
um/mod          ( ud1 un2 -- un3 un4 )
                Vorzeichenlose Division mit Rest un3.
umax            ( un1 un2 -- un3 )
umin            ( un1 un2 -- un3 )
unsmudge        ( -- )                                  C1
                Wortheader zur Vocabularsuche freigeben; in {;does>} enthalten.
until           ( n1 -- ) (C) ( sys: ptr 1 -- )
                Bedingungen werden in derselben Weise optimiert, wie bei {if}.
update-off      ( -- )                                  F6
                Update-Flag des aktuellen Blocks l„schen.
update          ( -- )
                aktuellen Block markieren, sodaœ er vor dem §berschreiben durch
                einen neuen Block, oder bei {flush}, zur‡ckgeschrieben wird.
uq/mod          ( +q1 d2 -- d3 d4 )                     F6
uqm/mod         ( +q1 ud2 -- ud3 ud4 )                  F6
user            ( -- ptr ) (C) ( nn USER name )        (F6)
                Der Name steht f‡r eine Variablenart, bei der durch Umstellen
                eines Pointers ein ganzer Datensatz ausgetauscht werden kann.
                Dies ist die 4th-eigene Grundlage zum Multitasking, €hnlich,
                wie z.B. auch die Basic-Jobs der Minerva verwaltet werden.
                Dazu sind alle die Systemgestalt bestimmenden Variablen und
                auch einige Aufrufe in diesem Bereich notiert. {up} enth€lt den
                Laufptr in diesen Bereich, und {u0} zeigt auf den Anfang. Neue
                Datenposten werden dort mit {user} reserviert und erhalten Platz
                f‡r eine einfache Integer zugewiesen. Bei gr„œeren Posten z€hlt
                man anschlieœend {up} entsprechend weiter - und beachtet die Be-
                reichsgrenze von 256 Bytes, die vom System nicht ‡berwacht wird!
                nn ist der 16-Bit-Index in den Wertespeicher; bei nn = -1 weist
                das F6-System der neuen Variablen den n€chsten freien Index zu.
                        ' dp @ 2- user dp-l
                macht den Langwort-DP zug€nglich. Alle {user}-Variablen zeigt:
                        also  forth selected wtyp base words
                        also hidden selected wtyp base words
                               root selected wtyp base words previous previous
using           ( USING filename )(I) (iP)              F83 C1 (lmi)
                filename wird zum Laden/Lesen/Schreiben oder Editieren ge„ffnet
                und die Kanal-ID dem F6-Kanal {screen} zugewiesen. Ein vorher
                offener {screen}-Kanal wird ggf automatisch zuerst geschlossen,
                sofern er nicht in einem weiteren F6-Kanal verzeichnet ist:
                        using flp1_fig_scr      besetzt {screen} mit der ID.
                        using flp1_forth_scr    schlieœt "fig_scr" und „ffnet
                                                erst dann den neuen Kanal.
                        screen file to-chan     {screen}-Kanal zugleich {file}.
                        using flp1_fig_scr      {screen} nun ID von "fig_scr",
                                                {file} weiterhin "forth_scr".
use             ( -- ptr )
                Ptr auf den augenblicklich benutzten Blockpuffer
u*              ( un1 un2 -- ud3 )                      F6
u.              ( un1 -- )
                vorzeichenlose Zahl un1 hinschreiben.
u0              ( -- ptr ) User-Vari
                Initiierungswert f‡r den Anfang des aktuellen User-Bereichs.
u<              ( un1 un2 -- flg )
up              ( -- ptr )
                User-Vari, h€lt den Laufindex in den freien User-Bereich.
* V
variable        ( -- ptr ) (C) ( n1 VARIABLE name )
                Variable im f.i.g.-Forth erwarten einen Initiierungswert!
voc-link        ( -- ptr )
                User-Vari, Vocabularverkettung
vocabulary      ( -- ) (C) ( VOCABULARY name )
                wird im f.i.g.-Forth konventionell stets immediate deklariert.
                Mit seinem Aufruf wird das Vocabular {context}, das vorherige
                {context}-Vocabular wird in der Suchfolge eins weitergeschoben,
                wobei das bisherige zweite Vocabular daraus verschwindet. Es
                kann vorher durch {also} an den gesicherten Bereich ‡bergeben
                werden, wo es dann solange bleibt, wie es nicht durch {only}
                zusammen mit allen anderen gel„scht wird, oder es nach einer
                Anzahl {#vocs} Aufrufen von {also} auch dort hinausf€llt.
                Entsprechend dem Vorgehen im f.i.g.-Forth werden Vocabulare im
                F6 wie alle neuen Worte dem CURRENT-Vocabular zugeordnet, sodaœ
                Untervocabulare in beliebiger Schachtelungstiefe gebildet werden
                k„nnen, die nur aus ihrem unmittelbar ‡bergeordneten Vocabular
                heraus zug€nglich sind. Ein Beispiel mit {pif} aus {qdos}:
                        ONLY FORH PIF FORTH
                bricht bei PIF mit Fehlermeldung ab,
                        ONLY FORTH QDOS PIF FORTH
                legt die Suchfolge an
                        FORTH PIF
                Die eingepr€gte secund€re Suchfolge wird unabh€ngig von ihrem
                Freigabemodus initial auf das CURRENT-Vocabular eingestellt.
                Wird ein Vocabular mit {forget} o.€. entfernt, ist anschlieœend
                FORTH das CURRENT-Vocabular. War das Vocabular auch CONTEXT, so
                ist dann das Definitionsvocabular unbestimmt, es muœ bei Bedarf
                neu angegeben werden.
                FP-Untervocabulare ‡bernehmen die fp-Zahlen compilierende Eigen-
                schaft und reichen diese an ihre Untervocabulare weiter. Bei den
                im Screenfile gegebenen {turtle}-Aufrufen wirkt sich zus€tzlich
                eine Sicherheitsfunktion der Untervocabulareigenschaft aus:
                {turtle} als {fp}-Vocabular kann nur danach aufgerufen werden,
                was un‡bersehbar darauf aufmerksam macht, daœ die Graphikaufrufe
                fp-Zahlen in der Stack‡bergabe erfordern, und womit automatisch
                daf‡r Sorge getragen ist, daœ dieses Vocabular auch wirklich ak-
                tiviert wurde.
* W
<with           ( -- ) (C) ( <WITH name -- )            F6(!)
                Eine Erg€nzung, die es erlaubt, gemeinsam mit seiner Bildungs-
                auch die Ausf‡hrungsvorschrift eines Definitionswortes weiter-
                zugeben. Die hierzu notwendigen Systemerg€nzungen k„nnen auch
                als hi-level-Code anderen Forth-Compilern mitgegeben werden.
                Eine Beispielkette dazu findet sich in "forth_scr".
                        : name <WITH cplname ... ;DOES> ... ;
                Darin kann cplname jedes beliebige Wort sein, das einen Namen
                holt und damit einen neuen Wortheader anlegt, egal, ob es die
                Definition mit <BUILDS oder mit CREATE aufbaut. In jedem Fall
                aber muœ der Ausf‡hrungsteil mit ;DOES> oder ;CDOES> eingelei-
                tet werden - das standardm€œige f.i.g.-DOES> kann eine solche
                "vollst€ndige Erbfolge" nicht weiterreichen.
                        ' task dds !
                Nach Festlegen des Ur-Zustandes
                        : name0 <WITH <BUILDS ... ;DOES> ... ;
                gleichermaœen auch
                        : name0 <WITH CREATE ... ;DOES> ... ;
                bildet man nun, nachdem {name0} wenigstens einmal benutzt wurde,
                ein weiteres Definitionswort, das seinerseits mit {name0} seine
                Definitionsphase einleitet,
                        : name1 <WITH name0 ... ;DOES> ... ;
                so verleiht dieser Aufbau den damit erzeugten Worten die Daten-
                struktur von name0 und die von name1 im Anschluœ; beim Aufruf
                werden die Ausf‡hrungsteile zuerst von name0 und dann von name1
                durchlaufen. Um die Folge zu sichern, muœ vor Bildung eines De-
                finitionswortes die Vorg€ngerdefinition einmal benutzt worden
                sein; wurden zwischendurch andere Definitionsworte gebildet, ist
                dies zu wiederholen. Das Probe-Wort kann sofort mit {forget}
                entfernt werden. Die Reihenfolge kann auch mitten in einer Kette
                aufgespalten werden, dazu braucht diese Procedur nur mit dem De-
                fionitionswort an der Abzweigstelle durchgef‡hrt zu werden. Was
                u.U. auch dann notwendig wird, wenn ein "fremdes" fortpflanzugs-
                f€higes {;does>} aufgerufen oder in ein Wort eingebaut wurde.
                Den definierten Ausgangszustend ohne Vorg€nger schafft man mit
                        ' task dds !
                {<with} revectorisiert {;does>}. Solange der Vorgabeposten auf
                der pfa+2 unver€ndert bleibt, stellt {;does>} sich automatisch
                mit dem Aufruf sofort wieder auf die Standarddefinition zur‡ck.
w-find          ( ptr1 -- ptr2 c3 flg | 0 )             F6
                Wenn ptr1 auf einen 4th- oder qdos-String zeigt, der einen
                in der aktuellen Suchfolge bekannten Namen enth€lt, gehen pfa,
                count- u. Typenbyte mit flg = 1 zur‡ck, sonst nur Null.
                {w-find} arbeitet identisch {-find}, es erm„glicht aber neben
                dem direkten Aufruf vor allem auch den Einbau in ein Wort, ohne
                daœ der Aufruf, den es zu finden gilt, schon bekannt sein muœ.
                Auœerdem dient es innerhalb eines {c-save}-Blocks dem Aufruf von
                dort definierten Worten durch andere Worte in diesem Block, was
                sonst wegen der fehlenden Relocationsm„glichkeit unzul€ssig ist.
w-forget        ( n1 -- )                               F6
                Wie {forget}, wenn n1 eine bekannte pfa ist, sonst keine Aktion,
                auch kein Fehlerabbruch.
w-save          ( W-SAVE filename ) (iP)                F6
                Sichert das F6-System in seinem aktuellen Zustand einschlieœlich
                der €uœeren Fensterabmessungen. Wird filename als Job gestartet,
                befindet sich das System im Forth-Vocabular, ist ansonsten mit
                dem Zustand, in dem es gsichert wurde, identisch.
warning         ( -- ptr )
                User-Vari mit einer Markierung zur Art der Fehlermeldungen.
warm            ( -- )
                Der Aufruf springt unmittelbar in die in Processorcode formu-
                lierte Initiierungsroutine zu der ein bis zu 4 Bytes lang co-
                dierter Sprung an der Stelle { 4 +origin } verzeichnet ist.
                Initial mit einem Warmstart besetzt, der die Systemdaten in
                definierten Zustand bringt, die i/o-Wartezeit auf -1 stellt
                und nach {quit} zur‡ckkehrt. Der Datenstack bleibt erhalten.
wd-size         ( c1 -- ny nx nh nw tf | ff )           F6
                ff wenn c1 keinen Fensterkanal repr€sentiert, sonst Fensterdaten
                Ursprung ny oben, nx links, Maœe nw breit, nh hoch, tf gibt die
                Cursorbreite an; alles in Pixelmaœen. In compilierter Form kann
                anschlieœend mit {l<i} auch die Zeichenh„he gelesen werden.
while           ( n1 -- ) (C) ( sys: ptr 1 -- sys: ptr 4 )
                Bedingungen werden in derselben Weise optimiert, wie bei {if}.
                        BEGIN .. .. cc WHILE .. .. REPEAT
                Zul€ssige Variante im F6 auch
                        BEGIN .. .. cc WHILE .. .. cc UNTIL
width           ( -- ptr )
                User-Vari zur L€ngenbegrenzung beim Compilieren von Wortnamen.
                Im F6 m„glichst nicht kleiner als die gr„œte benutzte L€nge zu
                setzen, dies w‡rde das Compilieren wesentlich verlangsamen, und
                als Preis f‡r die durch etwas ge€nderten Namensvergleich enorm
                beschleunigte Wortsuche leider auch mitunter zu Fehlern f‡hren.
window          ( ny nx nh nw -- )                      F6
                Das mit {work} identifizierte Fenster mit den angegebenen Maœen
                versehen, ohne border; Maœe s. {wd-size}.
within?         ( n1 n2 n3 -- flg )                     F83
                flg = 1 wenn n2 <= n1 < n3
within          ( n1 n2 n3 -- n4 )                      F6
                justiert n1 auf den mit n2 und n3 (je einschlieœlich) begrenzten
                Bereich und liefert das Resultat als n4 zum Stack
wmov            ( c1 -- )                               F6
                Durch Bet€tigung der Cursortasten Verlagerung und  nderung
                der Abmessungen des mit c1 identifizierten Fensters. Ist c1
                das Hauptfenster, und sind weitere Fenster offen, werden diese
                soweit m„glich mitgenommen und ggf. in den Maœen angepasst.
work-id         ( -- did )                              F6
                QDOS-ID des {work}-Kanals.
work-num        ( -- c1 )                               F6
                H„chste F6-Kanalnummer mit der QDOS-ID des {work}-Kanals.
word            ( c1 -- )
                mit dem Zeichen c1 begrenzten String aus dem Eingabestrom
                isolieren und mit f‡hrendem Countbyte nach {here} bringen.
                Bei c1 =<bl> gilt zum Ende hin auœer der <nul> auch jedes
                andere Zeichen mit ASCII-Code < 32 als Textbegrenzung.
            >>> isolates a char (c1) enclosed countiguous text segment from the
                input stream, if c1=<bl> any character code =/= 0 and below 32
                will also be recognized as an end-delimiter.
work            ( -- c1 )                               F6 C1
                Arbeitskanal f‡r alle QDOS-Operationen, durch {to-work} k„nnen
                ihm beliebige andere Kan€le zugewiesen werden (s. {set-work}).
                Standardkanal f‡r ausnahmslos alle i/o-Operationen des {qdos}-
                Vocabulars mit den Untervocabularen {pif} u. {minerva}.
                Auœerdem Ziel f‡r die ID aus den open-Varianten.
wraps           ( n1 n2 n3 -- n4 )                      F6
                justiert wie {within}, setzt n4 jedoch bei §berlauf auf die
                jeweils am anderen Ende gelegene Grenze.
wrds            ( -- )                                  F6S
                Leerer Operator f‡r {selected} zu WORDS aus "forth_scr"
wtyp            ( -- )                                  F6S
                Operator f‡r {selected} zu WORDS, der f‡r die Auswahl nach
                dem Typen eines danach anzugebenden Wortes sorgt:
                        forth selected wtyp base hidden words
                zeigt z.B. alle User-Variablen des {hidden}-Vocabulars an.
w=              ( ptr1 count ptr2 -- flg )             (F6)
                Standard-Stringvergleich identisch {-text} des f.i.g.-Editors,
                Vergleicht den String auf ptr1 der L€nge count mit dem bei ptr1.
w@              ( c1 -- ) (P)                           F6
                Holt einen String begrenzt mit dem Zeichen c1 oder durch
                <enter> aus der Eingabe und legt ihn mit count-word nach {pad}.
* X
xor             ( n1 n2 -- n3 )
                setzt n3 bitweise auf 1, wenn die entsprechenden Bits in n1
                und n2 ungleich sind, sonst auf 0.
xor!            ( n1 ptr -- )                           F6
                xor-Verkn‡pfung n1 mit dem Speicherinhalt bei ptr.
* [ etc.
[compile]       ( -- ) (C) ( [COMPILE] name )
                "immediate" Worte werden durch Voranstellen von {[compile]}
                mit ihrer cfa compiliert wie gew„hnliche Forth-Worte.
[fop]           ( n1 ptr2 -- derr ) (D)                 F6      8.16 => hidden
                Die zentrale Aktion aller {fop..}-Aufrufe. Ihr werden open-
                Typ n1 und ptr2 als ptr zum qdos-String des Filenamen im Stack
                ‡bergeben, und sie muœ den Fehlercode als double zur‡ckgeben.
                Als "open-Code" gelten die D3-Werte f‡r die Qdos-Trap:
                        0       zum Lesen und Schreiben
                        1       nur Lesen, mehrfache Nutzung m„glich
                        2       noch unbekanntes File neu einrichten
                        3  nur Minerva (und TK2): File neu einrichten
                        4  nur TK2 u.dgl.       : Directory-File „ffnen
                {[fop]} ist deferred eingerichtet, und erm„glicht damit etwa die
                automatische Ger€tevorgabe, durch die z.B. beim TK2 die fehlende
                Laufwerksbezeichnung ggf. nachgetragen wird. Gerade das fehlt im
                F6, um z.B. Irrl€ufer der Art "flp1_mdv2_.." zu vermeiden. Die
                Devicevorgabe nach TK2-Manier ist in "forth_scr" so beschrieben,
                daœ sie unabh€ngig vom TK2 nachgetragen und benutzt werden kann.
                F‡r die Kanalverkettung z.B. zwischen PIPEs durch §bergabe der
                ID als open-Code sind {open-link} rsp. {fop-link} vorgesehen.
[number]        ( ptr -- d1 ff | f1 ff | 1 ) (D)       (F6)
                Wie {number}, jedoch kein Abbruch bei einem Umwandlungsfehler.
                ptr zeigt auf das count-Byte eines aus Ziffernzeichen bestehen-
                den und mit wenigstens einem <bl> abgeschlossenen String. Das
                count-Byte wird nicht gelesen, bei (Teil-)Strings ohne Z€hler
                wird darum einfach die Position vor dem Anfang als ptr angege-
                ben. Auœer den ggf. durch {base} eingegrenzten g‡ltigen Ziffern
                darf der String die Zeichen "," oder "." und am Anfang auch ein
                Zahlen-Affix enthalten. Bei fp-Zahlen sind zus€tzlich das "%"
                am Ende und ein "E" ggf. vor dem Exponenten zul€ssig und das
                abschlieœende Leerzeichen ist nicht erforderlich.
                Werden diese Bedingungen nicht eingehalten, gibt der Aufruf
                den Flagwert 1 zur‡ck, sonst die ermittelte doppelte Integer
                rsp. eine fp-Zahl. Der Zahlentyp steht in {dpl} - s.dort.
\name           ( c1 -- ) (P)                           F6 (C1)
                Holt einen mit <enter> oder dem Zeichen c1 begrenzten String
                mit word-Count nach {pad}.
\.              ( f1 -- )                               F6
                Zahl f1 unabh€ngig von {context} als fp-Zahl hinschreiben.
"               ( -- ptr ) (C) ( " text... ..ende" ) (iP)
                Einen mit " oder <enter> begrenzten String compilieren, beim
                Aufruf wird der ptr auf das Count-word zur‡ckgegeben.
                " legt im interpretierenden Zustand den String nach {pad}
                und liefert sofort die Adresse zum Stack.
'               ( ' name -- pfa | abort ) (I)           "tick" - state sensitiv
                Im Unterschied zu sp€teren Standards holt das f.i.g.-"tick" die
                PFA von {name} als literal, dementsprechend ist es immediate und
                hat im Compile-Zustand selbst compilierende Funktion. Soll ein
                damit gebautes Wort sp€ter eine pfa holen, ist [compile] voran-
                zustellen. Interpretierend liefert es die pfa in den Stack.
                HINWEIS: Das "tick" sp€terer Standards ist nicht immediate und
                holt mit der CFA die 4th-Adresse, die den ptr auf den den Wort-
                typ bestimmenden direkt ausf‡hrbaren Codeteil enth€lt.
(               ( -- ) (I)
                Kommentar-Klammer, der folgende Text bleibt bis zum Zeilenende,
                einem <enter> oder der n€chsten rechten Klammer unbeachtet.
*               ( n1 n2 -- n3 ) ( f1 f2 -- f3 )         (fp: QDOS)
+               ( n1 n2 -- n3 ) ( f1 f2 -- f3 )         (fp: QDOS)
,               ( n1 -- )
                16-Bit-Wert n1 in das Dictionary eintragen, Dictionary-Ptr
                um zwei Bytes weiterz€hlen.
,,              ( dn1 -- )
                double {,}.
-               ( n1 n2 -- n3 ) ( f1 f2 -- f3 )
.               ( n1 -- ) ( f1 -- )
                vorzeichenbehaftete Integer n1 oder fp-Zahl f1 hinschreiben.
/               ( n1 n2 -- n3 ) ( f1 f2 -- f3 )
?               ( ptr -- )
                Inhalt der Speicherzelle ptr hinschreiben.
i               ( -- n1 )
                inneren Index einer DO..LOOP holen.
j               ( -- n1 )
                Index der ersten umgebenden DO..LOOP holen.
                F‡r die weiteren Ebenen s. {ni}.
[               ( -- ) (I)
                Interpret-Klammer, §bergang in den interpretierenden Zustand.
                Mit abschlieœender Compile-Klammer {]} auch innerhalb einer
                Wort-Definition anwendbar, z.B. f‡r die Ermittlung von Fest-
                werten, die in das Wort eingebaut werden sollen. Der System-
                zustand unterscheidet sich dann in keiner Weise vom interpre-
                tierenden Zustand auœerhalb einer Wort-Definition.
|               ( -- ) (I)                              F6
                Dieses Hilfsmittel zum Ausprobieren beliebiger Wortfolgen
                leitet den fl‡chtigen Compile-Zustand ein rsp. schlieœt ihn ab.
                Eine im interpretierenden Zustand in "|" eingefaœte Sequenz
                wird compiliert, sofort ausgef‡hrt und unmittelbar danach wie-
                der freigegeben. Damit sind neben durch die Compilezeit unbe-
                lasteten genauen Zeitmessungen vor allem auch Strukturworte in
                direkter Eingabe ausf‡hrbar:
                        | tick 2>r 1000. DO 1000. DO LOOP LOOP tick 2r> d- d. |
                w€re sonst nur als Wortdefinition m„glich.
                Und ein Probeaufruf z.B. mit
                        bl word here count type probetext
                liefert immer nur den Text "type" und einen Fehler, wogegen
                        | bl word here count type | probetext
                das mit einer Colon-Definition vergleichbare Ergebnis zeigt,
                womit so mancher Versuch ‡berhaupt erst durchf‡hrbar wird.
                {here} und damit auch {pad} liegen f‡r die Dauer der Ausf‡hrung
                einer solchen Wortfolge entsprechend h„her, vorher nach {pad}
                ‡bertragene Daten m‡ssen also ggf. mit der zu jenem Zeitpunkt
                g‡ltigen Adresse in diese Aufrufe ‡bergeben werden.
                Auch Einzelschrittbetrieb ist mit diesen Sequenzen m„glich.
                Die Compile- & Interpret-Klammern haben gegen‡ber {|} Vorrang
                und d‡rfen nicht gemeinsam damit verwandt werden.
\               ( -- )                                  F83
                Text nach dem "\" bleibt bis zum Ende der Zeile unbeachtet.
                Dient nur der Compatibilit€t, da "(" aufgrund der Tatsache,
                daœ im F6 Block- und Zeilenl€nge gleich sind, dasselbe leistet.
]               ( -- )
                Compile-Klammer, zum §bergang in den compilierenden Zustand.


* FP-Vocabular
Flieœkommazahlen sind im Forth zumeist ‡berfl‡ssig, da das Standardvocabular
die Scalierungsoperatoren mit jeweils doppeltgenauem innerem Zwischenergebnis
hat. Auch ist die Arbeit damit zumeist entschieden langsamer. Sie lassen sich
jedoch oft einfacher handhaben, und weil sie im QDOS auœerordentlich leicht
zug€nglich sind, wurden ihre Operationen in einem eigenen Vocabular angegeben.
Die Genauigkeit ist allerdings mit nur neun Dezimalstellen recht gering, und so
werden in vielen F€llen die vierfachgenauen Integer vorzuziehen sein, die trotz
(dezimal) 18-stelliger Genauigkeit noch deutlich schneller verarbeitet werden.

Ist dieses Vocabular oder eines seiner Abk„mmlinge CONTEXT, so werden Zahlen im
QDOS-Flieœkommaformat erzeugt, f‡r Integer stellt man ein Basis-Praefix voran.
Die fp-Zahlen-erzeugende Eigenschaft ist im 11-ten Byte der Vocabulardefinition
festgelegt. Etwa mit { ' vocname 11 + $80 toggle } kann sie gesperrt oder frei-
gegeben werden - was ohne Ausnahme f‡r alle Vocabulare gilt.

Die Operationen mit bereits in FORTH-Vocabular aufgef‡hrten Namen haben auœer
der Tatsache, daœ sie mit Flieœkommazahlen im QDOS-Format arbeiten, dieselbe
Funktion wie dort. §ber die Stackdarstellung hinaus werden sie darum hier nicht
erneut beschrieben. Flags haben Integer-Format. Die mit QDOS-Namen belegten und
"Q" markierten Worte rufen den Rechner-Vector des Betriebssystems auf, alle an-
deren sind vollst€ndig in m„glichst optimaler Form im F6 codiert. Die Operatoren
zur Umwandlung von FP nach Integer und umgekehrt geh„ren zum Forth-Vocabular und
sind hier nur der §bersicht halber mit aufgef‡hrt. Sie enthalten ebenfalls keine
QDOS-Aufrufe.

Im allgemeinen lassen sich die fp-Operationen auf beliebige Datenkonstellationen
anwenden. Um jedoch Fehler des QDOS abzufangen, die oft in Endlosschleifen enden
k„nnen, wird in einigen F€llen das h„herwertige Exponentenbyte (entsprechend dem
h„chstwertigen Stack- oder Speicherbyte) mit %00001111 AND-verkn‡pft und grenzt
den Exponenten damit auf zul€ssige Werte ein. Allgemeine Datenposten werden dann
u.U. verf€lscht. Die betr. Operationen sind:
        Q                       alle hier als QDOS-Operationen markierten
                                Aufrufe haben am Ende(!) diese Maskierung,
                                um z.B. (versehentliche) Ausgabeversuche
                                nach einem Fehler abzusichern.
        ri-exec                 Vectoraufruf entsprechend den Q-Operationen.
        constant                bei der Werte-§bergabe zum Stack.
        2*
        2/
        $>f                     (forth)
        [number]                (forth)
Dagegen kann {flit}, das diese Kontrolle nicht enth€lt, und auch {dpl} unber‡hrt
l€œt, zuverl€ssig beliebige Dreifachposten compilieren. -2 in {dpl} signalisiert
fp-Posten bei reinen Zahlenwerten, {constant}en und nach {2*} sowie {2/}.

*               ( f1 f2 -- f3 )         Multiplikation          Q
+               ( f1 f2 -- f3 )         Addition                Q
-               ( f1 f2 -- f3 )         Subtraktion             Q
.               ( f1 -- )               Zahl hinschreiben      (Q)
*/              ( f1 f2 f3 -- f4 )      Verkettung f1*f2/f3     Q
+-              ( f1 n1 -- f2 )
-rot            ( f1 f2 f3 -- f3 f1 f2 )
-1      -2      Cons, mit -2 in {dpl}.
0<              ( f1 -- flg )
0=              ( f1 -- flg )
0>              ( f1 -- flg )
1/2     1/4     Cons, mit -2 in {dpl}.
2swap           ( f1 f2 f3 f4 -- f3 f4 f1 f2 )
2*              ( f1 -- f1*2 )          schnelle Verdopplung, setzt dpl := -2
2/              ( f1 -- f1/2 )          dto., Halbierung
>r              ( f1 -- rp: f1 )
>               ( f1 f2 -- flg )
<               ( f1 f2 -- flg )
abs             ( f1 -- f2 )            Betrag bilden           Q
acos            ( f1 -- f2 )            arcus cosinus           Q
acot            ( f1 -- f2 )            arcus tangens           Q
asin            ( f1 -- f2 )            arcus sinus             Q
atan            ( f1 -- f2 )            arcus tangens           Q
cmp             ( f1 f2 -- flg )        flg aus { f1 f2 - sgn }
constant        ( -- f1 ) (C) ( f1 CONSTANT name )
                Abweichend von den anderen {constant}-Definitionen wird mit dem
                Aufruf {dpl} besetzt, wo der Wert -2 eine fp-Zahl kennzeichnet.
                ' name liefert mit dem Parameterfeld den Ort, an dem der fp-Wert
                gespeichert ist, die pfa kann also wie der ptr einer Variablen
                verwandt werden; auœerdem ist IS anwendbar.
cos             ( f1 -- f2 )            cosinus                 Q
cot             ( f1 -- f2 )            cotangens               Q
d>f             ( d1 -- f2 )(f)
                Double in fp-Zahl umrechnen, entspricht {float}, ist schneller.
drop            ( f1 -- )
dup             ( f1 -- f1 f1 )
exp             ( f1 f2 -- f3 )         exponentialfunktion     Q
f>d             ( f1 -- d1 )(f)         entsprechend {nlint}.
f>q             ( f1 -- q1 )(f)         quad, sonst wie {f>d}
float           ( n1 -- f1 )            Integer nach fp         Q
int             ( f1 -- n1 )            fp gekappt nach Integer Q
literal         ( -- f1 ) (C) ( f1 -- )
log10           ( f1 -- f2 )            log zur Basis 10        Q
ln              ( f1 -- f2 )            nat‡rlicher logarithmus Q
neg             ( f1 -- f2 )            Negation                Q
nint            ( f1 -- n1 )            fp zur n€chsten Integer gerundet  Q
nlint           ( f1 -- d1 )            fp zur n€chsten doppelten Integer Q
                {f>d} ist schneller und vermeidet qdos/TK2-Fehler ab f1 > 2^29.
over            ( f1 f2 -- f1 f2 f1 )
pick            ( fn f1 .. fx m1 -- fn f1 .. fx fm )
pi              Cons, mit -2 in {dpl}.
q>f             ( q1 -- f2 )(f)         Quad nach fp.
ri-exec         ( +opcode -- ergebnis ) oder ( progptr variptr -nn -- ergebnis )
                Wird irgendeine negative Zahl als opcode angegeben, leitet dies
                einen QDOS-Rechneraufruf ein, der eine ab progptr codierte Fol-
                ge Rechenoperationen ausf‡hrt, zugleich muœ dann auch variptr
                f‡r den in diesem Vectoraufruf verwalteten Variablenbereich an-
                gegeben sein. Die Codierung ist den einschl€gigen QDOS-Dokumen-
                ten zu entnehmen (z.B. PiQ).
roll            {pick} und aufr‡cken in die copierte Position,
                negative Postennummer f‡r Rotieren in umgekehrter Richtung.
rot             ( f1 f2 f3 -- f2 f3 f1 ) entspricht { 2 roll }
r>              ( rp: f1 -- f1 rp: -- )
s>f             ( n1 -- f1 )(f)
                Einfache integer nach fp.
sin             ( f1 -- f2 )            sinus                   Q
sgn             ( f1 -- n1 )            n1=0 bei f1=0, sonst n1=f1/abs(f1)
sqrt            ( f1 -- f2 )            Wurzel                  Q
swap            ( f1 f2 -- f2 f1 )
tan             ( f1 -- f2 )            tangens                 Q
!               ( f1 ptr -- )
!l              ( f1 dadr -- )
/               ( f1 f2 -- f3 )         Division                Q
0  1  2  3      Cons, mit -2 in {dpl}.
=               ( f1 f2 -- flg )
@               ( ptr -- f1 )
@!              ( ptr1 ptr2 -- )        §bertragung eines fp-Wertes
@l              ( dadr -- f1 )
^               ( f1 f2 -- f3 )         Potenzierung            Q


* EDITOR-Vocabular (das vollst€ndige Vocabular kommt mit "fig_scr")
Bei den hier genannten Worten zum Textvergleich wird zwischen Nichtbeachtung und
Beachtung der Schreibweise mittels der Constanten (upper) unterschieden, mit der
die einzelnen Zeichen vor dem Vergleich AND-verkn‡pft werden.
Bei -1 hat (upper) keinen Einfluœ, bei 127 wird das h„chstwertige Bit ausgeblen-
det, sodaœ nur der einfache ASCII-Zeichensatz in den Vergleich eingeht und auch
die Markierungen der Wortnamen ohne Einfluœ bleiben, -33 dient durch Ausblenden
des Bit 5 (mit Nebeneffekten!) dem von der Schreibweise unabh€ngigen Vergleich.

flush           ( -- )
                Augenblicklich alle {update}-markierten Bl„cke sichern.
match           ( ptr1 n1 ptr2 n2 -- flg n3 )           f.i.g.-Editor
                Suche des Strings der L€nge n2 ab ptr2 im Bereich der L€nge n1
                ab ptr1. Bei Erfolg R‡ckgabe flg = 1 und Abstand n3 zu ptr1
                als der ersten Speicherstelle NACH dem gefundenen Text, sonst
                gehen flg = 0 und n3 mit dem Wert von n1 zur‡ck.
                Entsprechendes an wirklichen Speicheradressen s.u. {s==}.
s=              ( n1 dadr1 n2 dadr2 -- flg )            F6
                Vergleich, flg = 1 wenn der String der L€nge n2 am Ort dadr1 im
                Speicher auf dadr2 vorhanden ist. n1 ist Code eines Zeichens,
                das immer als gefunden gilt und unbekannte Posten ersetzen kann.
                Soll kein "Joker"-Zeichen gelten, ‡bergibt man n1 mit -1.
s==             ( n0 dadr1 n1 dadr2 n2 -- flg n3 )
                Stringsuche im Bereich der L€nge n2 ab dadr2 nach dem String auf
                dadr1 der L€nge n1 auf wirklichen Speicheradressen und mit einem
                Joker-Code in n0 (oder -1). n3 wie bei {match}.
text            ( c1 -- ptr )
                steht im Forth-Vocabular


* ROOT-Vocabular
Kann als einziges Vocabular nicht von der Suchfolge ausgeschlossen werden.
Hier sind darum die Worte definiert, die den Systemzugriff bestimmen, und
solche, die stets verf‡gbar sein m‡ssen, rsp. deren von der ‡brigen Voca-
bular-Konstellation unabh€ngiges Vorhandensein zweckm€œig ist.

2nd-voc         ( -- ptr )                              F6
                Vari, =/= 0 gibt Vocabular-spezifische Folge-Vocabulare frei.
                Im Vorgabezustand ist die secund€re Suchfolge gesperrt.
also            ( -- ) (I)                              F83 modifiziert
                Schiebt die Suchfolge eins "hoch", d.h., der Vorg€nger-CONTEXT
                wird in die gesicherte Suchfolge eingereiht und das aktuelle
                CONTEXT-Vocabular an zweite Position im Vocabularstack copiert.
                Die Behandlung des Vocabularstacks weicht im F6 etwas vom F83-
                Vorbild ab, vor allem zur Vereinbarkeit mit dem f.i.g.-Modell:
                Der Vocabularstack umfaœt zwei Bereiche, von denen der erste mit
                den j‡ngsten zwei Posten vom zweiten miterfaœt wird.
                Der mit {also} gesicherte Bereich beginnt erst beim dritten in
                Folge aufgerufenen Vocabular, die beiden "unteren" Vocabulare
                werden in einem eigenen zweistufigen Stack mit jedem Aufruf au-
                tomatisch um einen Posten weitergeschoben, es sind also stets
                die beiden j‡ngst aufgerufenen Vocabulare verf‡gbar. Der jeweis
                zweite Vorg€nger f€llt aus der Suchordnung hinaus.
                {also} schiebt s€mtliche Vocabulare eine Position 'h„her', so-
                daœ dann das zweite Vocabular an dritte Position gelangt, wo es
                nicht mehr durch einen neuen Vocabularaufruf verschwinden kann.
                Die j‡ngste Vocabulareintragung wird dupliziert, sodaœ nun Platz
                f‡r ein danach genanntes Vocabular frei wird, um welches sich
                die Suchordnung dann erweitert.
                Mehrere {also} nacheinander bewirken gew„hnlich nichts anderes,
                als daœ das j‡ngste Vocabular von den {find}-Varianten entspre-
                chend oft durchsucht wird und sich die Compilezeit dadurch ohne
                jeden Nutzeffekt ganz enorm erh„ht. Im F6 wird dergleichen durch
                eine Markierung unterbunden, die w€hrend der Worsuche besetzt
                und verarbeitet wird. Gleichg‡ltig, wie oft ein Vocabular in der
                Suchfolge erscheint, wird es nur einmal durchsucht, sodaœ die
                Compilezeit von Mehrfacheintragungen unbeeinfluœt bleibt.
                Der erste, fl‡chtige, Teilstack erlaubt es, die im f.i.g.-Forth
                ‡bliche §bertragung des Definitionsvocabulars in die Suchordnung
                zu ‡bernehmen und gleichzeitig den vorher eingestellten Posten
                verf‡gbar zu halten, ohne daœ sie dadurch peu a peu am Ende
                ganz aus solchen Eintragungen besteht, da der Bereich oberhalb
                der beiden j‡ngsten Posten unver€ndert bleibt.
                Das w€re z.B. auch durch die {state}-abh€ngige Miterfassung des
                Current-Vocabulars (und bei der gew€hlten Datenanordnung im 4th-
                Speicher eher besser) m„glich; die Verfahrensweise resultiert
                aus anf€nglichen Versuchen und, den m„glichen Nutzen betrachtet,
                es lohnt deren  nderung den Aufwand nicht. In der aktuellen Form
                gilt die §bertragung NUR bei Colon-Definitionen - was durch die
                Auswertung von {state} allein ohnehin nicht zu erreichen w€re.
                Ausf‡hrliche Beschreibung in "F6CHG_txt" rsp. "FORTH_txt".
asm68           ( -- )                                  F6
                Vocabular, initial dem Aufruf {assembler} zugewiesen
assembler       ( -- ) (D)(I)
                Deferred, vorgesehen f‡r unterschiedliche Assembler-Vocabulare.
blk+            ( -- n1 )                               F6
                n1 = -1 bei direkter Eingabe in t.i.b., 0 bei neuem Screenfile
                oder eine Zahl > 0 f‡r die n€chste Blocknummer im Screenfile.
bye             ( -- )
                Verlassen des Forth-Systems, der F6-Job wird aufgegeben.
definitions     ( -- )
                Macht den CONTEXT zum CURRENT-Vocabular, dem die nun folgenden
                neuen Definitionen zugeordnet werden. Danach kann das vorige
                CURRENT-Vocabular mit {prevdef} wiederhergestellt werden.
forth           ( -- ) (I)
                Nach {root} das Stamm-Vocabular des Systems
h,              ( cfa -- ) (C)                                  F6
                Compiliert eine von auœen(!) in eine Colon-Definition hineinge-
                reichte cfa, nimmt sie vom Stack & justiert {csp} entsprechend.
                {h,} eignet sich auch zum Einbau irgendeiner Zahl in den Code,
                die von auœen ‡bergeben wurde, und macht dann zus€tzliche Maœ-
                nahmen zum Einhalten der Stackbilanz ‡berfl‡ssig:
                        1234 : test 8766 lit+ H, 10000 = IF ." oke! " ENDIF ;
                Das {h,} ersetzt hier die Sequenz
                                      ... [ dup ] literal ... ;  drop
h;              ( -- ) oder ( ptr 9 -- ) (C)                    F6S
                Abschluœ einer headerlosen Colon-Definition in den €lteren F6-
                Versionen. Funktion identisch {;}, darum nicht mehr im Kern.
h]              ( H] name -- ptr ) (I)                          F6
                Leitet eine headerlose Colon-Definition ein. Der zur‡ckgegebene
                ptr ist von den aufrufenden Worten sp€ter als cfa zu verwenden.
                Die Platzeinsparung entspricht der ungeradzahlig aufgerundeten
                L€nge eines Namen + 3; auœerdem belasten diese Worte die Suche
                beim Compilieren nicht, da sie f‡r {-find} nicht existieren.
                Ausf‡hrungszeitvorteile bieten die namenlosen Worte nicht.
                        H] " ein headerloses wort " -print H;
                        : probe ." aufruf: " H, ." wurde eingebaut " cr ;
                Soll solch ein Wort mehrfach compiliert werden, ist die cfa im
                Stack vorher z.B. mit {dup} entsprechend oft dort abzulegen.
                Sie kann aber auch in irgendeiner Hilfsvariablen/-Constanten
                zwischengespeichert und dann ganz "normal" mit dem Komma com-
                piliert werden:
                        H] ..irgendwas.. H;     is temp-cons
                        : probe ... [ temp-cons , ] ... ;
                Das bietet sich besonders dann an, wenn in einem Programm ohne-
                hin Constante definiert wurden, denen ihr eigentlicher Wert aber
                erst sp€ter oder durch das Programm selbst zugewiesen wird.
no-search       ( -- ) (I)
                Vocabularspezifische zweite Suchfolge sperren.
only            ( -- ) (I)                              F83
                Alle Vocabulare aus der Suchfolge nehmen, nur {root} bleibt
                zug€nglich, {current} wird nicht ver€ndert.
prevdef         ( -- ) (I)                              F6
                voriges Definitionsvocabular wieder einsetzen. Benutzt eine ein-
                fache Variable, kann daher nur das unmittelbar vor dem j‡ngsten
                {definitions} vohandene {current}-Vocabular wiederherstellen.
previous        ( -- ) (I)
                Die gesamte Suchfolge um das j‡ngste Vocabular verk‡rzen.
rvoc            ( -- ) (I)                              F6
                Das zweite Vocabular an erste Stelle setzen, keine weiteren
                 nderungen, der eigentliche Vocabularstack bleibt unber‡hrt.
search          ( SEARCH name ) (I)                     F6
                dem CONTEXT-Vocabular ein neues Secund€rvocabular einpr€gen.
selected        ( SELECTED xxxx )                       F6S
                Modifiziert den n€chsten Aufruf von {words} und beschr€nkt die
                Ausgabe auf bestimmte Wortgruppen. Grunds€tzlich gelten die
                nach {selected} folgenden max. 7 Zeichen bis zum n€chsten Leer-
                zeichen als alphabetisches Auswahlkriterium f‡r den Wortanfang
                der Ausgabe. Die Kriterien beim Textvergleich entprechen {t=}.
                Daneben gibt es Sondergruppen mit:
                selected imed           f‡r die "immediate"-Worte;
                selected prim           die Standard- und die mit Langwort-Ptr
                                        aufgerufenen Primitives;
                selected defn {name}    faœt die Worte zusammen, deren pfa den-
                                        selben Inhalt wie {name} hat, z.B. also
                                        die Worte aus demselben Definitionswort;
                selected wtyp {name}    die Worte vom selben Typen wie {name}.
vlist           ( -- )
                Alle Worte des CONTEXT-Vocabulars nach {out-cons} schreiben.
                Immediate-Worte werden durch vertauschte Hintergrund- und
                Schriftfarben hervorgehoben.
words           ( -- )                                  F6S (F83)
                Wie {vlist}, jedoch alphabetisch sortiert und tabellarisch
                angeordnet. Der Aufruf kann mit {selected} modifiziert werden.
€               ( -- ) (D) (I)                          (F6)
<nul>           Das "€" wird von {id.} anstelle der ASCII-<nul> hingeschrieben,
                die den wirklichen Wortnamen bildet. Dieses Wort ist eines der
                wichtigsten in f.i.g.-Forth-Systemen: Die <nul> ist nicht nur
                absolutes Begrenzungszeichen, sondern auch aktives Wort. Da sich
                die Notwendigkeit, einen neuen Text zu holen und das Textende im
                allgemeinen decken, veranlaœt hier jeder Text selbst das System,
                an seinem Ende f‡r Nachschub zu sorgen oder nach {quit} zur‡ck-
                zukehren, dem €uœeren Interpreter, wo weitere Eingaben erwartet
                werden. So wird es, indem es die laufende Kontrolle selbst ‡ber-
                nimmt, v„llig unabh€ngig von irgendeinem ‡berwachenden Programm-
                rahmen. Das "neue" {refill} des ANS-Standard kommt der <nul>,
                deren Funktion im Laufe der Zeit verlorengegangen schien, schon
                wieder recht nahe, es fehlt lediglich der automatische Aufruf
                am Ende des aktuellen Zeichenstroms.
                Dadurch, daœ im F6 die <nul> auch mit Namen {€} hingeschrieben
                werden kann, ist sie sehr leicht auch in neue Worte compilier-
                bar, was z.B. die Ersatzdefinition des genannten {refill} ohne
                irgendwelch Umst€nde sofort erm„glicht.


* HIDDEN-Vocabular                                      F6 F83 lmi
Viele der hier verzeichneten Worte sind selten f‡r Programmierer oder Anwender
sinnvoll einsetzbar. Andere erfordern tiefergehende Detailkenntnisse. Darum
sind hier nicht alle Aufrufe vollst€ndig beschrieben, es wird f‡r den Bedarfs-
fall auf den (kommentierten) Assembler-Quelltext verwiesen.

#user           ( -- n1 )                              (F6) F83
                Cons, Gr„œe des gesamten User-Bereichs
(")             Runtime f‡r {"}
(+loop)         Runtime f‡r {+loop}
(.")            Runtime f‡r {."}
(;)             Runtime des optimierenden {;}           F6 8.16
(;code)         Runtime f‡r {;code}
(abort")        ( -- ) (D)                              F6
                Von {abort}-Varianten aufgerufen, f‡hrt initial nach {quit},
                auf entsprechende Anwendungs-Worte vectorisierbar.
(abort)         ( -- ) (D)                              F6
                Wird nach L„schen des Datenstacks von {abort} aufgerufen und
                f‡hrt die weitere Re-Initiierung durch: Stellt {dr0} ein,
                Zahlen dezimal, und nach evtl. n„tigem §bergang in den user-
                Modus des 680xx-Processors Hinschreiben der Systemkennung.
(bs)            ( -- c1 )                               F6
                Definiert den Zeichencode f‡r {bs}
(ctl)           ( -- ptr )                              F6
                Vari, 0 unterbindet die Aktionen von {ctrl}.
(debug)         ( -- ) inaktiv ( pfa -- ) mit debugger (D) F6
                Ausf‡hrender Debugger-Aufruf, wird ggf. vor jede cfa compiliert.
                In der Vorgabe mit $8001 besetzt und damit f‡r schnellstm„gliche
                Abarbeitung de-aktiviert. Wird beim Compilieren des Debuggers
                auf ein Wort mit Pr‡fung und Ausf‡hrung von {debug} gestellt.
(do)            Runtime von {do}, identisch {2>r}.
(exec)          Hilfsaufruf u.a. zu {clone-4th}.
(find)          ( ptr1 ptr2 -- pfa count tf | ff )
                Zentraler Aufruf von {-find}, der je ein einzelnes Vocabular,
                dessen j‡ngste nfa als ptr2 angegeben wurde, nach dem N
                amen
                mit Countbyte ab ptr1 durchsucht. ptr2 kann eine beliebige nfa
                sein, von der an zu €lteren Worten hin gesucht wird. (find)
                ist darum auch f‡r das Durchsuchen beliebiger anderer Listen
                geeignet, sofern die einzelnen Posten nur in derseben Weise
                wie Forth-Worte verkettet sind (s. ganz oben).
(loop)          Runtime von {loop}
(number)        ( d1 ptr1 -- d2 ptr2 )          F6 bis vers. 8.07
convert         ( d1 ptr1 -- d2 ptr2 )          dasselbe ab vers. 8.08 (fth)
                Accumuliert die Ziffern ab ptr1 in d1 bis zum ersten nicht in
                der aktuellen {base} als Ziffer g‡ltigen Zeichen und gibt den
                Accu d2 samt der Adresse des Abbruchs ptr2 zur‡ck.
(quit)          ( -- ptr )                              F6
                Ausf‡hrungs-cfa von {quit} und Hilfe zur Erzeugung selbsstarten-
                der F6-Programme. Die hier eingetragene cfa wird beim Start des
                F6-Jobs ausgef‡hrt und kann auf jedes Wort gestellt werden, das
                ein geschlossenes Programm ausf‡hrt - die "turnkey"-Anwendung.
                Automatisches Nachladen fehlender Definitionen:
                Beim Antreffen eines nicht vorhandenen Wortes wird die gew„hn-
                liche Fehlerbehandlung durchlaufen, die normalerweise nach der
                Ausgabe eines Hinweistextes und Teil-Initiierung nach {quit}
                f‡hrt. Stellt man {(quit)} nun auf einen {l-load}-Aufruf ein,
                der den Namen von {here} ‡bernimmt, kann jeder solcher Fehler
                automatisch das Laden eines unbekannten Wortes veranlassen. Um
                dies wirklich sinnvoll anwenden zu k„nnen, bedarf es ggf. noch
                der Entfernung des {latest} Wortes, in dem beim Compilieren
                solch ein Fehler auftrat, und es muœ die Position im Eingabe-
                strom mit den dann erneut zu interpretierenden Text gesichert
                worden sein. All dies vorausgesetzt, bei einheitlicher Quelle
                f‡r nachzusetzende Definitonen, l€œt sich der Compiler soweit
                ausbauen, daœ er v„llig selbst€ndig die fehlenden Definitionen
                einsammelt und nachtr€gt.
+branch         ( flg -- )                              F6
                Runtime f‡r die Optimierung z.B. aus: 0< IF
                Bei Aufrufen aller {branch}-Varianten ist zu beachten, daœ die
                Sprungdistanz als vorzeichenbehaftete 16-Bit-Zahl bewertet wird.
                Ist also ein Aufruf 32K Bytes entfert, oder mehr, so darf er
                keinesfalls mehr direkt angesprungen werden, da die compilierte
                Distanz dann in die falsche Richtung weist. In solchen F€llen
                ist nur der standardm€œige Forth-Aufruf zul€ssig - was bei der
                automatischen Schluœoptimierung selbst€tig ber‡cksichtigt wird.
-branch         ( flg -- )                              F6
                Runtime f‡r die Optimierung z.B. aus:  0= IF
0-branch        ( flg -- )                              F6
                Runtime f‡r die Optimierung z.B. aus: 0> IF
0<branch        ( flg -- )                              F6
                Runtime f‡r die Optimierung z.B. aus: 0< 0= IF
0>branch        ( flg -- )                              F6
                Runtime f‡r die Optimierung z.B. aus: 0> 0= IF
0branch         ( flg -- )                              F6
                Runtime f‡r IF
<cmove          ( ptr1 ptr2 n1 )
                Transportiert - ggf. ‡berschreibend - n1 Bytes von ptr2 nach
                ptr1, ohne Aktion, wenn n1 nicht > 0 ist.
?0branch        ( flg -- flg | )                        F6
                Runtime f‡r die Optimierung, entspricht
                        -dup IF
?1branch        ( flg -- flg | )                        F6
                Runtime f‡r z.B. {case?}, entspricht
                        over = IF drop
?numerr         ( flg -- flg 0 )                        F6
                Zusammenfassung von
                        ( flg ) 0 ?error
back            ( ptr -- )
                Compiliert eine r‡ckw€rtsgerichtete Sprungdistanz in {here}.
branch          Runtime f‡r {else} und andere unbedingte Spr‡nge
clone-jdt       ( did -- did )(D)                       F6
                Letzte Aktion in {(exec)} unmittelbar vor der Job-Activierung.
                Vectorisiert auf {noop}, vorgesehen f‡r anwendungsbezogene
                Besonderheiten. Die Adresse der zugeh„rigen jdt kann mit {a2l@}
                gelesen werden, die dID des Jobs muœ im Stack erhalten bleiben.
dataspace       ( -- ptr )                              F6
                Vari, Wert des mit {w-save} festgelegten Bereichs, der dem so
                erzeugten Job beim Aufruf f‡r Stacks, Puffer und Dictionary
                zugewiesen wird. Bei -1 ermittelt das System den gr„œtm„glichen
                Wert, mit anderen Zahlen ist die Zuweisung zur Verringerung des
                k‡nftigen Speicherbedarfs reduzierbar. Der Wert von ca. 3000
                sollte jedoch nicht unterschritten werden, andernfalls wird es
                Stackfehler geben.
debug           ( pfa n1 -- ) exec )(D)                 F6S
                case:-Liste der Debug-Einrichtung, kann mit Anwenderdefinitionen
                in den freien Posten (5 bis 8) re-vectorisiert werden. Erh€lt
                in n1 den Wert MAX( db-on,0 ), und eine pfa, die die ausf‡hren-
                den Worte vom Stack nehmen m‡ssen. Davor wird db-on=0 ausgefil-
                tert, sodaœ n1=0 nur bei negativen Werten von db-on vorkommt.
dlit            ( -- d1 )
                Runtime f‡r doppeltgenaue Festwerte.
doforget        ( cflg xflg nfa1 nfa2 -- cflg xflg nfa1 n3 ) (D) F6  8.18
                Anwender-definierbarer Vorspann in {forget}. Darf nfa1 mit der
                j‡ngsten nfa des j‡ngsten Vocabulars nicht €ndern, und muœ
                zumindest irgendeine Zahl n3 anstelle der nfa2 des Wortes, bis
                zu dem das Dictionary freigegeben werden soll, zur‡ckgeben.
                Bei Erreichen von {doforget} steht bereits fest, daœ {fence}
                nicht erreicht wurde, und im QXL-System ist die Cache inaktiv.
                cflg = 0/1 Return-Wert von CACHE
                xflg =/= 0 als Abbruchflag zum vorzeitigen Verlassen der betr.
                FORGET-Variante ohne  nderungen im Dictionary setzbar.
end-loc         (C)( sys: n1 -- )                       F6
                auœerordentliche Freigabe des {local}-Bereichs, z.B. vor {;s},
                ben„tigt die Anzahl freizugebender Bytes, z.B.
                   : name local AB| .. IF .. [ 8 ] end-loc ;s ENDIF .. ;
                Der Eingriff "von Hand" in den Compiler wurde gew€hlt, da, weil
                {end-loc} in den unterschiedlichsten Situationen vorkommen kann,
                die Lage der Systemdaten nicht vorhersagbar ist. In solch einer
                Situation ist es einfacher, die Anzahl Bytes direkt anzugeben.
flit            Runtime f‡r fp-Festwerte                F6
ini-loc         (C) ( sys: n1 -- )                      F6
                Reservierung von n1 Bytes localen Speichers, wie {end-loc}.
is-prt          ( c1 -- )
                Definition einer Kanalnummer als Druckerkanal
lit             Runtime f‡r einfache Festwerte
memvec          ( n1 -- dadr | -dn )                    F6
                n1 ist die Nummer eines Vectors im MEM-device der IO2-Sammlung,
                dessen Adresse zur‡ckgegeben wird, negative Werte und Null sind
                nicht brauchbar, sie signalisieren einen Fehler.
                F‡r die detaillierte Beschreibung der Vectoren wird auf die
                Dokumentation zur IO2-Sammlung (vom Autor des F6) verwiesen.
ocontext        ( -- ptr )                              F6
                User-Vari, bei {context}-Wechsel mit dem bisherigen ptr besetzt.
ocurrent        ( -- ptr )                              F6
                User-Vari, durch {definitions} mit dem bisherigen ptr besetzt.
qlit            Runtime f‡r quad-Festwerte
seal            ( -- )                                  (F83) F6
                Das aktuelle Definitionsvocabular wird abgeschlossen; es er-
                scheint nach dem Aufruf leer und ist so weiterverwendbar, als
                sei es gerade erst definiert worden.
t3do                                                    F6
                Runtime f‡r eine Anzahl Aufrufe der QDOS-trap #3
[convert]       ( ptr -- )                             (F6)
                Der Zahlenkonverter des Interpreters, holt den aktuellen
                Gegebenheiten entsprechend eine Zahl, falls der interpretierte
                Text nicht als Wort gefunden wurde. Im compilierenden Zustand
                werden zwei aufeinanderfolgende einfache {lit} umgeordnet und
                und mit {dlit} zu einer doppelten Integer zusammengefaœt, bei
                einer weiteren {lit} entsteht eine {flit}-Anordnung.
[cpl]           ( cfa -- cfa ) (D)                      F6
                Unmittelbar vor dem Eintragen einer cfa in das Dictionary
                aufgerufenes Wort, das frei ist f‡r Anwendungs-Aktionen.
[debug]         ( -- ) (C)                              F6
                Wird in {interpret} aufgerufen, wenn {db-on} nicht Null ist und
                compiliert dann {(debug)} vor jede cfa.
[error]         Initiale Aktion von {error}             F6
[find]          ( ptr -- ptr ) (D)                      F6
                Anwender-definierbarer Vorspann in {(-ffind)} als erste Aktion
                unmittelbar nach §bergabe des Textes mit dem zu suchenden Namen,
                der mit seinem count-Byte bei ptr steht. Initial inaktiv.
[interpret]     ( pfa c1 -- pfa c1 seinem count-Byte ) (D) F6
                Anwender-definierbarer Vorspann in {interpret} nach erfolgrei-
                cher Wortsuche mit pfa des Wortes und seinem count-Byte c1, die
                beide unver€ndert weiterzugeben sind. Initial inaktiv.
[nul-pfa]       ( -- pfa )                              F6
                Cons, pfa des <nul>-Wortes, kann nach Umwandlung in CFA mit
                Komma compiliert werden und wird wie das <nul>-Wort ausgef‡hrt.
[nul]           ( -- cfa )                              F6
                Die initiale Aktion von <nul>


* QDOS-Vocabular                                        F6 QDOS

In diesem Vocabular finden sich nur QDOS- rsp. QL-spezifische Aufrufe, die
in vielen F€llen genaue Gegenst‡cke zu Aufrufen des SBasic sind. Abweichun-
gen gibt es insofern, als die Parameterangaben vorzugsweise auf die Erfor-
dernisse der QDOS-Traps ausgerichtet sind, was vor allem wesentlich verbes-
serte Laufzeiteigenschaften zur Folge hat.
Aktionen und Parameter-Erfordernisse sind den g€ngigen Dokumenten zum QDOS
zu entnehmen, oder z.B. dem "Programmieren in QDOS" vom Autor des F6. Doch
auch mit einiger Kenntnis des SBasic sollte die Programmierung nicht allzu
schwer sein, ein wenig Hilfe geben auch die unten gew€hlten Bezeichnungen.
Die Namen stimmen mit den dort genannten QDOS-Bezeichnungen ‡berein, womit
sie leicht auffindbar sind und sich hier detaillierte Angeben er‡brigen.

* Trap #0 Processorzustand
N‡tzlich f‡r alle Vorg€nge, die ohne Unterbrechung - z.B. durch das Multi-
tasking des QDOS - en bloc ablaufen m‡ssen, etwa die ser1/ser2-Bedienung bei
Minerva oder auch sonst in den h„heren Baudraten. Ausnahmsweise auch, wenn
ein (m„glichst kleiner) Programmteil besonders schnell ausgef‡hrt werden soll.

Der Aufruf wird durch die "chk"-exception mit Hilfe der QDOS-Trap-Umleitung
in einer f‡r alle 680xx-Processoren zul€ssigen Weise so dargestellt, daœ
Aufrufe zu beliebigem Zeitpunkt m„glich sind, unabh€ngig vom Processortypen
und dem aktuellen Systemzustand. "Exception-handler" sind darum nicht erfor-
derlich, rsp. werden nicht aktiv - vor allem f‡r die Laufzeit vorteilhaft.
F‡r die Paarung der Worte zur Status-Umschaltung gilt dieselbe Regel, wie
f‡r >R und R>, und muœ strikt eingehalten werden. Die F6-Worte der Fehler-
Aktionen sorgen zwar f‡r gefahrlose R‡ckkehr, wird aber bei sonst einwand-
freiem Verlauf der Status nicht richtig geschaltet, geraten F6-Returnstack
und der QDOS-Systemstack durcheinander, was zu ‡belsten Fehlern f‡hrt.

Einfache Regel:
Der Processorzustand muœ am Ende eines Wortes derselbe sein, wie zu Anfang,
was im Wortinnern auœerdem f‡r jede einzelne DO..LOOP gilt. Da Systemstack
und Return-Stack dieselben sind, d‡rfen auch Returnstackoperationen nur paar-
weise benutzt werden, und sich NIE mit einem der Trap#0-Aufrufe ‡berschneiden.

Vorsicht bei Recursion oder Datenablage im Returnstack:
Die nutzbare Stacktiefe im QDOS-Systemstack ist auf 256 Bytes begrenzt!
Das entspricht einer Forth-Schachtelung von 128 Aufrufen, aber bei z.B.
Ladevorg€ngen oder DO..LOOPs reduziert sich diese Zahl schon wesentlich,
da das F6-System dort auch Daten zwischenspeichert.

sr!             ( n1 -- )
                Statusregister mit dem 16-Bit-Wert n1 besetzen, auch zum
                Betriebsartenwechsel (user oder supervisor) verwendbar.
           HINWEIS: Es werden auch die Interrupt- und Trace-Bits besetzt!
sr@             ( -- n1 )
                Statusregister lesen.
trap0r          ( -- )
                §bergang in den user-Modus.
trap0s          ( -- )
                §bergang in den supervisor-Modus.
trap0           ( -- n1 )
                §bergang in den supervisor-Modus, R‡ckgabe des alten Status.

* Trap #1 : Systemsteuerung (Managertraps)

activ           ( d.jobid prior execmode -- d.jobid )
alchp           ( d.len d.jobid -- dlen dadr )
baud            ( d.baud -- )
cjob            ( d.start d.datamem d.codemem d.jobid -- d.jobid )
free            ( -- d.maxmem )
frjob           ( d.jobid d.ernum -- )
ipcom           ( parmptr -- byte )
jinf            ( d.job1 d.job2 -- d.nxtjob d.ojob sus&priflg d.start )
mode            ( aufl„sung bildschirm -- a.alt b.alt )
prior           ( d.jobid d.prior -- )
rclck           ( -- d.date )
rechp           ( d.adr -- )
reljb           ( d.jobid -- d.jobid )
sclck           ( d.date -- )
susjb           ( d.jobid time -- d.jobid )
tra             ( d.chrtab d.msgtab -- )
scach           ( d.flag -- ) cache ein(1) aus(0) - nur im SMSQ aktiv

trap1a          ( d.A1 d.D3 d.D2 d.D1 opcode -- d.D1 )
trap1           ( d.D1 d.D2 opcode -- d.D1 )

* Trap #2 : Kanal-Zuweisung - alle Aufrufe im Forth-Vocabular vorhanden

delet           ( ptr -- )
formt           ( ptr -- )

* Trap #3 : i/o-Operationen
Alle Aufrufe der Trap #3 arbeiten mit dem {work}-Kanal, darum ist eine Kanal-
nummer als Parameter nicht vorgesehen. Die Wartezeit wird der User-Variablen
{io-time} entnommen und kann auœerdem mit den weiter unten notierten Register-
Operatoren ver€ndert werden. Fehlercode 0 steht f‡r ordnungsgem€œen Verlauf.
Kennzeichnung (G):
Die Graphik-Aufrufe belassen abweichend von der sonst strikt befolgten Regel
ihre Parameter im Stack. Grund ist die Ausf‡hrungsgeschwindigkeit. Da zumeist
mehrere solcher Aufrufe aufeinander folgen, und sie h€ufig die Vorg€ngerdaten
weiterverwenden, werden sie auf diese Weise wesentlich schneller abgearbeitet.
Sie arbeiten s€mtlich mit Flieœkommazahlen.

arc             ( fxs fys fxe fye fa -- ... )(G)
                ..s Anfangs-, ..e End-Koordinaten, fa ¤ffnungswinkel
at              ( zeile spalte -- )
bfill           ( y0 x0 hoch breit farbe -- )
border          ( breit farbe -- )
chenq           ( -- zeile spalte breit hoch )
clrbt           ( -- )
clrln           ( -- )
clrrt           ( -- )
clrsc           ( -- )
clrtp           ( -- )
csize           ( hoch breit -- )
curdis          ( -- )
cursen          ( -- )
edline          ( ptr1 maxlen -- ptr2 len ) vereinfachter Aufruf, ptr1 zeigt
                auf das count-Wort der Textvorgabe, len ist die max. L€nge.
                Zur‡ck gehen ptr2 und len passend f‡r sofortiges {type}, d.h.
                ptr2 zeigt dann auf das erste Zeichen der Eingabe. Arbeitet
                im {in-cons}-Kanal an aktueller Cursorposition. Mit
                        in-cons work >chan< edline in-cons work >chan<
                kann bei Erhalt aller ‡brigen Kanalzuweisungen auch dieses
                Wort auf den {work}-Kanal bezogen werden.
elips           ( fx fy fex frad1 frad2 -- ... )(G)
fbyte           ( -- c1 err )           c1 nur g‡ltig bei err = 0
flash           ( flg -- )
fline           ( ptr len -- len err )
flood           ( flg -- )
fount           ( adr1 adr2 -- err )
fpos            ( -- d.fpos )
fscheck         ( -- err )
fsflush         ( -- )
fsload          ( d.adr d.len -- )
fsmkdr          ( -- )
fsrename        ( ptr -- )              nur mit Minerva oder TK2 - auœer bei
                Minerva arbeitet die Trap nur an eigens dazu ge„ffneten Kan€len.
fssave          ( d.adr d.len -- )
fstrunc         ( -- )                  nur mit Minerva oder TK2
                L€œt sich mit der Kombination {headr} & {heads} nachbilden, wenn
                der Header mit der verk‡rzten Filel€nge zur‡ckgeschrieben wird.
fstrg           ( ptr len -- err )
fsvers          ( d.vernum -- )         Version lesen mit {d1l@}, nur TK2
gcur            ( ycpix xcpix ygpix xgpix -- ... ) (G) nicht fp
headr           ( ptr -- len err )      Lese-L€nge mit {d2w!} einzustellen.
heads           ( ptr -- len err )      immer 14 Bytes senden
ink             ( farbe -- )
line            ( fxs fys fxe fye -- ... ) (G)
mdinf           ( ptr -- gut frei err )
ncol            ( -- )
nrow            ( -- )
nl              ( -- )
panln           ( pixel -- )
panrt           ( pixel -- )
pan             ( pixel -- )
paper           ( farbe -- )
pcol            ( -- )
pend            ( zeit -- err )
pixp            ( ypix xpix -- )
point           ( fx fy -- .. )(G)
posab           ( d.fpos -- err )
posre           ( d.len -- err )
prow            ( -- )
pxenq           ( -- ypix xpix hoch breit )
recol           ( ptr -- )
sbyte           ( c1 -- )
scale           ( fmaœstab fx fy -- ... )(G)
scrbt           ( linien -- )
scroll          ( linien -- )
scrtp           ( linien -- )
setmd           ( flg -- )              flg mit der Zahl wie OVER zu ‡bergeben
sstrg           ( ptr len -- err )
strip           ( farbe -- )
tab             ( spalte -- )
under           ( flg -- )
wdef            ( y0 x0 hoch breit border farbe -- )
xinf            ( ptr -- err )
                holt 64 Bytes der Medien-Definition nach ptr. Wegen eines
                Fehlers in einigen TK2-Versionen sollten f‡r die Ablage zur
                Sicherheit 100 Bytes freigehalten werden. Der F6-Aufruf
                arbeitet auch mit MDV-Laufwerken und unabh€ngig vom TK2.
            >>> This version does not depend on the TK2 being present,
                and it woks with any directory device, MDV inclusive.
                Due to an error in some versions of TK2 this call should
                work on a 100 bytes buffer to prevent system damage.

trap3           ( c1 -- )
                Arbeitet mit dem Kanal c1 und benutzt die zuvor mit den
                Registeroperatoren (s.u.) eingetragenen Werte.

* Registerzugriff bei Aufrufen der Trap #3              LR
* ..! zum Ablegen vor dem Aufruf, ..@ zum Lesen danach

a1l!    a1l@
a1w!    a1w@
a2l!    a2l@
a2w!
d0w!    d1b@
d1h!    d1h@
d1l!    d1l@
d1w!    d1w@
d2l!
d2w!
d3w!
sp!a1           Stackpointer auf F6-Referenz bezogen als A1.L vorlegen.

* nicht wiedereintrittstauglich, darum nur paarweise unverschachtelt aufzurufen:
d3t!            alte Wartezeitangabe sichern, neue festlegen.
d3r             alte Wartezeitangabe wiederherstellen.

* Varianten und besondere Systemaufrufe

[jdt]           ( -- ptr )
                Cons, liefert den ptr auf eine Adresse im F6 mit folgenden
                beim Job-Start ermittelten Kenndaten des umgebenden Systems:
                Alle nicht anders bezeichneten Posten enthalten Langwort-Werte.
                        disp    Bedeutung
                jdttab  0       Adresse der eigenen Job Definition Table
                procftb 4    .b -1 68010+, 0 sonst
                emuflag 5    .b -2 qxl, -1 emu, 1 vor JS, 0 sonst
                        6    .b qdos Version, Nationalit€ten-Kennbuchstabe
                miflag  7    .b -1 minerva, 0 sonst
                mtinftb 8       eigene Job-id
                        12      bereinigte (s.o. Pos. 6) QDOS-Versionsnummer
                sysvari 16      Basisadresse der Systemvariablen
                deftch  20      Standard-Fensterkanal (als Notfall-Vorgabe)
                        24      F6 Basispointer a6 = [bp]
                        28      (Verwendung
                refclon 32      bei f6-clone A6 des Besitzers
                wmanvec 36      Window-Manager Basisvector oder 0
                        40   .w (intern benutzte Flag)
                hishnd  42      Commandline-History Handler
                                initial -1, vom 1. Aufruf {is-his} besetzt.
call            ( d.A4 .. d.A0 d.D4 .. d.D0 dadr -- d.A4 .... d.D0 ) F6
                Allgemeiner Aufruf der Stelle dadr, setzt d7:=d0 und a5:=a3.
                Die 4th-Register (d6/d7/a3/a4/a5/a6) werden restauriert.
                Als Beispiel hierzu ist {is-his} auch in "forth_scr" definiert.
cdt             ( c1 -- d.adr flg | -1. -1 )                    F6
                flg = 49 bei PIF-aktivem Fenster, 1 ohne PIF, 0 anderer Kanal.
                Mit diesen R‡ckgabewerten ist es leicht, ohne besondere Vorkeh-
                rungen bei automatischer Ber‡cksichtigung des PIF die Parameter-
                basis eines Fensterkanals zu bestimmen:
                        ( c1 ) cdt dup 0> IF 1- m+ ELSE d0= d0= ENDIF ( dn | 0 )
                was entweder diese Adresse liefert, oder einfachen flg-Wert 0;
                Fehlerbehandlung danach z.B. m„glich mit
                        ( dn | 0 ) -dup 0= IF -15 error ENDIF ( dn | abort )
d>date          ( d.date -- ptr count )         Text mit Datum & Uhrzeit
d>day           ( d.date -- ptr count )         Text mit dem Tag
eof             ( -- flg )                      flg = 1 wenn eof erreicht ist,
eof?            ( -- flg )                      flg = 1 wenn ernum = -10 ist,
                      und {eof?} vor der Abfrage von {ernum} aufgerufen wurde.
                             .. sbyte eof? 1- ernum drop and dup ?error
                      schlieœt z.B. EOF aus dem Fehler-Abbruch aus.
flen            ( -- d.flen )
fstrg-l         ( d.adr len -- )
pif             ( -- )(I)                       Vocabular
poseof          ( -- )                          eof aufsuchen
sstrg-l         ( d.adr len -- )
-xstrip         ( c1 flg -- )
                flg =/= 0: Schrift- und Hintergrundfabe des Kanals c1 tauschen.
xstrip          ( c1 -- )
                wie {-xstrip}, stets ausgef‡hrt.

* PIF-Vocabular, Untervocabular von QDOS
Wenn das Pointer-I.F. nicht vorhanden ist, erscheint dieses Vocabular leer.

flim            ( -- ymin xmin maxhoch maxbreit )
lblb            ( ys xs ye xe d.blob d.patt -- )
outl            ( y0 x0 hoch breit set/mov -- ) "outline" ohne "Schatten"
pick-job        ( d.jobid -- )
pinf            ( -- d.pifvers d.wmanvec )
qflim           ( -- y x h b )
                identisch {flim} jedoch mit Standardvorgabe, wenn PIF fehlt.
rptr            ( y x tab 0 recordptr -- y x )
rpxl            ( y x d2-code -- farbe posn )
rspw            ( y x flg 0 ptr.maœe d.saveadr -- )
spry            ( y x d(.w)pix d.blob d.patt -- y x )
sptr            ( ypix xpix flg -- y x )
svpw            ( y x 0/hoch&breit ptr.maœe d.memadr -- d.saveadr )
swdf            ( d.adr -- )
wblb            ( y x d.blob d.pat -- )
wrst            ( d.adr flg -- )
wsav            ( d.adr d.len -- )
wspt            ( y x d.sprite -- )

* Hotkey-System

hot!            ( ptr len -- err )              String in den Hotkey-Puffer
hot@            ( ptr -n1 -- ptr len )          -n1 lfd. Nr. im Hotkey-Puffer
[th-entry]      ( -- ptr )
                Vari, mit Basisadresse des "Thing"-System-Einsprungs.
[wman]          ( -- ptr )
                Vari, mit Basisadresse des Window-Manager-Einsprungs.
                        [wman] 2@ 4 type-l
                schreibt die wman-Versionsnummer hin.

* Trap #4 : A6-relative Adressierbarkeit
Ein Trap#4-Aufruf steht nicht zur Verf‡gung, da in standardm€œigen QDOS-Jobs,
wie dem F6, der Wert des Registers A6 nur durch das Programm selbst ver€ndert
werden kann und darum die f‡r die Trapaufrufe ben„tigten relativen oder wirk-
lichen Werte gefahrlos zusammengesetzt werden d‡rfen.

* Trap 5 bis 15
Sind s€mtlich unbenutzt, werden aber von der Trap-Umleitung des F6 miterfaœt
und zu diesem Zweck auf ein RTE gelenkt. Mit eigenen Aufrufen besetzt sind:
CHK             Umschaltung in den Supervisor-Modus, Statusregister zum Stack.
ADDRESS ERROR   Abfangen von Adressierungsfehlern; systemabh€ngig.
Wie im einzelnen dies durchgef‡hrt wird, ist dem Assemblertext zu entnehmen.

* MINERVA-Vocabular (leer, rsp. seit Vers. 8.08 nicht mehr vorhanden)

* ASM68-Vocabular (Assembler in "f6asm_scr", Beschreibung in "as_gls")
Das Vocabular ist vorbereitet, ein vollst€ndiger 6800x-Macro-Assembler steht
in "f6asm_scr" zur Verf‡gung. Er nimmt ca. 10K in Anspruch, einschlieœlich
umfangreicher Hilfsaufrufe und Strukturworte werden daraus rund 16K. F‡r
Anwendungen, die einzelne Assembler-codierte Passagen enthalten sollen, kann
mit Hilfe von {c-save} und {c-load} der Assembler sp€ter fortgelassen werden,
sodaœ dann nur der Platzbedarf f‡r die assemblierten Forth-Worte entsteht.
F‡r den Anfang stehen hier die Ptr auf einige wichtige Stellen im System.
Sie sind etwas ausf‡hrlicher erl€utert, um die Verbindung mit nachtr€glichen
erg€nzenden Definitionen zu erleichtern. Zur weitergehenden Dokoumentation
wird auf den Assembler-Quelltext verwiesen, das Glossar zum Assembler, und
viele Anwendungsbeispiele in "f6task_scr", "f6a80_scr" sowie "f6xco_scr".
Grundlage ist ein irgendwann Anfang der 90-er Jahre in die H€nde des Autors
gelangtes Derivat des 68000-Assemblers von Laxen & Perry, das f‡r das F6
vervollst€ndigt, stark erweitert und auch von Fehlern befreit wurde.

Als 4th-Register m‡ssen bei neuen Processorcode-Aufrufen gesch‡tzt werden:
Im F6 mit besonderer Verwendung:
                D2      bei Deferred-Aufrufen zur inneren Daten‡bergabe
        OS      D6      Segment Offset (reserviert)
        NX      A3      Einsprung in den Inneren Interpreter
        BP      A6      Basis-Ptr, Bezugspunkt f‡r 4th-Adressen
Gem€œ dem f.i.g.-Modell bezeichnet und verwandt:
        US      D7      Offset rel. BP auf User-Area, Werte der User-Vari
            ("US" der Klarheit halber, da UP durch ein Forth-Wort besetzt ist)
        IP      A4      Instruction Ptr, der 4th-Programmz€hler
        SP      A5      Datenstack
        RP      A7      Returnstack
Alle anderen Register k„nnen ver€ndert werden, werden aber ‡berschrieben.
Solange die folgenden erhalten bleiben, liefern sie die Informationen:
                D0      allgemeine Flag f‡r {l<i} - s. dort.
                D1      Case-Index f‡r {#case}
Der Innere Interpreter bei <next> ver€ndert nur die folgenden Register:
         T      A1      u.a. zur Ermittlung der Aufrufadressen
         W      A2      u.a. Word Ptr, unmittelbar nach dem Aufruf Ptr in pfa,
                        kann bei Primitive-Definitionen stets sicher als Ptr
                        auf die der cfa folgenden Daten benutzt werden.
        IP      A4      Instruction Pointer (Programmz€hler des Forth).
A1 und A2 k„nnen davor beliebig verwandt werden, A4 muœ unber‡hrt bleiben.

* F6: Die [namen] liefern als Constante einige wichtige Stellen im System:
[docall]        ptr zum Einsprung in Subroutinen mit Return nach <next>
[docol]         ptr nach <docolon>, leitet hi-level-Definitionen ein.
[dodefer]       ptr nach <dodefer>, verlangt den ptr auf die cfa im W-Register.
[dojump]        cfa der Primitives mit auœerhalb des 4th-adressierbaren Bereichs
                liegendem Programmcode.
[do;does]       Einsprung des Runtime-Aufrufs von {;does>} dosemidoes
                {;does>} f‡hrt das standardm€œige {(;code)} aus und compiliert
                vor den hi-level-Ausf‡hrungsteil den Sprung nach <dosemidoes>
                        jsr     dosemidoes-Z(BP)   (Z ist der BP-Bezugspunkt)
[donext]        Der Subroutinenaufruf des virtuellen 4th-Processors ist <next>
                mit dem 4th-ptr [donext]. Dort steht der innere Interpreter.
[dosemis]       4th-Ptr auf das rts- quivalent des f.i.g.-Modells.
[cprim]         2constant mit der d.adr eines Hilfsaufrufs f‡r Primitive-4th-
                Worte, die damit als gew„hnliche Subroutine ausgef‡hrt werden.
                Beschreibung s.u., Hinweise zum F6 Assembler-Quelltext.
[cdefer]        entsprechend f‡r {defer}ed angelegte Worte.
* im Forth-Vocabular:
nopdf           ist eine {defer}red Definition im F6-Kern und kann als Referenz
                f‡r in Primitives eingebaute {defer}red-Aufrufe benutzt werden.
                Die betr. Stelle im Assemblercode relativ zum Blockanfang wird
                z.B. mit Hilfe eines Labels in eine Constante ‡bergeben, durch
                die sich nach dem Einf‡gen eines Codeblocks mit {c-load} der
                Aufruf auf den wirklichen Vector justieren l€œt.
+nul            als Variable mit dem Inhalt 0 l€œt sich €hnlich nutzen.


* Hi-/Lo-Level-Mix
Dem einfachen §bergang zwischen Forth-Worten und Assembler-codierten Passagen
dienen {;c} und {code}, deren endg‡ltige Definitionen in "f6asm_scr" stehen:
        : name ..forthworte.. ;c ..assemblercode.. code ..forthworte.. ;


» ende glossar, folgt Anhang mit Referenzlisten "F6REF_txt" »
