Sysygy Script Engine - Version 0.99h

[littleDave]

Zitat von Geri:

Die Script engine ist für mich immer noch interessant. Du schreibst aber, dass du an einer Neuen Scriptengine dran bist. Hast du schon einen Zeitpunkt für das erste Release und macht es dann besser wenn man auf diese neue Engine wartet?

Zitat von mkinzler:

Bzw wie kompatibel wird die neue zu der (schon hervorragenden) "alten" Engine sein?

Also die neue Script-Engine kommt ganz gut vorran - im Momemt bin ich bei der Implementierung von arrays und records. Danach stehen Klassen auf der ToDo-Liste.

Generell wird die Script-Engine nicht sehr kompatibel zu der alten sein. Die Virtual Machine ist komplett neu geschrieben und ist somit nicht von den Daten kompatibel. Jedoch wird die Syntax ebenfalls wieder Pascal sein, somit ist die Sprache an sich sehr kompatibel. Jedoch hab ich die Syntax auch schon erweitert und die Funktionen werden in virtuellen statischen Klassen in der Script-Engine zusammengefasst.

Hier mal ein Beispiel

Delphi-Quellcode:

//alte Script-Sprache
var i: integer;
begin
  i := StrToInt('123');
  WriteLn(IntToStr(i));
end;

// Neue Script-Sprache
var i: integer;
begin
  i := Convert.StrToInt('123');
  Console.WriteLine(Convert.IntToStr(i)); // Entweder so
  Console.WriteLine(i); // oder so - overloaded Methoden werden unterstützt
end;

Jedoch wird man Projekte an die neue Script-Engine etwas anpassen müssen. Die grundlegenden Funktionen bleiben in etwa gleich, jedoch mit etwas anderen Parametern:

Delphi-Quellcode:

var PE: TSE2RunTime;
begin
  PE := Compiler.Compile('program Test; begin end.');
  try
    if PE <> nil then // korrekt kompiliert
    begin
      // z.B.
      PE.SaveToFile('Compiled.dat');

      PE.Initialize; 
      PE.Run;
      PE.Finalize;
    end; 
  finally
    PE.Free;
  end;

  // Oder so
  PE := TSE2RunTime.Create;
  try
    PE.LoadFromFile('Compiled.dat');
    PE.Initialize;
    PE.Run;
    PE.Finalize;
  finally
    PE.Free;
  end;
end;

Wann der erste Release sein wird, kann ich noch nicht sagen - aber ich beeil mich

[mkinzler]

Meine Frage zielte auch eher auf die Anwendung. Das sich intern viel geänder hat, habe ich erwartet.

[Namenloser]

Zitat von igel457:

Hallo little Dave,

ich verfolge deine Scriptengine nun schon seit einer Weile gespannt. Das Projekt hört sich auf jeden Fall hochinteressant an. Vielleicht kann ich die Script Engine ja in Andorra 2D integrieren um so die GUI, Gameplay usw. steuern zu können.

Weiter so,
Andreas

Das wäre genial für gescriptete Gegner!

[Florian Hämmerle]

Wird es die Scriptengine auch wieder als OpenSource geben?

mfg Florian

[EugenB]

Gibt es welche Updates?

Oder Testversionen?

Es warten wohl viele auf diese Script-Engine =)

MfG,
Eugen

[littleDave]

Sorry das ich mich in letzter Zeit (bzw. in den letzten 6 Monaten) nicht mehr so oft melde. Das kommt halt davon wenn man nicht mehr Student sondern Azubi ist.

Also ich arbeite immer noch an der Script-Sprache. Jedoch hat sich bei mir ein heftiger Design-Fehler eingeschlichen, der mich dazu zwang, relativ viel neu zu schreiben. Jedoch bin ich langsam wieder auf nem grünen Ast.

Ich kann bereits externe Klassen in die Script-Engine einbinden, externe Objekte erstellen, Funktionen aufrufen und Properties abfragen und setzen. Es ist also schon sehr viel erledigt. Zudem kann ich auch einzelne Script-Funktionen aus dem Programm heraus aufrufen.
Jetzt werd ich mal schauen, dass ich die Classes-Unit einbaue. Dann hat man schonmal nen guten Grundstock. Was jedoch noch nicht funktioniert sind arrays und records. Jedoch denke ich, dass ich es diesmal besser umsetzen werden.

Eine Testversion würd ich ja schon gerne mal hochladen, jedoch bin ich mir nicht mehr so ganz sicher, ob das wirklich gut ist. Nach dem letzten großen Design-Fehler bin ich mir nicht mehr sicher, wieviel sich an den Aufrufen noch ändern wird.

Es gibt noch viel zu tun, jedoch versuch ich in den nächten 2 Monaten was ordendliches fertig zu stellen. Für garantieren kann ich leider nichts.

[EugenB]

GuuuuuT,

weiter so =)

Also nicht mehr lange und die ScriptEngine unterstützt Classes? also OOP?

MfG,
Eugen

[littleDave]

Naja, so weit bin ich dann noch nicht.

Also ich hab die Script-Engine so aufgebaut, dass ich sie möglichst einfach erweitern kann. Alle wichtigen Eigenschaften wie virtual, overload, override, usw. sind schon als reservierte Worte drinnen und werden auch schon ein wenig benutzt. Jedoch kann man noch keine eigenen Klassen erstellen.

Aber ich will das irgendwie hinbekommen

[skydiablo]

moin !

