* 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 enthlt als Steuerzeichen nur <lf> - Code 10 - am Zeilenende und um-
fat 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 - EINFHRUNG
                     ->  Teil 2 - GLOSSAR
                              3 - Referenzlisten


* "F6GLS_txt" - Glossar

* Bezeichnungen, Angaben zur Notation:

4th             abgekrzt 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 Vorschlge des Autors.
             >> F6 special.
F6S             fr zustzlich 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
                fr den QL, insbes. die qdos-Kanal-Tabellen betreffend.

* Wort-Typen
integer         jeder 16-Bit-Wert, als Zahl im binren 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-Fliekommazahl,
                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 fhrendem Zhler-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 fhrendem Zhler-Byte, dem "countbyte".
             >> byte counted string

   Notierung fr 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 whrend
                dessen Ausfhrung zum Stack gelangt - s. auch "literal".
Wert            Bestand einer beliebigen Dateneinheit.
String          lckenlose Gruppe als Schriftzeichen interpretierbarer Bytes.
                Die meist vorzufindende Umschreibung "Zeichenkette" trifft nicht
                zu, da die Zeichen in keinerlei Zusammenhang miteinander stehen,
                "Zeichen-Strang" wre akzeptabel, ist aber ungebruchlich.
                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 heit 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 unntige Speicheroperationen.
                Der Klarheit halber wird in diesem Text zwischen "Pointern" als
                "4th-Adressen" und "wirklichen (32-Bit-)Adressen" unterschieden.
+ve             fr einen Wert ab Null,
-ve             fr einen Wert unter Null.
negative Null   Zahl, bei der nur das (hchstwertige) 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) zulssiger 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 spteren 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 ausfhrbarer Processorcodes.
primitive       Wort, das sofort in direkt ausfhrbaren Processorcode mndet.
runtime      1. Zeitpunkt der Ausfhrung eines Wortes, rsp.
             2. Kurz fr "runtime executive", die beim Aufruf eines Wortes aus-
                gefhrte 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 abhngig vom in {state} notierten Systemzu-
                stand (compilierend/interpretierend) unterschiedlich arbeitet.
AQ              Hinweis auf den Atari-QL, es gilt dasselbe wie bei QX.
QX              speziell fr QXL/SMSQ. Anwendung im SMSQ/E wegen immer wieder
                neuer und nicht stndig berprfbarer Versionen u.U. unsicher.
                Gewissenhafte Prfung bei zumutbarem Aufwand war nur in der
                Version 2.76 des mit der QXL gelieferten SMSQ mglich.
             >> 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" - Programmzhler, 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 fr MINERVA (und SMSQ) eingerichtete Ergnzung
                dazu fr 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 fhren, gilt zugleich fr Trump-/Gold-Card u. QXL/SMSQ.

* Systematische Begriffe
t.o.s.          "top of stack" - zuerst errreichbarer Stackposten.
sys             Compiler-Kontrolldaten, vorbergehend 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
                flchtigen 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 Seitengre
                (c/l * b/scr) teilbarer Lnge - Standardmig 1024 Bytes/Seite;
                der Name deutet auf die Darstellungsweise in Bildschirmseiten.
block           Die "screen" besteht aus Blcken mit einer systemabhngigen
                Anzahl Bytes, die einer Zweierpotenz entspricht.
                Im F6 hat eine "screen" 16 "block"s zu 64 Bytes Lnge.
             >> One screen is 16 blocks of 64 bytes - re below.

* Wortgestalt
{name}          Forth-Worte erscheinen im Text zwischen geringelten Klammern.
                Die Namen drfen 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 spter auch erkannt, jedoch knnen mehrdeutige
                Namen entstehen: Das System prpariert sie so, da die gltigen
                Schriftzeichen mit gelschtem 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 gltigen Codes ab 33 zur
                Deckung und knnen nicht als verndert erkannt werden, soda die
                damit gebildeten Namen spter verflscht 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 unzugnglich 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 fhrender rsp abschlieender Zeichen bei 4th-Namen {...}
- ...           fhrendes "-" deutet an, da das Wort eine Aktion Flag-abhngig
                ausfhrt, oder selber eine Flag liefert.
