Différences entre DelphiScript et Delphi

Différences entre DelphiScript et Delphi

Cette section présente les différences essentielles entre le langage de script DelphiScript et le langage de programmation Delphi d’Embarcadero, ainsi que leur application à l’API d’Altium Designer.

Le système de script d’Altium Designer utilise le langage DelphiScript non typé ; il n’y a donc pas de types de données dans les scripts. Bien que vous puissiez déclarer des variables et leurs types, et spécifier les types des fonctions/procédures ou des paramètres de méthode pour améliorer la lisibilité, DelphiScript convertit les variables non déclarées lors de l’exécution d’un script. Ainsi, par exemple, vous ne pouvez pas définir d’enregistrements ni de classes.

Variables DelphiScript

Toutes les variables d’un script sont de type Variant, et les types indiqués dans une déclaration de variable sont ignorés et peuvent être omis. Ainsi, ces trois déclarations sont correctes :

Var
a : Integer;
 
Var
b : Integer;
 
Var
  c, d;

Les types des paramètres dans une déclaration de procédure/fonction sont également ignorés et peuvent être omis. Par exemple, ce code est correct :

Function Sum(a, b) : Integer;
Begin
  Result := a + b;
End;

De manière générale, les variants peuvent être utilisés pour stocker n’importe quel type de données et effectuer de nombreuses opérations et conversions de type. Un variant est vérifié et évalué à l’exécution. Le compilateur n’émettra pas d’avertissement concernant d’éventuelles erreurs dans le code, qui ne pourront être détectées qu’au moyen de tests approfondis. Dans l’ensemble, les portions de code qui utilisent des variants peuvent être considérées comme du code interprété, car de nombreuses opérations ne peuvent pas être résolues avant l’exécution. Cela peut affecter la vitesse du code.

Il en résulte qu’une fois qu’une variable variant a été déclarée et a reçu une valeur variant, elle peut être copiée vers n’importe quel type de données compatible ou incompatible :

Var
V;
Begin
  // variable V can be assigned values of several different types:
  V := 10;
  V := 'Hello, World';
  V := 45.55;
End;

Si un type de données incompatible a été affecté à une variable, l’interpréteur DelphiScript effectue une conversion lorsque cela est possible. Sinon, une erreur d’exécution est générée. En pratique, un variant stocke les informations de type avec les données ; DelphiScript est donc plus lent que le code compilé équivalent en Delphi d’Embarcadero.

Ensembles dans les scripts

DelphiScript ne possède pas de types Set et ne prend pas en charge les opérateurs Set, contrairement au langage Delphi qui possède des types Set et prend en charge les opérateurs Set.

Pour utiliser des Sets dans des scripts DelphiScript, utilisez les fonctions intégrées qui manipulent les ensembles dans un script.

Consultez l’entrée Using Sets in DelphiScript pour plus d’informations

Fonctions ou procédures internes

Lorsqu’il s’agit d’utiliser des fonctions et des procédures inside a Function or Procedure, l’approche recommandée consiste à écrire des fonctions/procédures autonomes — bien que les procédures/fonctions récursives soient autorisées.

L’extrait de fonction suivant n’est pas recommandé :

Function A
Function B
Begin
// blah
End;
Begin
B;
End;

Structure de fonction recommandée :

Function B
Begin
// blah
End;

Function A
Begin
B;
End;

Mot-clé Result

Utilisez le mot-clé Result pour définir la valeur de retour dans un bloc de fonction. Par exemple :

Function Foo : String;
Begin
Result := 'Foo Foo';
End;

Routines imbriquées

Les routines imbriquées sont prises en charge, mais les variables de la fonction de niveau supérieur ne peuvent pas être utilisées depuis la routine imbriquée.

Éléments de tableau

Le type des éléments de tableau est ignoré et peut être omis ; ainsi, ces deux déclarations sont équivalentes :

Var
x : array [1..2] of double;

Var
x : array [1..2];

Notez que vous ne pouvez pas déclarer de types de tableau, mais vous pouvez déclarer des tableaux dans des variables.

Illegal example:

Type
TVertices = Array [1..50] Of TLocation;
Var
NewVertices : TVertices;

Legal example:

Var
NewVertices : Array [1..50] of TLocation;

Déclaration de tableau ouvert

La déclaration Open Array n’est pas prise en charge.

Mot-clé Case

Le mot-clé Case peut être utilisé pour n’importe quel type. Ainsi, ce qui suit est valide :

Case UserName of
'Alex', 'John' : IsAdministrator := true;
'Peter' : IsAdministrator := false;
Else
Raise('Unknown user');
End;

Déclarations de classe

De nouvelles classes ne peuvent pas être définies dans DelphiScript, mais vous pouvez utiliser des classes DelphiScript existantes et les instancier. Par exemple, les classes TList et TStringList peuvent être créées et utilisées dans vos scripts.
See also
TList
TStringList

Fonction CreateObject

La fonction CreateObject peut être utilisée pour créer des objets qui seront libérés implicitement lorsqu’ils ne seront plus utilisés.

Ainsi, au lieu de :

Procedure Proc;
Var
  l;
Begin
    l := TList.Create;
  Try
    // do something with l
  Finally
  L.Free;
End;

...vous pouvez écrire :

Procedure Proc;
Var
  l;
Begin
  l := CreateObject(TList);
  // Do something with l
End;

See also
fonction CreateObject.

Lever des exceptions

Le mot-clé Raise peut être utilisé sans paramètres pour relancer la dernière exception. Raise peut également être utilisé avec un paramètre de chaîne pour lever une exception avec le message spécifié. Les objets Exception ne sont pas pris en charge dans DelphiScript, car le mot-clé On n’est pas pris en charge.

Example:

