\begin{appendix}
\chapter{Optimierungsphasen am Beispiel der {\sf while}-Methode}

Im folgenden sollen die einzelnen Optimierungsphasen anhand der
{\sf while}-Methode noch \mbox{einmal} vorgef"uhrt werden.
Der Code ist den Ausgaben des "Ubersetzers ohne Ver"anderungen
ent\-nommen.

\begin{itemize}

\item
Der urspr"ungliche TML-Code der Methode l"a\3t sich aus einem Eintrag in
der Profiltabelle f"ur die Empf"angerklasse
{\tt Nil} auffinden. Alle Operationen sind durch
Methodenaufrufe realisiert.

\begin{verbatim}
proc(self_2 cond_3 statement_4 c_1)
  (send "[]" cond_3 cont(t_5)
  (send "?" t_5
  | proc(c_7)
  | : (send "[]" statement_4 cont(t_8)
  | : (send "while" self_2 cond_3 statement_4 cont(t_9)
  | : (c_7 t_9)))
  | cont(t_10)
  | : (c_1 t_10)))
\end{verbatim}

\item

Nach einer Klassenanalyse sind einige dynamische
Methodenaufrufe durch statisch \mbox{gebundene} Aufrufe ausgetauscht worden.
Aufrufe an die Methode  {\tt [$\:$]} der Klasse {\tt Fun}
sind durch die  direkten Funktionsaufrufe {\tt (cond\_905 ..)} und
{\tt (statement\_906 ..)}  ersetzt worden.
Folgende Funktionen sind in das Y-Konstrukt
aufgenommen:

\begin{itemize}
\item
False:?
\begin{verbatim}
proc(self_918 ifTrue_919 c_920)
  (c_920 ok)
\end{verbatim}
\item
True:?
\begin{verbatim}
proc(self_922 ifTrue_923 c_924)
  (ifTrue_923 cont(t_925)
  (c_924 t_925))
\end{verbatim}
\end{itemize}

\pagebreak

\begin{verbatim}
proc(c_927)
  (Y proc(c_928 False:?_921 True:?_926 Nil:while_913)
  (c_928
  | cont()
  | : (c_927 Nil:while_913)
  | proc(self_918 ifTrue_919 c_920)
  | : (c_920 ok)
  | proc(self_922 ifTrue_923 c_924)
  | : (ifTrue_923 cont(t_925)
  | : (c_924 t_925))
  | proc(self_904 cond_905 statement_906 c_907)
  | : (cond_905 cont(t_908)
  | : (lambda(a:?:1365_914)
  | : | . (lambda(a:?:1366_915)
  | : | . | : (classTest t_908 "False" "True"
  | : | . | : | cont()
  | : | . | : | . (False:?_921 t_908 a:?:1365_914 cont(t_916)
  | : | . | : | . (a:?:1366_915 t_916))
  | : | . | : | cont()
  | : | . | : | . (True:?_926 t_908 a:?:1365_914 cont(t_917)
  | : | . | : | . (a:?:1366_915 t_917)))
  | : | . | cont(t_912)
  | : | . | : (c_907 t_912))
  | : | proc(c_909)
  | : | . (statement_906 cont(t_910)
  | : | . (Nil:while_913 self_904 cond_905 statement_906 cont(t_911)
  | : | . (c_909 t_911)))))))
\end{verbatim}

\item
Im Resultat der Beta-Reduktionsphase ist erkennbar, da\3
der endrekursive Aufruf an {\tt Nil:while\_913} in einen
rekursiven Fortsetzungsaufruf {\tt recurse\_946} "uberf"uhrt ist:
\begin{verbatim}
proc(c_927)
  (Y proc(c_928 Nil:while_913)
  (c_928
  | cont()
  | : (c_927 Nil:while_913)
  | proc(PARAM:self_943 PARAM:cond_944 PARAM:statement_945 c_907)
  | : (Y proc(c_947 recurse_946)
  | : (c_947 recurse_946 cont()
  | : (PARAM:cond_944 cont(t_908)
  | : (== t_908 false true
  | : | cont()
  | : | . (c_907 ok)
  | : | cont()
  | : | . (PARAM:statement_945 cont(t_936)
  | : | . (recurse_946))))))))
