Eine Prozedur ist ein Unterprogramm mit lokalem Speicher und mit optionalen Parametern. Sollen Variablen und/oder Werte im Unterprogramm verarbeitet werden, können sie dem Unterprogramm beim Aufruf übergeben werden. Alternativ kann man globale Variablen des Hauptprogramms/der übergeordneten Klasse verwenden.

Siehe auch: Was ist ein Unterprogramm?

Es können benötigte Variablen innerhalb eines Unterprogramms lokal deklariert werden, die dann nur solange existieren bis die Methode verlassen wurde. Beim Aufruf ist zu beachten, dass durch die Übergabe der Parameter zusätzlicher Speicher benötigt wird, bis das Unterprogramm abgearbeitet ist. Ohne Parameter und lokale Variablen ist das nur die Rücksprungadresse (2 bytes).

Siehe auch: Dim, Abschnitt Sichtbarkeit von Variablen und Schlüsselwort „static“

Ist der übergebene Datentyp ungleich dem des Parameters im Unterprogramm, findet bei numerischen Datentypen eine automatische Typumwandlung statt. D.h. übergibt man eine Variable des Typs „word“ als Parameter und ist der Parameter als „byte“ deklariert, wird der Wert der „word“-Variable vor der Übergabe in einen Byte-Wert gewandelt.

Parameter können als Kopie oder Referenz¹⁾ dem Unterprogramm übergeben werden. Die Parameterübergabe erfolgt über den normalen Programm-Stack (siehe avr.Stack).

Als Übergabeparameter per Kopie (byVal) sind erlaubt:

• Konstanten
• Variablen (außer Strukturen und komplette Arrays)
• Ausdrücke
• Objekteigenschaften und -Methoden mit Rückgabewert
• Methoden mit Rückgabewert

Als Übergabeparameter per Referenz (byRef) sind erlaubt:

• Konstanten-Zeichenketten
• Konstanten-Objekt "data"
• Arbeitsspeicher-Objekte "sram" (Variablen, Arrays, Strukturen, ..)
• Variablen inkl. Strukturen

Das Schlüsselwort „byVal“ muss nicht zwingend angegeben werden. Vorgabe ist die Übergabe per Kopie.

InitialValue ist eine Funktionalität, mit der man Parametern optional einen Startwert zuweisen kann:

procedure test(a as byte, b as word = 456)
endproc
procedure test1(a as byte = 123, b as word)
endproc

Der Aufruf kann dann durch den dann optionalen Parameter verschieden erfolgen, wobei der dann weggelassene Parameter beim Aufruf durch InitialValue automatisch ersetzt wird:

test(123,333)
test(100) 'der optionale zweite Parameter erhält den Initialwert
test1(,444) 'der erste Parameter erhält den Initialwert

Methoden-Überladen ist eine Funktionalität, bei der mehrere Methoden gleichen Namens mit verschiedenen Parametertypen und -Anzahl bzw. Rückgabewert definiert werden kann. Der Aufruf wird dann durch die Art- Anzahl und Typ der Parameter bestimmt.

test(123)     'methode #1 wird aufgerufen
test(123,456) 'methode #2 wird aufgerufen
a = test(123) 'methode #3 wird aufgerufen
 
'methode #1
procedure test(a as word)
endproc
'methode #2
procedure test(a as byte, b as word)
endproc
'methode #3
function test(a as byte) as byte
endfunc

Mit dem Schlüsselwort assigns beim letzten Parameter einer Methode legt man fest, dass der Methode (Procedure) im Quelltext ein Wert zugewiesen werden kann.

test(100) = 200
 
'[...]
procedure test(a as byte, assigns b as word)
  print "parameter  = ";str(a)
  print "assignment = ";str(b)
endproc

Das optionale Schlüsselwort inline führt zur Verwendung als Inline-Methode.

Siehe hierzu: http://de.wikipedia.org/wiki/Inline-Ersetzung

In Methoden hat man Zugriff auf globale Variablen der übergeordneten Klasse. Eine im Hauptprogramm deklarierte Variable „a“ kann also in einer Prozedure/Funktion verwendet werden. Deklariert man jedoch in einer Prozedure/Funktion eine gleichnamige Variable oder definiert sie als Parameter, wird Diese bevorzugt behandelt.

Methoden sind in Luna eintrittsinvariant (reentrant), können also verschachtelt oder rekursiv verwendet, oder in ein- oder mehreren Interrupts bzw. im Hauptprogramm aufgerufen werden.

Syntax:

• [inline] Procedure Name( [ byVal/byRef ] [Var as Datatype[, [ byVal/byRef ] VarN as Datatype]])
  • Programmcode
  • [ Return ]
  • Programmcode
• EndProc

• Name: Bezeichner des Unterprogramms
• Var: Bezeichner der Parameter-Variable

' Hauptprogramm
dim wert as integer
dim s as string
 
ausgabe("Meine Zahl: ",33) ' Aufruf des Unterprogramms
' Weitere Aufrufmöglichkeit
wert = 12345
s = "Andere Zahl: "
call ausgabe(s,wert)
 
do
loop
 
' Unterprogramm
procedure ausgabe(text as string, a as byte)
  dim x as integer  ' lokal gültige Variable
  x=a*100
  print text+str(x)
endproc

struct point
  byte x
  byte y
endstruct
 
dim p as point
 
p.x=23
test(p)
print "p.x = ";str(p.x)   ' Ausgabe: p.x = 42
 
do
loop
 
procedure test(byRef c as point)
  print "c.x = ";str(c.x)  ' Ausgabe: c.x = 23
  c.x = 42
endproc

Beispiel 3:

test(text)      ' Ausgabe: c.PString(0) = "hallo"
test("ballo")   ' Ausgabe: c.PString(0) = "ballo"
 
do
loop
 
procedure test(byRef c as data)
  print "c.PString(0) = ";34;c.PString(0);34
endproc
 
data text
  .db 5,"hallo"
enddata