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
|
% vim: set spelllang=nl:
\subsection{Voorbeelden}
\label{sec:intro:exmp}
Nu we alle commando's hebben gezien bekijken we nog een paar voorbeelden die
aangeven hoe conditionele executie kan worden behaald in Smurf.
\begin{exmp}
\label{exmp:headortail}
Dit programma laat de gebruiker kiezen welke functie er wordt uitgevoerd:
\begin{smurf}
"h""head"p "t""tail"p \\
"Voer een string in.\textbackslash{}n"o iq \\
"Wil je de head of de tail?\textbackslash{}n"o \\
ig +"o"+ x
\end{smurf}
Allereerst zetten we de variabelen \lit{head} en \lit{tail} tot \lit{h} en
\lit{t}, de commando's voor de head en tail van een string. We vragen de
gebruiker om een string en zetten die in quotes zodat ze gebruikt kan worden
in een Smurfprogramma. We vragen de gebruiker om \lit{head} of \lit{tail} in
te voeren en halen de bijbehorende functie op. Op dit moment kan de stack er
bijvoorbeeld uit zien als \lit{h}, \lit{"mijn string"} (bovenste element
eerst). Met \smurfinline{+"o"+} bouwen we hiervan het programma
\smurfinline{"mijn string"ho}, wat we met \smurfinline{x} uitvoeren. De
uitvoer van het programma is dus \lit{m}, in dit geval.
Wat gebeurt er als de gebruiker iets anders dan \lit{head} of \lit{tail}
invoert? In dit geval bestaat er geen variabele met de naam die de gebruiker
had ingevoerd. Het commando \smurfinline{g} levert dan de lege string op. Dit
betekent dat we het programma \smurfinline{"mijn string"o} bouwen. Als de
gebruiker geen correcte keuze maakt, dan zal de hele string dus worden
teruggegeven.
\end{exmp}
\begin{exmp}
Het volgende programma is een Smurf interpreter:
\begin{smurf}ix\end{smurf}
We halen input op van de gebruiker en voeren dit uit als Smurfprogramma.
\end{exmp}
Ten slotte geven we nog een wat groter voorbeeld waar recursie wordt
voorgedaan:
\begin{exmp}
Dit programma geeft als output de input, de tail van de input, de tail van de
tail van de input, etc., tot en met de lege string.
\begin{smurf}
\footnotesize
i "s"p \\
"s"g"\textbackslash{}n"+o \\
"t\textbackslash{}"s\textbackslash{}"p\textbackslash{}"s\textbackslash{}"g\textbackslash{}"\textbackslash{}\textbackslash{}n\textbackslash{}"+o\textbackslash{}"c\textbackslash{}"p\textbackslash{}"c\textbackslash{}"gq\textbackslash{}"s\textbackslash{}"gq\textbackslash{}"c\textbackslash{}"g++q\textbackslash{}"x\textbackslash{}"+\textbackslash{}"s\textbackslash{}"gp\textbackslash{}"\textbackslash{}"\textbackslash{}"\textbackslash{}"p\textbackslash{}"s\textbackslash{}"ggx" "c"p \\
"c"gq "s"gq "c"g++ \\
x
\end{smurf}
Met de eerste twee regels halen we input op en sturen die naar de output. Ook
wordt de input in een variabele \lit{s} opgeslagen. De derde regel zet een
Smurfprogramma in \lit{c}. In de vierde regel plakken we dat gequotifiede
programma, de gequotifiede input en het programma aan elkaar vast. Het
resultaat voeren we uit.
Op dit moment voeren we dus het programma uit dat bestaat uit twee keer een
string pushen en vervolgens het programma uit \lit{c}. Dan bekijken we nu dit
programma, wat we in de derde regel hierboven hebben gedefinieerd, in een
iets makkelijkere opmaak:
\begin{smurf}
t "s"p "s"g "\textbackslash{}n"+o \\
"c"p \\
"c"gq "s"gq "c"g++ \\
q"x"+ "s"gp \\
""""p \\
"s"ggx
\end{smurf}
Met de eerste regel slaan we de tail van de oude input op in \lit{s}. We
sturen deze tail ook naar de output. Hierna staat alleen nog de eerste string
op de stack, d.w.z. het programma waar we naar kijken. Dit slaan we op in
\lit{c}. De derde regel hier is hetzelfde als de vierde regel hierboven: we
maken een nieuw programma, wat er precies hetzelfde uitziet als dit, behalve
dat we van de tweede string één karakter hebben weggehaald.
Het is verleidelijk op dit moment weer \smurfinline{x} te gebruiken. We
moeten echter eerst nog controleren of we niet met de lege string te maken
hebben. Het is namelijk niet mogelijk om x uit te voeren als de stack leeg
is. We maken dus van het nieuwe programma wederom een nieuw programma, wat
bestaat uit het pushen van het oude programma en vervolgens \smurfinline{x}
aanroepen. Dit programma slaan we op in de variabele met als naam de waarde
van \lit{s} (de input).
Mocht deze input de lege string zijn, dan overschrijft de vijfde regel dit
programma met een leeg programma. Vervolgens halen we in de zesde regel het
programma (of het lege programma, in het geval van de lege string) op, en
voeren dit uit. Door deze laatste paar regels zullen we dus niet
\smurfinline{t} uitvoeren op de lege string.
\medskip
De uitvoer van dit programma met de input \lit{smurf} is dus:
\begin{verbatim}
smurf
murf
urf
rf
f
\end{verbatim}
\end{exmp}
|
