afl-material: comparison handouts/ho07.tex

equal deleted inserted replaced

-:c82a45f48bfc
+:5365ef60707e
 \end{lstlisting}
 \noindent The first instruction loads the constant $1$ onto the stack,
 the next one loads $2$, the third instruction adds both numbers together
 replacing the top two elements of the stack with the result $3$. For
-simplicity, we will consider throughout only arithmetic involving
+simplicity, we will consider only arithmetic operations involving
 integer numbers. This means our main JVM instructions for arithmetic
 will be \instr{iadd}, \instr{isub}, \instr{imul}, \instr{idiv} and so on.
 The \code{i} stands for integer instructions in the JVM (alternatives
 are \code{d} for doubles, \code{l} for longs and \code{f} for floats
 etc).
 $cs_2$, but always jump to after the last instruction of $cs_2$
 (the code for the \pcode{else}-branch). Note that this jump is
 unconditional, meaning we always have to jump to the end of
 $cs_2$. The corresponding instruction of the JVM is
 \instr{goto}. In case $b$ turns out to be false we need the
-control-flow
+control-flow to be:
 \begin{center}
 \begin{tikzpicture}[node distance=2mm and 4mm,line cap=round,
 block/.style={rectangle, minimum size=1cm, draw=black, line width=1mm,
 top color=white,bottom color=black!20},
 the instructions for the else-branch, followed by the
 after-the-else-branch label. Consider for example the
 if-statement:
 \begin{lstlisting}[mathescape,numbers=none,language=While]
-if 1 = 1 then x := 2 else y := 3
+if 1 == 1 then x := 2 else y := 3
 \end{lstlisting}
 \noindent
 The generated code is as follows:
 \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
+expression \texttt{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 recursive
 calls of \textit{compile}. The function receives an environment $E$, but
 \pcode{write}. It takes a single integer argument indicated by the
 \pcode{(I)} and returns no result, indicated by the \pcode{V} (for
 void). Since the method has only one argument, we only need a single
 local variable (Line~2) and a stack with two cells will be sufficient
 (Line 3). Line 4 instructs the JVM to get the value of the member
-\pcode{out} from the class \pcode{java/lang/System}. It expects the value
+\pcode{out} from the class \pcode{java/lang/System}. It expects the
-to be of type \pcode{java/io/PrintStream}. A reference to this value
+value to be of type \pcode{java/io/PrintStream}. A reference to this
-will be placed on the stack.\footnote{Note the syntax \texttt{L
+value will be placed on the stack.\footnote{Note the syntax
-\ldots{};} for the \texttt{PrintStream} type is not an typo. Somehow the
+\texttt{Ljava\ldots{};} for the \texttt{PrintStream} type is not an
-designers of Jasmin decided that this syntax is pleasing to the eye. So
+typo. Somehow the designers of Jasmin decided that this syntax is
-if you wanted to have strings in your Jasmin code, you would need to
+pleasing to the eye. So if you wanted to have strings in your Jasmin
-write \texttt{Ljava/lang/String;}\;. If you want arrays of one
+code, you would need to write \texttt{Ljava/lang/String;}\;. If you
-dimension, then use \texttt{[\ldots}; two dimensions, use
+want arrays of one dimension, then use \texttt{[\ldots}; two
-\texttt{[[\ldots} and so on. Looks all very ugly to my eyes.} Line~5
+dimensions, use \texttt{[[\ldots} and so on. Looks all very ugly to
-copies the integer we want to print out onto the stack. In the line
+my eyes.} Line~5 copies the integer we want to print out onto the
-after that we call the method \pcode{println} (from the class
+stack. In the line after that we call the method \pcode{println} (from
-\pcode{java/io/PrintStream}). We want to print out an integer and do not
+the class \pcode{java/io/PrintStream}). We want to print out an
-expect anything back (that is why the type annotation is \pcode{(I)V}).
+integer and do not expect anything back (that is why the type
-The \pcode{return}-instruction in the next line changes the control-flow
+annotation is \pcode{(I)V}).  The \pcode{return}-instruction in the
-back to the place from where \pcode{write} was called. This method needs
+next line changes the control-flow back to the place from where
-to be part of a header that is included in any code we generate. The
+\pcode{write} was called. This method needs to be part of a header
-helper-method \pcode{write} can be invoked with the two instructions
+that is included in any code we generate. The helper-method
+\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}
 would allow us to generate more interesting WHILE-programs by
 translating BF*** programs into equivalent WHILE-code. Therefore in this
 section let us have a look at how we can support the following three
 constructions
-\begin{lstlisting}[mathescape,language=While]
+\begin{itemize}
-new(arr[15000])
+\item \lstinline|new(arr[15000])|
-x := 3 + arr[3 + y]
+\item \lstinline|x := 3 + arr[3 + y]|
-arr[42 * n] := ...
+\item \lstinline|arr[42 * n] := ...|
-\end{lstlisting}
+\end{itemize}
 \noindent
 The first construct is for creating new arrays. In this instance the
 name of the array is \pcode{arr} and it can hold 15000 integers. We do
 not support ``dynamic'' arrays, that is the size of our arrays will

changeset 943	5365ef60707e
parent 941	66adcae6c762
child 960	c7009356ddd8