Discussion :

[sjrd]

Sepi est un moteur de script orienté objet pour applications Delphi.

La principale différence d'avec les autres moteurs de script existant, tels que Pascal Script de RemObjects Software ou Scripter Studio de TMS Software, est que Sepi permet non seulement aux scripts d'instancier et de manipuler des objets de classes Delphi natives, mais aussi et surtout de créer leurs propres classes.

Les classes ainsi créées par Sepi sont des classes Delphi natives, mais créées à l'exécution. Elles sont tellement natives que les appels de méthodes virtuelles, dynamiques, de messages ou l'utilisation d'opérateurs comme is fonctionnent de manière complètement transparente.

Pour réaliser cela, le module principal de Sepi est un module de réflexion. Donc un module qui permet d'obtenir des informations détaillées sur les types et classes pendant l'exécution du programme. Mais qui permet aussi - et c'est unique dans le monde des langages compilés ! - de créer des types et des classes entièrement compatibles avec les classes natives pendant l'exécution.

Les scripts sont compilés en un pseudo-code intermédiaire avant d'être exécutés. Ce pseudo-code est unique pour Sepi, mais les scripts peuvent être écrits en divers langages. Il suffit de développer un compilateur pour chaque langage de script, Sepi proposant de grandes facilités pour la construction de compilateurs pour son pseudo-code. Par exemple, la partie spécifique au langage Delphi ne fait actuellement que 2000 lignes - rien en comparaison de tout ce qui est offert par Sepi et partagé entre tous les compilateurs.

Il est ainsi possible aux applications de proposer du scripting personnalisé pour leurs besoins, afin de permettre à leurs utilisateurs finaux de les personnaliser. C'est là le but essentiel de Sepi.



Le projet est sur le point d'être terminé pour sa première version. Il est d'ailleurs tout à fait utilisable. Il faut juste encore le stabiliser un peu.

[sjrd]

Les fonctionnalités supportées sont les suivantes :

Fonctionnalités globales

• Moteur de script orienté objet pour les applications Sepi.
• Un byte-code unique avec son interpréteur.
• Un compilateur prêt à utiliser pour le langage Delphi.
• Des facilités considérables pour créer des compilateurs pour d'autres langages (ex. : domain-specific language), avec notamment un générateur d'analyseur syntaxique sur base de grammaire.
• Les scripts peuvent utiliser les objets et classes (champs, méthodes et propriétés), tous les types de données, et toutes les routines de l'application Delphi native, via un programme d'import.
• Les scripts peuvent créer de nouvelles classes, qui s'intègrent de façon transparente dans la hiérarchie des classes de l'application Delphi native.
• Les RTTI de tous les types Sepi sont construits comme s'ils avaient été créés par le compilateur Delphi natif, ce qui permet d'utiliser les mécanismes de RTTI sur les objets de classes Sepi.
• Interpréteur thread-safe.

Constructions du langage supportées par le compilateur Delphi

En fait, l'entièreté du langage Delphi (version Delphi 7) est supportée, à l'exception des points suivants :

• Types fichiers, c-à-d Text et les file of TSomeRecord ;
• Variables locales déclarées absolute ;
• Directive automated ;
• Directive implements ;
• La directive inline est ignorée ;
• Types dispinterface : ils sont parsés et compilés mais ne sont pas traités correctement plus loin ;
• Appels de méthodes ou sélection de propriétés de Variant (comme les Variant implémentés avec TPublishableVariantType) ;
• Constructions amenées avec Delphi 2005 ou supérieurs (génériques, class/record helper, etc.) - néanmoins, sont supportés les types internes, les record avancés (méthodes et propriétés), ainsi que les variables, constantes et propriétés de classe ;
• Déclaration de routines external (dans des DLL) - il est possible d'utiliser LoadLibrary et Co. manuellement.

Voilà, à moins que j'aie oubliée quelque chose, tout ce qui n'a pas été cité est supporté

En particulier, les points suivants sont bel et bien supportés :

• Routines et méthodes overload, y compris pour celles importées depuis le code natif ;
• override dans un script de fonctions natives virtual, dynamic ou message ;
• Support des interfaces ;
• Paramètres tableaux ouverts et paramètres non typés ;
• La compilation conditionnelle avec {$IFDEF}, {$IFNDEF} et même {$IF}, avec notamment les pseudo-routines Defined() et Declared() dans les {$IF} ;
• L'inclusion de fichier avec {$INCLUDE} ou {$I} ;
• try..except, try..finally et raise.