Mots-clés

Cette référence couvre les mots-clés DelphiScript utilisés par le système de script dans Altium Designer. Le système de script prend en charge le langage DelphiScript, qui est très similaire au langage de programmation Embarcadero Delphi™. La principale différence est que DelphiScript est un langage de script sans typage.

Dans cette section, les mots-clés DelphiScript courants sont présentés avec des informations détaillées et des exemples. Pour plus d'informations sur les mots-clés, comme les routines Delphi de gestion de fichiers, de mathématiques et de chaînes, voir Functions et la Embarcadero Delphi Reference.

And

Declaration
L'opérateur And effectue un ET logique/bit à bit.

Description
L'opérateur And effectue un ET logique si les opérandes sont de type booléen, ou un ET bit à bit si les opérandes sont des entiers.

Example of a boolean And evaluation:

Var
  I, J : Integer
Begin
  I := $F0;
  J := $8F;
  ShowMessage(IntToStr(I and J));
End;

Example of a logical And evaluation:

Var
  S : String;
Begin
  S := '';
  If (Length(S) > 0) and (S[1\] = 'X') Then Delete(S,1,1);
End;

See also
Mot-clé Or
Mot-clé Xor

Array

Declaration
Array [index range];

Description
Le langage DelphiScript est un langage sans typage, donc la taille ou la plage d'un tableau doit être spécifiée. Le type d'éléments que le tableau peut contenir peut tout de même être défini, mais ce n'est pas nécessaire. La déclaration Open array n'est pas prise en charge.

Example:

var x : array [1..2]; 

Begin

Declaration
Begin
  statement
End;

Description
Le mot-clé begin démarre un bloc dans le script. Un bloc constitue le corps principal d'un script et peut contenir un nombre quelconque d'instructions ; il peut être utilisé partout où une seule instruction est requise, comme dans le corps d'une instruction conditionnelle ou de boucle.

Example:

Var
  Test : Integer;
Begin
  Test := Test + 4;
  ShowMessage(IntToStr(Test));
End;

See also
Mot-clé End

Break

Declaration
Break;

Description
Un Break permet de sortir d'une boucle, de manière similaire à une instruction Goto.

Example:

While Condition Do
Begin
  DoSomething;
  Begin
    If AnotherCondition Then
      Break;
  End;
End;

See also
Mot-clé While
Mot-clé ContinueMot-clé Do
Mot-clé Repeat

Case

Declaration
Case expression Of
  Value range : Expression;
Else Expression;
End;

Description
Les instructions Case sélectionnent une branche parmi plusieurs branches possibles, selon la valeur de l'expression.

Dans de nombreuses situations, un ensemble complexe d'instructions If peut être simplifié en les remplaçant par des instructions Case. Une instruction case dans une expression est utilisée pour sélectionner une valeur, une liste de valeurs possibles ou une plage de valeurs. Tous les types peuvent être utilisés dans une instruction case parce que DelphiScript est un langage non typé. Les instructions Case peuvent comporter une instruction else qui est exécutée si aucune des étiquettes ne correspond à la valeur du sélecteur (dans la condition Case Of).

Example 1:

Case Char Of
  '+'     : Text := 'Plus sign';
  '-'     : Text := 'Minus sign';
  '*', '/': Text := 'Multiplication or division';
  '0'..'9': Text := 'Number';
  'a'..'z': Text := 'Lowercase character';
  'A'..'Z': Text := 'Uppercase character';
Else
  Text := 'Unknown character';
End;

Example 2:

Case UserName Of
  Jack', 'Joe' : IsAdministrator := true;
  'Fred' : IsAdministrator := false;
Else
  Raise('Unknown User');
End;

See also
Mot-clé Of

Continue

Declaration
Continue

Description
L'instruction Continue saute le corps d'une boucle, de manière similaire à l'instruction Goto ;

Example:

Var
  I := 0; s:= 1;
Begin
  While True Do
  Begin
  S := S \* 2;
  I := I \\+ 1;
  If I <> 4 then continue;
  Break;
End;

See also
Mot-clé Break
Mot-clé While
Mot-clé Continue
Mot-clé Do
Mot-clé Repeat

Const

Declaration
Const
Name = Expression;

Description
Le mot-clé Const spécifie toute expression constante comme valeur d'une constante. Si vous essayez de modifier dans le script l'expression qui est de type const, le système de script générera une erreur d'identifiant non déclaré.

