Hallo,
ich möchte eine Prozedur schreiben, bei der der Code zuerst generiert wird, weil der Code von vielen Bedingungen abhängig ist.

So dass man den auszuführenden Code in einen String packt und den String dann aufführt, wie ganz normalen Code!

Wie kann ich das einfach anstellen?

Mfg

JoKeR

Delphi ist kein Interpreter. Kuck mal bei Torry nach einer Script-Komponete oder bei den Jedis ist, glaube ich, auch was passendes dabei.

...das würden wir alle gerne machen können!

Im ernst: Das ist fast unmöglich...es sei denn du schreibst dir nen compiler, nur der kann wohl nix im laufenden programm anrichten. oder nimmst einen interpreter her, der aber langsam wäre und der auch nicht auf deine internen variablen zugreifen könnte...es sei denn es sind properties.

viel spass...lass es uns wissen, wenn du es geschafft hast

maximus hat folgendes geschrieben:

...und der auch nicht auf deine internen variablen zugreifen könnte...es sei denn es sind properties.

Ähm, was ist denn an Properties so anders? Solange er keinen Interpreter hat, kann er nichts machen. Wenn er einen hat (oder selber schreibt), kann er selbstverständlich sowohl auf Properties als auch auf interne Variablen zugreifen. Er muss halt nur entsprechende Schnittstellen im Interpreter definieren. Properties sind aber Schnittstellen des Compilers selber.

Cu,
Udontknow

@UDontKnow: Ich denke Mr. JokeR wollte den code für/im laufenden prog ausführen und da sind dann alle variablen nur noch adressen (keine namen mehr...denke das ist dir bekannt), nur properties könnte er mit RTTI verarbeiten. viel mehr dann aber auch nicht...oder hasst einen weg gefunden, ohne properties auf fields zuzugreifen?

Wer sagt denn, das er überhaupt objektorientiert programmiert?

Das sind zwei verschiedene Paar Schuhe. Ich habe eigentlich schon versucht, es zu erklären.

Nehmen wir mal an, das Programm erhält den String "ShowMessage(Str1)".
Solange er nicht in irgendeiner Weise diesen String auswertet, kann er damit nichts anfangen.

Ein simpler Anfang, um soetwas wie einen Interpreter aufzubauen, wäre nun:

Hierbei ist es egal, ob Str1 nun eine interne Variable ist oder ein Property, es muss eben nur die Schnittstelle des Interpreters dementsprechend aufgebaut werden.

Das ganze bezieht sich aber wie gesagt auf die Variablen des Programmes selber, welche ja von vornherein (Arrays und Listen lassen wir mal aussen vor) gegeben sind. Ein ordentlicher Interpreter sorgt natürlich auch noch für die Erzeugung von Variablen zur Laufzeit. Wenn man also die Anweisung "var x,y,z:Integer" übergibt, müsste das Programm sich die Namen und Typen dieser Variablen merken und Speicher für diese Variablen reservieren.

Cu,
Udontknow

Wir sollten uns deswegen nicht streiten...is ja auch wurst.

Sagen wir es so: Ohne weiteres kann man auf normale variablen nicht zugreifen, es sei denn man macht einen unterbau

hihi... Wie willst du ohne "Unterbau" auf properties zugreifen?

Nein, wir wissen, wie´s gemeint ist. Man könnte Code basteln, der zur Laufzeit nachguckt, welche Properties vorhanden sind. Aber: Das geht meines Wissens nach nur mit published Properties.

Cu,
Udontknow

Ist es nicht möglich einen Delphibefehl, genau wie einen Dosbefehl in Delphi auszuführen?

z.B

mache(format c

oder halt in delphi

mache( messagebox('Test') )

Schlicht und einfach: Ohne Interpreter lautet die Antwort "Nein".

Die DOS-Eingabeaufforderung bzw. das Programm "Format" interpretiert ja schliesslich auch. Es wird nachgeschaut welches Programm gestartet werden soll. Format interpretiert die Parameter, die übergeben wurden (wenn "C:" angegeben wurde, wird C: formatiert).

Cu,
Udontknow

hihi...

Udontknow hat folgendes geschrieben:

hihi... Wie willst du ohne "Unterbau" auf properties zugreifen? Nein, wir wissen, wie´s gemeint ist. Man könnte Code basteln, der zur Laufzeit nachguckt, welche Properties vorhanden sind. Aber: Das geht meines Wissens nach nur mit published Properties. Cu, Udontknow

..dafür muss ich nur die unit typInfo einbinden und fertig is der lack! Der unterbau ist ja schon in delphi drinn und nennt sich rtti Und ja...es geht nur mit published-props.

aber lassen wir das

Wäre schön, wenn es mit dem Einbinden einer Unit getan wäre. Fertig ist der Lack dann noch lange nicht. Du musst eben, wie oben schon angedeutet, die Schnittstelle zwischen Interpreter und Programm basteln.

BTW: In .NET lassen sich Objekte wirklich komplett ohne Beschränkungen zur Laufzeit analysieren. Felder, Methoden und deren Namen, deren Parameter und deren Namen. Das gefällt mir eigentlich ganz gut.

Cu,
Udontknow

Aber ich muss nicht explizite if-abfragen, ala 'if WertInKlammern='Str1'...', machen, wie du es vorgeschlagen hast, sondern kann ausdrücke, ala 'root.item[2].ding.text' relativ einfach auflösen(sofern mir 'root' bekannt ist). Habs selbst schon umgesetzt...behauptet ja auch niemand, dass das einfach ist...aber elegant Und code brauch man ja immer ..um was hinzukriegen.

fertig is der lack