ich baue zur Zeit einen C-Interpreter (wie es dazu gekommen ist, kann hier noch mal nachgelesen werden: http://www.c-plusplus.net/forum/280390).

Mittlerweile geht es richtig gut voran, lexikalisch als auch syntaktisch. Im Moment denke ich schon mal etwas vor und mache mir Gedanken übers eigentliche interpretieren. Meine "Zwischensprache" die ich interpretiere wird der vom Parser erzeugte Syntaxbaum sein. So weit, so gut. Grundsätzlich ist es ja so, dass ein Interpreter nur vorliegenden Source-Code interpretieren kann. Ich möchte jedoch eine Anbindung zu kompilierten Code herstellen. Dieser Code muss zwangsweise als .dll bzw. .so vorliegen, da es nicht anders möglich ist, Code zur Laufzeit zu laden. So weit ich bisher gedacht habe, sollte das auch problemlos funktionieren ... bis auf eine Kleinigkeit (mehr oder weniger klein).

Folgendes Szenario mal als Beispiel:

Der Programmierer erstellt eine Funktion. An späterer Stelle wird eine DLL-Funktion aufgerufen und die Adresse der vorher erstellten Funktion übergeben (Funktionszeiger). Die DLL-Funktion soll die andere Funktion über den Zeiger aufrufen können.

Wie könnte das mit den Adressen gelöst werden? Schließlich existiert die Funktion nur in einer von mir definierten Struktur (Syntaxbaum), und nicht als kompilierter Code (somit auch ohne Adresse). Ich bräuchte also etwas, was mir Adressen generiert, mapped oder managed (oder irgendwie sowas) und auf Aufrufe bzw. Zugriffe reagiert ... und das nicht nur auf abstrakter Ebene, sondern auch wenn kompilierter Code tatsächlich die Adresse (wie im obigen Beispiel) aufruft.

Ich dachte mir, dass ein Betriebssystem praktisch auch nichts anderes mit physikalischen Speicher macht. Jedoch weiß ich im Moment hinten und vorne nicht ob das funktionieren kann, und wenn ja, wie.

Hat jemand eine Idee?

Viele Grüße

du darfst dann der externen Funktion nicht direkt die Adresse übergeben, sondern übergibst ihr die Adresse einer eigenen Funktion, welche dann die Abarbeitung durchführt.
Du müßtest dann natürlich die Adresse deiner Struktur (im Syntaxbaum) noch irgendwie global speichern, damit du dann in der Funktion darauf zugreifen kannst. Probleme entstehen dann natürlich sobald du mehrere Callback-Adressen an die externen DLLs übergibst.
Evtl. ein Array für die Funktionszeiger anlegen und dann eine feste Anzahl von eigenen Funktionen erstellen, welche dann entsprechend auf einen unterschiedlichen Index des Arrays zugreifen:

typedef void (*Func_array)();
Func_Array func_array[MAX];

int func_array_index = 0; // aktueller (freier) Index (zum Eintragen in das Array)

void Func1(...)
{
  // Zugriff auf Array-Index 1
}

void Func2(...)
{
  // Zugriff auf Array-Index 2
}

...

So und nun kommt das eigentliche Problem: die Signatur der Funktion, d.h. die Parameter und der Rückgabewert!
Du müßtest dann (wahrscheinlich direkt mit Assembler) die Funktionsparameter von dem Stack auslesen und für den Rückgabewert den passenden Wert zurückgeben.

Alles in allem kaum praktikabel durchführbar (außer du beschränkst dich auf bestimmte Signaturen).

Mit "virtual address space" hat dein Problem aber nichts zu tun, denn du willst ja den Code interpretieren und nicht einfach nur eine andere Adresse übergeben.