\end{verbatim}

\item
Zum Vergleich sei der
nahezu "aquivalente TML-AST eines Aufrufs des TL-{\sf
while}-Schl"usselwortes
herangezogen. Es ist deutlich erkennbar, da\3 das innere
Y-Konstrukt 
obiger TooL-Schleife mit dem des TL-{\sf while}-Baums
"ubereinstimmt:

\begin{verbatim}
proc(cond_6 statement_7 e_4 c_5)
  (lambda(whileEnd_9)
  | : (Y proc(c_12 while_8)
  | : (c_12
  | : | cont()
  | : | . (while_8)
  | : | cont()
  | : | . (cond_6 e_4 cont(t_11)
  | : | . (== t_11 true
  | : | . | cont()
  | : | . | : (statement_7 e_4 cont(t_10)
  | : | . | : (while_8))
  | : | . | whileEnd_9))))
  | cont()
  | : (c_5 ok)))
\end{verbatim}

\item
Da der TRM-Codegenerator nicht
in dem TooL-"Ubersetzer eingebaut ist,
soll der folgende TRM-Code der TL-Schleifenfunktion  illustrieren,
da\3 rekursive Fortsetzungen in Spr"unge "ubersetzt werden:

\begin{verbatim}
0               0       push            r0              ; 
1               1       push            r1              ; cond
2               2       push            r2              ; statement
241  0          3       branch          while8; 
                while8:
80  1           5       ld_sp           r0       1      ; cond
48              7       call             0              ; cond
211  240        8       ld_true         r15             ; 
139  15         10      eq              r0      r15     ; 
242  2          12      branch_cf               l0; 
241  5          14      branch          whileEnd9; 
                l0:
80  0           16      ld_sp           r0       0      ; statement
48              18      call             0              ; statement
241  ~16        19      branch          while8; 
                whileEnd9:
209  0          21      ld_ok           r0              ; 
67              23      return           3              ; 
\end{verbatim}
\end{itemize}

