687 Maybe a useful addition to the While-language are arrays. This 

   687 Maybe a useful addition to the While-language would be arrays. This

   688 lets us generate more interesting While-programs by translating

   688 would let us generate more interesting While-programs by translating

   689 BF*** programs into equivalent While-programs. This means we 

   689 BF*** programs into equivalent While-code. So in this section lets have

   690 want to support the following three constructions

   690 a look at how we can support the following three constructions

   699 The first one creates a new array with name \pcode{arr} that can 

   699 The first construct is for creating new arrays, in this instance the

   700 hold a given number of integers. The second is referencing an array

   700 name of the array is \pcode{arr} and it can hold 15000 integers. The

   701 inside a arithmetic expression. Essentially we have to be able to 

   701 second is for referencing an array cell inside an arithmetic

   702 look up the contents of an array at an index. Similarly we need to be

   702 expression---we need to be able to look up the contents of an array at

   703 able to update the content of an array (3rd line). The latter two

   703 an index determined by an arithmetic expression. Similarly, we need to

   704 constructions state that the index to an array can be given by 

   704 be able to update the content of an array at an calculated index---the

   705 an arithmetic expression. For creating a new array we need to generate

   705 3rd feature.  

   706 the following JVM instructions:

   706 

   707 For creating a new array we can generate the following three JVM

   708 instructions:

   715 First we need to put the dimension of the array onto the

   717 First we need to put the dimension of the array onto the stack. The next

   716 stack, then next instruction creates the array and last we

   718 instruction creates the array. With the last we can store the array as a

   717 need to store the array in a local variable (like ``simple'' variables).

   719 local variable (like the ``simple'' variables from the previous

   718 For looking up an element in an array we can use the following code

   720 section). The use of a local variable allows us to have multiple arrays

   721 in a While-program. For looking up an element in an array we can use the

   722 following JVM code

   727 This first loads the ``pointer'' to the array onto the stack. Then we have the

   731 The first instruction loads the ``pointer'' to the array onto the stack.

   728 instructions corresponding to the index where we want to look up the array. The

   732 Then we have some instructions corresponding to the index where we want

   729 idea is that these instructions will leave a concrete number on the stack, which is

   733 to look up the array. The idea is that these instructions will leave a

   730 the index. Finally we just need to load the corresponding element onto the stack.

   734 concrete number on the stack, which will be the index into the array we

   735 need. Finally we need to tell the JVM to load the corresponding element

   736 onto the stack. Updating an array at an index with a value is as

   737 follows.

   738 

   739 \begin{lstlisting}[mathescape,language=JVMIS]

   740 aload loc_var 

   741 index_aexp 

   742 value_aexp 

   743 iastore

   744 \end{lstlisting}

   745 

   746 \noindent

   747 Again the first instruction loads the ``pointer'' to the array onto the

   748 stack. Then we have some instructions corresponding to the index where

   749 we want to update the array. After that come the instructions for with what

   750 value we want to update the array. Finally the instruction for 

   751 updating the array.

   752 

   753 Next we need to update our grammar rules: it seems best to extend the 

   754 rule for factors in arithmetic expressions with a rule for looking up

   755 an array.

   756 

   757 \begin{plstx}[rhs style=, margin=3cm]

   758 : \meta{E} ::= \meta{T} $+$ \meta{E}

   759          | \meta{T} $-$ \meta{E}

   760          | \meta{T}\\

   761 : \meta{T} ::= \meta{F} $*$ \meta{T}

   762           | \meta{F} $\backslash$ \meta{T}

   763           | \meta{F}\\

   764 : \meta{F} ::= ( \meta{E} )

   765           | $\underbrace{\meta{Id}\,[\,\meta{E}\,]}_{new}$

   766           | \meta{Id}

   767           | \meta{Num}\\

   768 \end{plstx}

   769 

   770 \noindent

   771 There is no problem with left-recursion as the \meta{E} is ``protected''

   772 by an identifier and brackets. There are two new rules in statements,

   773 namely creation of an array and array assignment:

   774 

   775 \begin{plstx}[rhs style=, margin=2cm, one per line]

   776 : \meta{Stmt} ::=  \ldots

   777               | \texttt{new}\; \meta{Id}\,[\,\meta{Num}\,] 

   778               | \meta{Id}\,[\,\meta{E}\,]\,:=\,\meta{E}\\

   779 \end{plstx}