% 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 <sys/types.h>
\c #include <unistd.h>
\ 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}