" ...           Variante der Operation {ccc} fr eine Folge von Schriftzeichen.
? ...           zumeist eine Prfoperation mit {abort} im Fehlerfalle.
2 ...           Stackoperation an allgemeinen doppelt-groen Posten
4 ...           dto., vierfache Postengre.
d ...           vorwiegend fr vorzeichenbehaftete 32-Bit-Zahlen; Arithmetik.
q ...           dto., vierfachgenaue Zahlen.
 ... "          Wort erwartet oder holt eine Folge von Schriftzeichen.
 ... .          Schreibt eine Zahl rsp ein Textstck (auch bei fhrendem ".").
 ... :          Definitionswort.
 ... ?          Liest Daten und schreibt davon abgeleitete Zahl oder Text.
 ... ]          Wort mit bergang in den Compile-Zustand.
   Diese Namensmarkierungen sind standardmig nicht immer konsequent benutzt,
   geben aber meist zuverlssige Hinweise auf die Funktionen der betr Worte.

   Begrenzungszeichen zwischen Worten ist das Leerzeichen, auerdem gilt die
   ascii-<nul> (chr$ 0) als unbedingte Begrenzung, die dazu noch eigene Akti-
   vitten auslst, da sie zugleich Name eines (wichtigen!) Forth-Wortes ist.
   Gleiche Bedeutung hat das Zeilenende, unabhngig von der Eingabequelle.

   Zahlenangabe ist in verschiedener Form unabhngig von {base} mglich:
        %101    binr           !123    quaternr
        &123    oktal           #123    dezimal
        123    duodezimal      $123    sedezimal
        {A      ein Zeichen-Code (ersetzt z.B. das ASCII des F83-Forth),
                gilt mit Ausnahme der Lnge 2 fr 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 hchstwertigem Bit (7),
  p     precedence-Bit (6), das den "immediate"-Status bestimmt,
  s     smudge-Bit (5), das den Wortheader fr {-find} sperrt oder freigibt
  c     und den fnf niederwertigen Bits als Zhler fr die Lnge des Namen.
name    bis zu 31 Schriftzeichen, gesetztes Bit 7 markiert das Ende.
        Die hchstwertigen Bits der Codes von 128 bis 160 werden vor Eintragen
        der Grenzenmarken gelscht und durch {id.} restauriert.
        Die nfa kann an ungerader Adresse liegen  - s. {create} - der Compiler
        justiert sie so, da die lfa geradzahlig unmittelbar anschliet.
lfa     "linkfield address"
        mit einem ptr, der auf den Vorgnger im selben Vocabular zeigt.
cfa     "codefield address" (auch: compilefield)
        weist auf direkt ausfhrbaren 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 fr cfa, bezeichnet eine Eintragung in der Parameterliste.

* frei definierte Worte

Die Standardform entsteht mittels <BUILDS .. .. DOES> und erzeugt den Aufbau
wie anschlieend am Beispiel der Vocabulare dargestellt. Alternativ kann auch
die in den spteren Forth-Typen eingefhrte 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. bezglich
ihrer PFA nicht mehr von den Colon-Definitionen:

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

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

* Vocabulare

Die Definition ist Standard-vertrglich (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" hlt die nfa des jngsten Wortes des Vocabulars.
        Der Ptr auf diese Position gelangt beim Aufruf in den Vocabularstack.
voclink sein "codefield" verkettet ein Vocabular mit dem bis dahin jngsten,
        indem es auf dessen [voclink]-Position gerichtet wird und die eigene
        Adresse bei der Vocabulardefinition in die User-Vari {voc-link} gelangt.
    zustzlich:
search  die eingeprgte secundre Suchfolge, initial mit {current} besetzt.
ff      das niederwertige Byte dient als Flag fr fp-compilierende Vocabulare,
        das hherwertige Byte sperrt bei den {-find}-Varianten ein bereits
        durchsuchtes Vocabular fr die erneute Suche, soda mehrmaliges Vor-
        kommen in der Suchfolge keinen Einflu auf die Compilezeit hat, und
        Endlosschleifen durch das Secundrvocabular ausgeschlossen werden.

        Dank dieser Struktur ist es recht einfach, wie z.B. in {forget}, die
        gesamte Vocabularkette Wort fr 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 zunchst aus der Vocabulardefinition die
        nfa des jngsten Wortes, von wo ausgehend mit denselben Aufrufen
        die Kette dann zurck bis nach [vocnfa] fhrt. Gleichheit mit dem
        dort hilfsweise eingetragenen Ur-Namen ist Abbruchkriterium fr die
        Wortkette, whrend die Vocabularverkettung im F6 mit $8000 endet.
        $8000 ist auerdem Inhalt der ersten lfa des Systems im Wort {root}
        und mu darum in die Abfrage der inneren Schleife einbezogen werden.

        Das eingeprgte Secundrvocabular entspringt dem Versuch, ohne einen
        seiner Natur nach notwendig begrenzten Vocabularstack auszukommen, und
        die mgliche Suchfolge auf eine beliebig groe Anzahl Vocabulare auszu-
        dehnen. Obwohl das auch genau so der Fall ist, wurde die Stackstruktur
        zustzlich bernommen, da sie sich als sehr handlich erwiesen hat.
        Ntzlicher Nebeneffekt ist die fr die OOP erforderliche und hierdurch
        leicht mgliche fix eingeprgte Aufruf-Hierarchie.

        Mit beispielsweise nur CURRENT und beiden CONTEXT-Posten besetzt, etwa
                only forth definitions
                2nd-voc on
                hidden minerva
        sieht die eingeprgte Suchfolge mit den Vorgabedaten folgendermaen aus:
                hidden forth minerva fp qdos pif forth
        denn {hidden} hat das Secundrvocabular {forth}, das seinerseits kein
        weiteres Vocabular angibt, und {minerva} weist nach {fp}, dieses nach
        {qdos}, welches {pif} zum Secundrvocabular 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 fr den Processor benutzt wird, ist der Umgang
        mit der "Null" ein wenig heikel. In allen Fllen, die die Suche in
        Vocabularen betreffen, wird die wertmige 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 frheren Versionen auftretenden Probleme bei Worten nahe der
        4th-Adresse Null konnten damit nun auch restlos gelst 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 knnen 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 zugnglich, 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 Fliekommaposten 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 fr andere Zwecke eingesetzt werden.
             >> save the current stackptr
!name           ( ptr1 n2 ptr3 -- )
                max. n2 Bytes Text mit 16-Bit-Zhler 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 belt den Divisionsrest d2 im Stack.
                Anwendung zwischen <# und #>. Mit {#} lassen sich beliebig
                formatierte Ziffernstrings definierter Lnge 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#} ausgefhrt, 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 zuverlssigen Werte. Es
                wird der unvernderte Index angegeben, auch, wenn er ber eine
                der Grenzen hinausweist. Das erste oder letzte Wort einer Liste
                kann auf diese Weise berlaufende Werte gebndelt bernehmen
                und sie dann einzeln weiterbearbeiten. Innerhalb einer Worte
                ausfhrenden {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
                lt den Rest unverndert.
             >> 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
                grtmgliche 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 Rck-
                gabe der Lnge und des Ortes, wo der String zu finden ist. Der
                Ablagebereich wird durch jede Form der Zifferndarstellung (auer
                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 fr 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 vollstndig in Ziffern umwandeln und die Zeichen an ggf.
                bereits ermittelte Zeichen anhngen - zwischen {<#} und {#>}.
                Immer wird mindestens eine Ziffer geschrieben, so lassen sich
                z.B. auch Zahlen einer gewissen Mindestlnge erzeugen:
                        ( dn ) <# # # # #s #> type
                schreibt eine wenigstens vierstellige Zahl hin, lngere Zahlen
                werden vollstndig ausgegeben, krzere auf vier Stellen mit
                fhrenden Nullen aufgefllt.
$>f             ( ptr1 -- f2 )                          F6 QDOS
                qdos-String von 4th-Adresse ptr1 als Fliekommazahl zum Stack.
                Setzt als fp-Signal {dpl} auf -2 und sichert den hchstwertigen
                Stackposten fr 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 binr 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 zustzlich angegeben wurde.
             >> ptr to a filename used by {s-load}
(d#)            ( dn1 n2 -- ptr3 n4 )                   F6      8.16 => hidden
                Zahl dn1 abhngig vom Vorzeichenflag n2 in String der Lnge 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. fr {chain} u.. Worte.
(file)          ( -- ptr )                              F6
             >> filename used by the editor and when {dr1} active.
(joker)         ( -- n1 )                               F6
                Constante, deren Wert einen Zeichencode reprsentiert, 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 Lnge n4 der Zeile n1 in Seite n2
                des gerade gltigen 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 Fllzeichens fr {.r} u. dgl.
(screen)        ( -- ptr )                              F6
                filename used by the editor, and when {dr0} active.
(update)        ( -- ptr )
                Schreibfreigabe fr {r/w}
(upper)         ( -- n1 )                               F6
                Maskierung fr die Aufrufe mit Zeichenvergleich bestimmt die
                Abhngigkeit von der Schreibweise: -33 nicht -1 beachten.
                Fehler, die durch diese einfache Maskierung entstehen knnen,
                betreffen (fast) nur Codes auerhalb des fr Schriftzeichen
                gltigen bereichs, welche darum zugunsten hherer Ausfhrungs-
                geschwindigkeit in Kauf genommen wurden.
(wcard)         ( -- n1 )                               F6 (vorlufig)
                Code fr ein "wildcard"-Zeichen, das bei {t=} und {tl=} eine
                Gruppe von Zeichen beliebiger Lnge 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 Verfgung, wobei aber beide Einsatz-
                zeichen nicht auf die blichen "?" und "*" festgelgt sind, son-
                dern je nach Erfordernis beliebig codiert werden knnen.
             >> 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 } geringfgig schneller ausgefhrt.
*/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 nchsten n1 Zeilen beim Lesen eines Screenfile,
                Bei negativem n1 zhlt die Zeile des {+continue} mit.
+loop           ( n1 -- )(C)
                Abschlu einer Zhlschleife mit Angabe der Zhlstufung n1.
                Endlosschleifen z.B. durch 0 +LOOP werden abgefangen.
+nul            ( -- ptr )                              F6
                Adresse einer Speicherstelle, die den Wert 0 enthlt.
+origin         ( n1 -- ptr )
                liefert mit einem Index lt. f.i.g.-Modell einige Initiierungs-
                Daten fr den Systemstart und die Wiederherstellung bei {cold}
                und {warm}. Zunchst die Verwendungsdefinition fr F6-Kanle:
                        -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 ausfhrbarer 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 nchsten Posten von der f.i.g.-Vorgabe
                ab. Die blichen User-Vari knnen in gewohnter Weise verwandt
                werden, sie mssen jedoch bei Vernderungen, 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-}
                Standardmige 16-Bit Initiierungswerte
                        28      {tib}
                        30      {width}
                        32      {warning}
                        34      {fence}
                        36 32-Bit {dp 2-}
                        40      {voc-link}
                        42      {up} User-Vari Laufptr
                Zustzlich schlieen 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, brcksichtigt 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 fr das "hotkey-thing"
                und als 16-Bit-Variablenwerte:
                        72      (quit) erste cfa fr den Systemstart
                        74      {ert}-Aktivierung/-Sperrung
                        76      Maus-Code fr {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 anhngen,
                beide Strings knnen auch an ungeraden Adressen stehen.
-               ( n1 n2 -- n3 ) ( f1 f2 -- f3 )
-->             ( -- ) (I)
                Beim Laden nchste Seite im Screenfile aufsuchen. Dies wird bei
                zugnglichem {in-cons}-Fenster dort mit einem Punkt angezeigt.
                Auch innerhalb von Worten oder Listen ohne besondere Manahmen
                im Compilezustand zur Fortsetzung einer Definition verwendbar.
                Falls beim Seitenwechsel der Stack eine andere Anzahl Posten
                enthlt, als beim Eintritt, werden zur Kontrolle und ggf. leich-
                teren Fehleranalyse Seitennummer und Differenz hingeschrieben.
                Darf nicht am Schlu eines Screenfile stehen, denn dann wrde
                der Ladevorgang endlos fortgesetzt, weil EOF bei Screenfiles
                nicht als Fehler gilt, also auch nicht zum Abbruch fhrt. Das
                Signal zum Beenden des Ladevorganges ist bei diesem Filetyp mit
                {;s} immer explizite anzugeben - fr {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"-abhngig Compilieren rsp. Ausfhren 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,
                unabhngig vom Typen als 4th- oder qdos-String, wobei beide
                max. 255 Zeichen lang sein drfen. 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 spterer Standards.
-exit           ( flg --) (C)                           F6
                Bedingtes Verlassen eines Wortes, steht fr
                        ... IF ;s ENDIF ...
                Optimiert zu {0=exit}, wenn {0=} vorangestellt ist; darf ohne
                zustzliche 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 einschlielich der Flags zum Worttypen. Ist dem {find}
                spterer Standards insofern berlegen, als es neben dem Prece-
                dence-Bit (fr den "immediate"-Status) auch die anderen Kopf-
                daten verfgbar macht:
                        -find {name}    0= 0 ?error     \ prft Vorhandensein
                                        dup $40 and .   \ Precedence-Bit
                                        dup $20 and .   \ Smudge-Bit (Null)
                                            $1f and .   \ Lnge des Namen
                Bei geeignetem Header-Aufbau und entsprechendem Verfahren zur
                Wortsuche ist auch das hchstwertige 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 nchstem 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 Lnge n2 vom Ende her nach demm Byte c3
                suchen, n4 als Bytenummer des gefundenen Zeichens zurckgeben:
                n4 zhlt ab 1, ist 0, wenn c3 nicht gefunden wurde.
-trailing       ( ptr count1 -- ptr count2 )
                <bl>s des String der Lnge count1 bei ptr vom Ende her kappen.
                Hierdurch wird nur der Zhler im Stack verndert - was fr die
                Ausgabe gengt; die Ursprungsdaten bleiben unberhrt.
-window         ( c1 -- flg )                           F6
                flg = 1 bei eigenem Fensterkanal ohne PIF, flg = 49 mit PIF.
-0              ( -- $8000 )                            F6
                Cons, "negative Null", fr alle vocabularbezogenen Aktionen,
                oder wo sonst der niedrigst mgliche Forth-Ptr bentigt 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 Lnge count1
                rechtsbndig in einem Feld der Lnge MAX( count1,count2 ),
                gezhlt ab der aktuellen Ausgabe-Position. Der Code fr das
                ggf. zum Auffllen benutzte Zeichen steht in {(r)}, kann also
                frei gewhlt werden - er gilt auch fr {.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 lnge 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 fr 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 whrend des Compilierens.
.r              ( n1 n2 -- )
                n1 rechtsbndig in ein Feld mindestens der Gre 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 zurck, 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 Prfung 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 ( -- )
                lt er sich unabhngig 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 lschen
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 hochrcken.
                ( d1.. dm .. dn -nm -- d1 .. dn dm .. dn-1 dm )
                Posten dn abheben und an Position nm einfgen.
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 zhlt 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, trgt ihn in das {current}-Vocabular
                ein und sperrt ihn zunchst fr die Wortsuche. {context} wird
                auf das {current}-Vocabular gesetzt, das bisherige zweite Voca-
                bular fllt 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 anschlieender Freigabe des Wortes fr 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: Zustzlich 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 Ausfhrungsteil. Beendet
                den Compilezustand, gibt den Wortheader fr {-find} frei und
                stellt {context} auf das Assemblervocabular ein. Einsetzbar
                wie {;does>} mit dem einzigen Unterschied, da die Ausfhrungs-
                vorschrift in lo-level-Code folgen mu. Da es keine weiteren
                Schutzmanahmen 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 ausgefhrt und um
                eine Speicherzelle krzer angelegt. Jene wird vom DOES> des F83
                nicht mehr bentigt, 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 knnen. Man konstruiert mit {;does>} also allgemein
                        : eigenerName
                                CREATE Bildungsanweisung
                                ;DOES> ausfhrungsanweisung ;
                Wie auch bei der Konstruktion aus <BUILDS .. DOES> lt 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 fr die sptere Wortanalyse bestimmbar:
                        0 constant n-cfa
                        : name CREATE ... ;DOES> [ here 4- is n-cfa ] ... ;
                Eine Besonderheit im F6 - die aber auch anderen Systemen nach-
                trglich mitgegeben werden kann - ist die "Vererbbarkeit" auch
                der Ausfhrungsanweisung. Dazu bedarf es zustzlicher Manahmen
                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 verndert werden.
                Worte, die mit {;does>} gebildet wurden, knnen von {c-load} nur
                wie 'normale' 4th-Worte behandelt werden, die Anpassung innerer
                Aufrufe an vernderte Adressenlage ist im Gegensatz zu den Defi-
                nitionen mit dem standardmigen {does>} dort nicht mglich.
                {;does} enthlt 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 zustzliche 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 erklrt:
                        LET cons% = 123
                Das Bildungsgesetz legt hier fest, da ein Name eingerichtet
                und irgendwie auffindbar gespeichert wird, soda daraus spter
                die ebenfalls eingerichtete Speicherstelle eindeutig auffind-
                bar wird. Die Ausfhrungsvorschrift legt fest, was mit dem
                Inhalt der identifizierten Speicherstelle geschehen soll, hier
                in einer Form, die die dort liegende Zahl verfgbar 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 trgt den Wert ein; spter 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 doppeltgroen Posten {hld 2+} auf denselben Wert,
                so ergibt sich eine Mglichkeit, 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 bentigt, gengt das etwas schnellere {-}.
>               ( n1 n2 -- flg ) ( f1 f2 -- flg )
>chan<          ( c1 c2 -- )                            F6
                Vertauschen der Tabellenpltze zweier offener(!) Kanle
>fount          ( n1 c2 -- )                            F6 bentigt dvs/IO2
                F6-Fensterkanal c1 den mit n1 codierten Zeichensatz zuweisen.
                Codie fr n1 s. {atne}, {bblu}, {hisc}, {losc}, u. -23: latin-1.
>loc            ( n1 -- )                               F6 (vorlufig)
                n1 Zellen "dynamische" Zuweisung eines localen Speicherblocks;
                richtet einen localen Speicherbereich von n1 Zellen ein, dessen
                Gre auch erst whrend der Programmausfhrung 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 Postengre weitergezhlt gelten. Zum Compilieren
                der Local-Constanten-Adressierung mu whrend des Compilevor-
                ganges wenigstens irgendein Datenposten in den Stack gebracht
                und am Wortende wieder fortgenommen werden. Eigene oder Locale
                Variable bergeordneter Worte bleiben unverndert adressierbar,
                allein die Indices sind dafr entsprechend weiterzuzhlen:
                    \ 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} nher beschrieben.
>resolve        ( sys1 -- )                             C1
                Auflsen einer Vorwrtsreferenz 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> bettigt wurde, wartet nach Bettigen der
                <space>-Taste auf erneuten Tastendruck, sonst ohne Wartezeit.
?exec           ( -- )
                abort, wenn im Compilezustand.
?key            ( -- 0 | $8000 | +code | -code )        (F6)
                Wird standardgem ausgefhrt, liefert jedoch zustzlich 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 Blcke Localer Speicherbereiche.
?pairs          ( n1 n2 -- )
                abort, wenn n1 =/= n2.
?stack          ( -- )
                abort bei Grenzenberlauf 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 Datentrger
a/fre           ( -- d1 )                               F6
                2Cons, Anzahl freie Zuweisungseinheiten
a>h             ( c1 -- c2 )                            H4
                Einen Buchstaben als Ziffer interpretiert, sofern mglich,
                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 zurck.
accept          ( ptr n1 -- n2 )                        8.18 ANS
                Wie EXPECT, jedoch mit Rckgbe der empfangenen Anzahl Zeichen
                einschlielich der abschlieenden <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 lschen.
             >> 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-Verknpfung 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-Zahlenprfix "{" ausgefhrt; im Screen-
                file angegeben, um Compatibilittsprobeleme mit F83 zu umgehen.
associative:    (I)                                     F6 (F83)
                Verwendung eigenstndig 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 ausgefhrt.
                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 zweckmig mit Basis-Praefix
                hingeschrieben. Es werden stets einfache Integer eingetragen,
                auch, wenn gerade das fp-Vocabular {context} sein sollte, darauf
                mu also keine Rcksicht genommen werden. In die derzeitige De-
                finition lassen sich Werte von auen bergeben durch:
                        : I, 3 roll , ; immediate
                        ( zahl )
                        associative: name erstezahl .. I, .. letztezahl ;
                Ausfhrung:
                        (nn -- associtative:-liste -- index)
                wo index die ab Null zhlende Nummer des Posten ist, der mit
                dem bergebenen Wert nn bereinstimmt, andernfalls geht die
                Anzahl Posten zurck, dem hchsten Index + 1 entsprechend.
                ndern einer Eintragung:
                        ( index nn ) IS asssociativename
atne            ( -- n1 )                               F6 & IO2
                Cons, Index fr 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-Zeichenstze
                sind wegen ihrer 8-Bit-Breite nur in den Minerva-Systemen vllig
                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 Lnge der Fileheader
b/scr           ( -- n1 )
                Cons, Blcke 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 fr die Zahlenbasis im Forth-System
basic           ( ptr -- flg )                          F6
                ptr zeigt auf das count-Wort eines im SBasic (Job 0) bekannten
                Namen. Reprsentiert der eine residente Procedur, die ohne
                Parameter benutzt werden kann, so wird diese ausgefhrt. In
                allen anderen Fllen kann mit {a1l@} der Wertepointer, falls
                ein Variablenname angegeben war, sonst die Ausfhrungsadresse
                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
                erhlt 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 ntige Vorsicht vorausgesetzt, knnen die SBasic-Variablen
                vom F6 auch verndert werden - bei Strings mu die Lnge im
                SBasic erhalten bleiben!:
                        basicv" e$" dup ?error
                                1 m+ count-l
                                " .hpr lt gren" count-w
                                rot min swap base+ rot cmove-l
bblu            ( -- n1 )                               F6
                Cons, Codierung fr einen Zeichensatz - s. {>fount}.
bclr            ( dn1 n2 -- dn3 )                       F6
                Mit n2 angegebene Bitnummer in dn1 lschen.
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 lschen.
                {L<I} liefert ggf. den bis dahin dort gltigen Bitwert.
bfset           ( dadr1 ud2 -- dn3 )
                Mit ud2 angegebene Bitnummer im Bitfeld ab dadr setzen.
                {L<I} liefert ggf. den bis dahin dort gltigen 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 Durchgnge zhlt, entspricht der Sequenz
                        over + swap
break           ( c1 -- )                               H4
                Erwartet den Tastencode zum bedingungslosen Programm-Abbruch.
                Dieselbe Taste zusammen mit ALT lst den Kaltstart aus - {cold}.
buffer          ( n1 -- ptr )
                Puffer fr den Block n1 zur Verfgung stellen.
bl              ( -- c1 )
                Cons, Zeichencode fr Leerzeichen
bs              ( -- )
                Position im Ausgabefenster um ein Zeichen zurcksetzen.
* 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 jngste
                nfa an der Stelle ptr1 eingetragen ist.
c/scr           ( -- n1 )
                Cons, Bytes pro (Editor-)Screen
c/l             ( -- n1 )
                Cons, Lnge 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:} eigenstndig 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 Ausfhrung von Steuer-Codes.
cc4th           ( -- ptr j)                             (F83)   8.16 => hidden
                User-Vari mit ptr zur aktuellen case:-Liste fr die Ausfhrung
                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 hchste F6-Kanalnummer, in der der im F6 offene
                QDOS-Kanal did verzeichnet ist, sonst -1.
chp             ( c1 -- ptr )                           LR
                Speicherplatz der zu c1 gehrigen Kanalnummer, c1 von 0 bis 15,
clone-4th       ( -- )
                Aktive eigenstndige Copie des aufrufenden-F6-Jobs erzeugen.
close           ( c1 -- )                               LR
                Kanal c1 schlieen, keine Fehleraktion.
cls             ( -- )
                Mit {out-cons} bezeichnetes Bildschirmfenster lschen.
cmove-l         ( dadr1 dadr2 n3 -- )                   C1
cmove           ( ptr1 ptr2 n3 -- )
                Speicherbereich der Gre +n3 von Forth-ptr1 nach ptr2 nicht-
                berschreibend bertragen.
cmc             ( -- ptr )
                Cons, als Wort-Zhler 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 mglich 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 weitergezhlte
                Adresse adr2.
count-w         ( ptr1 -- ptr2 n3 )
                z.b. 16-Bit-Zhler eines QDOS-String, ersetzt die Folge
                        2+ dup 2- @
count           ( ptr1 -- ptr2 c3 )
                liefert z.B. das Zhlerbyte von Forth-Strings; steht fr
                        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
                Ausfhrung eines Steuercodes mit unterschiedlichen Parametern.
current         ( -- ptr )
                User-Vari, enthlt 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)
                Nchsten 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 lnge n2 rechtsbndig hinschreiben.
d->s            ( d1 -- n1 | abort )                   (F6S)
                lt sich einschlielich berlaufkontrolle z.B. nachbilden:
                        : d->s 1abs -18 ?error ;
                sonst gengt 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, fr =/= 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 knnen 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 zurck.
date$           ( -- ptr count )                        F6 QDOS
                Legt den Datumsstring zur weiteren Bearbeitung rsp. fr die
                Ausgabe mit {type} bereit.
             >> SBasic's DATE$ ready to {type}
day$            ( -- ptr count )                        F6 QDOS
db-on           ( -- n1 )                               F6
                Cons, Flag fr 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 fr neue Worte oder den flchtigen Compilezustand vorbe-
                reitet. Nachdem die ergnzenden Debugger-Worte geladen wurden,
                knnen mit Werten von 1 bis 4 in {db-on} die prparierten Worte
                entsprechend abgearbeitet werden. Man ruft sie wie gewohnt auf
                und hat folgende zustzliche 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>
                        lst den nchsten Schritt aus.
                Negative Werte in {db-on} suspendieren den Debug-Betrieb, nicht
                aber das entsprechende Compilieren, und belassen die Tastatur-
                abfrage aktiv. Fr 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, fhrt dies u.a. auch {name1} aus, in
                dessen Rahmen die nchste WA ausgefhrt wird. Dies ist oft recht
                ntzlich, wenn ein allgemeiner Aufruf fr verschiedene Zwecke
                eingesetzt werden soll. Dem Debugger bleibt dies jedoch verbor-
                gen, und er fgt nach {name1} seine Arbeits-WA ein, die dann
                von {r+} flschlich gelesen wird, was zu Schden fhren kann.
                        : name2 ... [ db-on 0 is db-on ] name1 bell [ is db-on ]
                vermeidet solche Irrlufer. Mehr in "F6CHG_txt" u. "FORTH_txt".
dds             ( -- ptr )                              F6
                User-Vari, ptr zum hi-level-Einsprung in den Ausfhrungsteil des
                jngsten mit {;does>} gebauten Definitionswortes. Dient der
                Weitergabe der Ausfhrungsvorschrift neuer Definitionsworte.
ddup            ( n1 -- n1 n1 n1 )                      F6
decimal         ( -- )
default-is      ( name | -- )                           F6
                Einen Vector auf die Vorgabe-Aktion zurckstellen; ist auf
                weitere Worte anwendbar, die mit IS besetzt werden knnen
                und einen 16-Bit Datenposten beliebiger Art verarbeiten.
                Ntzlich auch, wenn ein Wort innerhalb eines Programms nur
                beim ersten Aufruf ausgefhrt werden soll, wie z.B. fr 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 unverndert bleibt.
             >> Re-assign a vector to it's default action.
defer           ( exec ) (C) ( DEFER name -- )          F83
                Vorwrtsreferenz einrichten, {name} kann spter mit {is} die
                gewnschte Aktion zugewiesen werden. Bis dahin, im Urzustand,
                fhrt {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 ausgefhrt, deren cfa auf ' name 2+ eingetragen ist.
                Liegt auch diese auerhalb 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 ursprngliche Aktion leicht
                zurckgewonnen werden kann, sondern auch, weil sie selbst
                gegenber dem sehr schnellen {noop} noch einen deutlichen
                Zeitgewinn bringt. Im Vergleich wurden in einer Schleife mit
                1.000.000 Durchgngen 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 zurckgehen und es lschen.
del-defb        ( --er )                                IO2/dvs_byt 8.18
                Aufruf der SBasic-Procedur aus TK2/GC/SMSQ.
digit           ( n1 -- n1 tf | ff )
                Liefert zustzlich den Flagwert 1, wenn n1 als Ziffer zur
                aktuellen Basis aus {base} gltig ist, ersetzt sonst n1 durch
                den Flagwert 0.
dliteral        ( -- dn )  (C)( dn -- )         - "state sensitive" -
                doppeltgenauer Festwert. Nheres 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 ausgefhrt 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 auzufhrenden Teil ein. Darf nur bei Worten ein-
                gesetzt werden, die mit {<builds} aufgebaut werden. Fr die im
                F83 mit {create} bliche Paarung ist {;does>} zu verwenden.
                Nach {does>} ist das im Aufbau begriffene Wort fr {-find} noch
                nicht erkennbar.
dp              ( -- ptr ) User-Vari
                Dictionary-Pointer, wird beim Compilieren weitergezhlt.
                Die niedrigste 4th-Adresse ist $-8000, die hchste $7fff.
                Vorsicht:
                Wird der Inhalt von {dp} direkt durch ein Programm verndert,
                und besteht dabei die Mglichkeit der Vorzeichennderung, mu
                dem Dictionary-Ptr auf der Langwortadresse { dp 2- } die vor-
                zeichenerweiterte doppeltgenaue 4th-Adresse zugewiesen werden.
                Widrigenfalls verkehren sich die Manahmen zur Adressierungs-
                sicherheit in ihr Gegenteil, und das System bricht zusammen.
dpl@            ( -- n1 )                               F6
                Liefert den Inhalt der User-Variablen {dpl}
dpl             ( -- ptr )                              ( F6 fr fp-Zahlen )
                User-Vari, nach der Umwandlung eines Ziffernstring in eine Zahl
                wird hier die Position des (letzten) Dezimal-Kommas (-Punktes)
                verzeichent, gezhlt von der letzten Ziffer an. Steht das Zei-
                chen an letzter Position, enthlt {dpl} Null, fehlt es, steht
                dort -1. Fliekommazahlen 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 auerordentlichen Verlassen eines Wortes.
dr0             ( -- )                                  LR
                Erstes Massenspeichergert aktivieren, i/o durch {screen}.
                Setzt {offset} auf Null. Gltige Screens von 0 bis 16383;
                Screen Null kann nicht in den Interpreter geladen werden!
dr1             ( -- )                                  LR
                Zweites Massenspeichergert 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 gltige 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 - Erluterungen 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 lschen.
empty           ( -- )                                  F6 F83
                Alle Definitionen jenseits der Grenze aus {fence} lschen.
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
                Textstck holen. Anfangs ist c1 nicht erforderlich, es mssen
                ab der Stelle ptr jedoch wenigstens zwei unterschiedliche Zei-
                chen vorhanden sein, deren letztes mit dem Code c1. Fhrende
                Begrenzungszeichen werden bersprungen, erst nach einem davon
                unterschiedlichen Zeichen gilt es als Begrenzung. Leerstrings
                kommen also nicht vor. Vielfach als strend empfunden ist das
                zum einen fr {word} erforderlich, zum andern aber auch zur
                optisch gnstigeren 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 umfat alle Zeichen"
                was sehr viel plausibler aussieht, als die (eigentlich korrekte)
                Schreibweise fr denselben Text:
                        string {name} die Begrenzung umfat alle Zeichen"
                Zurckgegeben wird der unvernderte 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 Lnge 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 fr den unbedingten Einsprung in eine
                BEGIN-Schleifenstruktur an den mit {entry} bezeichneten Ort.
                Dies macht den unbedingten Rcksprung der Strukturen der Art
                BEGIN..WHILE..REPEAT berflssig und erlaubt bei schnellerer
                Ausfhrung 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 zustz-
                liche Operator ohne Wirkung auf die Ausfhrungszeit 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 verrckt:
                        cc IF n1 n2 2>r ENTER [ 2swap ] ENDIF
                                 n3 n4 DO ... [ 2swap ] ENTRY ... LOOP
                Es ist also lediglich darauf zu achten, da fr {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 zurckgestellt.
                Zerstrungsfreies Lesen ist mglich mit:
                        ' ernum cfa @ 2+ base+ @l 2+ 2@
error           ( n1 -- )
                Schreibt die Fehlermeldung zum Code n1 und fhrt {warm} aus.
                Im Verlauf der Fehlerbehandlung wird vor dem Erreichen von
                {quit} eine Kette teils revectorisierbarer Worte ausgefhrt,
                die bedarfsweise auch auf andere Worte eingestellt werden
                knnen. Insbes. {(quit)} dient dabei dem automatischen Start
                und spteren stetigen Wiedereintritt in z.B. ein Programm.
                error (D)       fhrt [error] aus,
                [error]         bei warning > oder = 0 endet es
                                        in der Ausfhrung der cfa aus (quit).
                        (quit)          fhrt in den ueren Interpreter.
                                bei warning < 0 wird abort ausgefhrt
                        abort           ruft (abort) und (quit) auf:
                        (abort) (D)     ist initial mit einem headerlosen Wort
                                        zur Teil-Initiierung besetzt,
                        (quit)          schliet mit Ausfhrung der cfa ab,
                        quit            ist der uere 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 zurck.
             >> 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 nchsten <enter>
                oder der maximalen Lnge n1 und bringt sie nach ptr.
                Die empfangene Lnge ist unmittelbar danach in {span} lesbar.
                Fehler werden durch {(exper)} so abgefangen, da bei Verlust
                des Eingabekanals die Fenstervorgabe vom Systemstart sowohl
                fr in-cons als auch fr out-cons eingetragen wird. Eingabe
                ist sowohl aus Dateien als auch aus Fensterkanlen mglich.
* F
f/n             ( -- n1 )                               F6
                Cons, Maximallnge fr einen Filenamen.
f>$             ( f1 -- ptr count )                     F6 QDOS
                fp-Zahl in Zifferntext umwandeln und zur weiteren Bearbeitung
                rsp fr {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
                Lscht 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, enthlt die absolute Untergrenze fr {forget}, die
                zur einwandfreien Funktion von {empty} und {cold} unbedingt
                eine lfa sein sollte, z.B.:
                        ' task lfa fence !
                Wurde {empty} mit gendertem {fence} oder {forget} unterhalb
                der zuvor gltigen Grenze aufgerufen, sind danach mit {safe!}
                die Initiierungsdaten fr {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 Lnge aus
                {f/n} mit Zhler-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 Verknpfung 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 Mglichkeit, damit eine automatisch verwaltete Teilung
                von Prompt-/Eingabe- und Ausgabe-Fenster einzurichten:
                        " con_448x40a20x200" 0 ch-id 0 open-link
                erffnet ein nur fr die Eingabe zustndiges Fenster, das
                zugleich als "prompt"-Kanal dient, und lenkt die Standard-
                Ausgabe in den f6-Kanal 0, der nun nur die Ausgabe aufnimmt.
                Fr 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 schlielich 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
                Lscht ggf. das File name und fhrt dann {fop-new} aus,
                ist darum von TK2 oder Minerva unabhngig 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.
                Fr alle {fop..}-Varianten gilt:
                Falls {work} vor dem open-Versuch einen offenen Kanal reprsen-
                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-
                schdlich, 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 enthlt, 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 lschen und
                den betr. Bereich freigeben. {abort} wenn name nicht existiert.
                {forget} ist von der Vocabularordnung beim Aufruf unabhngig
                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 zurck; Vocabulare
                knnen problemlos mit {forget} ebenfalls entfernt werden.
                        fence @ top-nfa id.
                zeigt den Namen des letzten vor {forget} geschtzten Wortes an.
                In {forget} liegt die einzige Stelle des F6-Systems, an der die
                Caches der Processoren ab 68020 geschaltet werden. Dies dient
                fr sptere z.B. {defer}red oder lo-level-Aufrufe der sicheren
                Erkennung der Vernderungen durch den Processor. Nach auen hin
                tritt die vorbergehende Abschaltung nur mehr oder weniger zu-
                fllig in Erscheinung, wenn der mit {break} erzwungene Abbruch
                gerade in die Ausfhrung der entsprechenden {forget}-Passage
                fllt. Schdliche 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 zurck,
                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
                Prft, ob mit name ein lesbarer Kanal eingerichtet werden kann.
fp              ( -- ) (I)                              F6
                Vocabular fr Fliekomma-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 fr die eher heiklen Operationen zum Schutz gegen
                versehentlichen Aufruf, und fr Hilfsdefinitionen, die kaum
                allgemeine Anwendung haben, um die Wortsuche in den anderen
                Vocabularen nicht unntig zu verlangsamen.
hld?            ( -- flg )                               F6
                flg = 1 bei Erreichen der Bereichsgrenze zur Zifferndarstellung.
                Insbes. zur Kontrolle bei der quad-Umwandlung. Es bleibt stets
                noch gengend Platz, um ggf. durch einen voranzustellenden Ln-
                genzhler 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
                fr Einhaltung der Grenzen zu sorgen. Es wird Platz fr maximal
                66 Zeichen einschlielich evtl. des Lngenwortes bentigt.
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- } enthlt den vorzeichenerweiterten Wert.
                Bei Vernderung des Ptr von auen, 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 "abwrts" aufge-
                baut wird. Wird ein mit {>loc} reservierter Localer Speicherbe-
                reich hierzu benutzt, lassen dadurch sich jegliche Konflikte bei
                der Zahlenausgabe vollstndig ausschlieen.
hold            ( c1 -- )
                Fgt 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 jngsten Operation benutzten i/o-Kanals.
id.             ( nfa -- )
                Schreibt den zur angegebenen nfa gehrenden 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 auerdem
                die Definition einer Unzahl spezieller Operatoren fr jeden
                der mglichen Vergleichszustnde 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 krzeres quivalent, wird
                aber als besondere IF-Variante ebenfalls optimierend compiliert.
if-found        ( IF-FOUND name -- ) (I)                F6 (F83)
                Hilfe z.B. fr 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 jngste current-Wort zum Compiler-Wort, d.h. es
                wird "immediate" erklrt und damit stets sofort ausgefhrt.
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 lt 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 fr 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 gewhnlichen Fenstern, flg=-1 bei untauglichem Kanal.
is-ochan        ( c1 -- flg )                           F6
                flg = 1 wenn c1 einen eigenen Kanal des F6-Jobs reprsentiert.
is-open         ( c1 -- flg )                           F6
                flg = 1 wenn c1 einen offenen Kanal reprsentiert.
in              ( -- ptr ) User-Vari
                Enthlt 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 reprsentiert.
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 zugehrigen Adresse und einem {!}-Operator sehr
                viel schneller, IS dagegen ist transportabel in andere Forth-
                Systeme, da dessen Definition dort leicht ergnzt 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 (geringfgig 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 zurck.
key             ( -- n1 )                               ( F6 erweitert )
                Wartet auf Tastenbettigung und gibt den zugehrigen Zeichen-
                code zurck. Zusammen mit ALT ist der Wert negativ, war kein
                Tatstaturkanal zugnglich, kommt $8000 ( 32768 ).
                Die Wartezeit wird von {io-time} bestimmt und kann damit gen-
                dert werden, ist spter aber unbedingt wieder zurckzustellen.
* L
lit+            ( -- ) (C)                              F6
                Mit grter Vorsicht zu verwenden, da vllig ungeschtzt:
                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 fr den Aufruf,
                wenn ungewiss ist, ob die Initiierung schon vorher erfolgte.
                Da relativ aufwendig, und fr 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 fhrendem und
                abschlieendem Leerzeichen bei vorangestelltem Doppelpunkt ste-
                hen, ggf. auch als Kommentar:
                        ( : name1 : name2 und ggf. weiterer text )
                Bleibt er unverndert, kann der Filename fortgelassen werden.
                Bedingtes Compilieren wird zustzlich dadurch untersttzt,
                da {-lword} den gesuchten mit einem angegebenen Namen ver-
                gleicht und bei Erfolg als Flag 1 zurckgibt, 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 geffnet, soda auch Aufrufe im
                selben Quellenfile mit {l-load} mglich sind, oder mehrere F6-
                Jobs zur selben Zeit auf dieselbe Quelle zugreifen knnen.
                L-LOAD kann in ca. 30 Stufen geschachtelt aufgerufen werden:
                Es belegt im Returnstack die der Namenslnge des Aufruf-File
                zuzglich 11 entsprechende Anzahl Bytes, geradzahlig abgerundet.
           FEHLER: Regulre Fehlermeldung bei nicht gefundenem Wort ist err.ro,
                "Schreibschutz", weil intern ein Versuch zum normalen OPEN am
                bereits OPEN_IN-geffneten File scheitert, der standardmig
                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 Fehlermglichkeit unvollstndiger 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 durchzufhren,
                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 mssen.
l-mrg           ( -- ptr ) User-Vari                    F6
                Linker Rand bei der Bildausgabe, z.B. im Debugger.
l<i             ( -- dn1 )                              F6
                Gibt den jngsten Wert des Processor-Registers D0 zurck.
                Liefert nur compiliert sinnvolle Werte, die benutzt werden
                knnen, um z.B. das regulre Ende einer DO..LOOP vom Ende
                durch Verlassen mit LEAVE zu unterscheiden. Dieses Wort ist
                ganz und garnicht standardgem und drfte kaum bertragbar
                sein. Es sollte darum nur in Ausnahmefllen benutzt werden.
                Nheres hierzu in "FORTH_txt" rsp. hier am Schlu.
last            ( -- ptr )                              F79+
                User-Vari, enthlt die nfa der jngsten Definition im Sytem.
                Gegenber {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 whrend der Definitionsphase ein hchst unkonventionel-
                les (und sinnloses!) Vorgehen ist, so wird {latest} dann auf ein
                anderes Wort zeigen und die Referenz kann zu Fehlern fhren.
                        : name ... IF [ last @ pfa cfa , ] ENDIF ... ;
                beispielsweise fr eine "handgefertigte" Recursion.
latest          ( -- nfa )
                ist nfa des jngsten 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 auerdem noch krzer, als
                        : dr? offset c@ $40 and $40 = ;
                Fr alle {literal}-Varianten gilt:
                Beim Compilieren wird die zugehrige Zahl sofort vom Stack
                genommen und in das gerade zu definierende Wort compiliert.
                Kam sie also von "auen" 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 ausgefhrt, als die
                entsprechenden {constant}-Definitionen. Das Compilieren dauert
                etwas lnger, da Zahlen immer erst nach erfolgloser Wortsuche
                ermittelt werden. Sie bieten sich dort an, wo eine Zahl nach dem
                Compilieren nicht mehr gendert 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 zurck, 0 im Erfolgsfalle. Fehler-
                code 0 kann auch als zuverlssiger Hinweis auf Vorhandensein
                der "lightning"-Erweiterung ausgewertet werden.
l-ro            ( -- n1 )                               F6
                Cons, 1 fr {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 zugnglich - angezeigt.
                LOAD belegt jeweils drei Posten im Returnstack, womit mehr als
                250 Stufen geschachtelter Ladevorgnge sicher aufrufbar sind.
                Fr aufeinander folgende Aufrufe oder Anzahl unterschiedlicher
                Files gibt es bei keiner der Lade-Varianten eine Begrenzung.
                Durch Re-Vectorisierung von {load} lt 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} ausdrcklich been-
                det, bricht aber auch selbsttig ab, sofern in der zuletzt gele-
                senen Seite weder {-->} steht, noch ein neues {load}-Kommando.
loc>            ( n1 -- )                                       F6
                Gibt den n1 Zellen groen 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 umfat. Einziger Schaden besteht u.U. darin, da der
                "vergessene" Bereich nur dann zuverlssig zurckzugewinnen ist,
                wenn die Anzahl verbliebener Local-Bytes bekannt ist. Gegen die
                Freigbe zu groer Bereiche sind Manahmen getroffen, die jedoch
                nur als letzte Rettung zum Schutz des Systems wirksam werden.
                ltere locale Bereiche und evtl. auch regulr im Datenstack ab-
                gelegte Posten knnen in solchen Fllen verlorengehen.
loc>stk         ( n1 ... nn -- {a|A} {b|B} ... {z|Z} n1 .. nn )
                Auerordentlich 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
                unvernderter 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 vllig 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| ...
                fr einfache Integer, oder
                        : name .. LOCAL ABCD| ...
                fr Doppelte. Gemischte Schreibweise gilt als Kleinschreibung.
                Bei der Deklaration mu die Buchstaben-Liste mit einem "|" abge-
                schlossen werden, widrigenfalls knnen unkontrollierbare Fehler
                auftreten. Mehrere Listen im selben Wort sind nicht zulssig.
                Zwischen den Buchstaben und vor dem "|" knnen Leerzeichen ste-
                hen, sofern nur die Definition in derselben Zeile endet.
                Die Deklaration kann an beliebigem Ort erfolgen, es ist vllig
                belanglos, welche Operationen mglicherweise davor in den Stacks
                oder sonstwo im System vorgenommen wurden. Allein zum ordnungs-
                gemen Compilieren drfen 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 hinterlt. 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 Beschrnkung (weitgehend) unterbunden.
                In gewisser Weise bedingt ist es jedoch problemlos nach dem
                hier beschriebenen Muster mglich, 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 aufgelst, da
                dann das {;} am Schlu stets regulr 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 zulssig; d.h. sie mu auerhalb jeglicher
                in Forth-Worten abgefater Sprungstruktur stehen.
        Ausfhrung:
                Fr die Ausfhrung gibt es weder Einschrnkungen noch Abweichun-
                gen gegenber gewhnlichen Constanten und bei Adressierung mit
                Hilfe des Wortes {-loc} auch nicht gegenber Variablen. So wer-
                den insbes. weder DO-LOOP-Konstruktionen noch irgendwelche Ope-
                rationen in beiden(!) Stacks beeinflut. Gerade diese Eigenheit
                kann innerhalb von Schleifen zu enormem Zeitgewinn fhren, der
                die weiter unten beschriebene und zunchst eher umstndlich 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 erhht adressiert, wodurch sich mit u.U. groem
                Laufzeitgewinn locale Parameterblcke an untergeordnete Aufrufe
                weitergeben lassen. Stehen beim Compilieren nicht schon irgend-
                welche Compilerdaten im Stack, mu das betr. Wort wenigstens
                durch eine leere Deklaration prpariert werden:
                        : name ... IF ... local A ...
                        : name [ 0 ] ... local A ... ... [ drop ] ;
                erzeugen Leseaufrufe. Stets sicher, aber weniger schnell in der
                Ausfhrung, 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 Speicherblcke.
                Die Localen Variablen sind lediglich eine spezialisierte Form
                dieser Zuweisung, ergnzt um besondere Hilfsfunktionen. Darum,
                und wegen der Lage in einem Bereich, wo sie mit anderen System-
                erfordernissen nicht kollidieren, knnen smtliche Operationen,
                die etwa an einem mit {allot} reservierten Ort zulssig sind,
                auch 'local' vorgenommen werden. Alleinige Einschrnkung ist
                deren Localitt. 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 vertrglichen 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 fr den Stackanfang und bleibt
                damit weiterhin Ptr fr 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 knnen 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 zustzlich ord-
                nenden Daten ntig sind; dies ermglicht die Geschlossenheit des
                {local}-Bereichs und formatfreie mit z.B. den {user}-Variablen
                consistente durchgehende Adressierbarkeit aller {local}-Posten.
                Damit erffnet sich die sonst in Forth-Systemen unbekannte und
                nur mit hohem Aufwand nachzusetzende Mglichkeit der bergabe
                von (localen) Parametern unabhngig 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 temporre Forth-Worte angelegt werden knnen.
        Anwendung:
                Zum Reservieren rsp. Freigeben localen Speichers sind die Worte
                {ini-loc} und {end-loc} im hidden-Vocabular vorhanden - s.dort.
                Diese mssen 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
                uerst vielfltigen 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 Gre gelesen werden knnen, 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
                dafr 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
                Fliekommazahlen gearbeitet werden. Entsprechende Platzreser-
                vierung ist erforderlich und auch ohne Parameter u.a. dadurch
                mglich, da das Wort selbst vor der Deklaration die ntigen
                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 Ausfhrungsphase sind Auflsen 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 bentigte Zeit ist mit {constant}en vergleichbar.
                Zugegebenermaen hat der Autor Locale Variable im 4th schlicht
                fr Quatsch gehalten (mit all den "standardgemen" Einschrn-
                kungen sind sie das in der Tat), doch zeigte sich, da neben
                dem bequemen Umgang damit die hier eingerichtete Form auerdem
                zu erheblichem Zeitgewinn fhren kann. Damit wird der Einsatz
                Localer Variabler unabhngig von allen grundstzlichen Erwgun-
                gen durchaus sinnvoll, besonders, wenn wiederholt umfangreiche
                Stackoperationen erforderlich wren, 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
                zustzliche Datenposten im Stack vorhanden sind.
                bergeordnete Locale Variable indiziert man mit ihrem Index der
                Deklaration, erhht um dem grten 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 einschlielich evtl. eigener Local-Posten.
                Fr eine nur mit bergeordnetet Localen Werten arbeitende Defi-
                nition wie {name1} ist die zeitraubende Verwaltung des eigenen
                Speicherbereichs (der Gre Null) unntig. Mit einem Eingriff
                in den Compiler lt sich deren Einbau unterdrcken:
                        : 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 anschlieend verworfen. Auf diese Weise
                kann die Local-Deklaration mit einer {drop}-Funktion vereinigt
                werden - was aus Laufzeitgrnden wohl weniger zu empfehlen ist.
                Sollte aufgrund eines Fehlers einmal die selbsttige Freigabe
                versagt haben, lt sich der Local-Bereich durch Reinitiierung
                radikal freigeben, entweder mit {cold}
                                safe!           ( ggf. bisherige Worte schtzen
                                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 fr 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 entfllt 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
                Blcke der Lnge n4, gibt die weitergezhlten Adressen zurck.
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 zurck.
* 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-Zhler 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 zufgen.
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, fhrt {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 anschlieender Ver-
                minderung um Eins und kann oftmals auch zeitsparend eine solche
                Folge ersetzen. Fr 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)
                Fhrt {[number]} aus, bei Fehler anschlieend {?numerr}.
ni              ( n1 -- n2 )                            H4
                Holt den Schleifenindex der n1-ten nchstueren 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. Fr den open-Typ gelten die Codes der Qdos-Trap:
                        0       zum Lesen und Schreiben
                        1       nur Lesen, mehrfache Nutzung mglich
                        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 reprsen-
                tiert, so wird dieser vor der neuen Zuweisung geschlossen.
                Hinweis: {fop-over} bentigt die erweiterte open-Codierung des
                TK2 o.dgl. nicht, da es das File durch die Verbindung {delet}
                mit folgendem {fop-new} erst nach Lschen desselben ffnet.
opt             ( -- ptr )                              F6
                Vari fr globale Freigabe und Sperrung der hi-level-Optimierung,
                jeder von Null verschiedene Wert bewirkt Freigabe.
os              ( -- ptr )                              F6
                User-Vari, vorbereitet fr die Code-Segmentierung
out-cons        ( -- c1 )                               F6
                F6-Kanalnummer des Standard-Ausgabekanals.
out             ( -- ptr ) User-Vari
                ptr auf Zhler der in den Standard-Ausgabekanal geschriebenen
                Zeichen, wird durch {cr} auf Null gesetzt, durch {bs} und {del}
                zurckgezhlt.
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-Verknpfung n1 mit dem Speicherinhalt bei ptr.
* P
pad             ( -- ptr )
perform         ( ptr -- exec )                         F6/F79+
                ptr zeigt auf eine cfa, die durch {perform} ausfhrt 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 zhlend.
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 standardmigen "sharp", als zeit-
                bestimmender elementarer Aufruf zur Bildung eines Zahlenstring
                im Kern definiert; die restlichen Worte knnen 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 zurck.
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 fr 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 fr den Rest gegenber 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
                Veranlat, da die nchste Zahl im quad-Typen geholt rsp. com-
                piliert wird. Dies ist unabhngig von einer Dezimalmarke und
                gilt nur fr die nchste 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 Ausfhrung 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 fr {dpl} in keinem Falle grer als 64 werden
                kann, wurden neben der Angabe der (Dezimal-)Bruchmarkierung in
                den niederwertigen 8 Bits smtlich gesetzte Bits des hherwerti-
                gen Byte bei stets ungesetztem Bit 7 als quad-Signal gewhlt.
                {dpl@} kann dafr dann Werte von $ff00 bis $ff40 annehmen, die
                von den anderen Mglichkeiten 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  ." Mll "    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 fr {expect}, s.dort.
quit            ( -- )
                Der uere Interpreter - sicherer Rckkehrpunkt 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 jngsten 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 nchste
                Zahl der Liste wenigstens um eins grer ist als jene, oder
                kein weiterer Listenposten folgt. Liegt die Zahl unterhalb des
                niedrigsten Listenposten, geht Null zurck, regulre Indices
                zhlen 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 unverndert.
                VORSICHT bei FP: Der Posten m1 mu stets als Integer angegeben
                werden, im FP-Format kann es wegen Interpretation des Exponenten
                als Zhler durch Bereichsberschreitung zu blen Fehlern kommen.
root            ( -- )                                  F83
                Vocabular, enthlt nur das Minimum an Worten, das vorhanden
                sein mu, um das System in Betrieb zu nehmen. Neue Definitionen
                sollten hier nur sparsam und berlegt eingefgt werden. Zum ei-
                nen ist {root} quasi der Schlssel zum System, zum andern wird
                es bei erfolgloser Wortsuche zum Schlu unabhngig 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 erhhen.
rot             ( n1 n2 n3 -- n2 n3 n1 ) ( f1 f2 f3 -- f2 f3 f1 )
row             ( -- ptr )                              F6
                User-Vari, Zeilenzhler 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 zhlt 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 ermglicht.
                Einige Anwendungen finden sich z.B. bei PRINTER in "forth_scr".
                Aufrufe eines ein {r+} enthaltenden Wortes drfen drfen NICHT
                mit aktiviertem DEBUGGER compiliert werden. Zumindest fr 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 fr 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 geffnet 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 Manahmen.
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, anschlieend
                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 Lnge n2 zurckgeben,
                an der das Zeichen c1 gefunden wurde. Das nchste Vorkommen
                desselben Zeichens findet mann dann z.B. mit
                        $ffff.0001 d+ ( c1 ) scan
                worin die double-Addition eine verkrtzte Form der Sequenz zum
                Weiterrcken auf das nchste 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 fr (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 gltigen
                Wert in n2 zurck, oder nur letzteres bei n1 = -1.
set-cal         ( -- )                                  F6
                Systemeigenen Zeit-Zhler (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 unabhngig 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 fr 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 Lnge n2 zurckgeben,
                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 fr S-LOAD - und damit auch L-LOAD, um die Re-
                Vectorisierung fr letztgenannten Aufruf zu ermglichen.
                Initial mit {\name} besetzt.
smudge          ( -- )
                Freigabezustand der jngsten Definition im current-Vocabular
                umschalten. Nach {create} erforderlich, wenn das Wort auffind-
                bar (und ausfhrbar) gemacht werden soll, oder z.B. bei Fehler-
                abbruch whrend des Compilierens, um {forget} auf das jngste,
                wegen des Fehlers unvollstndige Wort anwenden zu knnen.
source          ( -- ptr n1 )                           F83 & 8.18
                Ort und verfgbare Lnge 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 Lnge des jngsten 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" ausfhrlich beschrieben, hier kurz:
                Universeller Stackoperator fr mit kleinen Buchstaben bezeich-
                nete einfache oder mit Grobuchstaben 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 knnen benannt werden, die Listen
                drfen 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 } ausfhrt, 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 auerdem den flchtigen compilieren-
                den Zustand zwischen "|"-Zeichen bei der direkten Eingabe.
stk>loc         ( n1 ... nn -- ) ( sys: -- ptr 9 )      F6S
                Auerordentlich schnell ausgefhrte Altternative zum Einrichten
                Localer Variabler bei bergabe smtlicher 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      Nationalitten-Kennbuchstabe des QDOS
                    lsbyte      -1 Minerva-System, 0 sonst
                Auerdem lassen sich mit Hilfe von {qsys+} einige Eigenheiten
                jngerer qdos-Abkmmlinge 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 fr 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 zurck. In direkter
                Eingabe wird dafr {pad} benutzt, sonst der Bereich ab {here}.
ti-cal          ( -- d1 )                               F6
                gibt den Kalibrierungswert des F6-Zeitzhlers zurck. Dieser
                entspricht der Anzahl Durchgnge einer im F6-System verankerten
                Zhlroutine innerhalb 50 20ms-Intervallen. Sie ist so aufgebaut,
                da der Processor ggf. nicht in den "loop"-Modus geht, lt aber
                die evtl. vorhandene Cache-Speicherung unberhrt und unbeachtet.
                Die unterschiedliche Ausfhrungstaktung der 68008- gegenber den
                anderen Processorvarianten ist bereits bercksichtigt, die beim
                Atari-QL mglichen besonderen Interruptintervalle jedoch nicht.
                Das Ergebnis ist die effektive Rechnertaktung/sec/10, die Zahl
                dient der Synchronisierung zeitabhngiger Vorgnge; wieweit die
                Taktung tatschlich damit bereinstimmt, hat demgegenber keine
                sonderliche Bedeutung, dieser Wert soll lediglich einen qualita-
                tiven berblick geben. Wegen der Vorgnge beim Jobaufbau des
                SMSQ/E wird die Startmeldung um eine Sekunde verzgert, damit
                sofort der wirkliche Wert zur Verfgung 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 ergbe.
                3.      10.     Gold-Card-QL
                                bei Werten ab 8 MHz bis < 23 MHz.
tib             ( -- ptr )
                User-Vari, enthlt 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 Eingabelnge. Wird nach der ersten
                Eingabe auf 171 reduziert, kann bei Beachtung der Grenze von
                1080 Bytes fr den gemeinsamen Bereich von Returnstack und
                t.i.b. erhht werden durch
                        ( zahl ) ' tib-max 2+ !
                Oder einmalig fr 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 ermglicht.
tib@            ( -- ptr )                              F6
                Inhalt von {tib}, Anfang des t.i.b.
tick            ( -- d1 )                               F6
                Augenblicklicher Stand des F6-Zeitzhlers in 20ms-Einheiten.
                Mit einem einfachen allgemeinen Aufrufrahmen lt {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 fr die leere Schleife eintragen:
                   ' noop is test       \ Wort fr 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 fr {4dup}
                    ' t1 is test
                    ti-test
                    ' 4dup is test
                    ti-test
                Nach dem Durchgang erscheint die Zeit in Mikrosekunden fr den
                einzelnen Aufruf und es verbleibt die Anzahl 20ms-Einheiten
                fr den gesamten Test im Stack, z.B. fr die Ermittlung der
                Zeitdifferenz zweier Tests oder zur Ausgabe mit {time$}. Als
                Gedchtnissttze wird auerdem 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-verknpft. Da die so
                mglichen Fehler auerhalb der 7-Bit-Schriftzeichenbereiche
                liegen, wurde dieses einfache aber schnelle Verfahren gewhlt.
                Ein Code in {(joker)} gilt fr ein Zeichen im Vergleichsstring,
                das immer als gefunden zhlt, also fr den Vergleich nicht von
                Belang ist. Der ggf. in {(wcard)} eingetragene Code reprsen-
                tiert in gleicher Weise ein Zeichen, das eine ab 1 beliebig
                groe Gruppe beliebiger Zeichen reprsentiert (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 fr Gleichheit beider Strings zurck.
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 ausfhren.
top-nfa         ( ptr -- nfa | 0 )                      F6
                Hilfswort zur Ermittlung der jngsten nfa, die ungeachtet der
                Suchordnung noch im Dictionary-Bereich bis ptr liegt. Liefert
                z.B. in {forget} den Wert fr {last}, und wird neben {safe!}
                u.a. auch in {c-save} und {c-load} bentigt.
                        fence @ top-nfa id.
                zeigt den Namen des letzten vor {forget} geschtzten Wortes an.
traverse        ( ptr1 n1 -- ptr2 )
                Tastet den Speicher ab ptr1 bis zu einem Byte mit gesetztem
                hchstwertigem 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 rechtsbndig in Feld der Lnge 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 lschen.
update          ( -- )
                aktuellen Block markieren, soda er vor dem berschreiben durch
                einen neuen Block, oder bei {flush}, zurckgeschrieben 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 fr 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} enthlt den
                Laufptr in diesen Bereich, und {u0} zeigt auf den Anfang. Neue
                Datenposten werden dort mit {user} reserviert und erhalten Platz
                fr eine einfache Integer zugewiesen. Bei greren Posten zhlt
                man anschlieend {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 nchsten freien Index zu.
                        ' dp @ 2- user dp-l
                macht den Langwort-DP zugnglich. 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 geffnet
                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    schliet "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 fr den Anfang des aktuellen User-Bereichs.
u<              ( un1 un2 -- flg )
up              ( -- ptr )
                User-Vari, hlt 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 gelscht wird, oder es nach einer
                Anzahl {#vocs} Aufrufen von {also} auch dort hinausfllt.
                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
                knnen, die nur aus ihrem unmittelbar bergeordneten Vocabular
                heraus zugnglich 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 eingeprgte secundre Suchfolge wird unabhngig von ihrem
                Freigabemodus initial auf das CURRENT-Vocabular eingestellt.
                Wird ein Vocabular mit {forget} o.. entfernt, ist anschlieend
                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 zustzlich
                eine Sicherheitsfunktion der Untervocabulareigenschaft aus:
                {turtle} als {fp}-Vocabular kann nur danach aufgerufen werden,
                was unbersehbar darauf aufmerksam macht, da die Graphikaufrufe
                fp-Zahlen in der Stackbergabe erfordern, und womit automatisch
                dafr Sorge getragen ist, da dieses Vocabular auch wirklich ak-
                tiviert wurde.
* W
<with           ( -- ) (C) ( <WITH name -- )            F6(!)
                Eine Ergnzung, die es erlaubt, gemeinsam mit seiner Bildungs-
                auch die Ausfhrungsvorschrift eines Definitionswortes weiter-
                zugeben. Die hierzu notwendigen Systemergnzungen knnen 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 Ausfhrungsteil mit ;DOES> oder ;CDOES> eingelei-
                tet werden - das standardmige f.i.g.-DOES> kann eine solche
                "vollstndige Erbfolge" nicht weiterreichen.
                        ' task dds !
                Nach Festlegen des Ur-Zustandes
                        : name0 <WITH <BUILDS ... ;DOES> ... ;
                gleichermaen 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 Ausfhrungsteile zuerst von name0 und dann von name1
                durchlaufen. Um die Folge zu sichern, mu vor Bildung eines De-
                finitionswortes die Vorgngerdefinition 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 durchgefhrt zu werden. Was
                u.U. auch dann notwendig wird, wenn ein "fremdes" fortpflanzugs-
                fhiges {;does>} aufgerufen oder in ein Wort eingebaut wurde.
                Den definierten Ausgangszustend ohne Vorgnger schafft man mit
                        ' task dds !
                {<with} revectorisiert {;does>}. Solange der Vorgabeposten auf
                der pfa+2 unverndert bleibt, stellt {;does>} sich automatisch
                mit dem Aufruf sofort wieder auf die Standarddefinition zurck.
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 enthlt, gehen pfa,
                count- u. Typenbyte mit flg = 1 zurck, sonst nur Null.
                {w-find} arbeitet identisch {-find}, es ermglicht 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.
                Auerdem dient es innerhalb eines {c-save}-Blocks dem Aufruf von
                dort definierten Worten durch andere Worte in diesem Block, was
                sonst wegen der fehlenden Relocationsmglichkeit unzulssig 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 einschlielich
                der ueren 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} zurckkehrt. Der Datenstack bleibt erhalten.
wd-size         ( c1 -- ny nx nh nw tf | ff )           F6
                ff wenn c1 keinen Fensterkanal reprsentiert, sonst Fensterdaten
                Ursprung ny oben, nx links, Mae nw breit, nh hoch, tf gibt die
                Cursorbreite an; alles in Pixelmaen. In compilierter Form kann
                anschlieend mit {l<i} auch die Zeichenhhe gelesen werden.
while           ( n1 -- ) (C) ( sys: ptr 1 -- sys: ptr 4 )
                Bedingungen werden in derselben Weise optimiert, wie bei {if}.
                        BEGIN .. .. cc WHILE .. .. REPEAT
                Zulssige Variante im F6 auch
                        BEGIN .. .. cc WHILE .. .. cc UNTIL
width           ( -- ptr )
                User-Vari zur Lngenbegrenzung beim Compilieren von Wortnamen.
                Im F6 mglichst nicht kleiner als die grte benutzte Lnge zu
                setzen, dies wrde das Compilieren wesentlich verlangsamen, und
                als Preis fr die durch etwas genderten Namensvergleich enorm
                beschleunigte Wortsuche leider auch mitunter zu Fehlern fhren.
window          ( ny nx nh nw -- )                      F6
                Das mit {work} identifizierte Fenster mit den angegebenen Maen
                versehen, ohne border; Mae 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 einschlielich) begrenzten
                Bereich und liefert das Resultat als n4 zum Stack
wmov            ( c1 -- )                               F6
                Durch Bettigung der Cursortasten Verlagerung und nderung
                der Abmessungen des mit c1 identifizierten Fensters. Ist c1
                das Hauptfenster, und sind weitere Fenster offen, werden diese
                soweit mglich mitgenommen und ggf. in den Maen angepasst.
work-id         ( -- did )                              F6
                QDOS-ID des {work}-Kanals.
work-num        ( -- c1 )                               F6
                Hchste F6-Kanalnummer mit der QDOS-ID des {work}-Kanals.
word            ( c1 -- )
                mit dem Zeichen c1 begrenzten String aus dem Eingabestrom
                isolieren und mit fhrendem Countbyte nach {here} bringen.
                Bei c1 =<bl> gilt zum Ende hin auer 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 fr alle QDOS-Operationen, durch {to-work} knnen
                ihm beliebige andere Kanle zugewiesen werden (s. {set-work}).
                Standardkanal fr ausnahmslos alle i/o-Operationen des {qdos}-
                Vocabulars mit den Untervocabularen {pif} u. {minerva}.
                Auerdem Ziel fr 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 fr {selected} zu WORDS aus "forth_scr"
wtyp            ( -- )                                  F6S
                Operator fr {selected} zu WORDS, der fr 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 Lnge 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-Verknpfung n1 mit dem Speicherinhalt bei ptr.
* [ etc.
[compile]       ( -- ) (C) ( [COMPILE] name )
                "immediate" Worte werden durch Voranstellen von {[compile]}
                mit ihrer cfa compiliert wie gewhnliche 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 zurckgeben.
                Als "open-Code" gelten die D3-Werte fr die Qdos-Trap:
                        0       zum Lesen und Schreiben
                        1       nur Lesen, mehrfache Nutzung mglich
                        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 ermglicht damit etwa die
                automatische Gertevorgabe, durch die z.B. beim TK2 die fehlende
                Laufwerksbezeichnung ggf. nachgetragen wird. Gerade das fehlt im
                F6, um z.B. Irrlufer der Art "flp1_mdv2_.." zu vermeiden. Die
                Devicevorgabe nach TK2-Manier ist in "forth_scr" so beschrieben,
                da sie unabhngig vom TK2 nachgetragen und benutzt werden kann.
                Fr 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 Zhler
                wird darum einfach die Position vor dem Anfang als ptr angege-
                ben. Auer den ggf. durch {base} eingegrenzten gltigen Ziffern
                darf der String die Zeichen "," oder "." und am Anfang auch ein
                Zahlen-Affix enthalten. Bei fp-Zahlen sind zustzlich das "%"
                am Ende und ein "E" ggf. vor dem Exponenten zulssig und das
                abschlieende Leerzeichen ist nicht erforderlich.
                Werden diese Bedingungen nicht eingehalten, gibt der Aufruf
                den Flagwert 1 zurck, 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 unabhngig 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 zurckgegeben.
                " 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 spteren 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 spter eine pfa holen, ist [compile] voran-
                zustellen. Interpretierend liefert es die pfa in den Stack.
                HINWEIS: Das "tick" spterer Standards ist nicht immediate und
                holt mit der CFA die 4th-Adresse, die den ptr auf den den Wort-
                typ bestimmenden direkt ausfhrbaren Codeteil enthlt.
(               ( -- ) (I)
                Kommentar-Klammer, der folgende Text bleibt bis zum Zeilenende,
                einem <enter> oder der nchsten 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 weiterzhlen.
,,              ( 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.
                Fr die weiteren Ebenen s. {ni}.
[               ( -- ) (I)
                Interpret-Klammer, bergang in den interpretierenden Zustand.
                Mit abschlieender Compile-Klammer {]} auch innerhalb einer
                Wort-Definition anwendbar, z.B. fr 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 auerhalb einer Wort-Definition.
|               ( -- ) (I)                              F6
                Dieses Hilfsmittel zum Ausprobieren beliebiger Wortfolgen
                leitet den flchtigen Compile-Zustand ein rsp. schliet ihn ab.
                Eine im interpretierenden Zustand in "|" eingefate Sequenz
                wird compiliert, sofort ausgefhrt und unmittelbar danach wie-
                der freigegeben. Damit sind neben durch die Compilezeit unbe-
                lasteten genauen Zeitmessungen vor allem auch Strukturworte in
                direkter Eingabe ausfhrbar:
                        | tick 2>r 1000. DO 1000. DO LOOP LOOP tick 2r> d- d. |
                wre sonst nur als Wortdefinition mglich.
                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 durchfhrbar wird.
                {here} und damit auch {pad} liegen fr die Dauer der Ausfhrung
                einer solchen Wortfolge entsprechend hher, vorher nach {pad}
                bertragene Daten mssen also ggf. mit der zu jenem Zeitpunkt
                gltigen Adresse in diese Aufrufe bergeben werden.
                Auch Einzelschrittbetrieb ist mit diesen Sequenzen mglich.
                Die Compile- & Interpret-Klammern haben gegenber {|} Vorrang
                und drfen nicht gemeinsam damit verwandt werden.
\               ( -- )                                  F83
                Text nach dem "\" bleibt bis zum Ende der Zeile unbeachtet.
                Dient nur der Compatibilitt, da "(" aufgrund der Tatsache,
                da im F6 Block- und Zeilenlnge gleich sind, dasselbe leistet.
]               ( -- )
                Compile-Klammer, zum bergang in den compilierenden Zustand.


* FP-Vocabular
Fliekommazahlen sind im Forth zumeist berflssig, 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 auerordentlich leicht
zugnglich sind, wurden ihre Operationen in einem eigenen Vocabular angegeben.
Die Genauigkeit ist allerdings mit nur neun Dezimalstellen recht gering, und so
werden in vielen Fllen die vierfachgenauen Integer vorzuziehen sein, die trotz
(dezimal) 18-stelliger Genauigkeit noch deutlich schneller verarbeitet werden.

Ist dieses Vocabular oder eines seiner Abkmmlinge CONTEXT, so werden Zahlen im
QDOS-Fliekommaformat erzeugt, fr 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 fr alle Vocabulare gilt.

Die Operationen mit bereits in FORTH-Vocabular aufgefhrten Namen haben auer
der Tatsache, da sie mit Fliekommazahlen 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 vollstndig in mglichst optimaler Form im F6 codiert. Die Operatoren
zur Umwandlung von FP nach Integer und umgekehrt gehren zum Forth-Vocabular und
sind hier nur der bersicht halber mit aufgefhrt. 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
knnen, wird in einigen Fllen das hherwertige Exponentenbyte (entsprechend dem
hchstwertigen Stack- oder Speicherbyte) mit %00001111 AND-verknpft und grenzt
den Exponenten damit auf zulssige Werte ein. Allgemeine Datenposten werden dann
u.U. verflscht. 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 enthlt, und auch {dpl} unberhrt
lt, zuverlssig 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; auerdem 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 )            natrlicher logarithmus Q
neg             ( f1 -- f2 )            Negation                Q
nint            ( f1 -- n1 )            fp zur nchsten Integer gerundet  Q
nlint           ( f1 -- d1 )            fp zur nchsten 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 ausfhrt, zugleich mu dann auch variptr
                fr den in diesem Vectoraufruf verwalteten Variablenbereich an-
                gegeben sein. Die Codierung ist den einschlgigen QDOS-Dokumen-
                ten zu entnehmen (z.B. PiQ).
roll            {pick} und aufrcken in die copierte Position,
                negative Postennummer fr 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 vollstndige 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-verknpft werden.
Bei -1 hat (upper) keinen Einflu, bei 127 wird das hchstwertige 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 unabhngigen Vergleich.

flush           ( -- )
                Augenblicklich alle {update}-markierten Blcke sichern.
match           ( ptr1 n1 ptr2 n2 -- flg n3 )           f.i.g.-Editor
                Suche des Strings der Lnge n2 ab ptr2 im Bereich der Lnge n1
                ab ptr1. Bei Erfolg Rckgabe 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 zurck.
                Entsprechendes an wirklichen Speicheradressen s.u. {s==}.
s=              ( n1 dadr1 n2 dadr2 -- flg )            F6
                Vergleich, flg = 1 wenn der String der Lnge 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 Lnge n2 ab dadr2 nach dem String auf
                dadr1 der Lnge 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 verfgbar sein mssen, rsp. deren von der brigen Voca-
bular-Konstellation unabhngiges Vorhandensein zweckmig ist.

2nd-voc         ( -- ptr )                              F6
                Vari, =/= 0 gibt Vocabular-spezifische Folge-Vocabulare frei.
                Im Vorgabezustand ist die secundre Suchfolge gesperrt.
also            ( -- ) (I)                              F83 modifiziert
                Schiebt die Suchfolge eins "hoch", d.h., der Vorgnger-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 umfat zwei Bereiche, von denen der erste mit
                den jngsten zwei Posten vom zweiten miterfat 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 jngst aufgerufenen Vocabulare verfgbar. Der jeweis
                zweite Vorgnger fllt aus der Suchordnung hinaus.
                {also} schiebt smtliche Vocabulare eine Position 'hher', so-
                da dann das zweite Vocabular an dritte Position gelangt, wo es
                nicht mehr durch einen neuen Vocabularaufruf verschwinden kann.
                Die jngste Vocabulareintragung wird dupliziert, soda nun Platz
                fr ein danach genanntes Vocabular frei wird, um welches sich
                die Suchordnung dann erweitert.
                Mehrere {also} nacheinander bewirken gewhnlich nichts anderes,
                als da das jngste Vocabular von den {find}-Varianten entspre-
                chend oft durchsucht wird und sich die Compilezeit dadurch ohne
                jeden Nutzeffekt ganz enorm erhht. Im F6 wird dergleichen durch
                eine Markierung unterbunden, die whrend der Worsuche besetzt
                und verarbeitet wird. Gleichgltig, wie oft ein Vocabular in der
                Suchfolge erscheint, wird es nur einmal durchsucht, soda die
                Compilezeit von Mehrfacheintragungen unbeeinflut bleibt.
                Der erste, flchtige, Teilstack erlaubt es, die im f.i.g.-Forth
                bliche bertragung des Definitionsvocabulars in die Suchordnung
                zu bernehmen und gleichzeitig den vorher eingestellten Posten
                verfgbar zu halten, ohne da sie dadurch peu a peu am Ende
                ganz aus solchen Eintragungen besteht, da der Bereich oberhalb
                der beiden jngsten Posten unverndert bleibt.
                Das wre z.B. auch durch die {state}-abhngige Miterfassung des
                Current-Vocabulars (und bei der gewhlten Datenanordnung im 4th-
                Speicher eher besser) mglich; die Verfahrensweise resultiert
                aus anfnglichen Versuchen und, den mglichen 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 wre.
                Ausfhrliche Beschreibung in "F6CHG_txt" rsp. "FORTH_txt".
asm68           ( -- )                                  F6
                Vocabular, initial dem Aufruf {assembler} zugewiesen
assembler       ( -- ) (D)(I)
                Deferred, vorgesehen fr unterschiedliche Assembler-Vocabulare.
blk+            ( -- n1 )                               F6
                n1 = -1 bei direkter Eingabe in t.i.b., 0 bei neuem Screenfile
                oder eine Zahl > 0 fr die nchste 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 auen(!) 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 auen bergeben wurde, und macht dann zustzliche Ma-
                nahmen zum Einhalten der Stackbilanz berflssig:
                        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 zurckgegebene
                ptr ist von den aufrufenden Worten spter als cfa zu verwenden.
                Die Platzeinsparung entspricht der ungeradzahlig aufgerundeten
                Lnge eines Namen + 3; auerdem belasten diese Worte die Suche
                beim Compilieren nicht, da sie fr {-find} nicht existieren.
                Ausfhrungszeitvorteile 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 spter 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
                zugnglich, {current} wird nicht verndert.
prevdef         ( -- ) (I)                              F6
                voriges Definitionsvocabular wieder einsetzen. Benutzt eine ein-
                fache Variable, kann daher nur das unmittelbar vor dem jngsten
                {definitions} vohandene {current}-Vocabular wiederherstellen.
previous        ( -- ) (I)
                Die gesamte Suchfolge um das jngste Vocabular verkrzen.
rvoc            ( -- ) (I)                              F6
                Das zweite Vocabular an erste Stelle setzen, keine weiteren
                nderungen, der eigentliche Vocabularstack bleibt unberhrt.
search          ( SEARCH name ) (I)                     F6
                dem CONTEXT-Vocabular ein neues Secundrvocabular einprgen.
selected        ( SELECTED xxxx )                       F6S
                Modifiziert den nchsten Aufruf von {words} und beschrnkt die
                Ausgabe auf bestimmte Wortgruppen. Grundstzlich gelten die
                nach {selected} folgenden max. 7 Zeichen bis zum nchsten Leer-
                zeichen als alphabetisches Auswahlkriterium fr den Wortanfang
                der Ausgabe. Die Kriterien beim Textvergleich entprechen {t=}.
                Daneben gibt es Sondergruppen mit:
                selected imed           fr die "immediate"-Worte;
                selected prim           die Standard- und die mit Langwort-Ptr
                                        aufgerufenen Primitives;
                selected defn {name}    fat 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, veranlat hier jeder Text selbst das System,
                an seinem Ende fr Nachschub zu sorgen oder nach {quit} zurck-
                zukehren, dem ueren Interpreter, wo weitere Eingaben erwartet
                werden. So wird es, indem es die laufende Kontrolle selbst ber-
                nimmt, vllig unabhngig 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 Umstnde sofort ermglicht.


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

#user           ( -- n1 )                              (F6) F83
                Cons, Gre des gesamten User-Bereichs
(")             Runtime fr {"}
(+loop)         Runtime fr {+loop}
(.")            Runtime fr {."}
(;)             Runtime des optimierenden {;}           F6 8.16
(;code)         Runtime fr {;code}
(abort")        ( -- ) (D)                              F6
                Von {abort}-Varianten aufgerufen, fhrt initial nach {quit},
                auf entsprechende Anwendungs-Worte vectorisierbar.
(abort)         ( -- ) (D)                              F6
                Wird nach Lschen des Datenstacks von {abort} aufgerufen und
                fhrt die weitere Re-Initiierung durch: Stellt {dr0} ein,
                Zahlen dezimal, und nach evtl. ntigem bergang in den user-
                Modus des 680xx-Processors Hinschreiben der Systemkennung.
(bs)            ( -- c1 )                               F6
                Definiert den Zeichencode fr {bs}
(ctl)           ( -- ptr )                              F6
                Vari, 0 unterbindet die Aktionen von {ctrl}.
(debug)         ( -- ) inaktiv ( pfa -- ) mit debugger (D) F6
                Ausfhrender Debugger-Aufruf, wird ggf. vor jede cfa compiliert.
                In der Vorgabe mit $8001 besetzt und damit fr schnellstmgliche
                Abarbeitung de-aktiviert. Wird beim Compilieren des Debuggers
                auf ein Wort mit Prfung und Ausfhrung 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 jngste 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 fr 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 gltigen Zeichen und gibt den
                Accu d2 samt der Adresse des Abbruchs ptr2 zurck.
(quit)          ( -- ptr )                              F6
                Ausfhrungs-cfa von {quit} und Hilfe zur Erzeugung selbsstarten-
                der F6-Programme. Die hier eingetragene cfa wird beim Start des
                F6-Jobs ausgefhrt und kann auf jedes Wort gestellt werden, das
                ein geschlossenes Programm ausfhrt - die "turnkey"-Anwendung.
                Automatisches Nachladen fehlender Definitionen:
                Beim Antreffen eines nicht vorhandenen Wortes wird die gewhn-
                liche Fehlerbehandlung durchlaufen, die normalerweise nach der
                Ausgabe eines Hinweistextes und Teil-Initiierung nach {quit}
                fhrt. 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 knnen, 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
                fr nachzusetzende Definitonen, lt sich der Compiler soweit
                ausbauen, da er vllig selbstndig die fehlenden Definitionen
                einsammelt und nachtrgt.
+branch         ( flg -- )                              F6
                Runtime fr 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 Fllen
                ist nur der standardmige Forth-Aufruf zulssig - was bei der
                automatischen Schluoptimierung selbsttig bercksichtigt wird.
-branch         ( flg -- )                              F6
                Runtime fr die Optimierung z.B. aus:  0= IF
0-branch        ( flg -- )                              F6
                Runtime fr die Optimierung z.B. aus: 0> IF
0<branch        ( flg -- )                              F6
                Runtime fr die Optimierung z.B. aus: 0< 0= IF
0>branch        ( flg -- )                              F6
                Runtime fr die Optimierung z.B. aus: 0> 0= IF
0branch         ( flg -- )                              F6
                Runtime fr 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 fr die Optimierung, entspricht
                        -dup IF
?1branch        ( flg -- flg | )                        F6
                Runtime fr z.B. {case?}, entspricht
                        over = IF drop
?numerr         ( flg -- flg 0 )                        F6
                Zusammenfassung von
                        ( flg ) 0 ?error
back            ( ptr -- )
                Compiliert eine rckwrtsgerichtete Sprungdistanz in {here}.
branch          Runtime fr {else} und andere unbedingte Sprnge
clone-jdt       ( did -- did )(D)                       F6
                Letzte Aktion in {(exec)} unmittelbar vor der Job-Activierung.
                Vectorisiert auf {noop}, vorgesehen fr anwendungsbezogene
                Besonderheiten. Die Adresse der zugehrigen 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 fr Stacks, Puffer und Dictionary
                zugewiesen wird. Bei -1 ermittelt das System den grtmglichen
                Wert, mit anderen Zahlen ist die Zuweisung zur Verringerung des
                knftigen 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. Erhlt
                in n1 den Wert MAX( db-on,0 ), und eine pfa, die die ausfhren-
                den Worte vom Stack nehmen mssen. Davor wird db-on=0 ausgefil-
                tert, soda n1=0 nur bei negativen Werten von db-on vorkommt.
dlit            ( -- d1 )
                Runtime fr doppeltgenaue Festwerte.
doforget        ( cflg xflg nfa1 nfa2 -- cflg xflg nfa1 n3 ) (D) F6  8.18
                Anwender-definierbarer Vorspann in {forget}. Darf nfa1 mit der
                jngsten nfa des jngsten Vocabulars nicht ndern, und mu
                zumindest irgendeine Zahl n3 anstelle der nfa2 des Wortes, bis
                zu dem das Dictionary freigegeben werden soll, zurckgeben.
                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
                auerordentliche Freigabe des {local}-Bereichs, z.B. vor {;s},
                bentigt die Anzahl freizugebender Bytes, z.B.
                   : name local AB| .. IF .. [ 8 ] end-loc ;s ENDIF .. ;
                Der Eingriff "von Hand" in den Compiler wurde gewhlt, 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 fr 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 fr einfache Festwerte
memvec          ( n1 -- dadr | -dn )                    F6
                n1 ist die Nummer eines Vectors im MEM-device der IO2-Sammlung,
                dessen Adresse zurckgegeben wird, negative Werte und Null sind
                nicht brauchbar, sie signalisieren einen Fehler.
                Fr 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 fr 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 fr 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 zusammengefat, 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 fr 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 unverndert 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 ausgefhrt.
[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 Fllen genaue Gegenstcke 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 gngigen 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 gewhlten Bezeichnungen.
Die Namen stimmen mit den dort genannten QDOS-Bezeichnungen berein, womit
sie leicht auffindbar sind und sich hier detaillierte Angeben erbrigen.

* Trap #0 Processorzustand
Ntzlich fr alle Vorgnge, die ohne Unterbrechung - z.B. durch das Multi-
tasking des QDOS - en bloc ablaufen mssen, etwa die ser1/ser2-Bedienung bei
Minerva oder auch sonst in den hheren Baudraten. Ausnahmsweise auch, wenn
ein (mglichst kleiner) Programmteil besonders schnell ausgefhrt werden soll.

Der Aufruf wird durch die "chk"-exception mit Hilfe der QDOS-Trap-Umleitung
in einer fr alle 680xx-Processoren zulssigen Weise so dargestellt, da
Aufrufe zu beliebigem Zeitpunkt mglich sind, unabhngig vom Processortypen
und dem aktuellen Systemzustand. "Exception-handler" sind darum nicht erfor-
derlich, rsp. werden nicht aktiv - vor allem fr die Laufzeit vorteilhaft.
Fr die Paarung der Worte zur Status-Umschaltung gilt dieselbe Regel, wie
fr >R und R>, und mu strikt eingehalten werden. Die F6-Worte der Fehler-
Aktionen sorgen zwar fr gefahrlose Rckkehr, wird aber bei sonst einwand-
freiem Verlauf der Status nicht richtig geschaltet, geraten F6-Returnstack
und der QDOS-Systemstack durcheinander, was zu belsten Fehlern fhrt.

Einfache Regel:
Der Processorzustand mu am Ende eines Wortes derselbe sein, wie zu Anfang,
was im Wortinnern auerdem fr jede einzelne DO..LOOP gilt. Da Systemstack
und Return-Stack dieselben sind, drfen 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.
Ladevorgngen 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, Rckgabe 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            ( auflsung 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 auerdem mit den weiter unten notierten Register-
Operatoren verndert werden. Fehlercode 0 steht fr ordnungsgemen Verlauf.
Kennzeichnung (G):
Die Graphik-Aufrufe belassen abweichend von der sonst strikt befolgten Regel
ihre Parameter im Stack. Grund ist die Ausfhrungsgeschwindigkeit. Da zumeist
mehrere solcher Aufrufe aufeinander folgen, und sie hufig die Vorgngerdaten
weiterverwenden, werden sie auf diese Weise wesentlich schneller abgearbeitet.
Sie arbeiten smtlich mit Fliekommazahlen.

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. Lnge.
                Zurck gehen ptr2 und len passend fr 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 gltig 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 - auer bei
                Minerva arbeitet die Trap nur an eigens dazu geffneten Kanlen.
fssave          ( d.adr d.len -- )
fstrunc         ( -- )                  nur mit Minerva oder TK2
                Lt sich mit der Kombination {headr} & {heads} nachbilden, wenn
                der Header mit der verkrzten Filelnge zurckgeschrieben 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-Lnge 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           ( fmastab 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 fr die Ablage zur
                Sicherheit 100 Bytes freigehalten werden. Der F6-Aufruf
                arbeitet auch mit MDV-Laufwerken und unabhngig 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, Nationalitten-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 Rckgabewerten ist es leicht, ohne besondere Vorkeh-
                rungen bei automatischer Bercksichtigung 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. mglich 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
                      schliet 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 ausgefhrt.

* 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.mae 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.mae 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 Verfgung, da in standardmigen QDOS-Jobs,
wie dem F6, der Wert des Registers A6 nur durch das Programm selbst verndert
werden kann und darum die fr die Trapaufrufe bentigten relativen oder wirk-
lichen Werte gefahrlos zusammengesetzt werden drfen.

* Trap 5 bis 15
Sind smtlich unbenutzt, werden aber von der Trap-Umleitung des F6 miterfat
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; systemabhngig.
Wie im einzelnen dies durchgefhrt 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 vollstndiger 6800x-Macro-Assembler steht
in "f6asm_scr" zur Verfgung. Er nimmt ca. 10K in Anspruch, einschlielich
umfangreicher Hilfsaufrufe und Strukturworte werden daraus rund 16K. Fr
Anwendungen, die einzelne Assembler-codierte Passagen enthalten sollen, kann
mit Hilfe von {c-save} und {c-load} der Assembler spter fortgelassen werden,
soda dann nur der Platzbedarf fr die assemblierten Forth-Worte entsteht.
Fr den Anfang stehen hier die Ptr auf einige wichtige Stellen im System.
Sie sind etwas ausfhrlicher erlutert, um die Verbindung mit nachtrglichen
ergnzenden 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 Hnde des Autors
gelangtes Derivat des 68000-Assemblers von Laxen & Perry, das fr das F6
vervollstndigt, stark erweitert und auch von Fehlern befreit wurde.

Als 4th-Register mssen bei neuen Processorcode-Aufrufen geschtzt werden:
Im F6 mit besonderer Verwendung:
                D2      bei Deferred-Aufrufen zur inneren Datenbergabe
        OS      D6      Segment Offset (reserviert)
        NX      A3      Einsprung in den Inneren Interpreter
        BP      A6      Basis-Ptr, Bezugspunkt fr 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-Programmzhler
        SP      A5      Datenstack
        RP      A7      Returnstack
Alle anderen Register knnen verndert werden, werden aber berschrieben.
Solange die folgenden erhalten bleiben, liefern sie die Informationen:
                D0      allgemeine Flag fr {l<i} - s. dort.
                D1      Case-Index fr {#case}
Der Innere Interpreter bei <next> verndert 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 (Programmzhler des Forth).
A1 und A2 knnen davor beliebig verwandt werden, A4 mu unberhrt 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 auerhalb des 4th-adressierbaren Bereichs
                liegendem Programmcode.
[do;does]       Einsprung des Runtime-Aufrufs von {;does>} dosemidoes
                {;does>} fhrt das standardmige {(;code)} aus und compiliert
                vor den hi-level-Ausfhrungsteil 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 fr Primitive-4th-
                Worte, die damit als gewhnliche Subroutine ausgefhrt werden.
                Beschreibung s.u., Hinweise zum F6 Assembler-Quelltext.
[cdefer]        entsprechend fr {defer}ed angelegte Worte.
* im Forth-Vocabular:
nopdf           ist eine {defer}red Definition im F6-Kern und kann als Referenz
                fr 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 Einfgen eines Codeblocks mit {c-load} der
                Aufruf auf den wirklichen Vector justieren lt.
+nul            als Variable mit dem Inhalt 0 lt sich hnlich nutzen.


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


 ende glossar, folgt Anhang mit Referenzlisten "F6REF_txt" 