Example:

Const
  b = 30;
Begin
  ShowMessage(IntTtStr(b));
End;

Toute tentative de modifier la valeur du paramètre b const générera une erreur, par exemple :

Const
  b = 30;
Begin
  b := 40;
  ShowMessage(IntToStr(b));
End;

Div

Declaration
dividend div divisor

Description
L'opérateur Div effectue une division entière qui ignore la partie fractionnaire sans arrondi. Si le diviseur est zéro, DelphiScript signale une erreur.

See also
Opérateur Mod
Opérateur Div

Do

Declaration

• For variable := expression1 to expression2 do instruction
• While expression do instruction
• With expression do instruction.

Description
Le mot-clé Do fait partie des instructions For, While and With de DelphiScript.

Example:

For i := 0 To AnIndex - 1 Do
  S := S + #13 + AString;

See also
Mot-clé For
Mot-clé To
Mot-clé While
Mot-clé With
Mot-clé DownTo

DownTo

Declaration
For variable := expression1 DownTo expression2 Do statement.

Description
Utilisez DownTo dans une boucle For pour effectuer un comptage décroissant.

See also
Mot-clé For
Mot-clé To
Mot-clé Do

Else

Declaration

• If condition then statement Else statement
• Try statement except exception Else statement end
• Case expression of Else end;

Description
Le mot-clé Else introduit la partie par défaut de plusieurs instructions. Notez que la partie else d'une instruction if est suivie d'une seule instruction, mais que la partie else des instructions try-except et case peut contenir plusieurs instructions.

See also
Mot-clé If
Mot-clé Then
Mot-clé Try
Mot-clé Case

End

Declaration

• Begin statements End;
• Try statements Except Exception clauses... else Statements... End;
• Try statements Finally statements End;
• Case Expression of clauses Else statements... End;

Description
Le mot-clé End termine un bloc ou une partie multiple telle que des déclarations, des instructions Case, etc.

See also
Mot-clé Begin
Mot-clé Case
Mot-clé Try

Except

Declaration
Try statements Except statements End;

Description
Utilisez des blocs Try-Except pour gérer les cas exceptionnels, par exemple pour intercepter des exceptions spécifiques et en faire quelque chose d'utile, comme les ajouter à un journal d'erreurs ou créer une boîte de dialogue conviviale. Puisque le mot-clé On n'est pas pris en charge dans DelphiScript, utilisez l'instruction Raise à l'intérieur du bloc Except et ne signalez qu'un message textuel.

Example:

Try
  X := Y/Z;
Except
  Raise('A divide by zero error!');
End;

See also
Mot-clé End
Mot-clé Finally
Mot-clé Try

Finally

Declaration
Try statements... Finally statements... End;

Description
Le mot-clé finally démarre la partie finally d'un bloc try-finally. Les instructions du bloc finally sont toujours exécutées, quelle que soit la manière dont le contrôle quitte le bloc try : exception, exit ou break. L'utilisation du bloc try-finally est recommandée lors de la création/destruction d'objets et des E/S de fichiers.

See also
Mot-clé End
Mot-clé Raise
Mot-clé Try

For

Declaration

• for variable := expression1 to expression2 do statement
• for variable := expression1 downto expression2 do statement

Description
Une boucle for évalue les expressions qui spécifient les limites de cette boucle, puis exécute le corps de la boucle de manière répétée via la variable de contrôle de boucle, qui est mise à jour après chaque itération.

Example:

For i := 0 to AnIndex - 1 Do
Begin
  S := S + #13 + AString;
End;
ShowMessage(S);

See also
Mot-clé Do
Mot-clé DownTo
Mot-clé Repeat
Mot-clé To
Mot-clé While
Mot-clé With

Forward

Declaration
subroutine header; forward;

Description
La directive Forward permet de déclarer une fonction ou une procédure avant son appel en déclarant l'en-tête (nom, paramètres et type de retour) avec la directive forward.

Function

Declaration
Function name (parameters) : return type;

Description
Une Function est une sous-routine qui renvoie une valeur. Notez que les pointeurs vers des fonctions ne sont pas autorisés dans les scripts — autrement dit, les types fonctionnels ne peuvent pas être définis. Les variables déclarées à l'intérieur d'une fonction ne sont pas accessibles en dehors de cette procédure.

