L?sningsforslag til ukeoppgaver uken 11. til 17. oktober 2008


Oppgave 1

For ? forhindre direkte rekursjon, kan vi ikke ha kall p? en funksjon
'fa' inni seg selv. Det enkleste da er ? ha en variabel
'underConstruction' (eller noe lignende) i 'FuncDeclUnit'-klassen;
variabelen er true mens 'fa' parsereres og false ellers. Ved alle
funksjonskall m? vi da sjekke denne variabelen.

Indirekte rekursjon trenger vi ikke bry oss om, for det kan aldri
forekomme i RusC. Hvis vi har to funksjoner 'f1' og 'f2' (deklarert i
denne rekkef?lgen), kan ikke 'f1' kalle p? 'f2' siden navnet enn? ikke
er kjent.


Oppgave 2

'f' vil avslutte normalt. Vi ser av kodetabell 5.7 p? side 44 at
funksjonsavslutningen genereres uavhengig av return-setningene.

Hvis avslutningen av en funksjon skjer uten return-setning, vil det
ikke v?re angitt noen returverdi, s? R1 vil inneholde den verdien den
sist fikk. I eksemplet v?rt blir 'f' oversatt til

Code    8:  201000000000005  SET       1  0    5  # R1 = 5
Code    9:  301000000000005  STORE     1  0    5  # x = 
Code   10:  103000000000004  LOAD      3  0    4  # <restore R3>
Code   11:  131000000000003  LOAD     31  0    3  # <restore return address>
Code   12: 1700000000000000  RET       0  0    0  # return (from f)

og vi ser at R1 fikk verdien 5 i SET-instruksjonen i adresse
8. Funksjonen 'f' vil alts? alltid returnere 5.


Oppgave 3

Dette programmet er et eksempel p? s?kalt ?selvmodifiserende kode? der
programmet endrer seg selv under kj?ringen. Koden for 'teller' ser
slik ut

Code    3:                   RES               1  # <return address> in teller
Code    4:                   RES               1  # <refuge for R3> in teller
Code    5:                   RES               1  # int a[1]
Code    6:  331000000000003  STORE    31  0    3  # <save return address>
Code    7:  303000000000004  STORE     3  0    4  # <save R3>
Code    8:  202000000000010  SET       2  0   10  # R2 = 10
Code    9:  101020000000005  LOAD      1  2    5  # <load variable>
Code   10:  203010000000000  SET       3  1    0  # <save operand>
Code   11:  201000000000001  SET       1  0    1  # R1 = 1
Code   12:  401030000000001  ADD       1  3    1  # +
Code   13:  202000000000010  SET       2  0   10  # R2 = 10
Code   14:  301020000000005  STORE     1  2    5  # a[...] = 
Code   15:  201000000000000  SET       1  0    0  # R1 = 0
Code   16: 1400000000000000  JUMPEQ    0  0    0  # return
--->   16: 1400000000000017                   17  # <update address of return>
Code   17:  103000000000004  LOAD      3  0    4  # <restore R3>
Code   18:  131000000000003  LOAD     31  0    3  # <restore return address>
Code   19: 1700000000000000  RET       0  0    0  # return (from teller)

Her ser vi at konstanten 0 som inng?r i return-setningen, ligger i
SET-instruksjonen i adresse 15.

Vi ser array-en 'a' starter i adresse 5, s? elementet 'a[10]' m? da
referere adresse 5+10=15, alts? der SET-instruksjonen v?r ligger. (At
'a' ikke har s? mange elementer, bryr ikke programmet v?rt seg om --
det sjekkes aldri om indekser ligger innenfor grensene.)

Funksjonen 'teller' gj?r f?lgelig to ting:
1. ?ker konstanten i SET-instruksjonen med 1.
2. Returnerer den nye konstanten.