\begin{slide}{Parameter-Übergabe (Semantik)}

Datenaustausch zw. Aufrufer (caller) 
und Aufgerufenem (callee):
über globalen Speicher 
\begin{verbatim}
#include <errno.h>
extern int errno;
\end{verbatim}
oder über Parameter.

Datentransport (entspr. Schüsselwörtern in Ada)
\begin{itemize}
\item in: (Argumente) vom Aufrufer zum Aufgerufenen
\item out: (Resultate) vom Aufgerufenen zum Aufrufer
\item in out: in beide Richtungen
\end{itemize}

\end{slide}

\begin{slide}{Parameter-Übergabe (Implementierungen)}

\begin{itemize} 
\item
  pass-by-value (Wert)
\item
  copy in/copy out (Wert)
\item
  pass-by-reference (Verweis)
\item
  pass-by-name (textuelle Substitution)

  selten \dots Algol68, CPP-Macros \dots Vorsicht!
\end{itemize}

\end{slide}

\begin{slide}{Parameterübergabe}
häufig benutzte Implementierungen:
\begin{itemize}\itemsep 2pt
\item
  Pascal: by-value (default) oder by-reference (VAR)
\item
  C: by-value (Verweise ggf. selbst herstellen)
\item 
  C++ unterscheidet zwischen Zeigern (*, wie in C)
  und Referenzen (\&, verweisen immer auf die gleiche Stelle,
  werden automatisch dereferenziert)
\item
  Java: primitive Typen 
  \emph{und} Referenz-Typen ($=$ Verweise auf Objekte) by-value
\item
  C\#: primitive Typen und struct by-value, 
  Objekte by-reference, Schlüsselwort \verb|ref|
\item 
  Scala: by-value oder by-name 
\end{itemize}

\end{slide}

\begin{slide}{Call-by-name}

äquivalent zu textueller Ersetzung

Algol(68): Jensen's device

\begin{verbatim}
sum (int i, int n; int f) { 
  int s = 0;
  for (i=0; i<n; i++) { s += f; }
  return s;
}
int [10] a; int i; sum (i, 10, a[i]);
\end{verbatim}

\end{slide}

\begin{slide}{Call-by-name (Macros)}

\begin{verbatim}
#define thrice(x) 3*x // gefährlich
thrice (4+y)  ==>  3*4+y
\end{verbatim}
  
``the need for a preprocessor shows
omissions in the language''
  \begin{itemize}\itemsep 1pt
  \item fehlendes Modulsystem (Header-Includes)
  \item fehlende generische Polymorphie

    ($\Rightarrow$ Templates in C+)
  \end{itemize}

weitere Argumente:
\begin{itemize}
\item mangelndes Vertrauen in optimierende Compiler
    (inlining)
  \item bedingte Übersetzung
  \end{itemize}

\end{slide}

\begin{slide}{Call-by-name in Scala}
(für Parameter mit \verb|=>|)
\begin{verbatim}
object Up {
    def If[T] (b : Boolean, yeah : => T, noh : => T) : T = {
        if (b) yeah else noh
    }  
    def main(args: Array[String]) {
        var x : Int = 0; var y : Int = 0
        If (false, x = 1, y = 2)
        println (x, y)
    } }
\end{verbatim}
Man benötigt call-by-name zur Definition 
von Abstraktionen über den Programmablauf.

Übung: \verb|While| als Scala-Unterprogramm
\end{slide}


\begin{slide}{Bedarfsauswertung}
  \begin{itemize} \itemsep 2pt
  \item andere Namen: (call-by-need, lazy evaluation)
\item Definition: das Argument wird bei seiner ersten Benutzung
ausgewertet 
\item 
wenn es nicht benutzt wird, dann nicht ausgewertet;

wenn mehrfach benutzt, dann nur einmal ausgewertet

\item
  das ist der Standard-Auswertungsmodus in Haskell:

  alle Funktionen und Konstruktoren sind \emph{lazy}

  da es keine Nebenwirkungen gibt,
  bemerkt man das zunächst nicht \dots

  \dots und kann es ausnutzen beim Rechnen 
  mit unendlichen Datenstrukturen (Streams)

  \end{itemize}


\end{slide}

\begin{slide}{Beispiele f. Bedarfsauswertung}

  \begin{itemize}
\item
\begin{verbatim}
[ error "foo" , 42 ] !! 0 
[ error "foo" , 42 ] !! 1 
length [ error "foo" , 42 ]
let xs = "bar" : xs
take 5 xs
\end{verbatim}

  \item Fibonacci-Folge
\begin{verbatim}
fib :: [ Integer ]
fib = 0 : 1 : zipWith (+) fib ( tail fib )
\end{verbatim}
  \item Primzahlen (Sieb des Eratosthenes)
  \item Papier-Falt-Folge
\begin{verbatim}
let merge (x:xs) ys = x : merge ys xs
let updown = 0 : 1 : updown
let paper = merge updown paper
take 15 paper
\end{verbatim}
vgl. \url{http://mathworld.wolfram.com/DragonCurve.html}
  \end{itemize}

\end{slide}

%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "compilerbau"
%%% End: 