Raise(Format('Invalid value : %d', [Height]));

See also
Mots-clés Try, Finally et Raise.

ThreadVar

Dans Delphiscript, le mot-clé Threadvar est traité comme Var. Notez qu’en Delphi d’Embarcadero, les variables déclarées à l’aide du mot-clé Threadvar ont des valeurs distinctes dans chaque thread.

Opérateurs Set

L’opérateur Set In n’est pas pris en charge. L’opérateur InSet peut être utilisé pour vérifier si une valeur est membre d’un ensemble. Par exemple :

If InSet(fsBold, Font.Style) then
ShowMessage('Bold');

Notez que les opérateurs Set de Delphi +, -, *, <=, >= ne fonctionnent pas correctement. Les fonctions intégrées de Delphiscript MkSet, MkSetRange, SetUnion, SetDifference, SetIntersection, SubSet and InSet sont utilisées à la place :

ASet := BSet + CSet; \\ should be changed to
ASet := SetUnion(BSet, CSet);

Les constructeurs d’ensemble [...] ne sont pas pris en charge — utilisez la fonction MkSet pour créer un Set:

Font.Style := MkSet(fsBold, fsItalic); 

See also
Mot-clé MkSet
Mot-clé MkSetRange
Mot-clé InSet
Mot-clé SetDifference
Mot-clé SetIntersection
Mot-clé SetUnion
Mot-clé SubSet
Mot-clé InSet

Opérateurs

Les opérateurs ^ et @ ne sont pas pris en charge.

Directives

Les directives suivantes ne sont pas prises en charge (notez que certaines sont obsolètes et ne sont pas non plus prises en charge par Delphi d’Embarcadero) : absolute, abstract, assembler, automated, cdecl, contains, default, dispid, dynamic, export, external, far, implements, index, message, name, near, nodefault, overload, override, package, pascal, private protected, public, published, read, readonly, register, reintroduce, requires, resident, safecall, stdcall, stored, virtual, write, writeonly.

Notez également que la directive in dans la clause Uses est ignorée.

Mots-clés ignorés

Les mots-clés interface, implementation, program et unit sont ignorés dans DelphiScript. Les scripts peuvent les contenir, mais ils n’ont aucun effet — toutefois, ces mots-clés peuvent améliorer la lisibilité des scripts.

Mots-clés non pris en charge

Les mots-clés suivants ne sont pas pris en charge dans DelphiScript :

• as, asm, class, dispinterface, exports, finalization, inherited, initialization, inline, interface, is, library, object, out, property, record, resourcestring, set, supports, type.

Les fonctions RTL Delphi suivantes ne sont pas prises en charge dans DelphiScript :

• Abort, Addr, Assert, Dec, FillChar, Finalize, Hi, High, Inc, Initialize, Lo, Low, New, Ptr, SetString, SizeOf, Str, UniqueString, VarArrayRedim, VarArrayRef, VarCast, VarClear, VarCopy.

Les fonctions de l’unité Windows de Delphi (le fichier windows.pas) ne sont pas prises en charge (par exemple, la fonction RGB n’est pas prise en charge).

Utilisation de l’API d’Altium Designer dans les scripts

Vous ne pouvez pas créer vos propres types d’enregistrements ou de classes à l’aide de DelphiScript ni les instancier dans un script ; toutefois, vous pouvez utiliser certaines classes de l’API d’Altium Designer. Par exemple, les classes TStringList et TList peuvent être instanciées et utilisées comme conteneurs de stockage de données (généralement du même type) pour répondre aux besoins d’un script.

Les interfaces d’objet de l’API qui représentent les objets d’Altium Designer peuvent être utilisées dans les scripts. Par exemple, vous pouvez mettre à jour des objets de conception dans des documents schématiques et PCB grâce aux interfaces d’objet schématique et aux interfaces d’objet PCB.

Par convention, les noms d’interface sont précédés d’un « I ». Par exemple, IPCB_Board représente une interface pour un document PCB existant.

Exemple d’interfaces PCB dans un script :

Procedure ViaCreation;
Var
  Board : IPCB_Board;
  Via : IPCB_Via;
Begin
  Board := PCBServer.GetCurrentPCBBoard;
  If Board = Nil Then Exit;
 
  (\* Create a Via object\* )
  Via           := PCBServer.PCBObjectFactory(eViaObject, eNoDimension, eCreate_Default);
  Via.X         := MilsToCoord(7500);
  Via.Y         := MilsToCoord(7500);
  Via.Size      := MilsToCoord(50);
  Via.HoleSize  := MilsToCoord(20);
  Via.LowLayer  := eTopLayer;
  Via.HighLayer := eBottomLayer;
 
  (* Put this via in the Board object*)
  Board.AddPCBObject(Via);
End;

Les API suivantes peuvent être utilisées dans les scripts :

• Certaines fonctions et classes Delphi™ d’Embarcadero, ainsi que des extensions DelphiScript
• API Client
• API PCB Server
• API Schematic Server
• API Workspace Manager Server
• API Integrated Library
• Fonctions de l’API d’Altium Designer
• Processus paramétriques

Informations complémentaires

Consultez les scripts de la collection de scripts downloadable pour voir les interfaces d’objet et fonctions d’Altium Designer, ainsi que les objets et fonctions Delphi utilisés dans les scripts.

Reportez-vous à la documentation principale Scripting pour obtenir des informations sur l’écriture de scripts pour Altium Designer.

Reportez-vous au guide Using the Altium Designer API pour plus de détails sur l’utilisation des objets de conception et de leurs interfaces dans vos scripts.

Reportez-vous à la Altium Designer API Reference pour des informations sur l’étendue des API d’Altium Designer et de leurs objets d’interface pour les scripts.