<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">% Content-encoding: UTF-8
\documentclass[ngerman]{article}
\usepackage[utf8]{inputenc}
\usepackage{multicol,babel}
\setcounter{secnumdepth}{0}
\setcounter{tocdepth}{0}

\begin{document}
\newcommand{\code}[1]{\texttt{#1}}

\renewcommand{\figurename}{Tabelle}

\title{Gforth 0.7.0}
%\ifx\shorttitle\undefined\else
%\shorttitle{Gforth 0.7.0}
%\fi
\author{Anton Ertl}
\maketitle

%\section{Gforth 0.7.0}

\begin{multicols}{2}
\section{Was ist Gforth?}

Gforth ist ein freies, portables, und schnelles Forth-System.  Gforth
implementiert ANS-Forth und die bis jetzt beschlossenen Erweiterungen
von Forth200x.  

\begin{description}

\item[Freiheit] Gforth wird unter der GNU General Public License v3
  verteilt, und die Benutzer kÃ¶nnen Gforth laufen lassen, kopieren,
  weiterverbreiten, studieren, Ã¤ndern und verbessern, und auch die
  geÃ¤nderten Versionen weiterverbreiten.

\item[PortabilitÃ¤t] Gforth lÃ¤uft auf diversen Unix-Varianten
  (0.7.0 wurde auf Linux, Solaris, und HP/UX getestet), auf Windows,
  und Mac\-OS~X.  Weiters gibt es noch die Embedded-Control-Variante
  Gforth EC, die u.a. auf dem R8C lÃ¤uft.

\item[Geschwindigkeit] Gforth verwendet eine einfache Methode zur
  Maschinencodeerzeugung und ist damit Ã¼blicherweise deutlich
  schneller als andere portable Systeme, auch wenn zu den schnellsten
  Forth-Compilern manchmal noch ein Faktor 2-3 fehlt.

\end{description}

Gforth ist Ã¼ber einen GNU-Mirror in Ihrer NÃ¤he erhÃ¤ltlich,
oder Ã¼ber \url{http://www.complang.tuwien.ac.at/forth/gforth/}; die
Homepage von Gforth ist auf
\url{http://www.jwdt.com/~paysan/gforth.html}.

\section{Was ist neu in Gforth 0.7.0?}

Die wichtigste Neuerung ist das neue \textbf{C-Interface} libcc.  Es
erlaubt, portable Deklartionen von C-Funktionen zu schreiben und
diese C-Funktionen dann Ã¼ber Forth-WÃ¶rter aufzurufen.  Die
Schwierigkeit hierbei ist, dass die gleiche Funktion auf verschiedenen
Plattformen verschiedene Typen haben kann.  Libcc gleicht das aus,
indem es einfach die \texttt{.h}-Dateien verarbeitet, in denen die
Deklarationen mit den richtigen Typen fÃ¼r die jeweilige Plattform
stehen, und indem die Argument-Typen des dazugehÃ¶rigen Forth-Wortes
explizit deklariert werden.  Libcc konvertiert dann, wenn nÃ¶tig,
zwischen den Forth-Typen und den C-Typen, und zwar so:

Libcc erzeugt eine Adapter-Funktion in C, die die Argumente von den
Forth-Stacks liest, dann die C-Funktion aufruft und am Schluss das
Ergebnis wieder auf den Forth-Stack schreibt.  Diese Adapterfunktion
wird von einem C-Compiler compiliert (der aus den \texttt{.h}-Dateien
die Argumenttypen der C-Funktion kennt), und dann von libcc dynamisch
in das Forth-System gelinkt.  Weiters erzeugt libcc ein Forth-Wort,
das diese Adapterfunktion (und dadurch die gewÃ¼nschte C-Funktion)
aufruft.  Der Nachteil dieser Methode ist, dass sie einen C-Compiler
zur Laufzeit braucht; wir arbeiten fÃ¼r die nÃ¤chste Version daran,
diesen Nachteil fÃ¼r die hÃ¤ufigsten FÃ¤lle zu eliminieren.

Ein Beispiel fÃ¼r die Deklarationen und Verwendung ist:

\begin{verbatim}
\ Deklaration C-Seite:
\c #include &lt;sys/types.h&gt;
\c #include &lt;unistd.h&gt;
\ Deklaration Forth-Seite:
c-function dlseek lseek n d n -- d
\ Forth-Name: dlseek, C-Name: lseek
\ Aufruf:
fd @ 10. SEEK_SET dlseek
\end{verbatim}

Eine weitere groÃŸe Neuerung ist die UnterstÃ¼tzung fÃ¼r UTF-8
(Unicode fÃ¼r ZeichensÃ¤tze aller mÃ¶glichen Sprachen) Ã¼ber die
\textbf{Xchars}-WÃ¶rter (siehe VD 1/2006, S. 19).  Diese Zeichen kÃ¶nnen
fÃ¼r alles verwendet werden: FÃ¼r Daten, in String-Konstanten, und sogar
fÃ¼r Wortnamen.  Gforth behandelt Ã¼brigens bei ASCII-Zeichen in
Wortnamen GroÃŸ- und Kleinbuchstaben als gleich, aber bei anderen
Zeichen wird zwischen GroÃŸ- und Kleinbuchstaben unterschieden.

Bei den \textbf{Zahlen-PrÃ¤fixen} gab es einige kleine, aber praktische
Neuerungen: Leute, die mit C-basierten Werkzeugen arbeiten, werden
\code{0x} als Hex-PrÃ¤fix zu schÃ¤tzen wissen (z.B. \code{0xff}).
Weitere Ã„nderungen in diesem Bereich kommen von Forth200x: Es gibt
jetzt \code{\#} als Dezimal-PrÃ¤fix und man kann jetzt auch das
Vorzeichen nach dem PrÃ¤fix schreiben, z.B. \code{\#-10}.  Und
schlieÃŸlich kann man Zeichenkonstanten jetzt auch mit abschlieÃŸendem
Hochkomma schreiben: \code{'a'}.  DafÃ¼r akzeptiert Gforth keine
Mehrzeichen-Konstante wie \code{'ab} mehr.

Bei einem portablen System wie Gforth sind natÃ¼rlich die
\textbf{Ports} wichtig.  Gforth enthÃ¤lt jetzt bessere UnterstÃ¼tzung
fÃ¼r \textbf{Mac\-OS~X}.  Einen groÃŸen Beitrag dazu leistete die
Forth-Gesellschaft, indem sie Bernd Paysan einen Mac~Mini zur
VerfÃ¼gung stellte.  Gforth dÃ¼rfte unter den Forth-Systemen fÃ¼r Mac\-OS~X
inzwischen einen groÃŸen Marktanteil haben, wohl vor allem, weil Gforth
durch seine PortabilitÃ¤t beim Apples-Umstieg auf Intel keine Probleme
hatte.

Es gibt jetzt auch einige neue Ports fÃ¼r Gforth EC.  Die sind
allerdings teilweise nur unvollstÃ¤ndig im Gforth-Paket; bei Bedarf
sollte man sich die
CVS-Version\footnote{\url{http://www.complang.tuwien.ac.at/forth/gforth/cvs-public/}}
anschauen.

AuÃŸerdem gibt es eine bessere UnterstÃ¼tzung fÃ¼r die
Architekturen AMD64, ARM, und IA-64.  Diese waren fÃ¼r Gforth 0.6.2
zwar noch nicht berÃ¼cksichtigt und getestet worden.  Trotzdem lief
Gforth durch seine PortabilitÃ¤t dort, allerdings ohne dynamische
Maschinencodeerzeugung und damit langsam.  Jetzt unterstÃ¼tzt Gforth
auch auf diesen Architekturen die dynamische Maschinencodeerzeugung,
und auÃŸerdem explizite Registerbelegung fÃ¼r weitere
Geschwindigkeitsvorteile.

In mehreren Bereichen gibt es eine \textbf{bessere Fehlerbehandlung}:
\code{Defer}ed words produzieren jetzt eine Warnung, wenn sie
ausgefÃ¼hrt werden, ohne vorher initialisiert zu werden.  Fehler bei
der ganzzahligen Division (z.B. Division durch 0) werden jetzt auf
allen Plattformen erkannt (auch ohne Hardware-UnterstÃ¼tzung),
allerdings nur durch \code{gforth}, nicht \code{gforth-fast}.

AuÃŸerdem gibt es bessere MÃ¶glichkeiten zur Sicherheit bei Exceptions,
z.B. durch Unterbrechungen: WÃ¶rter wie \code{outfile-execute},
\code{infile-execute}, und \code{base-execute} ermÃ¶glichen die
zeitweilige Ã„nderung von globalen Systemvariablen, so dass sie bei
einer Exception oder Unterbrechung sicher wieder zurÃ¼ckgesetzt werden.
Ã„hnliches kann man mit einem Ã¼berarbeiteten
\code{try}...\code{endtry}-Konstrukt selbst bauen.

Es gibt auch sonst eine Reihe \textbf{neuer WÃ¶rter}, z.B. fÃ¼r
Speicherzugriffe auf ganzzahlige Werte mit 16 und 32 Bits.  Oder
\code{next-arg} und \code{shift-args} fÃ¼r den Zugriff auf
Kommandozeilenargumente beim Aufruf von Gforth (nÃ¼tzlich fÃ¼r Scripts).

\textbf{Maschinencode} kann jetzt besser angezeigt werden: Es gibt
einen Assembler/Disassembler fÃ¼r die PowerPC Architektur (inklusive
64-bit-Befehle).  Weiters gibt es noch \code{disasm-gdb}, der den GNU
Debugger zum Disassemblieren aufruft.  Auf den Architekturen, fÃ¼r die
es noch immer keinen in Forth geschriebenen Disassembler in Gforth
gibt, ist \code{disasm-gdb} der Standard-Disassembler (davor
\code{dump}).  Und schlieÃŸlich gibt es noch \code{see-code}, ein
Decompiler fÃ¼r colon definitions, der einem den dynamisch erzeugten
Maschinencode anzeigt und wie er mit den Befehlen im threaded code im
Zusammenhang steht.

Im Bereich \textbf{Geschwindigkeit} hat sich auch einiges getan:
Gforth verwendet ja einen C-Compiler fÃ¼r die PortabilitÃ¤t und
spezielle Erweiterungen von GCC zur Leistungssteigerung.  GCC bekam in
der 3.x-Reihe mit jeder Version neue "`Optimierungen"', die dafÃ¼r
sorgten, dass die dynamische Codeerzeugung von Gforth nicht mehr
funktioniert hat und Gforth um mindestens den Faktor 2 langsamer
wurde.  Wir fanden Workarounds fÃ¼r diese Probleme und bauten sie in
Gforth ein.  Inzwischen ist mit gcc-4.4 schon eine neue gcc-Version
seit Gforth~0.7.0 erschienen, und brachte keine neuen
Geschwindigkeits-Probleme.

Bisher hatte die Installation von Gforth in der Standardeinstellung
konservative Einstellungen gewÃ¤hlt, die zu deutlichen EinbuÃŸen
in der Geschwindigkeit im Vergleich zu den schnellsten Einstellungen
fÃ¼hren, aber dafÃ¼r mit groÃŸer Sicherheit ein funktionierendes
Forth-System bauen.  Die Benutzer sollten aggressivere
Konfigurationsparameter ausprobieren, um ein schnelleres System zu
bekommen.  Allerdings hat sich bei den Linux-Distributoren keiner
diese MÃ¼he gemacht, und daher war Gforth unter Linux relativ
langsam.  Jetzt probiert die Installation verschiedene Einstellungen
durch, angefangen von den aggressivsten, bis sie eine findet, die
funktioniert; dadurch werden die optimalen Einstellungen automatisch
gefunden und das resultierende System ist dadurch deutlich schneller.
Allerdings sind wir mit dieser Methode an die Grenze dessen gestoÃŸen,
was in einem Makefile sinnvoll machbar ist.

Die gemischtgenaue Division wurde neu implementiert und ist auf
praktisch allen Plattformen nun deutlich schneller.

Einige Optimierungen helfen speziell bei bestimmten Architekturen:
Static Stack Caching hilft vor allem auf PowerPC (32-bit und 64-bit),
weil wir nur dort genÃ¼gend Register verwenden kÃ¶nnen, dass es hilft.
Branch target alignment beschleunigt Alphas deutlich.  Die bessere
UnterstÃ¼tzung fÃ¼r AMD64, ARM und IA-64 wurde schon frÃ¼her erwÃ¤hnt.

\textbf{Daneben} wurde noch eine Reihe Fehler behoben, und alle bisher
verabschiedeten Forth200x-Erweiterungen eingebaut.

\end{multicols}
\end{document}
</pre></body></html>