Example

Function TestFunc(Min, Max : integer) : integer;
Begin
  Result := Random(Max - Min +1);
End;

Goto

Declaration
goto label

Description
L'instruction goto transfère le contrôle à l'étiquette donnée. L'étiquette peut être n'importe quel identifiant ou une chaîne de chiffres comportant jusqu'à quatre chiffres.

Example

Label StartHere;
// code
 
StartHere: //do anything;
 
Goto StartHere;

See also
Mot-clé Label

If

Declaration

• if condition then statement;
• if condition then statement1 else statement2;

Description
La condition du mot-clé If doit être une expression booléenne. Le mot-clé Else est facultatif.

Example

If A > B Then
    ShowMessage('X>Y and A > B');
Else
    ShowMessage('X>Y and A <=B');
End;

See also
Mot-clé And
Mot-clé Begin
Mot-clé Or
Mot-clé Then
Mot-clé Else

Interface

Declaration
Interface
// Globally unique identifier string.
Methods
Properties
End;

Description
Le mot-clé interface permet d'accéder à un objet existant en mémoire et d'invoquer les méthodes de cet objet. Une interface ne peut être constituée que de propriétés et de méthodes — aucune donnée. Comme les interfaces ne peuvent pas contenir de données, leurs propriétés doivent écrire vers des méthodes et lire depuis celles-ci. Plus important encore, les interfaces n'ont pas d'implémentation, car elles ne définissent qu'un contrat vers un objet existant en mémoire.

Une interface peut être considérée comme un point de contact avec un objet existant dans la mémoire de l'ordinateur, et offre la possibilité de lire/écrire des données via les propriétés de l'interface. L'interface demande des données à l'objet qui lui est associé.

DelphiScript est un langage sans typage ; par conséquent, vous ne pouvez pas définir de nouveaux types tels que de nouveaux enregistrements, tableaux ou classes, ni les interfaces associées.

Label

Declaration
label digits, identifier, ...;

Description
Le mot-clé label déclare une ou plusieurs étiquettes. Une étiquette peut être une chaîne de chiffres comportant jusqu'à quatre chiffres ou un identifiant. Une étiquette peut être utilisée dans le même bloc pour identifier une instruction comme cible d'une instruction goto.

Example:

Label StartHere;
// code
StartHere: //do anything;
Goto StartHere;

See also
Mot-clé Goto

Mod

Declaration
Integer expression mod integer expression

Description
L'opérateur mod effectue une opération de modulo entier ou de reste. Le résultat de A mod B est A - (A div B) * B.

See also
Fonction Div

Nil

Declaration
const nil = pointer(0);

Description
Le mot-clé nil est une valeur spéciale de pointeur dont il est garanti qu'elle est distincte et ne pointe vers rien.

Not

Declaration

• not boolean expression
• not integer expression

Description
L'opérateur not effectue une négation. Si l'opérande est de type booléen, la négation est une négation logique. Not False = True et not true = false. Si l'opérande est un entier, l'opérateur not effectue une négation bit à bit de chaque bit de la valeur entière — c'est-à-dire une opération de complément.

Of

Declaration
case expression of
  selector: expression1
  ...
end

Description
Le mot-clé Of est utilisé pour l'instruction case.

See also
Instruction Case

Or

Declaration

• boolean expression or boolean expression
• integer expression or integer expression

Description
L'opérateur or effectue un OU logique si les opérandes sont de type booléen, ou un OU bit à bit si les opérandes sont des entiers. Un OU logique est faux uniquement si les deux opérandes sont faux ; sinon, il est vrai dès qu'au moins un opérande est vrai.

See also
Mot-clé And
Mot-clé Not
Mot-clé Shl
Mot-clé Shr
Mot-clé Xor

Procedure

Declaration

• Procedure name;
• Procedure Name (Parameter, ...);

Description
Le mot-clé procedure déclare une sous-routine qui n'a pas de type de retour. Les variables déclarées à l'intérieur d'une procédure ne sont pas accessibles en dehors de cette procédure. Notez que ce mot-clé peut être utilisé, mais il est ignoré par le système de script.

Example:

Procedure TestRand(Var Rand: Integer; Max : Integer);
Begin
  Rand := Random(Max);
End;

See also
Mot-clé Function

Program

