CPS 1 - Spring, 1997 - Ramm 4/9/97 #32

Announce
- Quiz Today

Chapter 10. Language Translation

Add Semantic Components to our Rules
Augment R1
- Syntax Rule Semantic Rule
 R1: j->w M(j)=w
- M ... Meaning of ... Name ... Memory location
- In other words, use same identifier name in both Pascal and Assembler
Revise R2

Syntax Rule Semantic Rules

R2: <e>i -> j

M(<e>i) = M(j)
code(<e>i) = //nothing//

No code generated!
Revise R3

Syntax Rule Semantic Rules

R3: <s>k -> j:=<e>i

code(<s>k) = code(<e>i)
COPY AX,M(<e>i)
COPY M(j),AX

Says code for statement is code to calculate expression <e>i and code to copy it into Memory associated with j

Syntax Rule	Semantic Rule
`R1: <i>j->w`	`M(<i>j)=w`

Demonstrate use of Rules -- Note: 2 Pass Process !!!
Pass 1: Use Syntactic Derivation to Generate Semantic Rules

X := Y

Derivation Syntax Rules	    Semantic Rules
s1	   R3: s1 -> i2:=e3 code(s1) = code(e3)
			   	       COPY AX,M(e3)
				       COPY M(i2),AX
i2 := e3   R1: i2 -> X	    M(i2) = X
X := e3	   R2: e3 -> i4	    M(e3) = M(i4)
	 		    code(e3) = //nothing//
X := i4	   R1: i4 -> Y	    M(i4) = Y
X := Y

Pass 2: Now use Semantic Rules to Generate Code

code(s1) =	code (e3)	BY R3
		COPY AX,M(e3)
		COPY M(i2), AX

code(s1) =	code (e3)	BY R1
		COPY AX,M(e3)
		COPY X, AX

code(s1) =	//nothing// 	BY R2
		COPY AX,M(i4)
		COPY X, AX

code(s1) =	COPY AX,Y 	BY R1
		COPY X, AX

Now Rules R4 and R5

Syntax Rule Semantic Rules

 R4: <e>i->(<e>j+<e>k)

`M(<e>i) = createname`
	`code(<e>i)=`	`code(<e>j)`
	`code(<e>k)`
	`COPY AX,M(<e>j)`
	`ADD AX,M(<e>k)`
	`COPY M(<e>i),AX`

Says code for <e>i is code to calculate expression <e>j followed by code to calculate expression <e>k and code to add them together and store that sum into Memory associated with <e>i

Syntax Rule Semantic Rules

 R5: <e>i->(<e>j*<e>k)

`M(<e>i) = createname`
	`code(<e>i)=`	`code(<e>j)`
	`code(<e>k)`
	`COPY AX,M(<e>j)`
	`MUL AX,M(<e>k)`
	`COPY M(<e>i),AX`

Says code for <e>i is code to calculate expression <e>j followed by code to calculate expression <e>k and code to multiply them together and store that sum into Memory associated with <e>i

Basically rules R4 and R5 are identical except that the + and ADD in one are replace by the * and MUL in the other.

Look at Example from Pages 276, 277 of book
It does Z := (X + Y)

More complicated example for U1 := (X + (Y * Z)) also in book. Look at it.

Rules for Looping
Sequence of statements

Syntax Rule Semantic Rules

`R6: <q>i ->`	`<s>j;`
	`<q>k`

`code(<q>i) =`	`code(<s>j)`
	`code(<q>k)`

Syntax Rule	Semantic Rules
`R7: <q>i -> <s>j;`	`code(<q>i) = code(<s>j)`

Says code for a sequence of statements is the code for the first statement followed by the code for the next statement, etc.

Compound Statement

Syntax Rule Semantic Rules

`R8: <c>i ->`	`begin`
	`<q>j`
	`end`

 code(<c>i) = code(<q>j)

While Statement

Syntax Rule Semantic Rules

`R9: <s>i ->`	`while <i>j < <e>k do`
	`<c>h`

`M(<s>i) = createname`
`M'(<s>i) = createname`
`code(<s>i) =`
`M(<s>i)`	`code(<e>k)`
	`COPY AX,M(<i>j)`
	`CMP AX,M(<e>k)`
	`JNB M'(s<i>)`
	`code(<c>h)`
	`JMP M(<s>i)`
`M'(<s>i)`	`NO-OP`

Cleanup Translation
Some code generated that can be removed.
Important: Everything done by simple substitution
Everything "adds up"

code( begin;<s>1;<s>2;<s>3;end )
is
code(<s>1)
code(<s>2)
code(<s>3)