% Content-encoding: UTF-8
\documentclass[ngerman]{article}
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\setcounter{secnumdepth}{0}
\setcounter{tocdepth}{0}


\renewcommand{\reftextbefore}{auf der vorherigen Seite}
\renewcommand{\reftextfacebefore}{auf der gegenüberliegenden Seite}
\renewcommand{\reftextafter}{auf der nächsten Seite}
\renewcommand{\reftextfaceafter}{auf der gegenüberliegenden Seite}
\renewcommand{\figurename}{Abbildung}

\begin{document}

\begin{figure*}[b]
\vspace*{2ex}
\begin{center}
\begin{normalsize}
\begin{tabular}{llllllll}
      &\multicolumn{4}{c}{\bf AND   ( n2 n1 -{}- n3 )} &          &tmp. &Daten-\\
      &   &                  &       &   &                  &AVR- &Stack-\\
      & \multicolumn{2}{l}{Input}&       &\multicolumn{2}{l}{Output}&Reg. & Adr.\\
      &   &                  &       &   &                  &     &      \\
      & 0 &                  &       & 0 &                  &---  & 0x100\\
      & 1 & n2 oberes  Byte  &       & 1 & n3 oberes  Byte  &R19  & 0x0FF\\
      & 2 & n2 unteres Byte  & SP $\to$ & 2 & n3 unteres Byte  &R18  & 0x0FE\\
      & 3 & n1 oberes  Byte  &       & 3 &                  &R17  & 0x0FD\\
SP $\to$ & 4 & n1 unteres Byte  &       & 4 &                  &R16  & 0x0FC\\
      & 5 &                  &       & 5 &                  &     & 0x0FB\\
\end{tabular}
\end{normalsize}
\caption{\label{pike11:bild1}Verhalten von \texttt{AND} bei umgedrehter Reihenfolge der Elemente auf dem Stack} 
\end{center}
\end{figure*}



\title{Forth von der Pike auf — Teil 11}
\author{Ron Minke}
\maketitle
%\vspace{-0.5ex}
Die mit freundlicher Genehmigung der HCC--Forth--gebruikersgroep in der Vierten Dimension in einer Übersetzung von Fred Behringer wiedergegebene achtteilige Artikelserie erschien ursprünglich in den Jahren 2004 und 2005 in der Zeitschrift \emph{Vijgeblaadje} unserer niederländischen Forth--Freunde. 
Der Autor arbeitet fleißig an seinem Projekt weiter: Im Vijgeblaadje waren Teil 9 und 10 der Serie (deutsche Übersetzung in den VD-Heften 3-4/2007 und 2/2008) erschienen. Auch die heutige Übersetzung aus dem Niederländischen (aus dem Vijgeblaadje 70) stammt von Fred Behringer.

Hier kommt nun Teil 11 der Wiedergabe des Versuchs, ein AVR--Forth--System mit der Voraussetzung \emph{from scratch} zu erstellen. 

\begin{multicols}{2}
\section{Big Oops}

In der vorigen Folge von \emph{Forth von der Pike auf} hatten wir zwei früher beschlossene Festlegungen (aus Teil 2) wieder zurückgenommen. Einige Zeit, nachdem das Vijgeblaadje in Druck gegangen war, stellte sich beim Experimentieren eine sehr unangenehme Eigenschaft der gerade angebrachten Änderung heraus. Was war passiert? Nach dem Umdrehen der Reihenfolge der Bytes auf dem Stack hatten wir die in \figurename\ \vref{pike11:bild1} gezeigte Situation (vergleiche das in Teil 10 Gesagte).

In Bezug auf das Forth--Wort AND beispielsweise ist nichts auszusetzen. Zwei 16--Bit--Werte auf dem Stack werden verarbeitet und ein 16--Bit--Wert wird zurückgegeben. Ob das obere Byte eines Wertes oder das untere Byte eines Wertes nun zuoberst oder zuunterst auf dem Stack steht, tut eigentlich nichts zur Sache. Der betreffende Maschinencode--Teil ist genau so codiert, dass das richtige Ergebnis herauskommt. Für High--Level--Worte gilt dasselbe.

\section{Was läuft da schief?}

Es läuft eigentlich gar nichts schief. Es ist die Interpretation der Werte auf dem Stack, die dafür verantwortlich ist, dass es nicht so läuft, wie wir das wollen. Schauen wir uns noch einmal zwei Werte auf dem Stack genauer an:

