* 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
                              2 - GLOSSAR
                     ->  Teil 3 - Anhang, Referenzlisten



* F6 Assembler-Quelltext

Alle ntigen Kommentare sind in "forth_asm" angegeben. Zum Aufbau von lo-level-
Routinen gibt es ein paar Hilfsmittel fr 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 verndert werden drfen. Innerhalb der Prfgren-
zen (s. Assemblertext) drfen die Adressregister ab A3 auch nicht ungerade sein.

Forth: 2constant [cdefer] im Assembler-Voc.
Bei {defer}red Definitionen soll die Ausfhrungsroutine 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 ermglichen. Die Ausfhrungszeit entspricht in etwa der Standard-Aufrufform.
Da bei gleichbleibenden Versionsnummern der auerhalb 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 unabhn-
gig von Vernderungen 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 grundstzlich auf smtliche 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 'auen'
                0 BP D0 .l d(Xi,PC     jsr,   \ deferred wort ausfhren & 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 knnen, mu ihnen dies
fr den einen Aufruf "abgewhnt" 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 ausfhrenden 4th-Wortes
sind nur bedingt brauchbar, deren Aufruf fhrt je nach Worttyp evtl. zu Fehlern.


Constante und Variable unterscheiden sich nur in der Ausfhrungsvorschrift,
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;
erhht dann unabhngig vom Typen den Wert einer Constanten oder den Inhalt einer
Variablen um Eins. - Dieses Beispiel darf NUR COMPILIERT eingesetzt werden!


* Betrachtungen zur Ausfhrungszeit:
Zum Vergleich mit Assemblercode dient das Beispiel <next> und <semis>, das der
Paarung JSR und RTS entspricht, und als halbwegs reprsentativ angesehen werden
kann. Mageblich fr 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 Verhltnis 4:1 fr Forth gegenber
optimiertem Assemblercode als verlliche "worst case"-Schtzung anzusehen ist.
Den mitunter genannten Faktor 1:3 bis 1:5 gegenber ausfhrbaren Code erzeugen-
den Compilern wird man nur beim Vergleich mit hchst ungeschickt aufgebauten
Systemen erzielen knnen, im F6 sicherlich nicht: Der Umbau des grten 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 anschlieender Ausfhrung 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 ausgefhrt.
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
{&} fhrt in Infix-Notation die Verkettung zweier Bytewerte als gepackte Integer
aus, in der das erste Byte der Eingabe an hherwertiger Stelle angeordnet wird.
War die erste Zahl als {literal} compiliert, wird diese bereits wrend des Com-
pilevorganges mit der zweiten Verknpft und in der genderten Form fixiert, so-
da whrend der Ausfhrung des hiermit gebildeten Wortes keine Rechenoperationen
mehr anfallen. Der Code wird dadurch um 6 Bytes krzer, d.h. es wird kein zu-
stzliches Wort compiliert, und die Ausfhrungszeit reduziert sich auf weniger
als ein Viertel gegenber z.B. einer fhrenden 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 prfen
  IF here 4- @ >< or here 4- ! -2 allot ;s ENDIF ENDIF  \ ggf. optimierung
  [compile] literal -compile or ;          immediate    \ oder standardform
Dieses Wort wurde fr einen speziellen Anwendungszweck geschaffen und dient
hier nur als Beispiel. Seine Verwendung ist dadurch eingeschrnkt, da die
zweite Zahl nur eine Constante oder ein Festwert sein darf, Parameter oder
(Locale) Variable knnen 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 grere Zahl von n1, n2
umax    ( u1 u2 -- u3                   u3 als absolut grere 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-Kanle

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

* ffnen/Schlieen
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

* Vernderungen 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 fr 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 lt sich nur unvollstndig 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 Fliekommavocabular.
io-err          Operationen an den Standardkanlen 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                  Stackberlauf
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 Ausfhrung
20      definition not finished         Definition unvollstndig
21      protected dictionary            geschtzter Wortebereich
22      use only when loading           nur beim Laden verwenden
23      off editting screen             auerhalb 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 - fr {l<i} prparierten Worte.

Diese Aufrufe liefern durch {l<i} lesbare Werte, die zum Multitasking einzelner
Forth-Worte anstelle der fr die Referenz unzureichenden 16-Bit-Werte verwandt
werden knnen. {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 Rckgabewerte sind folgendermaen 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 sptere 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-Registerbergabe)
><  >|< 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 ergnzenden Definitionen aus "forth_scr" und "f6xco_scr"

Die hier aufgefhrten Worte knnen 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 auerhalb des Forth-Speichers.
chain           beliebig stapelbares Laden von gewhnlichen Files.
debugger        der aktive Teil zum Einzelschrittbetrieb, Mini-Decompiler.
dump            Varianten fr Speicherauszge, desgl. auch {ldump}
heapmem         uerst sichere Zuweisung im QDOS-Systemspeicher.
msg"            Textsystem mit Datenablage in "heapmem"-Blcke. Als lo-level-
                Worte auch in "f6xco_scr", und fr {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          vollstndiger Satz Aufrufe zur incrementellen (Vector-)Graphik.
view            als wirkungsvolles Anwendungsbeispiel fr 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 bercksichtigt
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 eigenstndigen {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 auerhalb des 4th-Adressenbereich.
                Anzahl Dimensionen n1, Produkt aller spter festzulegenden
                Dimensionen und die Einzelpostengre n2 drfen je bis unter
                64K Bytes gro sein, das Produkt aus Postengre und Dimen-
                sionen mu kleiner als 256K sein. Mehr s. "forth_scr".
ascii           ( -- c1 ) (C) ( ASCII char -- )                 F83
                Im F6 entbehrlich, da "{" als Textprfix mehr leistet.
a-close         ( -- )
                Alle in der F6-Kanaltabelle verzeichneten Kanle schlieen,
                wobei {in-cons} und {out-cons} geschtzt sind. Auch die
                QDOS-Kanle 0 bis 2, sollte einer von ihnen versehentlich in
                die F6-Tabellen gelangt sein, knnen 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 drfen auch einen im F6 offenen Kanal haben. Die
                Filenamen mssen vollstndig angegeben werden; das mag lstig
                sein, wurde aber der Sicherheit halber bewut so eingerichtet.
?backup         ( -- )
                Wie {backup}, jedoch mit Eingabeanforderung fr beide Namen.
-bpt            ( flg -- flg )
                "breakpoint" fr 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 Lnge aus dem vorigen
                {dump}-Aufruf des nchst niedrigeren Anschlubereichs.
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} enthlt.
                Der Aufruf hinterlegt zwei Local-Posten, die durch {end} frei-
                gegeben werden und kann im Rahmen des verfgbaren Speichers be-
                liebig tief geschachtelt werden. Da die Files nur zum Lesen ge-
                ffnet werden, knnen mehrere F6-Jobs zugleich auf dasselbe File
                zugreifen. Datenbewegungen auch zwischen den Aufrufebenen sind
                mglich, solange der {local}-Bereich in Ordnung gehalten wird.
                Vorsicht: Systemzusammenbruch mglich, wenn das {end} fehlt!
chans           ( -- )
                QDOS-IDs und Nummern aller offenen Kanle des F6 hinschreiben.
clchp           ( -- )                                          F6
                Alle mit {heapmem} reservierten Speicherblcke auflsen. Die
                zugehrigen Definitionen bleiben weiter aktiv, soda mit ihrem
                Aufruf wieder eine gltige Speicheradresse zur Verfgung steht,
                nun aber in Form eines neu zugewiesenen und gelschten 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 Speicherberlauf scheitert. Notfalls ist dann Abhilfe mit
                direkter Manipulation der "heapmem"-Definitionsdaten mglich:
                        ' heapname 2@ heap-rmv
                        ' heapname 2off
c-load & c-save zum Laden und Sichern codierter Passagen wurden oben im Forth-
                Vocabular bereits ausfhrlich beschrieben.
console         ( -- )                                         (C1)
                Nimmt die evtl. mit {printer} aktivierte Druckerfreigabe zurck.
.dcm            ( .DCM name -- ptr ) oder ( pfa #DCM -- ptr )
                Ein Minimal-Decompiler, der, weil er nur wenige Bytes bentigt
                und recht hilfreich sein kann, mit dem Debugger geladen wird.
debugger        (h)( -- )                                       F6
                Hilfswort fr 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 dafr prpariert. Diese
                werden dann beim Aufruf mit Anzeige des Stackinhalts und des
                gerade bevorstehenden Aufrufs Wort fr Wort abgearbeitet.
                Fehler:
                Vorsicht ist geboten, wenn die zu untersuchenden Worte {case:}-
                Listen (und ihre Varianten) oder Returnstackmanipulationen ent-
                halten, die zu Vernderungen in der Wortreihenfolge fhren, wie
                {r+} oder {lit+}. Auch Vernderungen der Interpreter-Ptr knnen
                empfindliche Fehler verursachen. Zur Abhilfe gengt 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 zurckgenommen.
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. Auerdem erscheinen Filelnge (einschl. der
                Headerlnge!), Zugriffscode und Filetyp in der Ausgabe.
drk             ( -- ptr )
                Variable mit dem Namen des {printer}-Ausgabegerts in bis zu
                36 Zeichen Lnge. Hier kann ein beliebiger Gerte- oder Datei-
                name angegeben werden, die Bildschirmausgabe lt 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 fr den Einzelschrittbetrieb der Aufruf {vlist}
                vollstndig als hi-level-Aufruf (Colon-Definition).
                        l-load dvlist
                ldt bei Bedarf den Debugger, compiliert {dvlist} und fhrt
                es sofort im Einzelschrittbetrieb aus.
end             ( loc: did -- )                                 F6 (LR)
                Mu ein jedes mit {chain} aufgerufene File abschlieen.
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 fr bedingte Schleifen, beide Worte im Kern ent-
                halten und oben bereits beschrieben.
exit            ( -- )(I)                                       F79+
                Im f.i.g.-Forth identisch mit {;s}. Fr F79-Texte z.B.:
                        : EXIT -compile ;s ;
f-name          ( -- ptr ) (C) ( F-NAME name )
                Eine Stringvariable fr Filenamen definieren. Sie wird als
                qdos-String angelegt und auf maximal {f/n} Bytes Lnge justiert.
fname"          ( ptr FNAME" filename" -- ) (I)
                Textstck mit count-word bis zur maximalen Lnge {f/n} nach
                ptr bringen.
ftest           ( -- flg ) (C) ( FTEST filename ) (I)
                prft filename auf Zugnglichkeit fr 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 zugefgt werden knnen.
heap?           ( -- )
                Zeigt alle dem F6-Job gerade zugewiesenen {heapmem}-Blcke an.
heapmem         ( -- dadr ) (C) ( n1 HEAPMEM name )             F6
                Verwaltet auf besonders abgesicherte Weise einen Speicherblock
                mit der vierfachen Lnge der bei der Namensdefinition bergebe-
                nen Zahl n1 - was die Blockgre 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 Lnge einer {heapmem}-Reservierung zurck.
heap-new        (I)( use: nn HEAP-NEW name )
                Neudefinition der Blockgre, ggf. zuvor implizit {heap-rmv}.
                Kann mit festem Wert in ein Wort eigebaut werden
                        : name ... zahl heap-new {heapname} ... ;
                und stellt die Blocklnge beim Aufruf dieses Wortes ein, oder
                zur Angabe des Namen erst bei Ausfhrung
                        : 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 zugehrigen {heapmem}-Definition zurck, wenn
                dadr die Anfangsadresse eines damit reservierten Bereichs ist.
heap-rmv        ( dadr -- )                                     F6
                Gibt den bei dadr beginnenden Speicherblock an das Betriebssys-
                tem zurck. Prfungen sorgen dafr, da nur ein vom selben F6-
                Job reservierter Block aufgelst wird, und da die Adresse auch
                im QDOS keinen Fehler auslsen kann (z.B. ungerade oder nicht
                zu einem "heap"-Block gehrend). Die definierten Worte bleiben
                aktiv, soda mit ihrem nchsten Aufruf jeweils wieder ein leerer
                Speicherbereich gleicher Gre zur Verfgung 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 ausfhrlicher.
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 Ergnzung 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 hierfr 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 zhlend) 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"-Blcke,
                initial mit dem 2K groen Block {msm} besetzt. Direkte Daten-
                eintragungen in den Definitionsbereich drfen 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 Lnge n1
                nach ptr1 bertragen
ndump           ( -- )
                Speicherauszug in 16-Bytes-Gruppen der Lnge aus dem vorigen
                {dump}-Aufruf des nchst hheren Anschlubereichs.
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
                ausfhren soll, wie ein 'normales' Wort. Dies sind zwei grund-
                stzlich und derart unterschiedliche Vorgnge, da der Autor die
                identische Benennung fr vllig verfehlt hlt 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 Lnge n1
                einschlielich count-word bei ptr ablegen.
printer         ( -- ) (I)
                Ein Vocabular mit Definitionen zur Druckerbedienung, Einrichtung
                zur ausschlielichen, 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 zugnglicher
                Teil im Anhang von "ed_gls" nher beschrieben ist.
                Leider ist im Laufe der Zeit bei den endlosen Anpassereien an
                stndig variierende SMSQ-Versionen etliches an Funktionalitt
                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. Fr andere Drucker ist evtl. Modifikation
                der zugehrigen 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
                Wgefunktion zu {sorted}, s. dort.
sort            ( ptr n1 -- )
                Ausfhrender 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
                binrem Sortierverfahren ("quick-sort") geordnet.
                Im einfachsten Falle erzeugt man eine n1 Posten groe Tabelle
                und trgt dort von Null an fortlaufende Zahlen ein. Die Basis-
                adresse dieser Tabelle wird an {sorted} rsp {sort} bergeben.
                Fr {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 vllig unabhn-
                gig, nur das {precedes}-Wort mu diese bercksichtigen. Das
                Ergebnis ist eine Nummernliste, die in aufsteigender Reihenfolge
                den jeweils nchst greren (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 auerordentlich 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.
                Auerdem mit vectorisierte Lese- und Ablageoperatoren fr 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 zurck, sonst mit 0.
+text           ( ptr1 ptr2 -- )                                f.i.g.-Editor
                den qdos-String bei ptr2 an den qdos-String bei ptr1 anhngen.
then                                                            F79
                funktional identisch ENDIF.
turtle          ( -- ) (I)                                      F6
                Vocabular zur Turtle-Graphik fr bis zu 16 voneinander unabhn-
                gige Linienzge mit folgenden Aufrufen, die im Screenfile (auch
                anhand zweier Beispiele) nher 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 zugehrigen Quelltext anzeigen. Dafr
                werden die Wortheader entsprechend prpariert, 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 zustzlich zu {l-load} und dem Editor geladen werden.
                Fhrt einen {l-load}-Aufruf aus, bei dem das darin enthaltene
                {load} so re-vectorisiert ist, da es die Seite, wo das Wort
                gefunden wurde, schreibgeschtzt in den Editor holt. Beim Ver-
                lassen wird {load} automatisch wieder auf die eigene Funktion
                zurckgestellt. Der evtl. mitbergebene Filename ersetzt den
                bis dahin als Screenfile fr {l-load} gltigen Namen. In der
                vorliegenden Form lassen sich die {view}-Aufrufe nicht schach-
                teln, dazu mte ggf. {l-load} berarbeitet werden.
                Anders als bei {.view} erfordert diese Form keine gegenber dem
                "normalen" Compilieren unterschiedlichen Daten, die Worte werden
                allein mit den Hilfsmitteln des in beiden Fllen ohnehin ben-
                tigten Editors aufgesprt 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 knnen.
.vocs        (r)( -- )                                         (F83)
                Anzeige der aktuellen Suchordnung, des Definitionsvocabulars
                und der Namen smtlicher 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 geffnet 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} ausgefhrt wird.
[_]             ( [_] name -- pfa ) (C) ( [_] name -- )        (H4)
                hnlich {postpone} - s. dort, liefert im interpretierenden
                Zustand wie "tick" die pfa von {name}.


* Gegenberstellung 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 Mglichkeit
?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 "rckw-rts"

* Flags und Vergleichsoperationen
true                    -1
1                       1                       ( f.i.g.-4th true flag
0 0 = constant true                             ( umgeht alle..
1 0 = constant false                            (   ..Miverstndnisse
not                     0=                      ( Flag-Umkehr
        ( Ein Minimal-System braucht z.B. nur die Logikoperatoren < u< und 0=,
        ( sowie die Subtraktion. Damit knnen 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 natrlich Extrem-Beispiele, deren Operatoren gewhnlich
        ( zur Standardausstattung gehren sollten. Jedoch werden etliche der
        ( speziellen Logikoperatoren oft bereits durch berlegte Anordnung ent-
        ( behrlich, andere nur selten bentigt. 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+} fr 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 Einfhrungstext;
* 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 gegenstck
 IF dup >name c@ 1 ELSE drop 0 THEN             ( von F83 nach f.i.g.
create                  0 variable -2 allot
does>                   ;does>                  ( identisch, fr 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]               ( Ausfhrung 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 unntig
nuf?    ( soll wohl sowas wie "enough?" heien, 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 ausfhren
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 erfllter IF-Bedingung
    : -ENTER [compile] IF drop 5 ;                                  immediate
Weitere hi-level-quivalente im F6 definierter oder allgemein gebruchlicher
Worte finden sich an verschiedenen Stellen in "forth_scr" in einer Form, die
sie zumeist auch fr andere Forth-Systeme nutzbar macht.

* Das ANS-"Forth", ein paar Beispiele
Die Paarung {get-order}/{set-order} kann ganz allgemein zusammen mit einem neu
eingefhrten {def-order} lt. "forth_scr" gelegentlich ganz praktisch sein. Neben
dem Versuch in "ansext_scr", vollstndige 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} ausgefhrt.
wordlist                ( inaktive vocabulardefinition, nennung des namen gibt
                        ( eine adresse zurck, die dann erst an context oder
                        ( current etc. bergeben werden mu.
def-order               ( F6-Nachtrag, definiert Worte, die beim Aufruf die zum
                        ( Definitionszeitpunkt gltige Vocabularordnung passend
                        ( fr {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 nmlich eine doppelte CFA, die erste enthlt den
blichen Sprung in ausfhrbaren Code, nur ist die "Gebrauchsanweisung" hier
sehr allgemein gehalten, denn sie besagt allein, da der nchste Posten auf die
Adresse zeigt, an der das (;CODE) als Einleitung des beim Aufruf auszufhrenden
hi-level-Teils steht. Somit liegt die PFA, und damit die sonst z.b. mit "tick"
adressierbaren Daten eines Wortes, um zwei Bytes "hher": Die Daten z.B. einer
mit <BUILDS..DOES> gebildeten Constanten-Struktur drfen dann keineswegs mehr
mit "tick" verndert werden. Das quivalent der gewohnten PFA erhlt man mit
        ' name 2+

Diese vernderte Adressenlage hat gewisse Nachteile, fordert sie doch hufig
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 spteren Standards - im F6 mit ;DOES>
So lag die berlegung nahe, zur Vereinheitlichung die Zusatzinformation in den
DOES>-Part zu verlegen, und fr den Wort-Header das ohnehin bereits vorhandene
CREATE zu benutzen. Die CFA eines neuen Wortes zeigt dann direkt in den Ausfh-
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.
Bezglich der Ausfhrungszeit halten sich die beiden Varianten etwa die Waage,
die CREATE..;DOES>-Konstruktion bentigt im Definitionswort zwei zustzliche
Speicherzellen, spart jedoch bei den damit gebildeten Worten jeweils eine ein.

Da das vom f.i.g.-DOES> benutzte (;CODE) nur fr den Abschlu eines hi-level-
Wortes im Processorcode sorgt, mu eine Ergnzung angegeben werden, die irgend-
wie den "instruction pointer" (den 4th-Programmzhler) fr die Rckkehr sichert
und ihn auf den Ausfhrungsteil 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 Ausfhrungsanweisung 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 groen Schaden anrichten knnen.
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 abhngig 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) auschlielich
im EGA-Modus betreibt und da in den anderen Modi keinerlei weitere Prfungen
bezglich des F6 unternommen wurden.

Es kann vorkommen, da nach einer WIN-Operation die Meldung "fehlerhafter Da-
tentrger" erscheint, obwohl aus anderen Programmen heraus das betr. Laufwerk
noch zugnglich ist. Vor allem bei {l-load} trat dieser Fehler hufig auf. Er
war nie genau nachvollziehbar und lie sich nicht gezielt reproduzieren, obwohl
der Zusammenhang recht deutlich ist: Mehrere OPEN_IN-Kanle zum selben File,
nur Lesevorgnge 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
mglich, wo nun in den SMSQ-Varianten von einem F6-Job nicht mehr mehrere Ka-
nle auf dieselbe Datei zugleich geffnet werden.

PAR mit fixem Puffer ist SMSQ/E versionsabhngig extrem fehleranfllig, 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 bewhrte Command-Line-
History von Oktagon. Weitere Fehler ergeben sich in diesem Zusammenhang nicht.
Abhilfe zumindest fr den Basic-Befehl schafft PEX ab Version 18.


        Dennoch, f.f. wnscht 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 Schutzmanahme im
F6 nicht mehr vorkommen kann.

Das DOES> der F79+ Standards hat Vorteile, wegen derer das F6-System um die
Definitionen-Ausfhrung durch {;does>} erweitert wurde. Insbes. in "bh_scr"
sind mit Sicherheit noch nicht alle anzupassenden Stellen erfat (die PFA
liegt 2 Bytes niedriger). Dort ergeben sich vom Wortaufbau abhngige 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 Schluoptimierung werden zu groe Sprungdistanzen automatisch berck-
sichtigt, soda keine unkontrollierten Vorwrtssprnge mehr entstehen knnen.

BASIC wurde in das Forth-Vocabular bernommen und ist vom IO2 unabhngig.

EDLINE korrigiert, hat nach Eingabe am Stringende 2 Bytes zuviel gelscht.

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 Lnge des gesuchten Wortes.
Dies wurde in Ordnung gebracht.

{XX - Das Zahlen-Praefix fr ein Schriftzeichen eignet sich auch zum Holen
zweier Zeichen, die in den beiden Bytes einer Integer zurckgegeben werden.
Bei Strings mit anderer Lnge als 2(+1 fr die Klammer) kommt weiterhin nur
das erste Zeichen mit seinem Code als Integer zurck.

SEAL schliet das CURRENT-Vocabular ab, das danach leer erscheint.
Alle anderen Vocabulare und die Suchordnung bleiben unberhrt.

* Schutzfunktion des Secundr-Jobs - s. {break}
Die {find}-Varianten wurden wieder in den berwachten Bereich gelegt, auerdem
ein paar weitere Aufrufe aus der Ziffern-Umwandlung. Fngt sich das System bei
der Wortsuche einmal in einer endlosen Schleife, ist auch dort Abbruch mglich.
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 Mglichkeit mehr, unter den besonderen
Gegebenheiten des berwachungsjobs den auslsenden F6-Job zu ermitteln.
Darum wurde eine Variante eingefhrt, die durch die rechte Maustaste ausgelst
wird, whrend der Mauscursor ber dem Fenster des abzubrechenden F6-Jobs steht.
Wenn das PIF aktiv ist, und vor einem Abbruchversuch Maus oder Cursor bettigt
wurden, ist dies im allgemeinen die einzige Abbruchmglichkeit.

* NEU
Als neue (teils noch ungeprfte) 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                                          Prfung auf "history"
                                                (Erweiterungscode von 'Oktagon')
nopdf                                           leeres {defer}red Wort
[cprim] [cdefer]                                asm68: Subroutinen-Hilfspointer
[jdt]                                           qdos: ptr auf Systemdaten
* bei +origin eingefgt:
        56      Abstand cdt (A0 in extop) zur i/o-queue
        60      Adresse der PIF dummy-queue
Die Positionen ab th-entry erhhen sich entsprechend.
        78      Mauscode fr {break}.

* C-SAVE
CS-TYP als Cons zur freien Wahl der Filetyp-Codierung eingefhrt.
Die Standardvorgabe mit dem Wert 3 wurde unverndert beibehalten.

* DEBUGGER
Der Zahlendarstellung bei {.s}/{.rs} wurde zur Zifferngewinnung eine locale
Speicherpartie zugewiesen. Damit knnen nun auch Worte untersucht werden, die
mit {hld} arbeiten. Selbst das zur Zifferndarstellung der Zahlen eingesetzte
Wort wurde auf diese Weise tauglich fr 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 gendert 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-Ergnzung
PEX19 (oder jnger) geladen wird. MODE steht als erneuerter SBasic-Befehl mit
PEX zur Verfgung. Anderen Programmen wird er mit Hilfe eines Vectors aus dem
mit "dvs_byt" nachladbaren MEM-Device zugnglich. Der Mode-Aufruf des F6 nutzt
diese Mglichkeit, sofern der zustzliche Code geladen wurde, soda er dann
wieder einwandfreie Ergebnisse liefert. Auerdem wurde die Parameterbergabe
(mit den Vorgngerversionen konfliktfrei) gendert; dies ist oben an entspre-
chender Stelle im qdos-Vocabular angegeben.

* EDITOR
Der F6-Editor startet stets im schreibgeschtzten Modus, um versehentliche
nderungen an den Screenfiles mglichst ganz auszuschlieen. 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 mglich.
   SH/F2    zum Aufsuchen der nchsten Markirungsposition
   SH/F"
   CTR/SH/F2 lschen 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 "|" eingefat werden.
Die Vorgabe ist zunchst 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 gendert, da
sie auch mit Speicherblcken ab 32K fehlerfrei arbeitet. In "f6xco_scr" sind
die ausfhrenden Worte als lo-level-Definitionen angegeben, die wesentlich
schneller ausgefhrt 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 hlt sich insofern auch in sehr bescheidenen Grenzen, als es
lngst in brauchbarer Form vorliegt, und eine neue Version um ihrer selbst
willen zu erzeugen ganz und gar berflssig erscheint, zumal die Original-
version sich schon einige Jahre bestens bewhrt hat. Um dies zu belegen, ist
sie in ungeschmlerter Form beigefgt; sie mag bei Interesse als Referenz fr
eigene Versuche mit dem neuen F6-Kern dienen. Verwendung fr den Eigenbedarf
ist freigestellt.

* SOFTWARE-STACKS
Fr die nahezu unbegrenzte in Stackform verwaltete Datenspeicherung stehen in
"f6xco_scr" einige Operatoren zur Verfgung, die auch in vorcompilierter Form
mit {c-load} aus "f6xco_4th" geladen werden knnen, und dann ohne den Assembler
(aber zustzlich zu den "heapmem"-Worten) lediglich 400 Bytes Platz bentigen:
>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 Lnge count2 in Stack
        dadr2 anfgen 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 prfen und deren Postennummer ermitteln,
        dnum zhlt 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 )
        jngste Zahl entnehmen
"s>     ( dadr1 count dadr2 -- )(n.i.)
        Anzahl count Bytes vom Stack dadr2 nach dadr1 bringen.
@s      ( dn dadr -- zahl )
        ab ltester Position zhlenden Posten Nr. dn lesen; eine dem 4th-Wort
        {pick} entsprechende Funktion, zhlend ab Null, erhlt man z.B. mit
                : pick-s 2dup ?s 2rot d- 2swap @s ;
"s@     ( dadr1 nn dadr2 -- )(n.i.)
        Mit vorangestelltem count.w gezhlten 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, abhngig vom Vocabular, das zum
Zeitpunkt der Ausfhrung {context} ist.
Postennummern und Stacktiefe sind stets doppelte Integer, da fr maximal 255K
Bytes Stackge 16-Bit-Werte zur Numerierung bei Integer-Posten nicht gengen.
Sie zhlen ab 1; 0 fr leeren Stack oder bei {=s} fr 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 zurck.
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 zurckgegeben wird, und nach Bedarf mit
Angabe einer double-Postennummer sowie der abzulegenden Daten.

Ein hiermit verwalteter Softwarestack von z.B. 41K Gre wird eingerichtet:
        41 1024 4 */ heapmem stackmem
wonach der Aufruf {stackmem} nun immer die erforderliche Basisadresse liefert.
Die weitere Datenverwaltung erfolgt selbsttig 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-
trgt: { 0. stackmem 2!l }; ebenso lt sich der Laufpointer willkrlich vern-
dern (geradzahlig!), berschieende Werte werden automatisch abgefangen.


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

* F6-Kern

* Schreibweise          (v808), z.B. bei CREATE
Forth-Namen auf Groschreibung umgestellt, um den Freunden des ANS-Standards
Genge zu tun. Das System arbeitet weiterhin unabhngig von der Schreibweise.
Wortnamen werden von der Eingabe unabhngig in Groschreibung angelegt.
Zeichen ab Code 128 bleiben in der bisherigen Schreibweise erhalten.
Diese nderung geht geringfgig zulasten der Compilezeit.

* ( nn ) >LOC           (v805)
* ( nn ) LOC>
Die den Localen Variablen zugrundeliegende Speicherverwaltung ist hiermit direkt
zugnglich und erlaubt die "dynamische" Zuweisung und Freigabe localer Speicher-
bereiche. Damit knnen in einem Wort whrend dessen Ausfhrung in ihrer Gre
vom Programmverlauf abhngige Bereiche fr locale Daten angelegt werden.

* +ORIGIN               (v805)
Falsche Abstandsangabe ab Position 74, richtig sind
        74      {ert}-Aktivierung/-Sperrung
        76      Maus-Code fr {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 vllig zunichte machen knnen, wurde ein Programmteil eingefgt,
der jene berlagert. Im F6 mit dem genderten Aufruf { zahl BREAK } bergebe-
ne Codes einer Abbruch-Taste wirken nun zuverlssig und gegenber einer evtl.
mit demselben Code definierten Hotkey-Taste vorrangig, dies jedoch nur in der
Variante ALT/Tastencode. Die Funktionsweise im F6 ist unverndert geblieben,
d.h. auch die nicht zusammen mit ALT bettigte 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 zurck.

* 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 gendert).

* 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 enthlt. 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 zuverlssig ausgeschlos-
sen werden knnen.

* LOC> und END-LOC      (v808)
wurden gegen Freigabe zu groer Bereiche soweit abgesichert, da Schden am
System (durch berlauf von S0 in den T.I.B. oder Returnstack) auszuschlieen
sind. Die regulren Daten im Stack bleiben im allgemeinen erhalten, sind aber
je nach Situation nicht immer sicher. Gleiches gilt in hherem Mae fr 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 smtlicher aktueller Locals
in unvernderter Reihenfolge zum Stack. Ggf. vorher dorthingebrachte Posten
bleiben unverndert adressierbar, die Locals gelangen an das zu hheren
Adressen hin gelegene Ende in den Bereich ab dem ursprnglichen 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 gendert werden mu, da er ber den hchsten ehemaligen Local-Posten zeigt.
Es findet sonst keinerlei Datentransport statt. - Entsprechend s. STK>LOC.

* LOCAL                 (808)
Als Grundlage zur ANS-vertrglichen Systemerweiterung wurde die LOCAL-Dekla-
ration so abgendert, da eine beliebige Anzahl Leerzeichen zwischen den Buch-
staben und vor dem abschschlieenden Strich "|" stehen darf. Z.B. ist statt
        ..  LOCAL ABCD|  ..
nun auch folgende Schreibweise zulssig:
        ..  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 zurckgegebene Flagwert mit $ff00 verknpft. Dies ist
korrigiert, ebenso die Bearbeitung negativer Zahlen.

* S==
wurde mit verdrehter Parameteranordnung beschrieben. Richtig gilt dadr1
fr den zu suchenden String und dadr2 fr 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-Lnge besetzt.

* STK>LOC               (v813)
bergibt den gesamten Stack-Inhalt in den Local-Bereich.
Da hierfr lediglich S0 auf den Wert von SP@ zu setzen ist, wird dieser
Aufruf auerordentlich schnell ausgefhrt. - 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 zurck.

* WD-SIZE
Der bei Erfolg zurckgegebene 'true' Flagwert gibt zugleich die Cursorbrei-
te an. Compiliert kann anschlieend mit L<I auch die Hhe gelesen werden.
Fehler bei Rckgabe 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 angepat
und das Ganze im FORTH nachgeordneten Vocabular ANS-VOC zusammengefat.

* DEBUGGER
"Breakpoint" eingefhrt, Erluterung 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 lngerer Begriffe decken.

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

* QDOS-Jobs
EX und EW compilierende Form in Ordnung gebracht, ergnzt um EX-P und EW-P
mit Parameterstring. Die Varianten sind 'immediate'. Sie knnen 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 zurck:
        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 fr 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 ausgefhrt werden soll.
                Kanalparameter sind nicht vorgesehen.
        d.ernum ist der Fehlercode aus dem OPEN-Aufruf fr 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 zugehrige Kanal
                wird in {work} erwartet, wo ihn die {fopen}-Varianten des F6
                stets eintragen, am Ende des Aufrufs wird {work} geschlossen.
                Fehlermglichkeiten aufgrund ungerader Filelnge oder Daten-
                speicher-Zuweisung werden in {-exec} durch Justage auf den
                jeweils nchsthheren geradzahligen Wert abgefangen.
        d.jobid ist die Identifikation des neuen Jobs. Wurde d.ernum =/= 0
                zurckgegeben, ist deren Verwendbarkeit von der Art des Feh-
                lers abhngig. {frjob} zur Freigabe des ggf. fr den Job re-
                servierten Speichers ist aber stets riskolos und ohne Fehler-
                abbruch sofort mit den zurckgegebenen Daten ausfhrbar.

* "f6asm_scr"
Nach Korrekturen zum Assemblieren in Dateien haben einige Beipiele fehlerfreie
Codepassagen erzeugt, wieweit der ganze File-Assembler spielt, ist ungeprft:
{f-f}      hat von {posab} hinterlassene flag nicht bercksichtigt,
{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. fr den Forth-Speicher
        0. SEGMENT 4th
        4th
code: ...


 ende GF6-Beschreibung  eof 