bin eben per zufall hier im thread gelandet und wollte es ja nicht glauben ! das beschriebene hier ist die lösung meines prob ! ich habe ein recht großes projekt in delphi mit TjvInterpreter geschrieben... nun wollte ich das ganze ding neu coden, diesmal aber für linux und dafür fpc nutzen. wie sicherlich bekannt ist tjvinterpreter nicht fpc tauglich und so setze ich jetzt mal alles auf dieses pferd hier ! das ist echt klasse und ich freue mich schon auf deine umsetzung...

hast ein weiteren fan der sein nächstes projekt mit deinem code schmücken möchte

greez, sky...

EDIT: so, habe nun doch noch etwas weiter im netz nach scripting möglichkeiten gesucht. nun brauch ich eine doch recht objektive meinung deines interpeter: kannst du dich mit dem RemObjects Pascal Script in functionsumfang, geschwindigkeit und stabilität messen ?

greez & thx, sky...

[littleDave]

Hallo,

ich meld mich mal wieder *g*. In meinem letzten Post (der ja doch schon 2,5 Monate her ist ), hab ich ja angekündigt, dass ich versuche in 2 Monaten was auf die Beine zu stellen. Leider hab ich das Zeitlimit nicht geschafft, da ich mit diesem Post noch keine Version veröffentlichen will.

Aber ich hab mir gedacht - machste mal nen Status-Update - und diesmal ist es wirklich ein gewaltiger Schritt, den ich geschafft habe, denn

.... *trommelwirbel* ...

ich habe es endlich geschafft, dass meine Script-Sprache objekt-orientiertes Arbeiten möglich macht. Im Klartext heißt das, dass man jetzt im Script eigene Klassen erstellen kann (natürlich mit Variablen, Properties, Methoden, Constructor, Destructor, ...) und diese dann im Script verwenden. Dabei unterstützten die Klassen sogar Vererbung (also Zugriff auf Public/Protected-Properties/Methoden von Eltern-Klassen, Methoden überschreiben, usw.).

Am besten ich zeig euch mal ein kleines Script:

Delphi-Quellcode:

program Project1;

type
  TTest1 = class(TObject)
  private
    FABC : integer;
  public
    constructor Create; override;
    procedure Test1; virtual;
    
    property ABC : integer read FABC;
  end;
  
  TTest2 = class(TTest1)
  public
    constructor Create; override;
    procedure Test1; override;
  end;
  
  TTest3 = class(TTest2)
  public                  
    procedure Test1; override;
  end;

{ TTest1 }
  
constructor TTest1.Create;
begin                  
  inherited;               
  Self.FABC := 1024;
  Console.WriteLine('TTest1.Create'); 
end;

procedure TTest1.Test1;
begin            
  Console.WriteLine('TTest1.Test1');
end;

{ TTest2 }

constructor TTest2.Create;
begin                         
  inherited;
  Console.WriteLine('TTest2.Create');
end;

procedure TTest2.Test1;
begin         
  inherited;                      
  Console.WriteLine('TTest2.Test1');
end;

{ TTest3 }
     
procedure TTest3.Test1;  
begin        
  inherited; 
  Self.FABC := 512; // nur sichtbar, da in gleicher Unit
  Console.WriteLine('TTest3.Test1');
end;     

{ Main }

var p: TTest1; // Der Basistyp
begin            
  p := TTest3.Create; // eine abgeleitete Variante davon
  try         
    Console.WriteLine(p.ABC); 
    p.Test1;
    Console.WriteLine(p.ABC);  
  finally
    p.Free;
  end;      
end.

Wenn ich dieses Script ausführe, bekomme ich folgende Ausgabe in der Konsole:

Code:

TTest1.Create
TTest2.Create
1024
TTest1.Test1
TTest2.Test1
TTest3.Test1
512

Das ist jetzt schon etwas schwerer zu lesen, aber wenn man mal mit dem Finger den Ablauf so langgeht, dann kann man das schon ganz gut nachvollziehen.

Die Script-Klassen kann ich auch aus dem Programm heraus erstellen und die Vererbung nutzen. Hier mal ein wenig Pseudo-Code (Pseudo-Code, da die einzelnen Methoden noch ein paar andere Paremter haben, die hierfür erstmal nur stören würden)

Delphi-Quellcode:

var aClass  : Pointer;
    aObject : Pointer;
    method  : Pointer; 

begin
  // erstmal die Klasse suchen, die erstellt werden soll
  aClass := FRunTime.CodeAccess.FindClass('TTest3');
  // dann eine "Instanz" der Klasse erzeugen
  aObject := FRunTime.CreateClass(aClass);
  // dann noch die Basis-Methode suchen
  method := FRunTime.CodeAccess.FindMethod('TTest1.Test');
  // und dann die Methode mit "aObject" als Self-Parameter aufrufen
  FRunTime.Call(method, [aObject]);

  // -> jetzt wird im Script nicht die Funktion TTest1.Test ausgeführt, sondern
  // jetzt wird die Funktion "TTest3.Test" ausgeführt.
end;

Das ganze funktioniert schon sehr gut - jedoch muss ich den Compiler noch viel strenger machen. Zudem muss ich noch den Befehl "reintroduce" einbauen sowie den "inherited" - Befehl erweitern. Außerdem warten noch ein paar Bugs darauf, gelöscht zu werden.

Ich hoffe, dass ein paar Leute eine object-orientierte Script-Sprache brauchen könnten - ich brauch sie auf jeden fall

Grüße