Declaration
Program Name;
declarations...
Block

Description
Le mot-clé program commence un script. L'extension de fichier d'un script est *.pas. Notez que ce mot-clé peut être utilisé, mais il est ignoré par le système de script.

See also
Mot-clé Function

Raise

Declaration
Raise statement;

Description
Le mot-clé raise est lié au mot-clé Try. Le mot-clé Raise peut être utilisé sans paramètres pour relancer la dernière exception. Il peut également être utilisé avec un paramètre de chaîne pour lever une exception avec un message spécifique.

Example:

Raise(Format('Invalid Value Entered : %d', \[Height])); 

Notez que le mot-clé On n’est pas pris en charge dans DelphiScript, donc les objets Exception ne peuvent pas être utilisés dans les scripts.

Repeat

Declaration
repeat
statements;
until boolean expression

Description
Les instructions à l’intérieur d’un bloc Repeat Until sont exécutées de manière répétée jusqu’à ce que l’expression booléenne soit vraie.

Example:

Repeat
  Write('Enter a value (0..9): ');
  ShowMessage(IntToStr(I));
Until (I >= 0) and (I <= 9);

See also
Until keyword

Result

Declaration
Var result : Function return type;

Description
Toute fonction dans un script doit utiliser le mot-clé Result pour renvoyer une valeur résultante. Le type de la variable est le type de retour de la fonction.

See also
Function keyword

Shl

Declaration
value shl bits

Description
L’opérateur shl effectue un décalage à gauche d’une valeur entière de Bits positions de bit. Les bits libérés sont remplis à droite par des zéros.

See also
And keyword
Not keyword
Or keyword
Shr keyword
Xor keyword

Shr

Declaration
value shr bits

Description
L’opérateur shr effectue un décalage à droite d’une valeur entière de Bits positions de bit. Les bits libérés sont remplis à gauche par des zéros.

See also
And keyword
Not keyword
Or keyword
Shl keyword
Xor keyword

String

Declaration

• type string;
• type Name = string[Constant]

Description
Le mot-clé string représente le type chaîne.

Then

Declaration
If expression then statement

Description
Le mot-clé Then fait partie d’une instruction If.
See also
If keyword

To

Declaration
For variable := expression1 to expression2 do statement

Description
Le mot-clé to fait partie d’une boucle for à comptage croissant.

Example

For i := 0 to AnIndex - 1 do
  S := S + #13 + AString;

See also
Downto keyword
For keyword

Try

Declaration

• Try statements finally statements end;
• Try statements except statements end;

Description
Le mot-clé try introduit une instruction try-except ou une instruction try-finally. Ces deux instructions sont liées, mais servent à des fins différentes.

Try Finally
Les instructions du bloc finally sont toujours exécutées, quelle que soit la manière dont le contrôle quitte le bloc try : exception, Exit ou Break. Utilisez le bloc try-finally pour libérer les objets temporaires et autres ressources, et pour effectuer les opérations de nettoyage. En général, vous n’avez pas besoin de plus d’une instruction try-finally dans une sous-routine.

Example:

Reset(F);
Try
  ...  // process file F
Finally
  CloseFile(F);
End;

Try Except
Utilisez try-except pour gérer les cas exceptionnels, par exemple pour intercepter des exceptions spécifiques et en faire quelque chose d’utile, comme les ajouter à un journal d’erreurs ou créer une boîte de dialogue conviviale. Puisque le mot-clé On n’est pas pris en charge dans DelphiScript, utilisez l’instruction Raise à l’intérieur du bloc Except.

Example:

Try
  X := Y/Z;
Except
  Raise('A divide by zero error!');
End;

See also
Raise keyword

Type

Declaration
Type Name = type declaration ...

Description
Le mot-clé Type déclare le type d’une variable. Comme DelphiScript est un langage sans typage, il n’est pas nécessaire de déclarer les variables avec un type spécifique, mais cela peut être fait pour améliorer la lisibilité des scripts. Toutes les variables d’un script sont toujours de type Variant. La principale limitation lors de l’écriture de scripts est que vous ne pouvez pas déclarer d’enregistrements ni de classes.

Le transtypage est ignoré dans les scripts, donc les types dans les déclarations de variables sont ignorés et peuvent être omis. Ces déclarations sont donc correctes :

Example:
var a : integer;
var b : integer;
var c, d;

