Note: I am not providing all details - please work these out on your
own. If you have any questions, contact me via email. If you need a
meeting time, we can meet on Monday - just email me in advance to
arrange a meeting time.

Keep in mind that these are not the only possible solutions.

===

Q1: Use a synthesized attribute of type "List of INT/BOOL" for
<formalslist>. Use a similar attribute for <formal>, but here the list
will always be of size 1. At production

<formalslist> ::= <formal> , <formalslist>1

concatenate the lists for the two children

===

Q2: Use an inherited attribute expTypes for <actualslist>, of type
"List of INT/BOOL". At production

<actualslist> ::= <actual> , <actualslist>1

need a check 

Cond: size(<actualslist>.expTypes) > 1

The tail of the list is sent down to <actualslist>1. The head of the
list is sent down to <actual> as some inherited attribute
(e.g. <actual>.expType) where it is used for type checking.

At production 

<actualslist> ::= <actual> 

need a check 

Cond: size(<actualslist>.expTypes) = 1

===

Q3: In the grammar discussed in class, for production 

<block> ::= begin<declist> ; <stmtlist> end

we have 

<declist>.alltbl := push(<declist>.tbl, <block>.alltbl)

In the changed grammar, we need 

<declist>.alltbl := <block>.alltbl

At production 

<declist>1 ::= <decl> ;<declist>2

we can have 

<declist>2.alltbl := push(<decl>.tbl, <declist>1.alltbl)

Which will create a new entry on top of the stack: a symbol table with
one entry in it. Exactly the same rule can be applied for <decl>.alltbl
If the <decl> is a function declaration, typechecking of the function
body will consider all declarations before the function, including the
function declaration itself (this is needed for typechecking of
recursive functions).

===

Q4: At each <seq> node, compute a set of triples of string (x,y,z) such
that x:=y+z appeared earlier, and x/y/z are not modified since. There
are many ways to do this: e.g.

Inherited attribute <seq>.triples
Inherited attribute <stmt>.triples_in
Synthesized attribute <stmt>.triples_out

At production <seq>1 ::= <stmt> <seq>2,

have 

<stmt>.triples_in := <seq>1.triples
<seq>2.triples := <stmt>.triples_out

If <stmt> is an assignment id:=const, <stmt>.triples_out is obtained
from <stmt>.triples_in by removing any triples that contain id.lexval.

If <stmt> is an assignment id1:=id2+id3, <stmt>.triples_out is obtained
from <stmt>.triples_in by first removing any triples that contain
id1.lexval, and then adding the triple (id1.lexval,id2.lexval,id3.lexval)

Part 2: The key question is how to update triples_out when the
statement is <if>. Since the assignment may execute, we still have to
"kill" any triples in triples_in that contain the variable on the
left-hand side of the conditional assignment. For example, a
synthesized attribute for <assign> and <if> can be used to propagate
the string name of this left-hand-size variable.

===

Q5: If you understand how the if-then-else and while-do constructs are
handled (as described in the lecture notes), you should not have any
problems with this question - the solution is straightforward.