afl-material: comparison handouts/ho07.tex

equal deleted inserted replaced

-:af65ffff9cdd
+:a052a83f562e
 \noindent
 The generated code is as follows:
 \begin{lstlisting}[mathescape,language={}]
 ldc 1
-ldc 2
+ldc 1
 if_icmpne L_ifelse $\quad\tikz[remember picture] \node (C) {\mbox{}};$
 ldc 2
 istore 0
 goto L_ifend $\quad\tikz[remember picture] \node (A) {\mbox{}};$
 L_ifelse: $\quad\tikz[remember picture] \node[] (D) {\mbox{}};$
 -- ++(0mm,-17.3mm) |- (\tikztotarget)},line width=1mm] (B.east);
 \draw[->,very thick] (C) edge [->,to path={-- ++(10mm,0mm)
 -- ++(0mm,-17.3mm) |- (\tikztotarget)},line width=1mm] (D.east);
 \end{tikzpicture}
 \noindent The first three lines correspond to the the boolean
 expression $1 = 1$. The jump for when this boolean expression
 is false is in Line~3. Lines 4-6 corresponds to the if-branch;
 the else-branch is in Lines 8 and 9. Note carefully how the
-environment $E$ is threaded through the calls of
+environment $E$ is threaded through the recursive calls of
 \textit{compile}. The function receives an environment $E$,
 but it might extend it when compiling the if-branch, yielding
 $E'$. This happens for example in the if-statement above
 whenever the variable \code{x} has not been used before.
-Similarly with the environment $E''$ for the second call
+Similarly with the environment $E''$ for the second call to
-to \textit{compile}. $E''$ is also the environment that need
+\textit{compile}. $E''$ is also the environment that needs to
-to be returned.
+be returned as part of the answer.
 The compilation of the while-loops, say
 \pcode{while} $b$ \pcode{do} $cs$, is very similar. In case
