blob: 763a046a8ddc350d778ae7a8418a1147d4bc2b35 (
plain) (
blame)
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
|
% vim: set spelllang=nl:
\subsubsection{Het buitenste programma}
Het buitenste programma controleert of we te maken hebben met de lege string
als inputstring. Als dit het geval is geeft het de lege string als output.
Anders wordt het recursieve subprogramma gebruikt, dat alleen voor strings van
lengtes groter dan nul gedefinieerd is.
Omdat Smurf geen conditionals kent, moeten we hier op een slimme manier omgaan
met het feit dat waarden ook als variabelenaam kunnen worden gebruikt. Dit is
vergelijkbaar met \autoref{exmp:headortail}. Eerst schrijven we het recursieve
programma dat we moeten aanroepen als de inputstring niet leeg is naar de
variabele met als naam de inputstring zelf. Hierna schrijven we het programma
dat moet worden uitgevoerd als de string leeg is (het outputten van de lege
string) naar de variabele met als naam de lege string. Als de inputstring leeg
is overschrijven we daar dus het recursieve programma dat we eerst aan die
variabele hadden toegewezen. Als laatste voeren we het programma uit dat op de
variabele met naam de inputstring staat.
Het buitenste programma ziet er als volgt uit:
\begin{center}
\makebox{
\parbox{45mm}{
\begin{smurf}
\footnotesize
i "input" p\\
"input" g\\
"input" g q\\
"\textbackslash{}"\textbackslash{}""\emph{subprogramma-string}\\
+\\
"input" g p\\
"\textbackslash{}"\textbackslash{}"o" "" p\\
g x
\end{smurf}
}
\parbox{8mm}{
\begin{smurf}
\footnotesize
(1)\\
(2)\\
(3)\\
~\\
~\\
(4)\\
(5)\\
(6)
\end{smurf}
}}
\end{center}
\begin{enumerate}
\item Allereerst wordt de inputstring op de stack gezet en naar de variabele
met naam \smurfinline{input} geschreven. De stack is nu weer leeg.
\item We zetten de inputwaarde weer op de stack voor later gebruik. Waarom
dit nodig is wordt uitgelegd in punt 4.
\item Hierna halen we deze inputwaarde voor de tweede keer op, quotifyen we
hem en voegen we het toe aan het begin van de subprogramma-string. Dit is
vergelijkbaar met het doorgeven van een functieargument. De reden dat we de
input quotifyen is dat dit ervoor zorgt dat alle karakters in de input
behouden blijven (ook die met speciale betekenis zoals
\lit{\textbackslash{}}) wanneer het subprogramma wordt uitgevoerd. Het
subprogramma staat zelf al gequotifyed hier. Op dit moment staat het grote
programma met de input eraan voorgevoegd op de stack, met als element
eronder de inputwaarde die we zo nodig hebben.
\item Nu halen we opnieuw de waarde van de input op uit de variabele waarnaar
we het eerst hadden weggeschreven en gebruiken we dit als een variabelenaam
om het subprogramma naar weg te schrijven. Merk op dat we onze opslag van
de inputstring verliezen als die toevallig de waarde \smurfinline{input}
had, omdat we die variabele dan overschrijven. Dit is waarom we deze waarde
van tevoren een keer extra op de stack hebben gezet. Zo kunnen we hem bij
(6) nog gebruiken.
\item Nu zetten we het gequotifyde programma "output de lege string" in de
variabele $\lambda$. Ongequotifyed ziet het uit als \smurfinline{""o}.
\item Als laatste halen we het programma op van de variabele met als naam de
inputstring die we in (2) op de stack hadden gezet en voeren we dit
programma uit.
\end{enumerate}
|
