1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
# Opgave A
Hmm ved ikke lige med projekt men har en fed ide.
Openscad men til 2d graffik som **kompilere** til svg.
Tænker at man vil lave det i et sprog som c, go eller rust.
Rust ville være optimalt men det er også lidt svært.
Det skulle være et emperisk sprog med variabler og functioner.
Funktioner returnere ikke noget, men mere en bestemt figur.
Variables can be strings, floating point numbers.
Lists are defined as list.
Strings begin with big letters.
Bools are defined as numbers 0 and 1.
Lists are defined as [] and contain all numbers or all strings.
C style comments.
```
var Black = "#FFFFFF";
var White = "#000000";
list Names = [ "nice", "nice2" ];
var radius = 10.2;
func coolCircle(r, Name) {
// Defined as circle(radius, fgCol, bgCol)
circle(r, Black, White);
// Defined as insertText(Text, allign, fgCol)
insertText(Name, ALIGN_CENTER, Black);
}
translate(1, 2) {
coolCircle(radius / 2, Names[0]);
}
coolCircle(radius, Names[1]);
```
The code will generate two circles, one in the center and one on the coordinates 1, 2.
# Opgave B
Der er defineret to globale variabler, men de er ikke på stacken.
Inde i main laver man en pointer til a og sender ind i funktionen.
Dette betyder at denne pointer enten ligger på stacken eller i et register når funktionen ainc kører.
Men der kan siges sikkert at stacken indeholder en return pointer til main og en reference til den tidelige stack(tror jeg).
## Kode i assembly
Jeg har ikke taget højde for integer operationer.
```
JMP main
var_a: DB 4
ainc:
MOV B, [A]
ADD B, 1
MOV [A], B
RET
main:
MOV A, var_a
CALL ainc
HLT
```
## Forskellige compile trin
Proprocessor har ikke noget at lave.
Start med at compile til assembly:
Læg a og b i starten af programmet.
Compiler funktionen ainc og adec og sæt en label ved dem.
Dette gøres ved først at lave koden der henter argument ud og gemmer tidligere stack pointer.
Derefter compiles indholdet i funktionen.
Slut af med at returner til caller.
Derefter bliver assembly'en assemblet:
De forskellige mnenorics(eller hvad det nu hed) bliver lavet om til opcodes og lags sammen med deres argumenter.
Dette gøres for alle funktionerne.
a og b bliver placeret i filen.
Derefter placeres main ved entrypoint og de to funktioner bliver lagt ved siden af.
De forskellige referencer til funktioner og globale variabler bliver byttet ud med deres virkelige værdier i binary.
# Opgave C
Grammastart -> *Viggo* stmList *End*
stmList -> stm stmList | e
stm -> ident *=* exp *;*
ident -> letter symList
letter -> *a* | ... | *å* | *A* | ... | *Å*
digit -> *0* | ... | *9*
symbol -> letter | digit
symList -> symbol symList | e
exp -> term expB
exp -> termopr term expB | e
termOpr -> *+* | *-*
term -> factor termB
termB -> factorOpr factor termB | e
factorOpr -> _*_ | _/_
factor -> *(* exp *)* | ident
## C.2
See tree.png
## C.3
|