-the condition is true and we need to do another iteration, the
+the condition is true and we need to do another iteration,
-control-flow needs to be as follows
+and the control-flow needs to be as follows
 \begin{center}
 \begin{tikzpicture}[node distance=2mm and 4mm,
 block/.style={rectangle, minimum size=1cm, draw=black, line width=1mm},
 point/.style={rectangle, inner sep=0mm, minimum size=0mm, fill=red},
 \draw (cs1) edge [->, black, line width=1mm] (A3);
 \draw (A3) edge [->,skip loop] (A1);
 \end{tikzpicture}
 \end{center}
-\noindent While if the condition is \emph{not} true we
+\noindent Whereas if the condition is \emph{not} true, we
 need to jump out of the loop, which gives the following
 control flow.
 \begin{center}
 \begin{tikzpicture}[node distance=2mm and 4mm,
 \end{tikzpicture}
 \end{center}
 \noindent Again we can use the \textit{compile}-function for
 boolean expressions to insert the appropriate jump to the
-end of the loop (label $L_{wend}$).
+end of the loop (label $L_{wend}$ below).
 \begin{center}
 \begin{tabular}{lcl}
 $\textit{compile}(\pcode{while}\; b\; \pcode{do} \;cs, E)$ & $\dn$\\
 \multicolumn{3}{l}{$\qquad L_{wbegin}\;$ (fresh label)}\\
 \multicolumn{3}{l}{$\qquad L_{wend}\;$ (fresh label)}\\
 \multicolumn{3}{l}{$\qquad (is, E') = \textit{compile}(cs_1, E)$}\\
 \multicolumn{3}{l}{$\qquad(L_{wbegin}:$}\\
 \multicolumn{3}{l}{$\qquad\phantom{(}@\;\textit{compile}(b, E, L_{wend})$}\\
 \multicolumn{3}{l}{$\qquad\phantom{(}@\;is$}\\
-\multicolumn{3}{l}{$\qquad\phantom{(}@\; \text{goto}\;l_{wbegin}$}\\
+\multicolumn{3}{l}{$\qquad\phantom{(}@\; \text{goto}\;L_{wbegin}$}\\
 \multicolumn{3}{l}{$\qquad\phantom{(}@\;L_{wend}:, E')$}\\
 \end{tabular}
 \end{center}
+\noindent I let you go through how this clause works. As an example
+you can consider the while-loop
+\begin{lstlisting}[mathescape,numbers=none,language={}]
+while x <= 10 do x := x + 1
+\end{lstlisting}
+\noindent yielding the following code
+\begin{lstlisting}[mathescape,language={}]
+L_wbegin: $\quad\tikz[remember picture] \node[] (LB) {\mbox{}};$
+iload 0
+ldc 10
+if_icmpgt L_wend $\quad\tikz[remember picture] \node (LC) {\mbox{}};$
+iload 0
+ldc 1
+iadd
+istore 0
+goto L_wbegin $\quad\tikz[remember picture] \node (LA) {\mbox{}};$
+L_wend: $\quad\tikz[remember picture] \node[] (LD) {\mbox{}};$
+\end{lstlisting}
+\begin{tikzpicture}[remember picture,overlay]
+\draw[->,very thick] (LA) edge [->,to path={-- ++(10mm,0mm)
+-- ++(0mm,17.3mm) |- (\tikztotarget)},line width=1mm] (LB.east);
+\draw[->,very thick] (LC) edge [->,to path={-- ++(10mm,0mm)
+-- ++(0mm,-17.3mm) |- (\tikztotarget)},line width=1mm] (LD.east);
+\end{tikzpicture}
 Next we need to consider the statement \pcode{write x}, which
-can be used to write out the content of a variable. For this
+can be used to print out the content of a variable. For this
 we need to use a Java library function. In order to avoid
 having to generate a lot of code for each
-\pcode{write}-command, we use a separate method and just call
+\pcode{write}-command, we use a separate helper-method and
-this method with an argument (which needs to be placed on the
+just call this method with an argument (which needs to be
-stack). The code is as follows.
+placed onto the stack). The code of the helper-method is as
+follows.
 \begin{lstlisting}[language=JVMIS]
 .method public static write(I)V
 .limit locals 1
 \pcode{java/io/PrintStream}. A reference to this value will be
 placed on the stack. Line~5 copies the integer we want to
 print out onto the stack. In the next line we call the method
 \pcode{println} (from the class \pcode{java/io/PrintStream}).
 We want to print out an integer and do not expect anything
-back (that is why the type annotation \pcode{(I)V}). The
+back (that is why the type annotation is \pcode{(I)V}). The
 \pcode{return}-instruction in the next line changes the
 control-flow back to the place from where \pcode{write} was
 called. This method needs to be part of a header that is
-included in any code we generate. The method \pcode{write} can
+included in any code we generate. The helper-method
-be invoked with the two instructions
+\pcode{write} can be invoked with the two instructions
 \begin{lstlisting}[mathescape,language=JVMIS]
 iload $E(x)$
 invokestatic XXX/XXX/write(I)V
 \end{lstlisting}
 \noindent where we first place the variable to be printed on
-the stack and then call \pcode{write}. The \pcode{XXX} need to
+top of the stack and then call \pcode{write}. The \pcode{XXX}
-be replaced by appropriate class name (this will be explained
+need to be replaced by an appropriate class name (this will be
-shortly).
+explained shortly).
 \begin{figure}[t]
 \begin{lstlisting}[mathescape,language=JVMIS]
 .class public XXX.XXX
 By generating code for a While-program, we end up with a list
 of (JVM assembly) instructions. Unfortunately, there is a bit
 more boilerplate code needed before these instructions can be
-run. The code is shown in Figure~\ref{boiler}. This
+run. The complete code is shown in Figure~\ref{boiler}. This
-boilerplate code is very specific to the JVM. Lines 4 to 8
+boilerplate code is very specific to the JVM. If we target any
-contains a method for object creation in the JVM and is called
+other virtual machine or a machine language, then we would
-\emph{before} the \pcode{main}-method in Lines 10 to 17.
+need to change this code. Lines 4 to 8 in Figure~\ref{boiler}
-Interesting are the Lines 11 and 12 where we hardwire that the
+contain a method for object creation in the JVM; this method
-stack of our program will never be larger than 200 and that
+is called \emph{before} the \pcode{main}-method in Lines 10 to
-the maximum number of variables is also 200. This seem
+17. Interesting are the Lines 11 and 12 where we hardwire that
-conservative default values that allow is to run some simple
+the stack of our programs will never be larger than 200 and
-While-programs. In a real compiler, we would of course need to
+that the maximum number of variables is also 200. This seem to
-work harder and find out appropriate values for the stack and
+be conservative default values that allow is to run some
-local variables.
+simple While-programs. In a real compiler, we would of course
+need to work harder and find out appropriate values for the
+stack and local variables.
 To sum up, in Figure~\ref{test} is the complete code generated
 for the slightly non-sensical program
 \begin{lstlisting}[mathescape,language=While]
 x := 1 + 2;
 write x
 \end{lstlisting}
 \noindent Having this code at our disposal, we need the
-assembler to translate the generated code into bytecode (a
+assembler to translate the generated code into JVM bytecode (a
-class file) that can be understood by the JVM.
+class file). This bytecode is understood by the JVM and can be
+run by just invoking the \pcode{java}-program.
 \begin{figure}[p]
 \lstinputlisting{../progs/test-small.j}
-\caption{Generated code for a test program.\label{test}}
+\caption{Generated code for a test program. This code can be
+processed by an Java assembler producing a class-file, which
+can be run by the \pcode{java}-program.\label{test}}
 \end{figure}
 \end{document}
 %%% Local Variables:

changeset 377	a052a83f562e
parent 376	af65ffff9cdd
child 383	a6a6bf32fade