Les types des paramètres dans les déclarations de procédure/fonction sont 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’avertira pas des erreurs possibles dans le code, qui ne peuvent ê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.

Example:

Var
V
Begin
  // you can assign to it values of several different types:
  V := 10;
  V := 'Hello, World';
  V := 45.55;
End;

See also
Var keyword

Unit

Declaration

• Unit Name;
interface
   declarations
implementation
   declarations
   statements
Initialization
   statements
finalization
   statements
end.
   
• Unit Name;
interface
   declarations
implementation
   declarations
   statements
begin
   statements
end.

Le mot-clé unit introduit une unité, qui est le module de base d’un script. Notez que ce mot-clé peut être utilisé, mais qu’il est ignoré par le système de script.

See also
Function keyword
Program keyword

Until

Declaration
Repeat
Statements;
Until boolean expression

Description
Le mot-clé until marque la fin du bloc Repeat-Until. Les instructions à l’intérieur d’un bloc Repeat-Until sont exécutées de manière répétée jusqu’à ce que l’expression booléenne soit vraie.

Example:

Repeat
  Write('Enter a value (0..9): ');
  ShowMessage(IntToStr(I));
Until (I >= 0) and (I <= 9);

See also
Repeat keyword

Uses

Declaration
Uses Unit Name, ...;

Description
Le mot-clé uses liste les noms des unités importées dans l’unité englobante. La déclaration uses est facultative, car le système de script prend en charge les unités importées dans Altium Designer. Vous pouvez inclure la déclaration uses pour des raisons de lisibilité.

Toutes les unités stockées dans le même projet peuvent accéder aux variables globales de n’importe laquelle de ces unités. Gardez cela à l’esprit lorsque vous déclarez des variables dans des unités appartenant au même projet.

Les API Client, PCB, Schematic et WorkSpace Manager d’Altium Designer, ainsi que les unités SysUtils, Classes et autres de Delphi, sont importées et disponibles pour être utilisées dans les scripts ; il n’est donc pas nécessaire de déclarer spécifiquement ces unités dans les scripts.

See also

Var

Declaration
Name : Type
Name : Type = Expression;

DelphiScript Variables
Toutes les variables d’un script sont toujours de type Variant. Le transtypage est ignoré. Les types dans les déclarations de variables sont ignorés et peuvent être omis, donc ces déclarations sont correctes :
Var a : integer;
Var b : integer;
Var c, d;

Les types des paramètres dans les déclarations de procédure/fonction sont 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’avertira pas des erreurs possibles dans le code, qui ne peuvent ê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.

Déclaration d’une variable variant :

Var
  V;
Begin
  // you can assign to it values of several different types:
  V := 10;
  V := 'Hello, World';
  V := 45.55;
End;

Array elements
le type des éléments du tableau est ignoré et peut être omis, donc ces déclarations sont équivalentes :
Var x : array [1..2] of double;
Var x : array [1..2];

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

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

While

Declaration
while expression do statement

Description
L’instruction while exécute l’instruction de manière répétée tant que l’expression est vraie.

See also
Break keyword
Continue keyword
Do keyword
DownTo keyword
For keyword
Repeat keyword
To keyword
With keyword

With

Declaration
with expression do statement

Description
L’instruction With ajoute une référence d’enregistrement, d’objet, de classe ou d’interface à la portée pour la résolution des noms de symboles.

Normal version example:

Form.Canvas.Pen.Width := 2;
Form.Canvas.Pen.Color := clSilver;

With version example:

With Form.Canvas.Pen do
Begin
  Width := 2;
  Color := clSilver;
End;

See also
Do keyword

Xor

Declaration

• expression booléenne Xor expression booléenne
• integer expression Xor integer expression

Description
L’opérateur xor effectue un OU exclusif sur ses opérandes. Si les opérandes sont de type booléen, il renvoie un résultat booléen — vrai si les opérandes sont différents et faux s’ils sont identiques.

Un xor entier opère sur chaque bit de ses opérandes, en définissant le bit de résultat à 1 si les bits correspondants des deux opérandes sont différents, et à 0 si les deux opérandes ont des bits identiques. Si un opérande est plus petit que l’autre, le plus petit opérande est étendu avec des 0 dans les bits les plus à gauche.

See also
And keyword
Not keyword
Or keyword
Shl keyword
Shr keyword