Prozeduren und Funktionen
-------------------------

Prozeduren und Funktionen sind Unterprogramme, die sich
darin unterscheiden, dass Funktionen einen Wert zurueckgeben.
In beiden koennen eigene Konstanten und Variablen definiert
werden, die dann nur innerhalb der Prozedur bzw. Funktion
gelten. Prozeduren und Funktionen koennen wiederum eigene
Unterprozeduren bzw. -funktionen besitzen. Ausserdem koennen
Prozeduren und Funktionen sich selbst aufrufen (Rekursion).

Als Parameter akzeptiert G-Pascal nur Integerwerte. Es
entfaellt die sonst in Pascal uebliche Typenangabe bei den
Parametern.

Das folgende Programm errechnet fuer einen gewuenschten
Bereich an Ganzzahlen (hier 1 bis 10) die Quardratwerte
dieser Zahlen:

procedure berechnequadrat(von, bis);
  var
    zahl: integer;
  
  function quadrat(x);
     begin
       quadrat := x * x;
     end;
  
  begin
     for zahl := von to bis do
       writeln(zahl, " * ", zahl, " = ", quadrat(zahl));
  end;
  
begin
  berechnequadrat(1, 10);
end.

Array als Parameter

Wenn man ein ARRAY als Parameter uebergeben moechte, muss man
einen Umweg gehen, da G-Pascal nur Integerwerte als
Parameter akzeptiert. Statt des ARRAYs selbst wird nur die
Adresse des ersten Elements mit dem Schluesselwort ADDRESS
uebergeben und die Prozedure greift ueber das ARRAY MEMC
direkt auf den Speicher zu. De facto wird also ein Zeiger
auf das ARRAY uebergeben. Eine Besonderheit von G-Pascal ist,
dass ARRAYs in umgekehrte Reihenfolge im Speicher abgelegt
werden, also das letzte Element zuerst und das erste Element
am Schluss.

Zur Veranschaulichung hier ein Beispiel, in dem das Alphabet
in einem ARRAY als Zeichenkette abgelegt und mittels der
Prozedure strout ausgegeben wird. Im ersten Element des
Arrays (Index 0) ist die Laenge der Zeichenkette gespeichert.

const
  max = 26;
var
  s: array [max] of char ;
  i: integer ;

procedure strout(adr);
  var i: integer ;
  begin
    if memc [adr] > 0 then
      for i := 1 to memc [adr] do
        write (chr (memc [adr - i]));
    end ;

begin
  for i:= 1 to max do
    s[i] := i + 64;
  s[0] := max;
  strout(address (s[0])); writeln ;
end .

In anderen Pascal-Versionen, die den Type-Ausdruck
unterstuetzen, wuerde der Prozedure das Array direkt als
Paremeter uebergeben werden:

const
  max = 26;
type
  str = array[0..max] of char;
var
  s: str ;
  i: integer ;

procedure strout(s: str);
  var i: integer ;
  begin
    if s[0] > 0 then
      for i := 1 to s[0] do
        write (s[i]);
    end ;

begin
  for i:= 1 to max do
    s[i] := i + 64;
  s[0] := max;
  strout(s); writeln ;
end .