\begin{small}
\begin{tabular}{lllll}
        & 0 &                 &     &0x100\\
        & 1 & n2 oberes  Byte & R19 &0x0FF\\
        & 2 & n2 unteres Byte & R18 &0x0FE\\
        & 3 & n1 oberes  Byte & R17 &0x0FD\\
SP $\to$& 4 & n1 unteres Byte & R16 &0x0FC\\
        & 5 &                 &     &0x0FB\\
\end{tabular}
\end{small}


Wenn wir diese zwei Werte nicht als zwei einzelne Worte betrachten, sondern als ein einziges \emph{Doppelwort}, dann bleibt das Schema dasselbe, aber die Interpretation ändert sich. Jetzt wird es wichtig zu wissen, welches Wort eines Doppelwortes auf dem Stack zuoberst liegt. Wenn wir auf unserem Weg der \emph{umgedrehten Version} weitergehen, dann erhalten wir als Reihenfolge auf dem Stack:\medskip

\begin{small}
\begin{tabular}{llllll}
        &0              &              &     &0x100\\
        &1 oberes  Byte & oberes  Wort & R19 &0x0FF\\
        &2 unteres Byte & oberes  Wort & R18 &0x0FE\\
        &3 oberes  Byte & unteres Wort & R17 &0x0FD\\
SP $\to$&4 unteres Byte & unteres Wort & R16 &0x0FC\\
        &5              &              &     &0x0FB\\
\end{tabular}
\end{small}

An dieser Reihenfolge ist nichts verkehrt. Die Maschinencode--Programmteile, die hiermit arbeiten, holen von selbst die richtige Reihenfolge ab und legen sie auch richtig wieder zurück. Aber

\section{Was tun wir mit einer \emph{double}--Zahl?}

Hier zeigt sich das eigentliche Problem. Wenn wir auf dem Stack ein \emph{Single}--Wort haben und wenn wir das zu einem \emph{Double}--Wort umformen wollen, dann verwenden wir das Wort \texttt{S>D}. In der einfachen Version setzen wir eine Null davor. Das lässt sich am good--old FIG--Forth--System gut ablesen an der Definition:

\begin{verbatim}
	: U.  0 D.  ;
\end{verbatim}

Das Anfügen einer Extra--Null sorgt für die Erweiterung einer Single--Zahl zu einer Double--Zahl. Aber in dem oben stehenden Stack--Auszug kommt das nicht gut heraus. Die Extra--Null steht auf dem Platz des unteren Wortes, derweil wir es als das obere Wort haben wollen. 

Einzige Lösung: Die Reihenfolge wieder zurückdrehen. Damit sind wir dann wieder bei den urspünglichen Festlegungen 2 und 3 angelangt.

\section{Und wie weiter?}

Um die Sache nicht noch komplizierter zu machen, lassen wir die Registerbelegungen paarweise so, wie sie sind: R17:R16 gibt weiterhin das oberste Wort auf dem Stack an. Damit bekommen wir:

\begin{small}
\begin{tabular}{llllll}
         &0               &               &    &0x100\\
         &1  unteres Byte & unteres Wort  &R18 &0x0FF\\
         &2  oberes  Byte & unteres Wort  &R19 &0x0FE\\
         &3  unteres Byte & oberes  Wort  &R16 &0x0FD\\
SP $\to$ &4  oberes  Byte & oberes  Wort  &R17 &0x0FC\\
         &5	              &           &    &0x0FB\\
\end{tabular}
\end{small}

Die ursprünglichen Festlegungen 2 und 3 scheinen eben doch die richtige Wahl gewesen zu sein:

Das untere Byte eines 16--Bit--Wortes wird zuerst auf den Stack gelegt (hier R16), und darunter dann das obere Byte (hier R17).

Der Forth--Datenstack--Pointer SP zeigt bei einem 16--Bit--Wort auf das obere
Byte.

Alle anderen Anpassungen aus Teil 10 (wie beispielsweise die Anordnung der Buchstaben in einer Text--Passage im Flash--Speicher) bleiben dieselben.

Reichlich viel Arbeit, dafür aber ein weiterer Schritt in Richtung auf das System \emph{Forth von der Pike auf} zu!
\end{multicols}


\vfill
\begin{center}
\includegraphics[width=0.8\textwidth]{2009-01/atmel-pollin}\\
Das Low-Cost Atmel--Evaluationsboard von Pollin (Quelle: \url{www.pollin.de})
\end{center}
\vfill

\end{document}
