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
|
% 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.
% Dit is waarschijnlijk te veel anders.
%
%\begin{exmp}
% Het volgende programma implementeert een simpel bestelsysteem:
% \begin{smurf}
% "ijs" "0" p \\
% "pizza" "1" p \\
% "Wil je ijs (0) of pizza (1)?\textbackslash{}n" o \\
% "Ik ga " i g + " voor je maken!" + o
% \end{smurf}
% We zetten de variabelen \verb$0$ en \verb$1$ tot \verb$ijs$ en \verb$pizza$.
% Vervolgens vragen we de gebruiker een keuze te maken. Met \smurfinline{ig}
% kan de gebruiker in feite kiezen welke variabele wordt opgehaald.
%
% De uitvoer kan er dus uitzien als:
% \begin{verbatim}
% Wil je ijs (0) of pizza (1)?
% 1
% Ik ga pizza voor je maken!
% \end{verbatim}
%\end{exmp}
\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 \verb$head$ en \verb$tail$ tot \verb$h$ en
\verb$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 `head' of `tail' in te
voeren en halen de bijbehorende functie op. Op dit moment kan de stack eruit
zien als \verb$h$, \verb$"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 `m', in dit geval.
Wat gebeurt er als de gebruiker iets anders dan `head' of `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 dus geen correcte keuze maakt, dan zal de hele string 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 \verb$s$ opgeslagen.
De derde regel zet een Smurfprogramma in \verb$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 \verb$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 \verb$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
\verb$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 \verb$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 `smurf' is dus:
\begin{verbatim}
smurf
murf
urf
rf
f
\end{verbatim}
\end{exmp}
|
