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

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

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

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

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


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


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



* F6 Assembler-Quelltext

Alle n„tigen Kommentare sind in "forth_asm" angegeben. Zum Aufbau von lo-level-
Routinen gibt es ein paar Hilfsmittel f‡r den Einbau anderer 4th-Aufrufe, auf
die hier hingewiesen werden soll. Dabei zu beachten, daœ dabei kein Register
gesichert wird, dies muœ beim Aufruf selbst geschehen, wobei insbes. die oben
genannten Forth-Register nicht ver€ndert werden d‡rfen. Innerhalb der Pr‡fgren-
zen (s. Assemblertext) d‡rfen die Adressregister ab A3 auch nicht ungerade sein.

Forth: 2constant [cdefer] im Assembler-Voc.
Bei {defer}red Definitionen soll die Ausf‡hrungsroutine nie direkt angesprungen
werden, da sie jederzeit von einem Programm umgelenkt werden kann. Solche Worte
ruft man mit der Adresse des 4th-Ptr auf die betr. Routine auf:
                lea     deferred_pfa(pc),[w]
                jsr     Cdefer(pc)
Diese Form ist nur vorhanden, um den Einbau von {defer}ed Aufrufen in Codeteile
zu erm„glichen. Die Ausf‡hrungszeit entspricht in etwa der Standard-Aufrufform.
Da bei gleichbleibenden Versionsnummern der auœerhalb des Forth-Bereichs liegen-
de Code-Teil unterschiedliche Adressenlage aufweisen kann, empfiehlt sich im F6-
Assembler Lesen der relativen Adresse aus der PFA von {[cdefer]}. Der Aufruf ist
dann, solange dieselbe Versionsnummer zugrundeliegt, in derselben Weise unabh€n-
gig von Ver€nderungen in den grundlegenden lo-level-Aufrufen, wie ein "normales"
Forth-Wort. Und nur so kann die betr. Codepassage mit {c-load} sicher geladen
werden - was grunds€tzlich auf s€mtliche Referenzen in den F6-Kern zutrifft.
      ' deferredword >PC   d(PC  W     lea,   \ 4th-ptr im codeblock relativ!
            [cdefer] 32Bit .l # D0 .l move,   \ langwort-disp nach 'auœen'
                0 BP D0 .l d(Xi,PC     jsr,   \ deferred wort ausf‡hren & ret


Forth: 2constant  [cprim] im Assembler-Voc.
Normalerweise enden 4th-Primitives mit einem Sprung nach <next>. Um sie dann
als Subroutinen aus anderen Programmteilen aufrufen zu k„nnen, muœ ihnen dies
f‡r den einen Aufruf "abgew„hnt" werden. Dazu dient:
                lea     primitive_code(pc),[w]
                jsr     Cprim(pc)
Das W-Register muœ dazu mit der Adresse besetzt werden, an der die aufzurufen-
de Routine steht. Inhalt von PFA oder CFA eines jene ausf‡hrenden 4th-Wortes
sind nur bedingt brauchbar, deren Aufruf f‡hrt je nach Worttyp evtl. zu Fehlern.


Constante und Variable unterscheiden sich nur in der Ausf‡hrungsvorschrift,
darum kann ihr Datenfeld auf dieselbe Weise adressiert werden:
        ' name
was sich besonders bei Assembler-codierten Worten vereinfachend bemerkbar macht:
        code: [inc]   ip )+ a1 move,   #1 # 2 a1 bp d(xi addq,   next;
erh„ht dann unabh€ngig vom Typen den Wert einer Constanten oder den Inhalt einer
Variablen um Eins. - Dieses Beispiel darf NUR COMPILIERT eingesetzt werden!


* Betrachtungen zur Ausf‡hrungszeit:
Zum Vergleich mit Assemblercode dient das Beispiel <next> und <semis>, das der
Paarung JSR und RTS entspricht, und als halbwegs repr€sentativ angesehen werden
kann. Maœgeblich f‡r den Zeitbedarf kommt je namentlichem Aufruf ein [docol]
hinzu. Alle anderen Codeteile entsprechen Assembler-Aufrufen, sodaœ bei dem sehr
geringen Aufwand des Inneren Interpreters das Verh€ltnis 4:1 f‡r Forth gegen‡ber
optimiertem Assemblercode als verl€œliche "worst case"-Sch€tzung anzusehen ist.
Den mitunter genannten Faktor 1:3 bis 1:5 gegen‡ber ausf‡hrbaren Code erzeugen-
den Compilern wird man nur beim Vergleich mit h„chst ungeschickt aufgebauten
Systemen erzielen k„nnen, im F6 sicherlich nicht: Der Umbau des gr„œten Teils
Colon-Definitionen des Kerns in direkt codierte Aufrufe ergab etwa doppelte
Geschwindigkeit, nennenswerte Steigerung ‡ber den Faktor 2 hinaus wird kaum
zu erreichen sein. Oft wird aber ein spezielles lo-level-Wort noch sehr viel
schneller sein, als die gleichwertige Forth-Definition, wenn es gelingt, darin
die Funktion mehrerer hi-level-Worte zusammenzufassen.

Die Abschluœ-Optimierung mit Sprung in eine Colen-Definition statt deren norma-
len Aufrufs und anschlieœender Ausf‡hrung von {;s} spart die letzte [docol]-
[semis]-Paarung ein. Dem entspricht beim Processorcode die Einsparung der Adres-
sensicherung im Stack durch JSR mit einem RTS nach einer Subroutinenkette, wenn
stattdessen der letzte Aufruf durch einen einfachen Sprung erreicht wird. Eine
solche Kette wird bearbeitet wie ein Teil ein und desselben Wortes. Beispiel:
                F6                                      Assembler
                ... to-work ;                           JSR     to-work
                                                        RTS
