Walkthru of early steps in lab1

First steps walkthru of lab1

Here's a short example going through adding and testing some sample tokens and rules for the lab1 lex and yacc files.

I'm going to follow this sequence:

Add a tokens for identifiers and the set keyword, and revising the statement rule so that it accepts either of them or the numtok, and test what we've got so far.
Change the body rule so it accepts multiple statements (i.e. I can have multiple identifiers, set keywords, and numbers in my source code) then test it works.
Change the statement rule so that it recognizes a more realistic kind of statement, specifically a (simplified) assignment statement: set identifier number, and test it works.

1. Adding and checking tokens for identifiers and the set keyword

Adding the keyword token to the .lex
This could simply involve adding a line like the following (along with the begin, end, main keywords)
"set" { col+=3; return SETTOK; }
Adding the identifier token to the .lex
This needs to come after all the keywords, since otherwise they'd match as identifiers, but is just a rule for one or more alphabetic characters. (Note the strlen(yytext) used to figure out how long the identifier is, used when we update the current column.)
[a-zA-Z]+ { col+=strlen(yytext); return IDENTTOK; }
Adding the new tokens to the .yacc
In the .yacc file we need to update the %tokens line to include the new token types, i.e.
%token<long> NUMTOK BEGTOK ENDTOK MAINTOK IDENTTOK SETTOK
Updating the statement rule to accept the new token types
The statement rule (in the .yacc grammar rules) only recognizes NUMTOKs as valid statements so far, so now we'll tell it they can be NUMTOK or IDENTTOK or SETTOK:
statement: NUMTOK | IDENTTOK | SETTOK ;
Testing the new tokenizing with .vurb code
Let's create two new test programs, test1.vurb and test2.vurb, using the new token types:
main begin set end
main begin whatever end
Run make, which creates an updated lab1 executable, then see if it complains about either of our new test programs:
```
./lab1 < test1.vurb
./lab1 < test2.vurb
```
Hopefully neither of the above throws error messages when you try them out!

2. Changing the body rule to accept multiple statements

Right now the body can only have a single statment between begin and end, let's change that to be one-or-more.

To do so we'll change the (yacc) body rule to accept a statementlist rather than a single statement, and add a new rule to say that a statementlist can be either a single statement or a statement followed by more statements.

Adding a new 'statementlist' nonterminal
Here we simply need to add 'statementlist' to the end of the %type line in the .yacc
%type program body statement statementlist
Revising the body rule to expect a statementlist
This is simply replacing statement with statementlist in the body rule:
```
body:
   BEGTOK
   statementlist
   ENDTOK
   ;
```
Adding the statementlist rules
In the yacc rules we'll add two rules for statementlist, one for a statementlist being a single statement and one for it being one statement followed by more statements:
```
statementlist: statement ;

statementlist: statement statementlist;
```
Testing the new grammar rules
In theory, our programs can now have any number of statements (NUMTOKs, SETTOKs, and IDENTTOKs) inside the body. We'll revise our test1.vurb to try it out:
```
main
begin
    12345
    foo
    set
    set
    0
    whatever
end
```
Now run make to create the updated lab1, and try it with
./lab1 < test1.vurb

3. Changing the statement rule to handle (simplified) assignment statments

All the actual statements in the language are more complex than just single tokens, so let's change our statement rule to represent a single more realistic one.

We'll start with just a simple assignment statement of the following form:
set IDENTTOK NUMTOK
(eventually we'll want the right-hand side of that to be an expression rather than just a number, but start small and expand incrementally!)
We'll scrap the old statement rule, replacing it with something like statement --> assignstmt and add an assignstmt rule:

Add an assignstmt nonterminal
As we did with statementlist, add assignstmt to the end of the %types line in the .yacc
Revise the statement rule so a statement can be an assignstmt
our statement rule (since for now we'll just have one kind of statement) can be:
```
statement: assignstmt ;
```
(This is replacing our old statement rule of NUMTOK | IDENTTOK | SETTOK.)
Add a rule for assignstmt
Our assignments need a set keyword then an identifier then a number, so
```
assignstmt: SETTOK IDENTTOK NUMTOK ;
```
Test the new grammar rules
Now let's change our test1.vurb again, this time making it a series of assignments:
```
main
begin
set x 200
set foo 1
set ABC 12345
end
```
Run make again, and re-test with ./lab1 < test1.vurb