rekursiver Funktionsaufruf verbraucht 1814 Bytes??

Wie wärs auf die Rekursion zu verzichten und das ganze in ne Schleife zu 
packen:

schleife
  werte befehl aus
solange nicht programmende:
  spring nach "schleife"

Meine Kristallkugel streikt neuerdings am Sonntag,
hat wohl die Zeitumstellung nicht vertragen.

Poste doch mal den Code, dann wird geholfen.

Rekursives Aufrufen von Funktionen verbrät (gerne)
Speicher, denn die Variablen des vorigen Aufrufe
sollte wohl erhalten bleiben, und wenn das viele sind.....

Schönen Sonntag noch!

Hallo,

> Ich möchte ein art Betriebssystem programmieren, das ein programm in
> extrem einfacher und selbst entwickelten sprache ausführt. Dazu habe ich
> eine Funktion geschrieben, die ein gigantisches switch (153 cases)
> enthält, ein case für jeden Programmbefehl (von meiner eigenen sprache).

Du willst also einen Interpreter für Deine Sprache bauen.

> Nun möchte ich die funktion am ende rekursiv aufrufen, sodass die
> Befehle nach einander abgearbeitet werden.

Das ist keine gute Idee. Du gehst also pro Instruktion Deines 
interpretierten Programms einen Schritt tiefer in Deiner 
Rekursionshierarchie? Das ist ein Riesenaufwand, ganz zu schweigen von 
dem unbegrenzten Wachstum des Stacks. Normalerweise wird ein (simpler) 
Interpreter mit einem großen Switch-Befehl in einer Schleife 
verwirklicht. In jeder Iteration holst Du Dir die nächste Instruktion, 
dekodierst sie und führst dann die jeweilige Aktion aus. Dann schaust Du 
wo es im Kontrollfluß weitergeht und gehst in die nächste Iteration.

> als ich das komplette switch programmiert hatte, war der programmcode
> 2996 bytes gross. Als ich dann die zeile, wo sich die Funktion selbst
> aufruft (mit 2 parametern) einfügte, war das programm plötzlich 4810
> bytes gross!!
> Wie kann das sein??

Naja, für Deine Rekursion muß schon ganz schön Aufwand getrieben werden, 
den Call Stack jedesmal zu sichern und den Kontext der aufrufenden 
Funktion bei der Rückkehr wiederherzustellen. Ich sehe aber wie oben 
geschrieben keinen Grund Deinen Interpreter rekursiv zu bauen. Im 
Gegenteil, vermeide dies auf jeden Fall!

Alles Gute,
Murkser

Hallo!
Danke für die Tipps!
Ich habe das ganze nun mal in eine endlos schleife gemacht. Wenn mein 
Programmteil fertig ist, gibt es einfach einen return.
Nur: die Codegrösse ist immer die gleiche, ob mit schleife (main) oder 
rekursion (main2).
Den Code habe ich angehängt.
Erdbewohner

Danke, Yalu!
Du hattes recht. Ich hab es mal ohne optimierung compiliert und da war 
der unterschied nicht mehr da.
Wenn das programm dann nicht 600 takte zusätzlich macht (den grössten 
teil des switch überspringt er ja (hoffentlich)) bin ich ja beruhigt ;-)
Danke nochmal!
Gruss Erdbewohner