wird optimiert zu
                ... branch [ ' to-work here - ,         JMP     to-work
            und im Forth-Programm um ‡ber 50% schneller ausgef‡hrt.
Die Zeitersparnis macht sich besonders bei Aufrufketten aus vielen kurzen Colon-
Definitionen deutlich bemerkbar. Dort lohnt es sich, auf geeignete Wortanordnung
zu achten, damit diese Optimierungsform wirksam werden kann.

* Beispiel einer optimierenden hi-level-Definition
{&} f‡hrt in Infix-Notation die Verkettung zweier Bytewerte als gepackte Integer
aus, in der das erste Byte der Eingabe an h„herwertiger Stelle angeordnet wird.
War die erste Zahl als {literal} compiliert, wird diese bereits w€rend des Com-
pilevorganges mit der zweiten Verkn‡pft und in der ge€nderten Form fixiert, so-
daœ w€hrend der Ausf‡hrung des hiermit gebildeten Wortes keine Rechenoperationen
mehr anfallen. Der Code wird dadurch um 6 Bytes k‡rzer, d.h. es wird kein zu-
s€tzliches Wort compiliert, und die Ausf‡hrungszeit reduziert sich auf weniger
als ein Viertel gegen‡ber z.B. einer f‡hrenden Constanten. Man schreibt etwa
        .. #1 & 34 ..
im interpretierenden Betrieb oder in ein Wort compilierend. Die Definition:
: & depth state@ 0= < dup ?error -compile >< -find
  IF drop dup @ swap cfa @ [ ' 0 cfa @ ] literal -      \ 2. parm als cons
  ELSE here [number] -dup 0= IF 1abs ENDIF ENDIF        \ oder festwert
  abort" Zahl?" state@                                  \ oder fehler
  IF here 6- @ also hidden ' lit previous cfa =         \ code pr‡fen
  IF here 4- @ >< or here 4- ! -2 allot ;s ENDIF ENDIF  \ ggf. optimierung
  [compile] literal -compile or ;          immediate    \ oder standardform
Dieses Wort wurde f‡r einen speziellen Anwendungszweck geschaffen und dient
hier nur als Beispiel. Seine Verwendung ist dadurch eingeschr€nkt, daœ die
zweite Zahl nur eine Constante oder ein Festwert sein darf, Parameter oder
(Locale) Variable k„nnen an dieser Stelle nicht verarbeitet werden.


* Zusammenstellung der Worte zur Ganzzahlen-Arithmetik

* 1. Einfachgenaue Zahlen
+       ( n1 n2 -- n3 )                 n3=n1+n2
++      ( n1 n2 n3 -- n4 )              n4=n1+n2+n3
+!      ( n1 ptr -- )                           Addition n1 in den Speicher
+!l     ( n1 dadr -- )                          dto. an wirklicher Adresse
-       ( n1 n2 -- n3 )                 n3=n1-n2
*       ( n1 n2 -- n3 )                 n3=n1*n2
*/      ( n1 n2 n3 -- n4 )              n4=n1*n2/n3
*/mod   ( n1 n2 n3 -- n4 n5 )           n5=n1*n3/n3     n4 Divisionsrest
/       ( n1 n2 -- n3 )                 n3=n1/n2
/mod    ( n1 n2 -- n3 n4 )              n4=n1/n2        n3 Divisionsrest
mod     ( n1 n2 -- n3 )                 n3=n1-n2*(n1/n2)   Divisionsrest
u/      ( u1 u2 -- u3 )                 u3=u1/u2
u/mod   ( u1 u2 -- u3 u4 )              u4=u1/u2        u3 Divisionsrest
1+      ( n1 -- n2 )                    n2=n1+1
2+      3+      4+      5+      6+      7+      8+      entsprechend {1+}
1-      ( n1 -- n2 )                    n2=n1-1
2-      3-      4-      5-      6-      7-      8-      entsprechend {1-}
2*      ( n1 -- n2 )                    n2=n1*n2        Bit 15 bleibt Vorzeichen
3*      4*      5*      6*      10*     16*             entsprechend {2*}
2/      ( n1 -- n2 )                    n2=n1/2
4/      ( n1 -- n2 )                    n2=n1/4
abs     ( +n1 | -n1 -- +n1 )
1abs    ( n1 -- n2 )                    n2=+n1 oder Einercomplement bei -n1
min     ( n1 n2 -- n3 )                 n3 als kleinere Zahl von n1, n2
umin    ( u1 u2 -- u3 )                 u3 als absolut kleinere Zahl von u1, u2
max     ( n1 n2 -- n3 )                 n3 als gr„œere Zahl von n1, n2
umax    ( u1 u2 -- u3                   u3 als absolut gr„œere Zahl von u1, u2
0max    ( n1 -- 0 | +n1 )
* bitweise Operatoren
and     ( n1 n2 -- n3 )
and!    ( n1 ptr -- )                   AND-Operation mit n1 am Ort ptr
not     ( n1 -- n2 )                    n2 Einercomplement von n1
or      ( n1 n2 -- n3 )
or!     ( n1 ptr -- )                   OR-Operation am Ort ptr
xor     ( n1 n2 -- n3 )
xor!    ( n1 ptr -- )                   XOR-Operation am Ort ptr
* Stack- und Speicheroperatoren
dup     drop    over    swap    ndrop
sdup    sdrop   sover   pick    roll    rdrop   >r      >rr     r>      r
!       !l      @       @l      @!      c!      c!l     c@      c@l
@!      m>r     r>m

* 2. Doppeltgenaue Zahlen
d+      ( d1 d2 -- d3 )                 d3=d1+d2
2+!     ( d1 ptr -- )                           Addition d1 in den Speicher
2+!l    ( d1 dadr -- )                          dto. an wirklicher Adresse
d-      ( d1 d2 -- d3 )                 d3=d1-d2
#       ( d1 -- d2 )                    d2=d1/base@     Rest als Ziffer => hld
d*      ( d1 d2 -- d3 )                 d3=d1*d2
ud*     ( ud1 ud2 -- ud3                ud3=ud1*ud2     vorzeichenlos
d1+     ( d1 -- d2 )                    d2=d1+1
d2+     d4+                                             entsprechend d1+
d1-     ( d1 -- d2 )                    d2=d1-1
d2-     d4-                                             entsprechend d1-
d2*     ( d1 -- d2 )                    d2=d1*2
d4*     ( d1 -- d2 )                    d2=d1*4
d2/     ( d1 -- d2 )                    d2=d1/2
d4/     ( d1 -- d2 )                    d2=d1/4
d/      ( d1 d2 -- d3 )                 d3=d1/d2
ud*/mod ( ud1 ud2 ud3 -- ud4 ud5 )      ud5=ud1*ud2/ud3 ud4 32-Bit Divisionsrest
dabs    ( +d1 | -d1 -- +d1 )
2and    ( d1 d2 -- d3 )                 d3 = bitweise d1 AND d2
* Stack- und Speicheroperatoren
2dup    2drop   2over   2swap
        2sdrop          2pick   2roll   2>r     2>rr    2r>
2!      2!l     2@      2@l             2@!

* 3. Vierfachgenaue Zahlen
q+      ( q1 q2 -- q3 )                 q3=q1+q2
q-      ( q1 q2 -- q3 )                 q3=q1-q2
q2/     ( q1 -- q2 )                    q2=q1/2
q4/     ( q1 -- q2 )                    q2=q1/4
4+!     ( q1 ptr -- )                           Addition in den Speicher
4+!l    ( q1 dadr -- )                          dto. an wirklicher Adresse
qabs    ( +q1 | -q1 -- +q1 )
* Stack- und Speicheroperatoren
4dup    4drop           4swap
                        4pick   4roll
4!      4!l     4@      4@l             4@!

* 4. FP-Zahlen, Funktion entsprechend einfachen Integer, Rest s. FP-Vocabular.
+       -       *       */      2*      /       2/

* 5. Mischoperatoren mit Einfachgenauen Zahlen
m+      ( d1 n2 -- d3 )                 d3=d1+n2        n2 vorzeichenerweitert
m*      ( n1 n2 -- d3 )                 d3=n1*n2        16 nach 32 Bit
u*      ( u1 u2 -- ud3 )                ud3=u1*u2       dto. vorzeichenlos
s*      ( d1 n2 -- d3 )                 d3=d1*n2
m/      ( d1 n2 -- n3 n4 )              n4=d1/n2        n3 16-Bit Divisionsrest
m/mod   ( d1 n2 -- n3 d4 )              d4=d1/n2        n3 dto.
um/mod  ( ud1 u2 -- u3 u4 )             u4=ud1/ud2      u3 dto. vorzeichenlos
+-      ( n1 n2 -- n3 )                 n3=n1 oder n3=-n1 wenn n2 < 0
d+-     ( d1 n2 -- d3 )                 wie {+-}
q+-     ( q1 n2 -- q3 )                 wie {+-}

* 6. Mischoperatoren mit Vierfachgenauen Zahlen
qm+     ( q1 n2 -- q3 )                 q3=q1+n2        n2 vorzeichenerweitert
q#      ( q1 -- q2 )                    q2=q1/base@     Rest als Ziffer => hld
qs*     ( q1 n2 -- q3 )                 q2=q1*n2        64Bit-Produkt (accu)
dm*     ( d1 d2 -- q3 )                 d3=d1*d2        32 nach 64 Bit
udm*    ( ud1 ud2 -- q3 )               q3=ud1*ud2      63-Bit positives Produkt
qm/mod  ( +q1 d2 -- q3 d4 )             d4=q1/d2        q3 64-Bit Divisionsrest
uqm/mod ( +q1 +d2 -- +d3 +q4 )          q4=q1/d2        d3 32-Bit Divisionsrest
uq/mod  ( +q1 d2 -- d3 d4 )             d4=q1/d2        d3 32-Bit Divisionsrest

* 7. Vergleichsoperatoren; stets einfache Integer als Ergebisflag
* Byte
                                                uc<
* einfach
=       <       >       0=      0<      0>      u<      sgn
=/=                     0=/=
                        -0=
* doppelt
d=      d<              d0=     d0<             du<     2sgn
* vierfach
q=      q<              q0=     q0<             qu<
* FP
=       <       >       0=      0<      0>              sgn     cmp


* Verwaltung der QDOS-Kan€le

* Kanalnamen
file            i/o             in-cons         out-cons        prt
screen          work

* ¤ffnen/Schlieœen
close           fdelete         fopen           fop-in          fop-link
fop-new         fop-over        format          open            open-link
using

* Kanaltabellen
>chan<          cdt             ch-id           chp             is-chan
is-open         new-chan        set-chan        set-work        to-chan
to-work

* Ver€nderungen der Kanaldaten
>fount          pushfile        popfile         window          wmov

* Abfragen
-window         ch-num          edif            is-his          is-ochan
wd-size         work-id         work-num


* Liste der USER-Variablen
>>> as found by { selected wtyp base } in different vocabularies
#TIB     (PROMPT)  (R)       BASE      BLK       CC4TH     CONTEXT
CSP      CURRENT   DP        DPL       FENCE     FLD       FORGET-LK 
HLD      IN        IO-TIME   L-MRG     LAST      OFFSET    OS 
OUT      R#        R0        ROW       S0        SCR       SPAN 
STATE    TIB       U0        UP        VOC-LINK  WARNING   WIDTH 


* Liste der immediate-Worte
>>> as found by { selected imed words } in different vocabularies
€ (die null)    "               '               (               +
+loop           -->             -forget         -loc            ."
.(              ;               ;cdoes>         ;code           ;does>
>r              <with           abort"          again           also
asm68           assembler       associative:    begin           case:
case?           cmc             default-is      dliteral        do
editor          else            end-loc         endif           fdelete
fop-dir         fop-in          fop-link        fop-new         fop-over
fopen           format          forth           fp              ftest
h,              h]              hidden          i               if
if-found        if-nfound       if-true         ini-loc         is
literal         local           loop            minerva         name
no-search       only            pif             previous        qdos
r               r>              range:          recurse         repeat
root            rvoc            seal            search          s-load
stack           stack:          text            until           using
while           [               [compile]       [debug]         \
|

Als {€} erscheint hier die ASCII-<nul>, die als besonderes f.i.g.-Forth-Wort
beim Interpretieren des Eingabestroms f‡r Nachschub oder ggf. Abbruch sorgt.

* Liste der deferred-Worte
>>> as found by { selected wtyp cr words } in different vocabularies
€               (abort)         (abort")        (debug)         (exper)
-->             -find           ;does>          ?key            ?numerr
?terminal       assembler       block           bs              buffer
clone-jdt       cls             cr              del             doforget
echo            edit            emit            error           expect
key             l-load          load            number          pemit
prompt          ptype           query           sltext          type
type-l          w-find          [convert]       [cpl]           [find]
[fop]           [interpret]

* Liste der Primitives l€œt sich nur unvollst€ndig anlegen mit:
        { selected prim words }
>>> will find the standard and long jump primitives.

* Fehlercodierung
Das System liefert Fehlercodes zum Stack sowie in verschiedene Pseudo-Con-
stante, welche jeweils unmittelbar nach dem Lesen auf Null gesetzt werden:
Name            Bezug
4th-err         In {[error]}, bei Aufruf der Forth-Fehlerbehandlung,
                fehlgeschlagener Umwandlung von Zahlen in Strings,
                §berlauf bei quad-Division.
ernum           Alle Operationen des {qdos}-Vocabulars.
                Fehlschlag bei {w-save}, {wmov}, und den open-Varianten.
fp-err          Arithmetik-Operationen im Flieœkommavocabular.
io-err          Operationen an den Standardkan€len und
                in {w-save} bei Platzmangel im Zielmedium.

>>> system messages
* Meldungstexte
Mit negativem Index entsprechend ERNUM werden die QDOS-Meldungen adressiert,
im F6 werden einige QDOS-Texte auch bei positiver Fehlernummer ausgegeben.
Nicht mit Texten belegte Nummern werden mit ihrem Wert und vorangestelltem
"msg #" hingeschrieben. Das F6-System definiert folgende Meldungstexte:
1       empty stack                     Stack leer
3       adressing mode                  Adressierungsart
5       digit storage ovf               Ziffernspeicher voll
7       stack overflow                  Stack‡berlauf
9       fatal error - don't retry!      irreparabler Fehler, nicht wiederholen!
15      M68LR6                          (Systemkennung)
16      {version} F6 (C) .hpr'{datum}   (Versions- & Urheber-Vermerk)
17      compilation only                nur beim Compilieren verwenden
18      executing only                  nur zur direkten Ausf‡hrung
20      definition not finished         Definition unvollst€ndig
21      protected dictionary            gesch‡tzter Wortebereich
22      use only when loading           nur beim Laden verwenden
23      off editting screen             auœerhalb editierter Seite
24      ? vocabulary                    falsches Vocabular
25      - mpu effective timing          (bei Anzeige der gemessenen Taktung)
26      execution vector undef'd        vectorisierter Aufruf nicht definiert
27      system address error            reparabler Adressierungsfehler im System

Zum Ansehen aller Meldungen gibt man beispielsweise ein:
        | 30 -30 DO i 1- 0> -cr i i . message key 27 = -leave LOOP |  <enter>


* Verzeichnis der - versuchsweise - f‡r {l<i} pr€parierten Worte.

Diese Aufrufe liefern durch {l<i} lesbare Werte, die zum Multitasking einzelner
Forth-Worte anstelle der f‡r die Referenz unzureichenden 16-Bit-Werte verwandt
werden k„nnen. {l<i} ‡bergibt das Processor-Register D0 vom Ende des jeweiligen
Aufrufs und erlaubt darum nur unmittelbar danach und nur im compilierten Zustand
die sinnvolle Deutung. Die R‡ckgabewerte sind folgendermaœen zu interpretieren:

* §berlauf-Flag -1. als doppelte Integer, sonst beliebig positiv
f>d     f>q
+!      m+!     2+!     4+!     +!l     2+!l    4+!l
+       ++      -       over-   +-      minus   not     bounds
d+      m+      d-      2over-  d+-     dminus          d2*     d4*     2base+
q+      qm+     q-              q+-     qminus

* DO..LOOP Laufindex (was dem Wort den Namen gab)
loop            der zweite Integerposten (nach drop) liefert den Index, mit
+loop           dem die Schleife beendet wurde, auch nach LEAVE oder -LEAVE.

* 32-Bit-Ptr
<#              ptr auf den Beginn (das sp€tere Ende) der Ziffernablage
#>              anfang des Ziffernstring
#s              anfang des Ziffernstring
,       c,      Dictionary-ptr nach der Zuweisung
d>date          String-ptr
d>day           String-ptr
f>$             String-ptr
hld?            Abstand-3 der Ziffernablage zum Dictionary-Ptr
hold            Anfang des Ziffernstring
local buchst.   ptr auf den Ort der local-Daten
pad             Anfang des Ablagebereichs

Die folgenden Worte beeinflussen das Resultat von {l<i} nicht:
i/o in-cons out-cons work screen file prt dr0 dr1
1+  und  d1+                    (in allen Varianten mit je derselben CFA)
int+ 2/ 4/ 2* 4* h>a
-off 1off 1on toggle and! or! xor! count count-l count-w
! und @ und @!                  (alle varianten, auch fp)
skip scan cmove cmove-l <cmove
sr! sr@ trap0 trap0r trap0s
sp!a1 d1l@                      (alle Varianten der qdos-Register‡bergabe)
><  >|< c->s s->d
hex decimal base@ base! state@ tib@ dpl@ source sp@ rp@ depth #case
drop 2drop 4drop ndrop dup ddup 2dup 4dup ndup over 2over pick (ggf. auch fp)
rot 2rot swap 2swap 4swap sover sdrop 2sdrop
>r r> >rr r i j 2>r 2>rr 2r 2r> r+                (ggf auch fp)
previous also only vocabulary constant 2constant  (alle runtimes, ggf. auch FP)
definitions unsmudge latest execute perform ] [ -exit branch (alle Varianten)
bset bclr btst shift align even
qsys+ sysflg 4th-id +origin code+ base+ ti-cal q0<


* 32-Bit-Variablenwerte (user-Vari)
csp 2-          gespeicherter Stackptr
dds 2-          ;does> hi-level-Einsprung, aktuell nach jedem {;does>}
hld 2-          Laufpointer in die Ablage bei der Ziffernumwandlung
hld 2+          Anfangsptr der Zifferndarstellung (Strig-Ende)
dp 2-           dictionary ptr
s0 2-           stackptr
r0 2-           returnstackptr
u0 2-           uservari Datenbereich


* Die wichtigsten erg€nzenden Definitionen aus "forth_scr" und "f6xco_scr"

Die hier aufgef‡hrten Worte k„nnen mit L-LOAD {name} geladen werden.
Sie werden ‡bersprungen, wenn sie bereits vorhanden sind.

Besonders hingewiesen sei vor allem auf die Gruppen

array           frei dimensionierbare Variablenfelder nach Vorbild des SBasic
                mit Datenablage auœerhalb des Forth-Speichers.
chain           beliebig stapelbares Laden von gew„hnlichen Files.
debugger        der aktive Teil zum Einzelschrittbetrieb, Mini-Decompiler.
dump            Varianten f‡r Speicherausz‡ge, desgl. auch {ldump}
heapmem         €uœerst sichere Zuweisung im QDOS-Systemspeicher.
msg"            Textsystem mit Datenablage in "heapmem"-Bl„cke. Als lo-level-
                Worte auch in "f6xco_scr", und f‡r {c-load} in "f6xco_4th".
printer         Sammlung zum Drucken, auch simultan mit der Bildschirmausgabe.
sort & sort-l   schnelles und effizientes Sortierverfahren nach Zech, Forth 83.
turtle          vollst€ndiger Satz Aufrufe zur incrementellen (Vector-)Graphik.
view            als wirkungsvolles Anwendungsbeispiel f‡r vectorisierte Worte.
>s s> u.a.      Externe Stacks, Definition und Operatoren, der Effizienz halber
                nur in "f6xco_scr" rsp "f6xco_4th" als lo-level-Worte angegeben.

Die Anordnung in diesem Verzeichnis ist alphabetisch und ber‡cksichtigt
allein die Buchstabenfolge. Das betroffene Vocabular ist jeweils angegeben:
        (f) fp          (r) root        (h) hidden
Worte ohne Kennzeichnung sind im aufrufenden oder im Forth-Vocabular zu finden.

2^              ( n1 -- n2 )
                liefert die n1-te Potenz von Zwei - und ist zugleich Beispiel
                einer eigenst€ndigen {case}-Liste.
4th-heap        ( dadr -- flg )
                tf wenn dadr einen "heapmem"-Block des aufrufenden F6 bezeichnet.
ans             ( -- )
                Vocabular mit den (experimentellen!) ANSI-Definitionen.
array           ( n1 n2 ARRAY name )                            F6(!)
                Errichtet ein im Rahmen der Speichergrenze beliebig dimen-
                sioniertes Variablenfeld auœerhalb des 4th-Adressenbereich.
                Anzahl Dimensionen n1, Produkt aller sp€ter festzulegenden
                Dimensionen und die Einzelpostengr„œe n2 d‡rfen je bis unter
                64K Bytes groœ sein, das Produkt aus Postengr„œe und Dimen-
                sionen muœ kleiner als 256K sein. Mehr s. "forth_scr".
ascii           ( -- c1 ) (C) ( ASCII char -- )                 F83
                Im F6 entbehrlich, da "{" als Textpr€fix mehr leistet.
a-close         ( -- )
                Alle in der F6-Kanaltabelle verzeichneten Kan€le schlieœen,
                wobei {in-cons} und {out-cons} gesch‡tzt sind. Auch die
                QDOS-Kan€le 0 bis 2, sollte einer von ihnen versehentlich in
                die F6-Tabellen gelangt sein, k„nnen nicht geschlossen werden.
backup          ( -- ) (C) ( BACKUP quellenfile zielfile -- ) (I)
                Filecopie mit den Namen aus dem Standard-Eingabestrom oder
                ggf. den in ein aufrufendes Wort hineincompilierten Namen:
                        : wort ... BACKUP quelle ziel ... ; \ fest eingebaut
                        : wort ... [compile] BACKUP ... ;   \ vom eingabestrom
                Beide Files d‡rfen auch einen im F6 offenen Kanal haben. Die
                Filenamen m‡ssen vollst€ndig angegeben werden; das mag l€stig
                sein, wurde aber der Sicherheit halber bewuœt so eingerichtet.
?backup         ( -- )
                Wie {backup}, jedoch mit Eingabeanforderung f‡r beide Namen.
-bpt            ( flg -- flg )
                "breakpoint" f‡r den Debugger. Ist er aktiv, d.h. {db-on} =/= 0,
                aber im nichtanzeigenden Betrieb, signalisiert durch {db-on} <0,
                wird bei flg =/= 0 der Anzeigemodus wiederhergestellt.
basicv"         Basic-Variable holen; im Forth-Vocabular bereits beschrieben.
bdump           ( -- )
                Speicherauszug in 16-Bytes-Gruppen der L€nge aus dem vorigen
                {dump}-Aufruf des n€chst niedrigeren Anschluœbereichs.
case            Installation der Eaker-CASEs mit OF, ENDOF etc.
chain           ( CHAIN filename -- loc: did )                  F6 LR
                Zum Laden von Forth-Quelltexten aus "normalen" Textfiles, die
                aus bis zu 168 Zeichen langen mit <lf>, <cr><lf> o.dgl. abge-
                schlossenen Zeilen bestehen, deren letzte ein {end} enth€lt.
                Der Aufruf hinterlegt zwei Local-Posten, die durch {end} frei-
                gegeben werden und kann im Rahmen des verf‡gbaren Speichers be-
                liebig tief geschachtelt werden. Da die Files nur zum Lesen ge-
                „ffnet werden, k„nnen mehrere F6-Jobs zugleich auf dasselbe File
                zugreifen. Datenbewegungen auch zwischen den Aufrufebenen sind
                m„glich, solange der {local}-Bereich in Ordnung gehalten wird.
                Vorsicht: Systemzusammenbruch m„glich, wenn das {end} fehlt!
chans           ( -- )
                QDOS-IDs und Nummern aller offenen Kan€le des F6 hinschreiben.
clchp           ( -- )                                          F6
                Alle mit {heapmem} reservierten Speicherbl„cke aufl„sen. Die
                zugeh„rigen Definitionen bleiben weiter aktiv, sodaœ mit ihrem
                Aufruf wieder eine g‡ltige Speicheradresse zur Verf‡gung steht,
                nun aber in Form eines neu zugewiesenen und gel„schten Blocks.
clm             ( dadr -- )
                Wie HEAP-RMV, jedoch mit Markierung der Definitionsparameter
                durch Null-setzen der gespeicherten Adresse (4 Bytes ab PFA).
                Die PFA der Wortdefinition wird hier durch HEAP-PFA ermittelt,
                sodaœ sie auch in einem deferred Wort als indirekte Adresse
                stehen kann. Nachteil dieser Art Adressenermittlung ist, daœ
                der Speicherbereich erst einmal eingerichtet wird (oder bereits
                vorhanden sein muœ), bevor der Aufruf aktiv wird, er also u.U.
                bei Speicher‡berlauf scheitert. Notfalls ist dann Abhilfe mit
                direkter Manipulation der "heapmem"-Definitionsdaten m„glich:
                        ' heapname 2@ heap-rmv
                        ' heapname 2off
c-load & c-save zum Laden und Sichern codierter Passagen wurden oben im Forth-
                Vocabular bereits ausf‡hrlich beschrieben.
console         ( -- )                                         (C1)
                Nimmt die evtl. mit {printer} aktivierte Druckerfreigabe zur‡ck.
.dcm            ( .DCM name -- ptr ) oder ( pfa #DCM -- ptr )
                Ein Minimal-Decompiler, der, weil er nur wenige Bytes ben„tigt
                und recht hilfreich sein kann, mit dem Debugger geladen wird.
debugger        (h)( -- )                                       F6
                Hilfswort f‡r l-load zum Laden der aktiven Teile des Debuggers
                mit Einzelschrittbetrieb, der danach z.B. mit
                        4 is db-on
                geschaltet werden kann und neue Worte daf‡r pr€pariert. Diese
                werden dann beim Aufruf mit Anzeige des Stackinhalts und des
                gerade bevorstehenden Aufrufs Wort f‡r Wort abgearbeitet.
                Fehler:
                Vorsicht ist geboten, wenn die zu untersuchenden Worte {case:}-
                Listen (und ihre Varianten) oder Returnstackmanipulationen ent-
                halten, die zu Ver€nderungen in der Wortreihenfolge f‡hren, wie
                {r+} oder {lit+}. Auch Ver€nderungen der Interpreter-Ptr k„nnen
                empfindliche Fehler verursachen. Zur Abhilfe gen‡gt es, die
                betroffenen Bereiche von der Debugger-Behandlung auszunehmen,
                indem man dort {db-on} auf Null setzt:
                 4 is db-on
                 : name ..worte.. [ db-on 0 is db-on ] ..worte.. [ is db-on ]
dim             ( nn nn-1 .. n2 n1 DIM name -- )                F6
                Initiierung eines mit {array} eingerichteten Variablenfeldes.
                Bereits bestehende Zuweisungen werden vorher zur‡ckgenommen.
dir             ( -- )(I) ( DIR dirname ) oder ( DIR dirname_ )
                Wie der SBasic-Befehl, mit dem Unterschied, daœ bei einem "_"
                am Namensende nur die danach folgenden Teile der Filenamen hin-
                geschrieben werden. Auœerdem erscheinen Filel€nge (einschl. der
                Headerl€nge!), Zugriffscode und Filetyp in der Ausgabe.
drk             ( -- ptr )
                Variable mit dem Namen des {printer}-Ausgabeger€ts in bis zu
                36 Zeichen L€nge. Hier kann ein beliebiger Ger€te- oder Datei-
                name angegeben werden, die Bildschirmausgabe l€œt sich damit
                durch den {printer}-Aufruf ‡berallhin simultan weiterleiten.
dump            ( ptr1 n2 -- )
                Speicherauszug in 16-Bytes-Gruppen n2 Bytes ab ptr anzeigen.
                Varianten davon s. {bdump}, {ndump} und {rdump}.
dvlist          ( -- )
                Als Beispiel f‡r den Einzelschrittbetrieb der Aufruf {vlist}
                vollst€ndig als hi-level-Aufruf (Colon-Definition).
                        l-load dvlist
                l€dt bei Bedarf den Debugger, compiliert {dvlist} und f‡hrt
                es sofort im Einzelschrittbetrieb aus.
end             ( loc: did -- )                                 F6 (LR)
                Muœ ein jedes mit {chain} aufgerufene File abschlieœen.
ew              Einen qdos-Job..                                QDOS
ex                          ..installieren (€hnlich dem SBasic-Kommando),
ex-p ŸtextŸ     EX-Variante mit von "Ÿ" (char 159) begrenztem Parameterstring.
enter .. entry  hi-level-Code f‡r bedingte Schleifen, beide Worte im Kern ent-
                halten und oben bereits beschrieben.
exit            ( -- )(I)                                       F79+
                Im f.i.g.-Forth identisch mit {;s}. F‡r F79-Texte z.B.:
                        : EXIT -compile ;s ;
f-name          ( -- ptr ) (C) ( F-NAME name )
                Eine Stringvariable f‡r Filenamen definieren. Sie wird als
                qdos-String angelegt und auf maximal {f/n} Bytes L€nge justiert.
fname"          ( ptr FNAME" filename" -- ) (I)
                Textst‡ck mit count-word bis zur maximalen L€nge {f/n} nach
                ptr bringen.
ftest           ( -- flg ) (C) ( FTEST filename ) (I)
                pr‡ft filename auf Zug€nglichkeit f‡r einen Lesezugriff.
h]  h,          ( ... ) (I) im {root}-Vocabular                 F6
                Die Worte zum Anlegen rsp. Compiliern headerloser Definitionen
                sind im Kern vorhanden; in "forth_scr" ist ihr Aufbau so ange-
                geben, daœ sie auch anderen 4th-Systemen zugef‡gt werden k„nnen.
heap?           ( -- )
                Zeigt alle dem F6-Job gerade zugewiesenen {heapmem}-Bl„cke an.
heapmem         ( -- dadr ) (C) ( n1 HEAPMEM name )             F6
                Verwaltet auf besonders abgesicherte Weise einen Speicherblock
                mit der vierfachen L€nge der bei der Namensdefinition ‡bergebe-
                nen Zahl n1 - was die Blockgr„œe auf 256K begrenzt. Die Reser-
                vierung erfolgt mit dem ersten Aufruf {name} und immer dann,
                wenn dieser Speicherblock, egal aus welchem Grunde, dem System
                verlorengegangen ist oder er aufgegeben wurde. Das hiermit de-
                finierte Wort kann wie eine {2constant} eingesetzt werden, und
                bietet zugleich die Sicherheit, daœ immer ein ordnungsgem€œ dem
                F6-Job zugeeigneter Speicherbereich adressiert wird.
heap-len        ( dadr -- dn )
                Gibt die nutzbare L€nge einer {heapmem}-Reservierung zur‡ck.
heap-new        (I)( use: nn HEAP-NEW name )
                Neudefinition der Blockgr„œe, ggf. zuvor implizit {heap-rmv}.
                Kann mit festem Wert in ein Wort eigebaut werden
                        : name ... zahl heap-new {heapname} ... ;
                und stellt die Blockl€nge beim Aufruf dieses Wortes ein, oder
                zur Angabe des Namen erst bei Ausf‡hrung
                        : name .. zahl [compile] heap-new ... ;
                wobei die Zahl auch vorher als Parameter ‡bergeben werden kann.
heap-pfa        ( dadr -- ptr | 0 )                             F6
                Gibt die pfa der zugeh„rigen {heapmem}-Definition zur‡ck, wenn
                dadr die Anfangsadresse eines damit reservierten Bereichs ist.
heap-rmv        ( dadr -- )                                     F6
                Gibt den bei dadr beginnenden Speicherblock an das Betriebssys-
                tem zur‡ck. Pr‡fungen sorgen daf‡r, daœ nur ein vom selben F6-
                Job reservierter Block aufgel„st wird, und daœ die Adresse auch
                im QDOS keinen Fehler ausl„sen kann (z.B. ungerade oder nicht
                zu einem "heap"-Block geh„rend). Die definierten Worte bleiben
                aktiv, sodaœ mit ihrem n€chsten Aufruf jeweils wieder ein leerer
                Speicherbereich gleicher Gr„œe zur Verf‡gung steht. Nebenbei ist
                HEAP-RMV daher auch zum Null-Setzen eines Blocks geeignet.
history         ( +n1 c2 -- )                                   F6 & Oktagon
                Anzahl zu sichernder Zeilen und F6-Kanal, dem eine "Commandline
                History" zugewiesen werden soll. Voraussetzung ist, daœ die Er-
                weiterung dazu im Systen vorhanden ist ("history" von Oktagon).
is-his          ( c1 -- flg )                           (in Kern ‡bernommen)
                flg =/= 0, wenn c1 einen Fensterkanal mit "history" bezeichnet.
.jobs           ( -- )
                 hnlich dem JOBS aus dem TK2, jedoch ausf‡hrlicher.
l               ( -- )                                          FIG-Editor
                Aktuelle Screen des gerade benutzten Screenfile anzeigen.
ldump           ( dadr n1 -- )
                Wie {dump}, jedoch von wirklicher Speicheradresse dadr.
lbdump          ( -- )
                Wie {bdump}, entsprechend {ldump}
list            ( n1 -- )                                       FIG-Editor
                Screen Nr. n1 des gerade benutzten Screenfile anzeigen
l-load          ( L-LOAD name ) etc.                            F6
                "Library-Load", oben beim Forth-Vocabular bereits beschrieben.
                Diese Erg€nzung kann stets mit z.B. { 1 s-load flp1_forth_scr }
                compiliert werden. Ihre wirkliche Lage im Screenfile ist dann
                belanglos, da diese in scr 1 angegeben ist. Es werden nur die
                Worte geladen, die hierf‡r erforderlich sind.
lndump          ( -- )
                Wie {ndump}, entsprechend {ldump}
lrdump          ( -- )
                Wie {rdump}, entsprechend {ldump}
msg"            (I)( use: MSG" text" )                          F6
                Ablage eines Textes im "heapmem"-Block {msgmem}, der, sofern
                er nicht bereits existiert, beim Compilieren aus "forth_scr"
                mit 2K Bytes angelegt wird.
msg@            ( nn -- dadr cnt )                              F6
                nn-ten Text (ab 1 z€hlend) aus dem "msgmem"-Block ermitteln.
msg!            ( ptr -- )                                      F6
                Den Text aus dem qdos-String bei ptr mach "msgmem" ‡bertragen.
.msg            ( nn -- )                                       F6
                {type-l} des mit {msg@} ermittelten nn-ten Textes.
msgmem          ( -- dadr )(D)                                  F6
                deferred zur Revectorisierung auf andere "heapmem"-Bl„cke,
                initial mit dem 2K groœen Block {msm} besetzt. Direkte Daten-
                eintragungen in den Definitionsbereich d‡rfen darum nur nach
                Ermittlung der wirklichen "heapmem"-definierten PFA durch das
                Wort {heap-pfa} vorgenommen werden - wenn es denn sein muœ.
!name           ( ptr1 n1 ptr2 )
                den String mit countword bei ptr2 in der maximalen L€nge n1
                nach ptr1 ‡bertragen
ndump           ( -- )
                Speicherauszug in 16-Bytes-Gruppen der L€nge aus dem vorigen
                {dump}-Aufruf des n€chst h„heren Anschluœbereichs.
pdir            ( ptr -- )
                Wie {dir}, mit ptr auf einen Directory-Namen als qdos-String.
postpone        ( POSTPONE name -- ) (I)                        F83+
                        .. postpone postpone postpone IS ...
                schreibt man im f.i.g.-Stil des F6 z.B.:
                        .. compile [compile] IS ..
                Es wird strikt unterschieden zwischen dem Auftrag an eine neue
                Definition, ihrerseits ein Wort zu compilieren, selbst also als
                (spezialisierter) Compiler zu fungieren, und dem Einbau eines
                immediate-Wortes in ein Wort, das jenes dann beim Aufruf ebenso
                ausf‡hren soll, wie ein 'normales' Wort. Dies sind zwei grund-
                s€tzlich und derart unterschiedliche Vorg€nge, daœ der Autor die
                identische Benennung f‡r v„llig verfehlt h€lt und sie deshalb
                nicht ‡bernommen hat - "postpone" ist leicht nachzusetzen, ein
                Beispiel gibt {[_]} weiter unten.
ptext"          ( ptr n1 PTEXT" textpartie" ) (I)
                Mit " oder <enter> begrenzten Text bis zur maximalen L€nge n1
                einschlieœlich count-word bei ptr ablegen.
printer         ( -- ) (I)
                Ein Vocabular mit Definitionen zur Druckerbedienung, Einrichtung
                zur ausschlieœlichen, gleichzeitigen oder unterbundenen Ausgabe
                all dessen, was in die Ein- o. Ausgabefenster geschrieben wird.
                Bis hin zur Ausgabe-Umsetzung €hnlich TRA des SBasic werden hier
                die Worte definiert, deren aus dem Forth-Vocabular zug€nglicher
                Teil im Anhang von "ed_gls" n€her beschrieben ist.
                Leider ist im Laufe der Zeit bei den endlosen Anpassereien an
                st€ndig variierende SMSQ-Versionen etliches an Funktionalit€t
                der {printer}- Aktionen verlorengegengen. - Nach bedingungslo-
                ser Kapitulation seitens des F6-Autors mag der geehrte Anwen-
                der sich mit dem Rest zufriedengeben...
printer         ( -- )                                          F6 (C1)
                ist zugleich der Aufruf zur Aktivierung der Druckerausgabe. Das
                Wort "‡berdeckt" das Vocabular und sichert es gegen versehent-
                lichen zugriff - dessen besondere Worte sind ein wenig heikel.
                Vorsicht bei QXL und SMSQ(/E): Das System kann steckenbleiben!
                Zur Umleitung an beliebige Ausgabeziele s.o. bei {drk}.
prt-abt         ( -- )
                Ruft je nach Vorhandensein den SBasic-Befehl PRT_ABT oder
                PRT_ABORT auf.
9pin    24pin   zur Umstellung auf verschiedene Druckertypen, insbes. Star
                LC-10 und LC-240. F‡r andere Drucker ist evtl. Modifikation
                der zugeh„rigen Worte erforderlich.
q.              ( qn -- )
                Eine vierfachgenaue Zahl hinschreiben.
<q# q# q#s q#>  quad-Entsprechung der Standardaufrufe zur Zifferndarstellung.
q#              als laufzeitbestimmender elementarer Aufruf im Kern definiert,
                wie auch die Umwandlung von Ziffernstrings in Zahlen/Festwerte.
rdump           ( -- )
                {dump} mit den Angaben des vorangegangenen Aufrufs wiederholen.
.s              ( n1 ... nnn -- n1 .. nn 9
                Zeigt mit bis zu 32 Posten den Stackinhalt an, sowie die besetz-
                te Stacktiefe und die aktuelle Zahlenbasis.
precedes        ( n1 n2 -- flg )(D)                             Zech, Forth 83
                W€gefunktion zu {sorted}, s. dort.
sort            ( ptr n1 -- )
                Ausf‡hrender Aufruf zu {sorted}, s. dort.
sorted          ( use: ptr n1 SORTED precedesname )(I)  nach Zech, "Forth 83"
                Ein universell verwendbarer Rahmen zum Sortieren von max. 65535
                beliebigen Datenposten oder sonstigen statischen Erscheinungen.
                Sie werden mittels einer n1 Posten umfassenden Pointerliste nach
                einer im Wort {precedes} definierten Unterscheidungsfunktion in
                bin€rem Sortierverfahren ("quick-sort") geordnet.
                Im einfachsten Falle erzeugt man eine n1 Posten groœe Tabelle
                und tr€gt dort von Null an fortlaufende Zahlen ein. Die Basis-
                adresse dieser Tabelle wird an {sorted} rsp {sort} ‡bergeben.
                F‡r {precedes} gibt man dann ein Wort an, das mit diesen Nummern
                indiziert die zu untersuchenden Ereignisse vergleicht. Deren Art
                und Lage ist von der sortierenden Rahmenprocedur v„llig unabh€n-
                gig, nur das {precedes}-Wort muœ diese ber‡cksichtigen. Das
                Ergebnis ist eine Nummernliste, die in aufsteigender Reihenfolge
                den jeweils n€chst gr„œeren (oder kleineren) Posten indiziert.
                Da nur die Indices selbst im Speicher verlagert werden, nicht
                aber die untersuchten Daten, arbeitet {sort} recht schnell.
                Ein Beispiel, das zeigt, wie auœerordentlich einfach der Umgang
                mit diesem Sortierverfahren ist, findet sich unter dem Namen
                {refsort} in "f6z80_scr".
sorted-l        ( dadr n1 -- )(I)
                Wie {sort}, jedoch mit wirklichen Adressen adressierte Liste.
                Auœerdem mit vectorisierte Lese- und Ablageoperatoren f‡r den
                virtuellen Speicherzugriff. Anwendung u.a. in "bh_scr".
qsqrt           ( q1 -- d2 flg )                                F6
                Quadratwurzel einer positiven vierfachgenauen Integer, war q1
                negativ, geht flg mit 1 zur‡ck, sonst mit 0.
+text           ( ptr1 ptr2 -- )                                f.i.g.-Editor
                den qdos-String bei ptr2 an den qdos-String bei ptr1 anh€ngen.
then                                                            F79
                funktional identisch ENDIF.
turtle          ( -- ) (I)                                      F6
                Vocabular zur Turtle-Graphik f‡r bis zu 16 voneinander unabh€n-
                gige Linienz‡ge mit folgenden Aufrufen, die im Screenfile (auch
                anhand zweier Beispiele) n€her beschrieben sind:
                        deg             rad             Winkelumrechnung
                        turn            turnto          €hnlich den gleichlau-
                        penup           pendown         tenden SBasic-Kommmandos
                        pen             angle           Status, Turtle-Winkel
                        x-cor           y-cor           Ort der Turtle
                        move            moveto          €hnlich SBasic
                        arc-t                           Bogen-"Bewegung"
.view           ( .VIEW name -- )                              (F83)
                Eine Wortdefinition im zugeh„rigen Quelltext anzeigen. Daf‡r
                werden die Wortheader entsprechend pr€pariert, weshalb nur
                nach dem Laden neu compilierte Worte damit aufzufinden sind.
                Diese konventionelle Definition kann mit weitaus weniger Auf-
                wand durch das ebenfalls angebotene {view} ersetzt werden:
view            ( VIEW wortname -- )                            F6S
                ( VIEW wortname quelltextfile )
                Dient als Hilfe-Aufruf zum Ansehen einer Wortdefinition aus
                dem {l-load}-Vorgabefile oder einem anzugebenden Screenfile.
                In seiner Wirkung kommt es mit verschwindend geringem Aufwand
                den mit dem Wort "hypertext" belegten Hilfstext-Systemen nahe,
                und kann zus€tzlich zu {l-load} und dem Editor geladen werden.
                F‡hrt einen {l-load}-Aufruf aus, bei dem das darin enthaltene
                {load} so re-vectorisiert ist, daœ es die Seite, wo das Wort
                gefunden wurde, schreibgesch‡tzt in den Editor holt. Beim Ver-
                lassen wird {load} automatisch wieder auf die eigene Funktion
                zur‡ckgestellt. Der evtl. mit‡bergebene Filename ersetzt den
                bis dahin als Screenfile f‡r {l-load} g‡ltigen Namen. In der
                vorliegenden Form lassen sich die {view}-Aufrufe nicht schach-
                teln, dazu m‡œte ggf. {l-load} ‡berarbeitet werden.
                Anders als bei {.view} erfordert diese Form keine gegen‡ber dem
                "normalen" Compilieren unterschiedlichen Daten, die Worte werden
                allein mit den Hilfsmitteln des in beiden F€llen ohnehin ben„-
                tigten Editors aufgesp‡rt und angezeigt. Darum wird diese (mit
                126 Bytes extrem) kurze Variante im meist zu bevorzugen sein.
vwords          ( -- )
                 hnlich {vlist}, durch alle Vocabulare gehend. Der Aufbau zeigt
                beispielhaft die Vocabular-Einordnung, und wie sie bei neuen
                Definitionen in die Bearbeitung eingeschlossen werden k„nnen.
.vocs        (r)( -- )                                         (F83)
                Anzeige der aktuellen Suchordnung, des Definitionsvocabulars
                und der Namen s€mtlicher im System vorhandener Vocabulare.
where           ( n1 n2 -- )                                    FIG-Editor
                Nach einem Interpreter-Fehler aufgerufen schreibt dieses Wort
                die Zeile hin, in der der Fehler auftrat und markiert dessen
                Position. Ermittelt diese Angaben aus Nummer n2 des gerade ge-
                lesenen Blocks und der aktuellen Interpreterposition n1 darin,
                welche das System stets bei einem Fehler zum Stack bringt.
                Ein Screenfile bleibt ge„ffnet und kann durch {edit} sofort
                in den Editor geholt werden - wenn jener bereits geladen ist.
                Bei direkter Eingabe wird der t.i.b.-Inhalt anfangs durch das
                "where" ‡berschrieben, gibt aber sonst dieselbe Information.
wherr           ( -- n1 n2 )
                kann mit { ' wherr IS error } weitergegeben werden, wodurch dann
                bei jedem Fehler automatisch auch {where} ausgef‡hrt wird.
[_]             ( [_] name -- pfa ) (C) ( [_] name -- )        (H4)
                €hnlich {postpone} - s. dort, liefert im interpretierenden
                Zustand wie "tick" die pfa von {name}.


* Gegen‡berstellung einiger Varianten in ungeordneter Folge
* F83 u.a.                      f.i.g.-Forth rsp. F6    ( hinweis F6-variante

* Stacks
r@                      r                       ( t.o.r. lesen
rp0                     r0                      ( u.vari t.o.r. initial
sp0                     s0                      ( u.vari t.o.s. initial
sp0 @ sp!               sp!                     ( Stackptr direkt nicht €nderbar
nn sp!                  nn csp ! csp!           ( behelfsweise im F6
nn sp!                  nn sp@ 2- - 2/ ndrop    ( andere M„glichkeit
?dup                    -dup                    ( dup IF dup ENDIF
flip                    ><                    ( dup 256 * swap 256 / 256 and or
r>drop                  rdrop                   ( r> drop
nip                     sdrop                   ( swap drop
tuck                    sover                   ( n1 n2 -- n2 n1 n2 ( swap over
under                   sover                   ( dasselbe oder - uneinheitlich
                        over swap               ( n1 n2 -- n1 n1 n2
                        dup rot                 ( n1 n2 -- n2 n2 n1 ( plausibel
( nn ) -roll            ( -nn ) roll            ( roll "r‡ckw-€rts"

* Flags und Vergleichsoperationen
true                    -1
1                       1                       ( f.i.g.-4th true flag
0 0 = constant true                             ( umgeht alle..
1 0 = constant false                            (   ..Miœverst€ndnisse
not                     0=                      ( Flag-Umkehr
        ( Ein Minimal-System braucht z.B. nur die Logikoperatoren < u< und 0=,
        ( sowie die Subtraktion. Damit k„nnen dann alle anderen Operationen er-
        ( zeugt werden, etwa:
        (       : minus 0 swap - ;      : + minus - ;   : not minus 1 - ;
        (       : > swap < ;            : 0< 0 < ;
        (       : 0> 1 - 0< 0= ;        : = - 0= ;
        ( Dies sind nat‡rlich Extrem-Beispiele, deren Operatoren gew„hnlich
        ( zur Standardausstattung geh„ren sollten. Jedoch werden etliche der
        ( speziellen Logikoperatoren oft bereits durch ‡berlegte Anordnung ent-
        ( behrlich, andere nur selten ben„tigt. Darum sind im F6 undefiniert:
0<=                     1- 0<
<=                      1- <
0>=                     1+ 0>
>=                      1+ >
u<=                     1- u<
u>                      swap u<
u>=                     u< 0=
        ( Dasselbe gilt zusammen mit {m+} f‡r doppeltgenaue Operatoren:
d0<=                    -1 m+ d0<       oder    d1-  d0<
d0>                     -1 m+ d0< 0=            d0<= 0=
d0= 0=   IF ...               or IF
2dup d0< IF ...         dup   0< IF
d= IF ...               d- or 0= IF

* Zahlenoperationen
?negate                 +-                      ( Vorzeichen anwenden
negate                  minus                   ( Negation
negate 1-               not                     ( Einer-Complement
not                     not                     ( bitweise
invert                  not                     ( ANS bitweise
s>d                     s->d                    ( Vorzeichenerweiterung
rot min max             within                  ( auf Grenzen justieren
within                  within?                 ( flg ohne obere Grenze

* System (Standard-Referenz im f.i.g.-4th ist die pfa, in F83+ Systemen die cfa)
' execute               ' cfa execute           ( tick liefert PFA
[']                     [compile] ' cfa [compile] literal
'                       [compile] ' cfa         ( tick ist immediate

* Anordnung der Wort-ptr s. auch header-Beschreibung im Einf‡hrungstext;
* ein anderer ‡blicher Header-Aufbau, der gewisse Vorteile bietet, ist z.B.
        [ lfa ] [ name ] [ cfa ] [ pfa ... ]
* Umwandlung mit der universellen Hilfsdefinition:
*               : c>pfa [ ' task dup cfa - ] literal + ;
>body                   c>pfa                   ( cfa  =>  pfa = cfa+2
body>                   cfa                     ( pfa  =>  cfa = pfa-2
>link                   c>pfa lfa               ( cfa  =>  lfa = cfa-2
l>body                  ' here dup lfa - +      ( lfa  =>  pfa = lfa+4
>name                   c>pfa nfa               ( cfa  =>  nfa

* Ein-/Ausgabe, Compiler
sliteral                "                       ( compilierend: ansi-aequivalent
find                    -find IF $c0 < 2* 1- ELSE here 0 ENDIF
find                                            ( und das gegenst‡ck
 IF dup >name c@ 1 ELSE drop 0 THEN             ( von F83 nach f.i.g.
create                  0 variable -2 allot
does>                   ;does>                  ( identisch, f‡r F83+
create .. does>         create .. ;does>        ( die F83-paarung
0 constant              <builds                 ( Definitionswartanfang
unsmudge                unsmudge                ( aus C1 ‡bernommen
reveal                  unsmudge                ( identisch
r> dup 2+ >r            r+                      ( F6-kurzform
>in                     in
state @                 literal                 ( ist "state sensitiv"
  IF postpone literal THEN
postpone standardname   compile                 ( Compilerwort erzeugen
postpone immediatename  [compile]               ( Ausf‡hrung bei Aufruf
postpone                [_]                     ( nachbildung im F6
word    ( von tib )     word here               ( von Eingabequelle
end?                    blk@ -dup IF block ELSE tib@ ENDIF in @ + c@ 0=
        ( end? ist in der Aktion des <nul>-Wortes enthalten, darum im F6 unn„tig
nuf?    ( soll wohl sowas wie "enough?" heiœen, dann:
( nn ) nuf?             ( nn ) depth <
tib     ( ist Eingabequelle )   tib @           ( ist nur der t.i.b.
'tib                    tib                     ( die User-Vari
#tib                    span                    ( aus F79 ‡bernommen
variable                0 variable              ( f.i.g.-vari werden
2variable               0. 2variable            (     initiiert
?branch                 0branch
exit                    ;s                      ( im F6 stets ohne Risiko
then                    endif                   ( f.i.g.-4th hat nur ENDIF
                : then [compile] endif ; immediate ( mag als Ersatz dienen

* div. Operationen
ascii                   bl word here c@ literal ( im F6 als "{"-Praefix
alias                   defer                   ( der einfachste Ersatz, oder
                : newname -compile oldname ; immediate ( ohne Laufzeitverlust
aligned                 1 and allot             ( dp auf Adressenposten
align                   -2 swap and!            ( zelle geradzahlig
ctoggle                 swap toggle             ( xor im speicher
                        1- $ffff.00ff 2and xor! (    gleichwertig
perform                 perform         ( @ execute -- : cfa ausf‡hren
leave   ( bewirkt in einigen 4th-Varianten sofortiges Verlassen der Schleife
        ( ist im f.i.g.-4th das €quivalent von  { r> drop r> dup >r >r }
?leave                  -leave                  ( entspricht { IF leave ENDIF }
        ( das sofort beendende {?leave} kann nachgebildet werden:
?leave                  IF leave ELSE ... ENDIF LOOP
words                   vlist

* Eine hi-level-Definition von ENTER/ENTRY lautet
    : ENTER compile branch here 0 , 5 ;                             immediate
    : ENTRY ?comp depth 4 < 1 ?error 2swap 5 ?pairs here over - ! ; immediate
* und mit Einsprung z.B. bei nicht erf‡llter IF-Bedingung
    : -ENTER [compile] IF drop 5 ;                                  immediate
Weitere hi-level- quivalente im F6 definierter oder allgemein gebr€uchlicher
Worte finden sich an verschiedenen Stellen in "forth_scr" in einer Form, die
sie zumeist auch f‡r andere Forth-Systeme nutzbar macht.

* Das ANS-"Forth", ein paar Beispiele
Die Paarung {get-order}/{set-order} kann ganz allgemein zusammen mit einem neu
eingef‡hrten {def-order} lt. "forth_scr" gelegentlich ganz praktisch sein. Neben
dem Versuch in "ansext_scr", vollst€ndige Standard-§bereinstimmung herzustellen,
sind u.a. folgende Worte probehalber in "forth_scr" definiert:
additions               definitions             ( identisch
get-current             current @               (
get-order               ( z.B. im wort {.vocs} enthalten. Kann aufgebaut werden:
                    context 0 #vocs 0
                    DO drop count-w dup IF swap ELSE 2drop leave ENDIF i LOOP
search-wordlist         (find)                  ( mix aus f.i.g. & F83
set-current         ' vocabularname 4+ current !
set-order               ( umkehrprocedur von {get-order}, wird im F6 durch
                        ( nennung der vocabularnamen und {also} ausgef‡hrt.
wordlist                ( inaktive vocabulardefinition, nennung des namen gibt
                        ( eine adresse zur‡ck, die dann erst an context oder
                        ( current etc. ‡bergeben werden muœ.
def-order               ( F6-Nachtrag, definiert Worte, die beim Aufruf die zum
                        ( Definitionszeitpunkt g‡ltige Vocabularordnung passend
                        ( f‡r {set-order} zum Stack liefern.


* Die hi-level-Definitionsworte <BUILDS und DOES> rsp. CREATE und ;DOES>

* <BUILDS .. DOES> des f.i.g.-Forth
Zum Anlegen definierender Worte bedient man sich im f.i.g.-Forth der Paarung
<BUILDS mit DOES>, deren Namen recht genau beschreiben, wozu die jeweiligen
Teile eines solchen Wortes dienen. Die mit diesen gebauten neuen Worte weisen
zwar eine mit dem Programmiermodell konfliktfreie Datenstruktur auf, jedoch
stimmt diese in einem wesentlichen Teil nicht mit den sonstigen Colon-Defini-
tionen ‡berein. Sie erhalten n€mlich eine doppelte CFA, die erste enth€lt den
‡blichen Sprung in ausf‡hrbaren Code, nur ist die "Gebrauchsanweisung" hier
sehr allgemein gehalten, denn sie besagt allein, daœ der n€chste Posten auf die
Adresse zeigt, an der das (;CODE) als Einleitung des beim Aufruf auszuf‡hrenden
hi-level-Teils steht. Somit liegt die PFA, und damit die sonst z.b. mit "tick"
adressierbaren Daten eines Wortes, um zwei Bytes "h„her": Die Daten z.B. einer
mit <BUILDS..DOES> gebildeten Constanten-Struktur d‡rfen dann keineswegs mehr
mit "tick" ver€ndert werden. Das  quivalent der gewohnten PFA erh€lt man mit
        ' name 2+

Diese ver€nderte Adressenlage hat gewisse Nachteile, fordert sie doch h€ufig
Zusatzabfragen, da ja die Bauart nicht vorhergesagt werden kann. Was nebenbei
auch die §bertragung von Programmen in andere 4th-Systeme ungemein erschwert
und zumindest im ersten Anlauf dabei Fehler nahezu unvermeidbar macht.

* CREATE .. DOES> der sp€teren Standards - im F6 mit ;DOES>
So lag die §berlegung nahe, zur Vereinheitlichung die Zusatzinformation in den
DOES>-Part zu verlegen, und f‡r den Wort-Header das ohnehin bereits vorhandene
CREATE zu benutzen. Die CFA eines neuen Wortes zeigt dann direkt in den Ausf‡h-
rungsteil der dieses bildenden Definition. Folge ist, daœ die CREATE..;DOES>-
Paarung Worte aufbaut, deren Kopfteil sich in nichts mehr von den Standard-Wor-
ten unterscheidet, insbes. also mit dem Parameterfeld an gewohnter Stelle.
Bez‡glich der Ausf‡hrungszeit halten sich die beiden Varianten etwa die Waage,
die CREATE..;DOES>-Konstruktion ben„tigt im Definitionswort zwei zus€tzliche
Speicherzellen, spart jedoch bei den damit gebildeten Worten jeweils eine ein.

Da das vom f.i.g.-DOES> benutzte (;CODE) nur f‡r den Abschluœ eines hi-level-
Wortes im Processorcode sorgt, muœ eine Erg€nzung angegeben werden, die irgend-
wie den "instruction pointer" (den 4th-Programmz€hler) f‡r die R‡ckkehr sichert
und ihn auf den Ausf‡hrungsteil einstellt. Dies wird im F79 und den folgenden
Standards durch das Wort DOES> erledigt, welches im F6 aber bereits besetzt ist.
Darum wurde ;DOES> definiert, das dem DOES> der F79+ entspricht, und als Beson-
derheit im F6 auch die Vererbung der Ausf‡hrungsanweisung erlaubt.
Wie dieses ;DOES> aussieht, ist oben bei dem Assembler-Worten beschrieben.


* Systembedingte Fehler

In den Original-QL-Systemen gibt es Fehler bei gewissen Winkelfunktionen, die
neben den F6-Bereichen auch sonst im Speicher groœen Schaden anrichten k„nnen.
Ab Version 8.03 ist das F6-System hiergegen abgesichert (aber nicht das QDOS).

Beim SMSQ und SMSQ/E (im PeZe mit QXL-Karte) traten weitere Fehler auf:

Vom configurierten Monitortypen VGA oder EGA abh€ngig zeigten sich signifikante
Unterschiede im Ablauf der Bildschirm-Ein-/Ausgabe, selbst die Dateienbehandlung
war unter sonst identischen Bedingungen mitunter nicht gleich. Ursachenforschung
wurde hier nicht betrieben, aber aus diesem Grunde der Hinweis, daœ der Autor
das System (vor allem wegen der unverzerrten Graphik-Wiedergabe) auschlieœlich
im EGA-Modus betreibt und daœ in den anderen Modi keinerlei weitere Pr‡fungen
bez‡glich des F6 unternommen wurden.

Es kann vorkommen, daœ nach einer WIN-Operation die Meldung "fehlerhafter Da-
tentr€ger" erscheint, obwohl aus anderen Programmen heraus das betr. Laufwerk
noch zug€nglich ist. Vor allem bei {l-load} trat dieser Fehler h€ufig auf. Er
war nie genau nachvollziehbar und lieœ sich nicht gezielt reproduzieren, obwohl
der Zusammenhang recht deutlich ist: Mehrere OPEN_IN-Kan€le zum selben File,
nur Lesevorg€nge und Verstellen des Filepointers. Da er aber mit identischen
Dateien und Codes bei FLP-Zugriffen nie zu beobachten war, scheint die Ursache
eindeutig nicht im F6 zu suchen. Abhilfe war nur durch Umbau des Forth-Wortes
m„glich, wo nun in den SMSQ-Varianten von einem F6-Job nicht mehr mehrere Ka-
n€le auf dieselbe Datei zugleich ge„ffnet werden.

PAR mit fixem Puffer ist SMSQ/E versionsabh€ngig extrem fehleranf€llig, die
Fehler kommen insbes. bei der Druckerausgabe durch den F6-Editor zum tragen.

MODE ist futsch, sobald das CON-/SCR-Device durch eine Systemerweiterung ver-
€ndert wird; ein Beispiel gibt die sonst hervorragend bew€hrte Command-Line-
History von Oktagon. Weitere Fehler ergeben sich in diesem Zusammenhang nicht.
Abhilfe zumindest f‡r den Basic-Befehl schafft PEX ab Version 18.


        Dennoch, f.f. w‡nscht Ha-peh!
        Berlin, 14.9.1995 - 19.12.1995 - 18.1.1996 - 20.8.1996  .hpr


*  nderungen seit 8.00, €ltere Versionen s. "F6CHG_txt"

* F6-Kern

Einige Fehler bei den Aufrufen aus dem Pointer-Environment, die im Zusammenhang
mit den SMSQ/E-Varianten auftraten, wurden korrigiert.

Gegen den Fehler der QL-Systeme, der wegen Fehladressierung in einer Arithme-
tikroutine den Speicher verderben kann, wurden Vorkehrungen getroffen. Dies
zeigt sich im Original z.B. oft durch Steckenbleiben im Aufruf einer Winkel-
funktion oder verdorbenen Speicher, was nun aufgrund einer Schutzmaœnahme im
F6 nicht mehr vorkommen kann.

Das DOES> der F79+ Standards hat Vorteile, wegen derer das F6-System um die
Definitionen-Ausf‡hrung durch {;does>} erweitert wurde. Insbes. in "bh_scr"
sind mit Sicherheit noch nicht alle anzupassenden Stellen erfaœt (die PFA
liegt 2 Bytes niedriger). Dort ergeben sich vom Wortaufbau abh€ngige Fehler.

SEARCH und NO-SEARCH wurden in Ordnung gebracht.

Bei CASE:-Listen werden negative Indices auch bei Werten < -16383 von ersten
Wort ‡bernommen, positive entsprechend vom letzten.

In der Schluœoptimierung werden zu groœe Sprungdistanzen automatisch ber‡ck-
sichtigt, sodaœ keine unkontrollierten Vorw€rtsspr‡nge mehr entstehen k„nnen.

BASIC wurde in das Forth-Vocabular ‡bernommen und ist vom IO2 unabh€ngig.

EDLINE korrigiert, hat nach Eingabe am Stringende 2 Bytes zuviel gel„scht.

FSCHECK aus dem qdos-Vocabular korrigiert.

L-LOAD holt nun auch Worte mit Namen, die mit dem Anfang anderer Namen ‡ber-
einstimmen, und die in der Reihenfolge nach jenen im durchsuchten Screenfile
stehen. In der alten Form wurde z.B. ein {: ms} nach dem {: msg} nicht mehr
erreicht. Der Aufruf hat das zuerst mit dem Suchbegriff ab dessen Anfang iden-
tische Wort als gefunden bewertet, ungeachtet der L€nge des gesuchten Wortes.
Dies wurde in Ordnung gebracht.

{XX - Das Zahlen-Praefix f‡r ein Schriftzeichen eignet sich auch zum Holen
zweier Zeichen, die in den beiden Bytes einer Integer zur‡ckgegeben werden.
Bei Strings mit anderer L€nge als 2(+1 f‡r die Klammer) kommt weiterhin nur
das erste Zeichen mit seinem Code als Integer zur‡ck.

SEAL schlieœt das CURRENT-Vocabular ab, das danach leer erscheint.
Alle anderen Vocabulare und die Suchordnung bleiben unber‡hrt.

* Schutzfunktion des Secund€r-Jobs - s. {break}
Die {find}-Varianten wurden wieder in den ‡berwachten Bereich gelegt, auœerdem
ein paar weitere Aufrufe aus der Ziffern-Umwandlung. F€ngt sich das System bei
der Wortsuche einmal in einer endlosen Schleife, ist auch dort Abbruch m„glich.
Aufgrund von Systemeigenheiten des SMSQ/E darin jedoch gelegentlich wirkungslos.
Falls das PIF aktiv ist, kann nach einer Bewegung des Cursor-Sprite die in den
Systemvariablen vorhandene Referenz auf den gerade aktiven Job verlorengehen.
Sie wird dann durch Daten des PIF ‡berschrieben und es gibt keine sichere
oder in irgendeiner Form dokumentierte M„glichkeit mehr, unter den besonderen
Gegebenheiten des §berwachungsjobs den ausl„senden F6-Job zu ermitteln.
Darum wurde eine Variante eingef‡hrt, die durch die rechte Maustaste ausgel„st
wird, w€hrend der Mauscursor ‡ber dem Fenster des abzubrechenden F6-Jobs steht.
Wenn das PIF aktiv ist, und vor einem Abbruchversuch Maus oder Cursor bet€tigt
wurden, ist dies im allgemeinen die einzige Abbruchm„glichkeit.

* NEU
Als neue (teils noch ungepr‡fte) Worte im Kern wurden eingerichtet:
d1+     d2+     d4+     d1-     d2-     d4-     In-/Decrement an doubles
d2/     d4/     q2/     q4/                     schnelle Division
q<      qu<     qs*                             quad-Operatoren
qlit    quad    no-quad                         zum Compilieren von quad-Zahlen
roll                                            in FP auch -ve wie in FORTH
is-his                                          Pr‡fung auf "history"
                                                (Erweiterungscode von 'Oktagon')
nopdf                                           leeres {defer}red Wort
[cprim] [cdefer]                                asm68: Subroutinen-Hilfspointer
[jdt]                                           qdos: ptr auf Systemdaten
* bei +origin eingef‡gt:
        56      Abstand cdt (A0 in extop) zur i/o-queue
        60      Adresse der PIF dummy-queue
Die Positionen ab th-entry erh„hen sich entsprechend.
        78      Mauscode f‡r {break}.

* C-SAVE
CS-TYP als Cons zur freien Wahl der Filetyp-Codierung eingef‡hrt.
Die Standardvorgabe mit dem Wert 3 wurde unver€ndert beibehalten.

* DEBUGGER
Der Zahlendarstellung bei {.s}/{.rs} wurde zur Zifferngewinnung eine locale
Speicherpartie zugewiesen. Damit k„nnen nun auch Worte untersucht werden, die
mit {hld} arbeiten. Selbst das zur Zifferndarstellung der Zahlen eingesetzte
Wort wurde auf diese Weise tauglich f‡r den Einzelschrittbetrieb.

* MODE
Der {mode}-Aufruf aus dem qdos-Vocabular bleibt im SMSQ/E systembedingt ohne
Wirkung, falls die i/o-Aufrufadresse im CON-Handler ge€ndert wurde, wie z.B.
durch PEX oder die HISTORY von Oktagon (s.o.).
Im F6 (und im Basic) gibt es einen Ausweg, sofern als erste CON-Erg€nzung
PEX19 (oder j‡nger) geladen wird. MODE steht als erneuerter SBasic-Befehl mit
PEX zur Verf‡gung. Anderen Programmen wird er mit Hilfe eines Vectors aus dem
mit "dvs_byt" nachladbaren MEM-Device zug€nglich. Der Mode-Aufruf des F6 nutzt
diese M„glichkeit, sofern der zus€tzliche Code geladen wurde, sodaœ er dann
wieder einwandfreie Ergebnisse liefert. Auœerdem wurde die Parameter‡bergabe
(mit den Vorg€ngerversionen konfliktfrei) ge€ndert; dies ist oben an entspre-
chender Stelle im qdos-Vocabular angegeben.

* EDITOR
Der F6-Editor startet stets im schreibgesch‡tzten Modus, um versehentliche
 nderungen an den Screenfiles m„glichst ganz auszuschlieœen. Dies wird durch
die Variable {(update)} gesteuert, { (update) on } gibt das Schreiben frei.
SH/F5 (F10) schaltet im Editor zwischen Schreibfreigabe und -Sperrung um,
   F4       zeigt den jeweiligen Zustand an, ohne ihn zu €ndern.
Zeilenmarkierung:
   F2       setzt eine Marke in der aktuellen Cursorzeile. 16 Marken je
            File rsp Editor-Teilbereich sind m„glich.
   SH/F2    zum Aufsuchen der n€chsten Markirungsposition
   SH/F"
   CTR/SH/F2 l„schen aller Marken im aktuellen Editorteil.

* FTEST
Variante in "forth_scr" mit eigener und TK2-definierter Devicevorgabe
in Ordnung gebracht. Der gefundene Name ist unmittelbar nach dem Aufruf
als qdos-String in {here} lesbar - {here} ist ggf. geradzahlig justiert.
Als direkt eingebener Aufruf muœ FTEST darum in "|" eingefaœt werden.
Die Vorgabe ist zun€chst stillgelegt, man gibt sie mit { ddir on } frei.
Gesucht wird dann in der Reihenfolge:
        ohne Devicezusatz
        mit eigener Vorgabe aus der {f-name}-Definition {drv}
        mit progd$ des TK2 o. der ggf. automatisch nachgesetzten F6-Erweiterung
        mit datad$ dto.

* MSG
Die Wortgruppe zur externen Textspeicherung wurde dahingehend ge€ndert, daœ
sie auch mit Speicherbl„cken ab 32K fehlerfrei arbeitet. In "f6xco_scr" sind
die ausf‡hrenden Worte als lo-level-Definitionen angegeben, die wesentlich
schneller ausgef‡hrt werden, als die hi-level-Vorlage aus "forth_scr".

* "bh_scr"
Die versionsbedingten Verwirrungen stecken so tief, daœ es bisher noch nicht
gelungen ist, ein fehlerfrei arbeitendes Programm zu compilieren. Das Inter-
esse des Autors h€lt sich insofern auch in sehr bescheidenen Grenzen, als es
l€ngst in brauchbarer Form vorliegt, und eine neue Version um ihrer selbst
willen zu erzeugen ganz und gar ‡berfl‡ssig erscheint, zumal die Original-
version sich schon einige Jahre bestens bew€hrt hat. Um dies zu belegen, ist
sie in ungeschm€lerter Form beigef‡gt; sie mag bei Interesse als Referenz f‡r
eigene Versuche mit dem neuen F6-Kern dienen. Verwendung f‡r den Eigenbedarf
ist freigestellt.

* SOFTWARE-STACKS
F‡r die nahezu unbegrenzte in Stackform verwaltete Datenspeicherung stehen in
"f6xco_scr" einige Operatoren zur Verf‡gung, die auch in vorcompilierter Form
mit {c-load} aus "f6xco_4th" geladen werden k„nnen, und dann ohne den Assembler
(aber zus€tzlich zu den "heapmem"-Worten) lediglich 400 Bytes Platz ben„tigen:
>s      ( zahl dadr -- )
        Zahl ablegen.
">s     ( dadr1 count dadr2 --)(n.i.)
        Anzahl count Bytes von dadr1 auf den Stack dadr2 bringen.
&>s     ( dadr1 count1 count2 dadr2 --)(n.i.)
        Anzahl count1 Bytes von dadr1 an den String der L€nge count2 in Stack
        dadr2 anf‡gen und ggf. auf gerade Anfangsadresse justieren.
?>s     ( zahl dadr -- )
        Zahl ablegen, sofern sie noch nicht im Stack vorhanden ist.
=s      ( zahl dadr -- dnum|0 )
        Vorhandensein einer Zahl pr‡fen und deren Postennummer ermitteln,
        dnum z€hlt ab dem €ltesten Posten.
=s+     ( zahl dnum dadr -- dnum|0 )
        Zahl im Stack dadr suchen, beginnend nach dem Posten dnum (ab dnum+1).
s>      ( dadr -- zahl )
        j‡ngste Zahl entnehmen
"s>     ( dadr1 count dadr2 -- )(n.i.)
        Anzahl count Bytes vom Stack dadr2 nach dadr1 bringen.
@s      ( dn dadr -- zahl )
        ab €ltester Position z€hlenden Posten Nr. dn lesen; eine dem 4th-Wort
        {pick} entsprechende Funktion, z€hlend ab Null, erh€lt man z.B. mit
                : pick-s 2dup ?s 2rot d- 2swap @s ;
"s@     ( dadr1 nn dadr2 -- )(n.i.)
        Mit vorangestelltem count.w gez€hlten Stringposten nn aus dem Stack
        dadr2 ohne count.w nach dadr1 bringen.
?s      ( dadr -- dn )
        benutzte Stacktiefe ermitteln, entspricht dem Forth-Wort {depth}.
s-err   ( -- er )
        Fehlercode bei §berlauf oder leerem Stack

Die Art der Zahlenposten ist FP oder Integer, abh€ngig vom Vocabular, das zum
Zeitpunkt der Ausf‡hrung {context} ist.
Postennummern und Stacktiefe sind stets doppelte Integer, da f‡r maximal 255K
Bytes Stackg„œe 16-Bit-Werte zur Numerierung bei Integer-Posten nicht gen‡gen.
Sie z€hlen ab 1; 0 f‡r leeren Stack oder bei {=s} f‡r nicht vorhandenen Posten.

Bei §berlauf wird der €lteste Posten verworfen und die ‡bergebene Zahl gelangt
wie sonst auch an die obere Stelle im Stack. Bei leerem Stack geht Null zur‡ck.
Als Fehlercode bei §berlauf steht 7 in {s-err}, bei leerem Stack 1, sonst 0.

Referenz auf diese Stacks erfolgt durch die stets gleichbleibende Basisadresse,
wie sie von einer "heapmem"-Definition zur‡ckgegeben wird, und nach Bedarf mit
Angabe einer double-Postennummer sowie der abzulegenden Daten.

Ein hiermit verwalteter Softwarestack von z.B. 41K Gr„œe wird eingerichtet:
        41 1024 4 */ heapmem stackmem
wonach der Aufruf {stackmem} nun immer die erforderliche Basisadresse liefert.
Die weitere Datenverwaltung erfolgt selbst€tig durch die o.a. Worte.

Da an erster Position der Stackpointer in Gestalt der Anzahl durch Daten beleg-
ter Bytes steht, kann ein Stack "leer" gesetzt werden, indem man dort Null ein-
tr€gt: { 0. stackmem 2!l }; ebenso l€œt sich der Laufpointer willk‡rlich ver€n-
dern (geradzahlig!), ‡berschieœende Werte werden automatisch abgefangen.


*  nderungen nach 8.03 - 8.07 (25.8.96) - aktuell: 8.13 (20.3.97)
* (N€heres hierzu im obigen Haupttext)

* F6-Kern

* Schreibweise          (v808), z.B. bei CREATE
Forth-Namen auf Groœschreibung umgestellt, um den Freunden des ANS-Standards
Gen‡ge zu tun. Das System arbeitet weiterhin unabh€ngig von der Schreibweise.
Wortnamen werden von der Eingabe unabh€ngig in Groœschreibung angelegt.
Zeichen ab Code 128 bleiben in der bisherigen Schreibweise erhalten.
Diese  nderung geht geringf‡gig zulasten der Compilezeit.

* ( nn ) >LOC           (v805)
* ( nn ) LOC>
Die den Localen Variablen zugrundeliegende Speicherverwaltung ist hiermit direkt
zug€nglich und erlaubt die "dynamische" Zuweisung und Freigabe localer Speicher-
bereiche. Damit k„nnen in einem Wort w€hrend dessen Ausf‡hrung in ihrer Gr„œe
vom Programmverlauf abh€ngige Bereiche f‡r locale Daten angelegt werden.

* +ORIGIN               (v805)
Falsche Abstandsangabe ab Position 74, richtig sind
        74      {ert}-Aktivierung/-Sperrung
        76      Maus-Code f‡r {break} bei §bernahme durch PIF
        78      Abbruchcode von {break} - (neu v805)

* BREAK                 (v806)
Da die HOTEKEY-Routinen je nach Version (insbes. im SMSQ/E) die Funktion der
Abbruchtaste v„llig zunichte machen k„nnen, wurde ein Programmteil eingef‡gt,
der jene ‡berlagert. Im F6 mit dem ge€nderten Aufruf { zahl BREAK } ‡bergebe-
ne Codes einer Abbruch-Taste wirken nun zuverl€ssig und gegen‡ber einer evtl.
mit demselben Code definierten Hotkey-Taste vorrangig, dies jedoch nur in der
Variante ALT/Tastencode. Die Funktionsweise im F6 ist unver€ndert geblieben,
d.h. auch die nicht zusammen mit ALT bet€tigte Taste wirkt - sofern Hotkey-Job
oder das PIF dies nicht verhindern - zum PIF s.o. bei {break}. Wird ein F6-Job
aufgegeben, verliert zugleich auch seine Tastencodierung ihre Wirkung und die
vorher darauf gelegten Hot- oder Altkeys erhalten ihre alte Funktion zur‡ck.

* CONS+                 (v813)
definiert ein CONSTATen-€hnliches Wort, das beim Aufruf den bei Defininition
zugewiesenen Wert zu einem bereits vorhandenen Posten im Stack addiert.
Das Wort bildet u.a. die Grudlage zu den Increment-Operatoren {1+} etc.

* CONSM+                (v813)
Wie CONS+, jedoch wird die Zahl vorzeichenerweitert zum doppeltgenauen Posten
im Stack addiert.
Das Wort bildet u.a. die Grudlage zu den Increment-Operatoren {D1+} etc.

* DU>                   (v807)

* FOPEN-Varianten
waren nur in direkter Eingabe oder nach {[compile]} verwendbar, da ein
{literal} in der compilerenden Funktion fehlte. Dies ist nachgetragen.

* FSSAVE                (v814)
wird mittels io.sstrg simuliert, um Fehler durch vorzeitigen Abbruch beim
Senden ‡ber NETzwerk zu umgehen (BACKUP in forth_scr €hnlich ge€ndert).

* HLD                   (v808)
unmittelbar auf {hld} folgend steht ein weiterer Posten, der ab { hld 2+ }
als vorzeichenerweiterter doppeltgenauer 4th-Ptr den bei der Umwandlung von
Zahlen in Ziffern benutzten Anfangswert enth€lt. Damit und mit dem gleichar-
tigen Lauf-Ptr von { hld 2- } kann der Ziffern-Puffer an beliebige Stelle
umgesetzt werden, insbes. z.B. auf locale Speicherbereiche, wodurch dann
jegliche Konflikte zwischen ziffernausgebenden Worten zuverl€ssig ausgeschlos-
sen werden k„nnen.

* LOC> und END-LOC      (v808)
wurden gegen Freigabe zu groœer Bereiche soweit abgesichert, daœ Sch€den am
System (durch §berlauf von S0 in den T.I.B. oder Returnstack) auszuschlieœen
sind. Die regul€ren Daten im Stack bleiben im allgemeinen erhalten, sind aber
je nach Situation nicht immer sicher. Gleiches gilt in h„herem Maœe f‡r evtl.
existierende €ltere locale Felder. Dieser Schutz ist keinesfalls als Wort-
eigenschaft zu nutzen, er soll einzig sicherstellen, daœ insbes. durch §ber-
schreiben des Returnstack das umgebende System des QL nicht in Mitleidenschaft
gezogen wird. Besondere Fehlermeldung ist nicht vorgesehen.

* LOC>STK               (v813)
Ein besonders schneller Operator zur §bergabe s€mtlicher aktueller Locals
in unver€nderter Reihenfolge zum Stack. Ggf. vorher dorthingebrachte Posten
bleiben unver€ndert adressierbar, die Locals gelangen an das zu h„heren
Adressen hin gelegene Ende in den Bereich ab dem urspr‡nglichen Pointer aus
der User-Vari S0 bis zur nun dort verzeichneten Stack-Grenze.
Das "Geheimnis" dieser Variante liegt darin, daœ hierzu nur der Inhalt von S0
so ge€ndert werden muœ, daœ er ‡ber den h„chsten ehemaligen Local-Posten zeigt.
Es findet sonst keinerlei Datentransport statt. - Entsprechend s. STK>LOC.

* LOCAL                 (808)
Als Grundlage zur ANS-vertr€glichen Systemerweiterung wurde die LOCAL-Dekla-
ration so abge€ndert, daœ eine beliebige Anzahl Leerzeichen zwischen den Buch-
staben und vor dem abschschlieœenden Strich "|" stehen darf. Z.B. ist statt
        ..  LOCAL ABCD|  ..
nun auch folgende Schreibweise zul€ssig:
        ..  LOCAL   A B   C  D | ..

* M>S ( ..nn cm -- ..nn n1..nm )        (816)
Anzahl cm Bytes vom Speicher zum Stack holen.

* QUAD
Am Ende des von [number] durchlaufenen Aufrufs wurde bei gesetztem {quad}-
Flag statt {dpl} der zur‡ckgegebene Flagwert mit $ff00 verkn‡pft. Dies ist
korrigiert, ebenso die Bearbeitung negativer Zahlen.

* S==
wurde mit verdrehter Parameteranordnung beschrieben. Richtig gilt dadr1
f‡r den zu suchenden String und dadr2 f‡r den betr. Speicherbereichsanfang.

* S>M ( ..nn n1..nm cm -- ..nn )        (816)
Anzahl cm Bytes vom Stack in den Speicher ‡bertragen.

* SPAN
wird beim Jobstart mit der Parameterstring-L€nge besetzt.

* STK>LOC               (v813)
§bergibt den gesamten Stack-Inhalt in den Local-Bereich.
Da hierf‡r lediglich S0 auf den Wert von SP@ zu setzen ist, wird dieser
Aufruf auœerordentlich schnell ausgef‡hrt. - Entsprechend s. LOC>STK.

* SUSJB
Die Wartezeit wird als einfache Integer angegeben.

* USER
Automatische Indexzuweisung bei Angabe -1 in Ordnung gebracht.
Hinweis: {#user} gibt Anzahl Bytes der gesamten User-Area zur‡ck.

* WD-SIZE
Der bei Erfolg zur‡ckgegebene 'true' Flagwert gibt zugleich die Cursorbrei-
te an. Compiliert kann anschlieœend mit L<I auch die H„he gelesen werden.
Fehler bei R‡ckgabe Null, wenn angegebener Kanal nicht existiert, korrigiert.


* "forth_scr"

* ANS-Standard          (v807) => "ansext_scr" (v813)
Bis auf wenige Ausnahmen in den Erweiterungsvocabularen sind alle Worte des
ANS-Standards vorhanden. Mit "L-LOAD" und dem Suchbegriff "ANS-VOC" werden
die fehlenden Definitionen nachgesetzt, abweichende Eigenschaften angepaœt
und das Ganze im FORTH nachgeordneten Vocabular ANS-VOC zusammengefaœt.

* DEBUGGER
"Breakpoint" eingef‡hrt, Erl€uterung s.o.

* FTEST
erneut in Ordnung gebracht, alte Korrektur hatte ein {rdrop} ‡briggelassen.

* L-LOAD                (v807)
§berarbeitet sodaœ nun auch Suchworte gefunden werden, die sich mit dem
Anfang davor angeordneter l€ngerer Begriffe decken.

* T.
Zahlenausgabe in {.s} und {.rs} zum Debugger spielte nur bei {here} > 0.
Mit Hilfe localer Speicherung ge€ndert & oke.

* QDOS-Jobs
EX und EW compilierende Form in Ordnung gebracht, erg€nzt um EX-P und EW-P
mit Parameterstring. Die Varianten sind 'immediate'. Sie k„nnen in dersel-
ben Art, wie z.B. {fopen} compiliert, compilierend oder direkt aufgerufen
werden und geben die ID des neuen Jobs und den (double) Fehlercode zur‡ck:
        EX-P jobfilename Ÿ parametertext Ÿ
Das Zeichen {Ÿ} hat den Code 159 und liegt bei der deutschen QL-Tastatur
auf CTR/SH/- und bei QXL/SMSQ auf SH/'.
Der allen zugrundeliegende allgemeine Aufruf steht im hidden-Vocabular:
-exec           ( ex/ew ptr d.ernum -- d.jobid d.ernum )
        ex/ew   ist 0 f‡r freilaufende Jobs, -1 zur Verriegelung des initi-
                ierenden Jobs bis der neue Job beendet ist.
        ptr     zeigt auf den Parameterstring (qdos- oder 4th-Typ), den Ptr
                auf eine leere Zelle, z.B. {+nul}, ‡bergibt man, wenn der
                Aufruf ohne Parameterstring ausgef‡hrt werden soll.
                Kanalparameter sind nicht vorgesehen.
        d.ernum ist der Fehlercode aus dem OPEN-Aufruf f‡r das File, aus dem
                der Job installiert werden soll. Hat es nicht den Filetypen 1,
                oder konnten die typbestimmenden Daten nicht gelesen werden,
                bricht der Aufruf mit err.bp (-15) ab. Der zugeh„rige Kanal
                wird in {work} erwartet, wo ihn die {fopen}-Varianten des F6
                stets eintragen, am Ende des Aufrufs wird {work} geschlossen.
                Fehlerm„glichkeiten aufgrund ungerader Filel€nge oder Daten-
                speicher-Zuweisung werden in {-exec} durch Justage auf den
                jeweils n€chsth„heren geradzahligen Wert abgefangen.
        d.jobid ist die Identifikation des neuen Jobs. Wurde d.ernum =/= 0
                zur‡ckgegeben, ist deren Verwendbarkeit von der Art des Feh-
                lers abh€ngig. {frjob} zur Freigabe des ggf. f‡r den Job re-
                servierten Speichers ist aber stets riskolos und ohne Fehler-
                abbruch sofort mit den zur‡ckgegebenen Daten ausf‡hrbar.

* "f6asm_scr"
Nach Korrekturen zum Assemblieren in Dateien haben einige Beipiele fehlerfreie
Codepassagen erzeugt, wieweit der ganze File-Assembler spielt, ist ungepr‡ft:
{f-f}      hat von {posab} hinterlassene flag nicht ber‡cksichtigt,
{e?fer}    Fehlermeldung daraus wird nun hiermit abgefangen.
{segment}  und
{codefile} ganz umgebaut und in's Forth-Vocabular ‡bernommen.
Das Assemblieren muœ nun stets mit irgendeiner Form der Zielzuweisung begin-
nen, im einfachsten Falle z.B. f‡r den Forth-Speicher
        0. SEGMENT 4th
        4th
code: ...


» ende GF6-Beschreibung » eof »
