ScriptEngine II (v. 0.6.1)

[toms]

Im Indy+Thread Demo erhalte ich eine Fehlermeldung Could not add the unit "System.Xml" (Linie 5)

[littleDave]

Du musst in der IDE die Packages "installieren". In den Packages sind die jeweiligen Units. Um das zu machen, musst du in der IDE im linken PageControl die Seite "Packages" öffnen. Dort sind alle "Package-DLLs" aufgelistet, die im Moment geladen sind. Einfach einen Rechtsklick und man kann weitere DLLs hinzufügen oder vorhandene entfernen. Um zu sehen, welche Unit in welchen Package ist, gibt es unten im PageControl mit den Seiten "Messages", "Debug Output", etc. einen weiteren Tab: "Registered Packages". Dort kann man sich dann alle Units der Packages anschauen.

Lange Rede, kurzer Sinn: füge im "Packages"-Tab die DLLs "libXML.dll" und "libIndy.dll" hinzu und schon sollte es gehen.

[toms]

Zitat von littleDave:

Lange Rede, kurzer Sinn: füge im "Packages"-Tab die DLLs "libXML.dll" und "libIndy.dll" hinzu und schon sollte es gehen.

Alles klar, vielen Dank.

PS: http://www.delphipraxis.net/rdf.php existiert nicht mehr.

[littleDave]

Zitat von toms:

PS: http://www.delphipraxis.net/rdf.php existiert nicht mehr.

Oh, danke für den Hinweis. Ich habe das Beispiel lange nicht mehr angeschaut - ich habe daher mal eine aktuelle Version erstellt. Einfach kopieren und im Editor einfügen.

Delphi-Quellcode:

program Project1;

uses
  System.Threading,
  System.Xml,
  Net.Indy;

type
  { Feed Query Data }
  TFeedQuery = record
  private
    FURL      : string;
    FUsesUTF8 : boolean;
  public
    class function Create(URL: string; UsesUTF8: boolean): TFeedQuery;
  
    property URL      : string read FURL;
    property UsesUTF8 : boolean read FUsesUTF8;
  end;
  
class function TFeedQuery.Create(URL: string; UsesUTF8: boolean): TFeedQuery;
begin
  result.FURL := URL;
  result.FUsesUTF8 := UsesUTF8;
end;

type
  { Execution Thread }
  TMyExecution = class(TExecutionContext)
  private
    FData  : string;
    FError : boolean;
    FQuery : TFeedQuery;
  protected
    procedure Execute; override;
    function  ExtractTitles: string;
  public
    constructor Create(Query: TFeedQuery); virtual;
  end;
  
constructor TMyExecution.Create(Query: TFeedQuery);
begin  
  inherited Create;
  FQuery := Query;
end;

function   TMyExecution.ExtractTitles: string;
var s: string;
    iStart, iStop: integer;
    tmp : string;
begin
  s := Self.FData;
  iStart := s.IndexOf('<title>');
  while iStart > 0 do
  begin
    iStop := s.IndexOf('</title>');
    if iStop > 0 then
    begin
      tmp := XML.Decode(s.Copy(iStart + string('<title>').Length, iStop - iStart - string('<title>').Length));
      if Self.FQuery.UsesUTF8 then
         result := result + StringEncoding.ToString(StringEncoding.AsUTF8(tmp)) + #13#10 
      else
         result := result + tmp + #13#10;
      s := s.Copy(iStop + string('</title>').Length);  
      iStart := s.IndexOf('<title>');  
    end else
      iStart := 0;
  end;  
end;

