Einer Funktion einen Parameter zu uebergeben ist mit Hilfe des Registers HR kein Problem. Zur Not gingen auch zwei Parameter mit Hilfe von NR. Fuer mehr als zwei Werte ist dieses Verfahren nicht zu gebrauchen.
Eine Funktion namens fuellen soll einen Speicherbereich mit einem Wert fuellen. Wir haetten zu uebergeben die Anfangsadresse des Speicherbereiches, den Wert und die Anzahl der Bytes. Dies kann folgendermassen geschehen:
( screen , 'a' , 1000 fuellen )
Die Uebergabe kann ganz ohne globale Variablen erfolgen. Der Kommabefehl legt einen Wert in HR auf dem bereits bekannten Stapel ab. Eine oeffnende Klammer bewirkt etwas zusaetzliches, das bisher noch nicht besprochen wurde. Sie sichert den Stand des Parameterstapels auf dem Returnstapel. Eine schliessende Klammer berichtigt mit Hilfe des gesicherten Stapelstandes den Parameterstapel wieder. Wir duerfen daher innerhalb von Klammern einfach Werte auf den Parameterstapel befoerdern, auf welche dann eine Funktion (fuellen) zugreifen kann. Dies geschieht mit Hilfe von Parametervariablen:
void fuellen( adr zeichen )
begin
int anzahl ;
go prf
: wr zeichen ] adr ]++ by =
: prf anzahl ]-- if wr
bend
Dynamische Variablen sind Variablen, die sich auf dem Parameterstapel befinden. Funktionen, die solche Variablen benuetzen, muessen immer, auch wenn beim Aufruf keine Wertuebergabe stattfindet, innerhalb von Klammern aufgerufen werden. In der Klammer der Funktionsvereinbarung sind fuer die uebergebenen Werte Variablennamen anzugeben. Die Anzahl dieser Namen muss mit der Anzahl der Werte uebereinstimmen, sofern noch weitere dynamische Variablen innerhalb der Funktion definiert werden sollen. Im Beispiel wurden nur adr und zeichen als Parametervariablen angegeben, denn der letzte Wert anzahl wurde lediglich durch HR uebergeben. Diesen Wert haben wir zur Abwechslung in einer dynamischen Variablen abgelegt. Dynamische Variablen werden nach begin im Codebereich vereinbart. Die Vereinbarung ist mit Hilfe von int und char, fast genauso wie bei statischen Variablen moeglich. Kommas und Strichpunkte, die die Namen trennen beziehungsweise die Vereinbarung abschliessen, werden als Befehl, den Inhalt von HR auf den Stapel zu legen uebersetzt. Es kann daher bei der Definition bereits eine Zuweisung vorgenommen werden:
int a 5 3 + ;
Sogar Arithmetische Ausdruecke sind moeglich. Diese Ausdruecke duerfen aber keine Kommas oder Strichpunkte enthalten.
Verboten ist:
int a ( 5 , 3 exp ) ;
Moeglich dagegen:
( 5 , 3 exp ) int a ;
Eine wiederholte Vereinbarung in einer Programmschleife gilt es zu vermeiden. Also bitte nicht:
: lab int a ;
getc nif lab
Moeglich waere bei unserer Funktion fuellen auch gewesen:
void fuellen( adr zeichen anzahl )
begin ,
Hier stimmt die Anzahl der Variablen nicht mit den Werten auf dem Stapel ueberein, jedoch ein Komma nach begin legt den Wert nachtraeglich auf dem Stapel in anzahl ab. Der Vereinbarung weiterer dynamischer Variablen steht nichts mehr im Wege. Dynamische Variablen werden bei jedem Funktionsaufruf neu angelegt und behalten daher ihre Werte nicht bei, wie dieses bei statischen Variablen der Fall ist.
Es ist auch moeglich, eine unbestimmte Anzahl von Parametern zu uebergeben. Nur duerfen dann keine weiteren dynamischen Variablen innerhalb der Funktion mehr vereinbart werden, da der Compiler wegen Nichtkenntnis der Parameterzahl nicht deren Positionierung bestimmen kann. Aber fuer diesen Fall gibt es ja auch noch die statischen Variablen.
Ein Beispiel hierzu ist die Anweisung print, die im Unterschied zu putl mehrere Strings auszugeben vermag:
a$ putl b$ putl c$ putl
( a$ , b$ , c$ print )
Wir vereinbaren:
void print( liste )
int zg ;
begin , 0 ,
liste zg = ]
: lab putl 2 zg += ] if lab
bend
Nur fuer den ersten Wert wird eine Variable namens liste vereinbart. Nach begin wird der letzte Wert auf den Stapel gebracht und zusaetzlich eine Null, die das Ende der Liste markiert. Nach der Zuweisung liste zg = zeigt zg auf den Parameterstapel, wo sich die Variable liste befindet. Deren Inhalt ist die Adresse des ersten Strings. Die Ausgabe kann erfolgen. Nach Erhoehung des Zeigers zg um den Wert zwei wird auf die weiteren Parameter zugegriffen, bis die Nullmarkierung erreicht wird.
Programmbeispiel:
*/
def cls 147 putc;
def ]]++ ]++ by ];
void putc( )
begin
ac by = 0xffd2 sys
bend
void putl( )
int zg ;
begin
zg = go rd
: wr putc
: rd zg ]]++ if wr
bend
char getc( )
begin
0xffe4 sys ac by ]
bend
char key( )
begin
: next getc nif next
bend
void fuellen( adr zeichen anzahl )
begin ,
zeichen ] go prf
: wr swap adr ]++ by =
: prf anzahl ]-- if wr
bend
void print( liste )
int zg ;
begin , 0 ,
liste zg = ]
: lab putl 2 zg += ] if lab
bend
main()
char
fu "( 1024 , 'a' , 1000 fuellen )"
, taste " Weiter mit Taste "
, fi "( 1024 , 'b' , 1000 fill )" ;
begin
( "/147Die Funktion " , fu , " fuellt den ganzen Bildschirm./n/n/n" , taste print )
key ( 1024 , 'a' , 1000 fuellen )
( "/19" , taste print ) key
( "/147Die bereits in CP enthaltene Funktion/n" , fi , " ist/nwesentlich schneller./n/n/n" , taste print )