\chapter{TML-Primitive}
\section{Urspr"ungliche TML-Primitive im Tycoon-Backend}
\input{tmlprim}
\section{TooL-spezifische TML-Primitive}
\input{tooltmlprim}

\chapter{TRM-Befehlssatz}

\begin{tabular}{|| l | l | l ||} \hline
{\em Opcode (Hex)}    &  {\em Befehl}  &  {\em Bedeutung} \\ \hline
0i              &  {\tt push}            &  Register i im Keller ablegen\\
1i              &  {\tt drop}            &   i Kellerfelder entfernen \\
2i              &  {\tt jump}            &  Endrekursiver Sprung an das Codeobjekt in r0 \\
3i              &  {\tt call}            &  Aufruf des Codeobjekts in r0 \\
4i              &  {\tt return}          &  Return, i Kellerfelder entfernen  \\
5d ii           &  {\tt ld\_sp}           &  rd \(\leftarrow\) Kellerfeld ii \\
6d ii           &  {\tt ld\_lit}          &  rd \(\leftarrow\) Literal ii \\
7i ds           &  {\tt seti}            &  rd[i] \(\leftarrow\) rs \\
80 ds           &  {\tt get}             &  rd \(\leftarrow\) rd[rs] \\
8x ds           &  {\tt alu}             &  rd \(\leftarrow\) rd $\otimes $ rs, \\
                &                        &  $\otimes \in
		                           \{+,-,\times,\div,mod,\wedge,\vee,xor,shl,shr,=,>,\ge,<,\le\} $\\
90 ds           &  {\tt geti}             &  rd \(\leftarrow\) rd[i] \\
9x di           &  {\tt alui}            &  rd \(\leftarrow\) rd \(\otimes \) i, \\
                &                        &  $\otimes \in
		                           \{+,-,\times,\div,mod,\wedge,\vee,xor,shl,shr,=,>,\ge,<,\le\} $\\

ad ii           &  {\tt closure}         &  rd \(\leftarrow\) neues Feld der Gr"o\3e ii \\
bi jj           &  {\tt send}            &  send r0 Selektor: jj, Argumente in r1$\ldots$r15 \\
ci ii jj        &  {\tt sendLong}        &  send r0 Selektor: iijj, Argumente in r1$\ldots$r15 \\
d0 d-           &  {\tt set\_immutable}   &  TSP-Objekt in rd als unver"anderlich kennzeichnen \\
d1 d-           &  {\tt ld\_ok}           &  rd $\leftarrow$ ok (TSP-Wert f"ur nil) \\
d2 d-           &  {\tt ld\_false}        &  rd $\leftarrow$ false \\
d3 d-           &  {\tt ld\_true}         &  rd $\leftarrow$ true \\
d4 di ii        &  {\tt ld\_sp2}          &  rd $\leftarrow$ Kellerfeld iii \\
d5 di ii        &  {\tt ld\_lit2}         &  rd $\leftarrow$ Literal iii \\
d6 ds ii        &  {\tt seti2}            &   rd[ii] \(\leftarrow\) rs \\
e0 di           &  {\tt ld\_int}          & rd \(\leftarrow\) i \\
e1 ds           &  {\tt mov}             & rd \(\leftarrow\) rs \\
e2 ds           &  {\tt xchg}             & rd $ \leftrightarrow $  rs \\
e3 ds           &  {\tt size}             & rd $\leftarrow$ TSP\_size(rs) \\
e4 ds           &  {\tt not}              & rd $\leftarrow \neg $rs \\
e5 ds           &  {\tt neg}              & rd $\leftarrow$ -rs \\
e6 ds           &  {\tt char2int}         & rd $\leftarrow$ Integer(rs) \\
e7 ds           &  {\tt int2char}         & rd $\leftarrow$ Char(rs) \\
e8 ds           &  {\tt get\_byte}        & rd  $\leftarrow$ Bytezugriff: rd[rs] \\ \hline
\end{tabular}

\begin{tabular}{|| l | l | l ||} \hline
{\em Opcode (Hex)}    &  {\em Befehl}  &  {\em Bedeutung} \\ \hline
e9 ds           &  {\tt array}            & rd $\leftarrow$ neues TSP-Feld der Gr"o\3e rs initialisiert
                                            mit rd \\
ea ds           &  {\tt byte\_array}      & rd $\leftarrow$ neues TSP-Bytefeld der Gr"o\3e rs initialisiert
                                            mit rd \\
eb              &  {\tt push\_handler}    & Ausnahmebehandlung im Ausnahmekeller speichern \\
ec              &  {\tt pop\_handler}     & Ausnahmebehandlung l"oschen \\
ed              &  {\tt set}              & r0[r1] $\leftarrow$  r2 \\
ee              &  {\tt set\_byte}        & Bytezugriff: r0[r1]  $\leftarrow$  r2 \\
ef              &  {\tt block\_move}       & r0 Worte vom Feld in r1 beim Index r2\\
                &                          & ins Feld r3 ab dem Index r4 verschieben \\
f0              &  {\tt block\_move\_bytes} & r0 Bytes vom Feld in r1 beim Index r2\\
                &                           & ins Feld r3 ab dem Index r4 verschieben \\
f1 ii           &  {\tt branch}              & Sprung um ii Bytes \\
f2 ii           &  {\tt branch\_cf}           & Bedingter Sprung um ii Bytes \\
f3 iijj         &  {\tt long\_branch}      & Sprung um iijj Bytes \\
f4 iijj         &  {\tt long\_branch}      & Bedingter Sprung um iijj Bytes \\
f5              &  {\tt raise}             & Ausnahme ausl"osen \\
f6              &  {\tt ccall}             & C-Funktionsaufruf mit {\em Bibliothek:Funktionsname}, \\
                &                          &   {\em "Ubergabeformatstring} und Argumenten im Keller \\
fb ds           &  {\tt class\_new}        & rd $\leftarrow$ neues Exemplar der Klasse rd mit rs Slots\\
fc ds           &  {\tt byte\_class\_new}  & rd $\leftarrow$ neues Exemplar der Byteklasse rd mit rs Slots\\
fd iijj         &  {\tt sendSuper}         & send Super(r0) Selektor: iijj, Argumente in r1$\ldots$r15 \\ \hline
\end{tabular}

\end{appendix}