procedure  TMyExecution.Execute;
var http: TIdHTTP;
begin
  http := TIdHTTP.Create;
  try
    http.HandleRedirects := True;
    try
      Self.FData := http.Get(Self.FQuery.URL);   
      Self.FData := Self.FData
                   .Replace(#10, #13#10);
    except
      on e: EException do
      begin
        Self.FError := True;
        Self.FData := e.ToString;
      end;
    end;  
    
  finally
    http.Free;
  end;
end;  

function SelectFeedSource(var Query: TFeedQuery): boolean;
begin
  result := True;
  Console.WriteLine('Press [d] for Delphi, [s] for Spiegel, [h] for Heise, [esc] to cancel');
  while true do
  begin
    case Console.ReadKey.ToUpper of
    'D' :
      begin
        Query := TFeedQuery.Create('http://www.delphipraxis.net/external.php?type=RSS2', False);
        break;
      end;
    'S' :
      begin                                                
        Query := TFeedQuery.Create('http://www.spiegel.de/schlagzeilen/tops/index.rss', False);
        break;
      end;
    'H' :
      begin                                       
        Query := TFeedQuery.Create('http://www.heise.de/newsticker/heise.rdf', True);
        break;
      end;   
    Strings.FromASCIIIndex(KeyCodes.Escape) :
      begin
        result := False;
        exit;
      end;
    end;
  end;
end;

{ Main APP }
var t     : TThread;
    c     : TMyExecution;
    Query : TFeedQuery;
begin      
  if not SelectFeedSource(Query) then
     exit;
     
  repeat
    Console.Clear;
    c := TMyExecution.Create(Query);
    try
      t := TThread.NewThread(c);
      try      
        t.Start;
        
        Console.WriteLine('Connecting ' + Query.URL);
        Console.Write('Waiting ');
        while (t.State <> ThreadState.Finished) do
        begin               
          Console.Write('.');
          TThread.Sleep(100); 
          TThread.Sleep(100);
          TThread.Sleep(50);
        end;
        Console.Clear;
        if c.FError then
        begin
          Console.ForegroundColor := Colors.Red;
          Console.WriteLine(c.FData);
          Console.ForegroundColor := Colors.White;
        end
        else
          Console.WriteLine(c.ExtractTitles);
      finally
        t.Free;
      end;
    finally
      c.Free;
    end;
    
    Console.WriteLine;       
    if not SelectFeedSource(Query) then
       exit;
       
  until False;
end.

[littleDave]

Neue Version Version 0.6

Ist wurde mal wieder Zeit für einen größeren Versionssprung. Neu dabei ist unter anderem die for-in-Schleife, hier mal (wie immer) die Übersicht:

• Neuerungen
  • Die for-in-Schleife ist nun im Script möglich. Der benötigte Enumerator und dessen Aufbau ist im PDF beschrieben.
  • Enumeratoren für TList, TStrings, TIntegerList, TInt64List und TFloatList hinzugefügt
  • Der Index von for-Schleifen kann jetzt lokal im Schleifenkopf definiert werden: for var i: integer := 0 to 10 do ;
  • Die Inhaltsvariable von for-in-Schleifen kann ebenfalls lokal definiert werden: for var s: string in AList do ;
  • Die Script-Engine kann jetzt mit direkten Funktionspointern zu externen Methoden umgehen. Das schaut z.B. so aus:
    
    Delphi-Quellcode:

    type
      TMyCallback = procedure(SomeArg: integer); external; // wichtig: muss als external definiert sein, stdcall etc. ist erlaubt
    
    function GetCallbackEntryPoint: Pointer; external; // liefert den direkten Funktionspointer
    
    var t: TMyCallback;
    begin
      t := GetCallbackEntryPoint;
      t(1234); // Funktion wird ausgeführt
    end;

  • DLL-Methoden können jetzt direkt im Script definiert und importiert werden. Die RunTime hat zudem ein eingebautes Sicherheitsfeature, mit dem gesteuert werden kann, ob eine Funktion importiert werden kann. Dies ist Standard-mäßig verboten, im PDF ist aber beschrieben, wie man das erlaubt.
    
    Delphi-Quellcode:

    procedure Sleep(dwMilliseconds: DWORD); external 'kernel32.dll' name 'Sleep'; stdcall;
    
    begin
      Sleep(1000);
    end;

  • Neue Unit: System.Interop.Windows: Bietet die Klasse "TDynamicLinkLibrary" an, mit der man Funktionspointer aus DLLs dynamisch laden kann. Der gerade genannte Sicherheitsaspekt ist für diese Methode ebenfalls von Bedeutung.
    
    Delphi-Quellcode:

    uses
      System.Interop.Windows;
    
    type
      TSleep = procedure(dwMilliseconds: DWORD); external; stdcall;
    
    var Sleep: TSleep;
        Lib  : TDynamicLinkLibrary;
    begin
      Lib := TDynamicLinkLibrary.Create('kernel32.dll');
      try
        Sleep := Lib.FindMethod('Sleep');
        if @Sleep <> nil then
           Sleep(1000);
      finally
        Lib.Free;
      end;
    end.

• Änderungen
  • Compiler-Geschwindigkeit sowie Linker-Geschwindigkeit etwas verbessert
  • "exit", "break" oder "continue" ist jetzt innerhalb eines finally-end-Blockes verboten (wie in Delphi auch)
• Bug-Fixes
  • try-except-Block und try-finally-Block komplett neu geschrieben. Es gab einige Probleme mit den Anweisungen "exit", "break" und "continue" innerhalb eines try-Blockes.
  • interne Größe von set-of-Typen hängt jetzt ebenfalls von der Anzahl der Elemente in der Aufzählung ab. Dies ist jetzt kompatibel zu Delphi, was vor allem in Records Probleme machen konnte
  • Compiler hat innerhalb es "uses"-Blockes das Script nicht korrekt validiert
  • Funktionsaufrufe mit Rückgabewert über einen Funktionspointer haben nicht korrekt funktioniert
  • Fehler in der RunTime beim OpCode "JIZ" und "JNZ" behoben

Download-Link ist im ersten Post.

Grüße

[Florian Hämmerle]

NICE (:

Freut mich zu hören, dass sich in der SE2 immer noch so viel tut. Weiter so (:
wenn das hier jetzt facebook wäre, würde ich mal "gefällt mir" klicken

mfg Florian

[implementation]

Zitat von Florian Hämmerle:

wenn das hier jetzt facebook wäre, würde ich mal "gefällt mir" klicken

Sowas sollte man hier wirklich mal einführen
Oder einen Danke-Button wie in der EE.

[WorstNightmare]

Hi,

ich denke gerade darüber von RemObjects PascalScript auf deine ScriptEngine umzusteigen, aus dem einfachen Grund weil hier overloading unterstützt wird. Eines stört mich jedoch: Die Scripts müssen immer einen program-Header haben, in PascalScript konnte man den abschalten (über CompilerOptions). Kannst du das auch abschaltbar machen? Der verschwendet bei mir nur Platz, da ich ihn eh immer NPCScript oder so nennen würde und die Scripts über Dateinamen identifiziert werden.

Edit: Und gibt es irgendwo Inc() und Dec()? Wenn nein, warum nicht?

Edit 2: So, läuft ganz gut jetzt. Allerdings habe ich noch einen Feature-Wunsch:
Meine Scripts terminieren die Runtime aus sich heraus und wenn ich direkt nach Abort() Finalize() und Free() aufrufe, knallt es. Daher brauche ich ein Notify-Event, irgendwie OnAborted oder so in der Runtime. Im finally ganz unten in TSE2ExecutionContext.Call dann so aufrufen:

Delphi-Quellcode:

    if FDoAbort and Assigned(FOnAborted) then
      FOnAborted(TObject(FExecutionData.RunTime));

[littleDave]

Hallo WorstNightmare,

sorry für die späte Antwort, bin bisher nicht dazu gekommen

Zitat:

ich denke gerade darüber von RemObjects PascalScript auf deine ScriptEngine umzusteigen, aus dem einfachen Grund weil hier overloading unterstützt wird. Eines stört mich jedoch: Die Scripts müssen immer einen program-Header haben, in PascalScript konnte man den abschalten (über CompilerOptions). Kannst du das auch abschaltbar machen?

Ja, ich werde schauen, was sich da machen lässt. Wird jedoch noch etwas dauern, da ich mich endlich dazu überwunden habe und im Moment arrays einbaue. Ich bin dabei gerade mitten in der Implementierungs- und Testphase. Dadurch wäre es im Moment nicht so gut, den halbfertigen Code herauszugeben. Bis dahin kannst du ja vor dem Übergeben an den Compiler folgendes schreiben:

Delphi-Quellcode:

function CompileScript(const Source: string): TSE2PE;
begin
  result := Compiler.Compile('program program1; ' + Source + ' begin end.';
end;

Zitat:

Edit: Und gibt es irgendwo Inc() und Dec()? Wenn nein, warum nicht?

Diese Routinen habe ich zum einen aus Zeitgründen, zum anderen aus Featuregründen noch nicht drinnen (ich will eigentlich keine "Compiler-Magic" einbauen).

• Zeitgrund: für jeden Typ müssen die Routinen alle manuell deklarieren muss (also für byte, integer, etc. - jeweils mit und ohne Parameter).
• Feature-Grund: für ein einfaches "+1" eine einzelne Funktion aufrufen ist doch etwas overhead, daher wollte ich warten, bis ich "inline" - Methoden eingebaut habe.

Bei "pred()" und "succ()" hört der Spaß dann aber auf - die kommen mir nicht in die System-Unit (ich finde die total unübersichtlich)

Zitat:

Edit 2: So, läuft ganz gut jetzt. Allerdings habe ich noch einen Feature-Wunsch:
Meine Scripts terminieren die Runtime aus sich heraus und wenn ich direkt nach Abort() Finalize() und Free() aufrufe, knallt es. Daher brauche ich ein Notify-Event, irgendwie OnAborted oder so in der Runtime. Im finally ganz unten in TSE2ExecutionContext.Call dann so aufrufen:

Delphi-Quellcode:

    if FDoAbort and Assigned(FOnAborted) then
      FOnAborted(TObject(FExecutionData.RunTime));

Das versteh ich nicht, wieso das nötig sein sollte. Gehe ich richtig in der Annahme, dass du im Script einen Methode aufrufst, die die RunTime beenden und schließen soll? Das kann nicht funktionieren! denn so ziehst du dem Script die RunTime unter den Füßen weg und knallt somit auf den Boden. Die RunTime darf nicht von einer Funktion heraus gelöscht werden, wenn diese aus der RunTime heraus aufgerufen wird.

[littleDave]

Neue Version Version 0.6.1

Vor längerer Zeit habe ich ja eine neue Version angekündigt. Nun ist es soweit - wobei ich gleich sagen muss: arrays sind immer noch nicht fertig eingebaut. Somit ist das hier eher ein Bug-Fix-Release sowie eine experimentelle Version für arrays. Es ist noch nicht alles drinnen aber ich habe Arrays jetzt erstmal nicht deaktiviert.

Falls also wer die Arrays mal ausprobieren will, es geht noch nicht alles. Zudem gibt es folgende wichtige Einschränkung: man kann arrays nicht "inline" deklarieren, also folgendes geht NOCH NICHT: var t: array of integer; . Stattdessen muss man immer vorher den Array-Typ deklarieren: type TIntArray = array of integer; .

• Neuerungen
  • Basis-Array-Implementation eingebaut
  • Die Funktionen "System.Inc()" sowie "System.Dec()" sind jetzt vorhanden
• Veränderungen
  • Performance bei Conditional-Jumps verbessert
  • Byte-Code-Optimizer erweitert und verbessert
• Bug-Fixes
  • Fehler beim Aufrufen von überladenen Methoden mit var-Parameter behoben
  • Das Forwarden von Klassen war im Compiler nicht komplett - somit war die erstellte Klasse im Code nicht verwendbar. Dies trat in normalen Units nicht auf, da man da die Deklaration zuerst abschließen musste - in der "program" - Datei jedoch war das nicht zwingend notwendig.
  • Fehler beim Finden der korrekten, überlandenen Methode behoben, falls zwei verschiedene Klassentypen als Parameter-Varianz ausschlaggebend waren
  • Fehler bei break/continue innerhalb von try-except-Blöcken, die sich innerhalb eines try-finally-Blocks befanden, behoben
  • Fehler bei exit innerhalb eines try-finally-Blocks unter bestimmten Umständen
  • Fehler beim Aufrufen von Script-Methoden aus dem Delphi-Programm heraus mit double-var-Parametern (Danke an Denstern)

Download-Link ist im ersten Post.

Grüße