\subsection{Semantiekbeschrijving}
+Om de semantiekregels te kunnen beschrijven maken we gebruik van hulpfuncties. Hieronder staat het type van de functies en een korte beschrijving.
+De implementatie van deze functies staat in de appendix bij het aangegeven regelnummer.\\
+
+delete functie (d, r. 5):\\
Om het bovenste element van een stack weg te kunnen gooien gebruiken we de volgende
functie:\\
$$\mathcal{D} : Stack \rightarrow Stack$$
-$$\mathcal{D} [\:] = [\:]$$
-$$\mathcal{D} [a:rest] = [rest] $$
Deze functie haalt het bovenste element van de stack en gooit deze weg.\\
+extend functie (e, r. 9):\\
Om een stack uit te kunnen breiden met een element gebruiken we de volgende
functie:\\
$$\mathcal{E} : Stack\rightarrow (\mathbb{Z} \rightarrow Stack)$$\\
Deze functie neemt een stack en een integer en voegt de integer toe bovenop de
stack.\\
+add functie (add, r. 13):\\
Om de bovenste twee elementen van een stack op te tellen gebruiken we de volgende
functie:\\
$$\mathcal{ADD} : Stack \rightarrow Stack$$
-$$\mathcal{ADD} [\:] = [\:]$$
-$$\mathcal{ADD} [a] = [a] $$
-$$\mathcal{ADD} [a:b:rest] = [b+a:rest] $$\\
Deze functie haalt de bovenste twee waarden van de stack, telt ze bij elkaar op, en stopt
het resultaat bovenop de stack.\\
+subtract functie (sub, r. 18)\\
Om de bovenste twee elementen van een stack van elkaar af te trekken gebruiken we
de volgende functie:\\
$$\mathcal{SUB} : Stack \rightarrow Stack$$
-$$\mathcal{SUB} [\:] = [\:]$$
-$$\mathcal{SUB} [a] = [a] $$
-$$\mathcal{SUB} [a:b:rest] = [b-a:rest] $$\\
Deze functie haalt de bovenste twee elementen van de stack, trekt de bovenste
-waarde van de tweede bovenste waarde af, en stopt het resultaat bovenop de stack.
+waarde van de tweede bovenste waarde af, en stopt het resultaat bovenop de stack.\\
+multiply functie (mul, r. 23):\\
Om de bovenste twee elementen van een stack te vermenigvuldigen gebruiken we de
volgende functie:\\
$$\mathcal{MUL} : Stack \rightarrow Stack$$
-$$\mathcal{MUL} [\:] = [\:]$$
-$$\mathcal{MUL} [a] = [a] $$
-$$\mathcal{MUL} [a:b:rest] = [b*a:rest] $$\\
Deze functie haalt de bovenste twee elementen van de stack, vermenigvuldigt ze,
en stopt het resultaat bovenop de stack.\\
+division functie (div, r. 28):\\
Om de geheeltallige deling van de bovenste twee elementen van de stack bovenop de
stack te krijgen gebruiken we de volgende functie:\\
$$\mathcal{DIV} : Stack \rightarrow Stack$$
-$$\mathcal{DIV} [\:] = [\:]$$
-$$\mathcal{DIV} [a] = [a] $$
-$$\mathcal{DIV} [a:b:rest] = [b/a:rest] $$\\
Deze functie haalt de bovenste twee elementen van de stack, berekent de
geheeltallige deling van de tweede bovenste waarde door de bovenste waarde,
en stopt het resultaat bovenop de stack.\\
-Om gebruiken we de
-volgende functie:\\
+modulo functie (modc, r. 33):\\
+Om de tweede bovenste waarde modulo de bovenste waarde te berekenen
+gebruiken we de volgende functie:\\
$$\mathcal{MOD} : Stack \rightarrow Stack$$
-$$\mathcal{MOD} [\:] = [\:]$$
-$$\mathcal{MOD} [a] = [a] $$
-$$\mathcal{MOD} [a:b:rest] = [b \: mod \: a:rest] $$\\
-Deze functie haalt de bovenste twee elementen van de stack, berekent het resultaat van de tweede bovenste
-waarde modulo de bovenste waarde, en stopt dit bovenop de stack.\\
+Deze functie haalt de bovenste twee elementen van de stack, berekent het
+resultaat van de tweede bovenste waarde modulo de bovenste waarde, en
+stopt dit bovenop de stack.\\
+duplicate functie (dup, r. 38):\\
Om het bovenste element van een stack te dupliceren gebruiken we de
volgende functie:\\
$$\mathcal{DUP} : Stack \rightarrow Stack$$
-$$\mathcal{DUP} [\:] = [\:]$$
-$$\mathcal{DUP} [a:rest] = [a:a:rest] $$\\
-Deze functie haalt stopt een kopie van de bovenste waarde bovenop de stack.\\
+Deze functie haalt de bovenste waarde van de stack en stopt een kopie
+en de bovenste waarde bovenop de stack.\\
-Om de gebruiken we de
+not functie (notc, r. 42):\\
+Om de not van de bovenste waarde te berekenen gebruiken we de
volgende functie:\\
-$$\mathcal{NOT} : Stack \rightarrow Stack$$
-$$\mathcal{NOT} [\:] = [\:]$$
-$$\mathcal{NOT} [0:rest] = [1:rest]$$
-$$\mathcal{NOT} [\_:rest] = [0:rest] $$\\
-
+$$\mathcal{NOT} : Stack \rightarrow Stack$$\\
Deze functie neemt het bovenste element van de stack en stopt 0 bovenaan de
stack als deze waarde niet gelijk is aan 0 en 1 als deze waarde gelijk is aan 0.\\
-Om gebruiken we de
-volgende functie:\\
-$$\mathcal{GRE} : Stack \rightarrow Stack$$
-$$\mathcal{GRE} [\:] = [\:]$$
-$$\mathcal{GRE} [a] = [a] $$
-$$\mathcal{GRE} [a:b:rest]$$
-$$\qquad \qquad | \: a \geq b = [0:rest]$$
-$$\qquad \qquad | \: a < b = [1:rest]$$\\
-
-$$\mathcal{ROLL} : Stack \rightarrow Stack$$
-$$\mathcal{ROLL} [\:] = [\:]$$
-$$\mathcal{ROLL} [a] = [a] $$
-$$\mathcal{ROLL} [a:b:rest]$$
-$$\qquad \qquad | modulo \: a \: b == 0 = rest$$
-$$\qquad \qquad | b <= 0 = rest$$
-$$\qquad \qquad | b > length rest = rest$$
-$$\qquad \qquad | a == 1 = roll1 [b:rest]$$
-$$\qquad \qquad | a > 0 = roll([a-1] ++ [b] ++ roll1 [b:rest]$$
-$$\qquad \qquad | a < 0 = roll(modulo \: a \: b] ++ [b:rest])$$
-
-$$\mathcal{ROLL}1 : Stack \rightarrow Stack$$
-$$\mathcal{ROLL}1 [1:rest] = [rest]$$
-$$\mathcal{ROLL}1 [b:c:d:rest] = [d] ++ \mathcal{ROLL}1 [b-1:c:rest]$$
-
-
+greater functie (gre, r. 47):\\
+Om kijken of de tweede bovenste waarde groter is dan de bovenste waarde
+gebruiken we de volgende functie:\\
+$$\mathcal{GRE} : Stack \rightarrow Stack$$\\
+Deze functie haalt de bovenste twee waarden van de stack en stopt een 1 bovenop
+de stack als de tweede bovenste waarde groter is dan de bovenste waarde. Anders
+word een 0 bovenop de stack gestopt.\\
+
+roll functie (roll, r. 54):\\
+Om de stack te rollen gebruiken we de volgende functie:\\
+$$\mathcal{ROLL} : Stack \rightarrow Stack$$\\
Deze functie haalt de bovenste twee elementen van de stack en stopt 1 bovenop
de stack als het tweede bovenste element een hogere waarde heeft als dat van het
bovenste element. Anders word 1 bovenop de stack gestopt.\\
+pointer functie (pointer, r. 65):\\
+
+out number functie (outnum, r. 74):\\
+
+in number functie (innum, r. 83):\\
+
+
+
+
+
+(switch, outchar, inchar)\\
+
+
Met behulp van deze gedefinieerde functies kunnen we nu de volgende semantiekregels opstellen:\\
$
{[greater_{sos}]} \qquad
\langle greater, s_i, s_o, s\rangle \Rightarrow
\langle s_i, s_o, \mathcal{GRE}(s)\rangle\\
+{[pointer_{sos}]} \qquad
+\langle pointer, s_i, s_o, s\rangle \Rightarrow
+\langle s_i, s_o, \mathcal{D}(s)\rangle\\
{[push_{sos}]} \qquad
\langle push \: n, s_i, s_o, s\rangle \Rightarrow
\langle s_i, s_o, \mathcal{E}(n,s)\rangle\\
{[roll_{sos}]} \qquad
\langle roll, s_i, s_o, s\rangle \Rightarrow
\langle s_i, s_o, \mathcal{ROLL}(s)\rangle\\
-{[inchar_{sos}]} \qquad
-\langle inchar, s_i, s_o, s\rangle \Rightarrow
-\langle s_i, s_o, s\rangle\\
{[innum_{sos}]} \qquad
\langle innum, s_i, s_o, s\rangle \Rightarrow
+\langle \mathcal{INN_{SI}}(s_i), s_o, \mathcal{INN_S}(s)\rangle\\
+{[outnum_{sos}]} \qquad
+\langle outnum, s_i, s_o, s\rangle \Rightarrow
+\langle s_i, \mathcal{OUTN_{SO}}(s_o),\mathcal{OUTN_S}(s)\rangle\\
+{[inchar_{sos}]} \qquad
+\langle inchar, s_i, s_o, s\rangle \Rightarrow
\langle s_i, s_o, s\rangle\\
{[outchar_{sos}]} \qquad
\langle outchar, s_i, s_o, s\rangle \Rightarrow
\langle s_i, s_o, s\rangle\\
-{[outnum_{sos}]} \qquad
-\langle outnum, s_i, s_o, s\rangle \Rightarrow
+{[switch_{sos}]} \qquad
+\langle switch, s_i, s_o, s\rangle \Rightarrow
\langle s_i, s_o, s\rangle\\
$