1-     Les affectations
Les affectations se font à l’aide du signe = et permettent d’assigner des valeurs à des variables.

Exemple :

// L’instruction suivante assigne à la variable
// lw_fenetre_courante  l’objet fenetre courante

Window   lw_fenetre_courante
lw_fenetre_courante = This

Vous pouvez, également, assigner des valeurs à des variables au moment de leur déclaration.

Exemple :

String ls_resultat = "Résultat des opérations"

2-     Instruction de test If-Then-Else
Pour exécuter des instructions suivant certaines conditions, vous pouvez utiliser If-Then-Else, fréquemment employée dans la plupart des langages de programmation évolués. L’instruction If-Then-Else a deux syntaxes : une s’écrivant sur une seule ligne, une autre devant s’écrire sur plusieurs lignes.

Syntaxe 1 :
IF condition THEN instruction1 [ ELSE instruction2 ]

Exemple :

Integer li_num_fen

// on récupère le contenu d’un champ d’édition que l’on 
//  transforme en entier

li_num_fen = Integer (sle_num_fen.Text ) 

// on teste si l’entier récupéré est 1 on ouvre la fenêtre w_fen1 
// Sinon on ouvre la fenêtre w_fen2.
IF li_num_fen = 1 Then Open (w_fen1) ELSE Open (w_fen2)

Syntaxe 2 :
IF condition1 THEN
    instructions1
[ ELSEIF condition2 THEN
    instructions2 ]
[ ELSE
    instructions2 ]
END IF
   
Exemple :

Integer  li_salaire

li_Salaire  = Integer (sle_valeur.Text )   // On récupère un
       // montant
IF li_Salaire < 10000 Then
  MessageBox ("Aide", "Vous avez droit à une aide.")
ELSEIF li_Salaire = 10000 THEN
  MessageBox ("Aide", "Vous êtes à la limite de vos droits")
ELSE   // si li_salaire > 10000
  MessageBox ("Aide", "Impossible d’obtenir une aide")
END IF

Notez que l’instruction IF doit toujours être terminée par un END IF.Vous pouvez également répéter le ELSEIF autant de fois que vous le souhaitez.
L’instruction IF est intéressante lorsque le test à faire est basé sur une information existante.


3-     L’instruction décision Choose-Case
CHOOSE CASE variable_de_teste
CASE expression
    Instructions
[ASE expression
    instructions
    i
    i
    i

CASE ELSE
    instructions
END CHOOSE]

où
variable_de_teste est une variable qui peut contenir différentes valeurs que vous testez. Chaque instruction CASE teste le contenu de Variable_de_teste.
et
Expression peut être une des suivantes :

Expression                                   Exemples
Une simple valeur                                              CASE 2 ou CASE "A"
Une liste de valeur séparée par des virgules                         CASE 3,7,11
le mot clé IS suivit d’un opérateur de relation             CASE IS < 17
Le mot clé TO pour définir un intervalle                                CASE 25 TO 30
une combinaison de l’ensemble impliquant un OU                  CASE 4,5,6 TO 25, IS >= 30

4-     Les instruction de boucle FOR..NEXT
La structure de contrôle For ... Next est une itération numérique. Lorsque vous devez répéter un block d’instructions un nombre de fois bien déterminé vous utiliserez For ... Next.

Syntaxe :
FOR nom_variable = undice_debut TO indice_fin [STEP pas ]
    instruction
NEXT

où

nom_variable est le nom de la variable compteur d’itération. Cette variable est de type numérique (integer , double, long, decimal ou real). Pour des raisons de performance il est préférable d’utiliser le type integer.

Indice_debut est la valeur de départ de nom_variable.

Indice_fin est la valeur de fin de nom_variable.

Pas (facultatif) précédé par STEP est la valeur de l’incrémentation. La valeur de l’incrémentation doit être une constante du même type que celui de nom_variable. Par défaut l’incrémentation est de +1.

Exemple :

integer i, li_nb_enreg

li_nb_enreg = dw_1.RowCount ()   // li_nb_enreg contient le nombre 
        // d’enregistrements dans la datawindow
FOR i = 1 TO li_nb_enreg
  
NEXT

5-     L’instruction de boucle DO ... LOOP
L’instruction de boucle DO .. LOOP permet de répéter un block d’instruction tant que ou jusqu'à ce qu'une condition soit vérifiée. La boucle DO ... LOOP peut être utilisée sous quatre formats différents plus ou moins équivalents.

a-      Format DO WHILE ... LOOP
La structure de boucle DO WHILE ... LOOP exécute un même block instruction tant qu'une condition que vous devez spécifier soit évaluée à TRUE. Le block d’instruction inclus dans la boucle cesse d’être exécuter lorsque la condition est évaluée à FALSE. Si, la toute première fois, la condition n’est pas vérifiée, le block d’instruction inclus dans la boucle ne sera pas du tout exécuté.

Syntaxe :

DO WHILE condition
    block d’instruction
LOOP

où condition est une expression booléenne que vous aurez spécifiée.
et block d’instruction correspond au block d’instruction pouvant contenir toute instruction du Powerscript que vous voulez répéter tant que condition est vraie.

Exemple :

Integer li_max , li_element, li_cpt 
Integer li_tab [  ]  // soit un tableau dynamique contenant des 
          // entiers 
FOR li_cpt = 1 TO 10
  
  li_tab [ li_cpt ] = rand (100)  // on remplit le tableau de 10 
            // entiers compris entre 1 et 100
NEXT

li_cpt = 1
// on veut déterminer le plus grand élément du tableau
li_max = UpperBound (li_tab)
li_element = li_tab [1]
DO WHILE li_cpt <= li_Max  // Tant  que li_cpt <= li_MAX
   IF li_element < li_tab [ li_cpt ] THEN
    li_element = li_tab [ li_cpt ]
  END IF
  li_cpt ++
LOOP
MessageBox ("Le plus grand élément : " + String (li_element))

b-      Format DO UNTIL ... LOOP
La structure de boucle DO UNTIL ... LOOP exécute un même block instruction jusqu'à ce qu'une condition que vous devez spécifier soit évaluée à TRUE. Tant que la condition est évaluée à FALSE le block d’instruction inclus dans la boucle s’exécute. Si, la toute première fois, la condition est vérifiée, le block d’instruction inclus dans la boucle ne sera pas du tout exécuté.

Syntaxe :
DO UNTIL condition
    block d’instruction
LOOP


où condition est une expression booléenne que vous aurez spécifiée.
et block d’instruction correspond au block d’instruction, pouvant contenir tout instruction du Powerscript, que vous voulez répéter jusqu'à ce que condition soit vraie.

Exemple :

Integer li_max , li_element, li_cpt 
Integer li_tab [  ]  // soit un tableau dynamique contenant des 
        // entiers 
FOR li_cpt = 1 TO 10
  
  li_tab [ li_cpt ] = rand (100)  // on remplit le tableau de 10 
               // entiers compris entre 1 et 100
NEXT

li_cpt = 1
// on veut déterminer le plus grand élément du tableau
li_max = UpperBound (li_tab)
li_element = li_tab [1]
DO UNTIL li_cpt > li_Max  // Jusqu’à ce que li_cpt > li_MAX
   IF li_element < li_tab [ li_cpt ] THEN
    li_element = li_tab [ li_cpt ]
  END IF
  li_cpt ++
LOOP
MessageBox ("Le plus grand élément : " + String (li_element))

c-      Format DO... LOOP WHILE
La structure de boucle DO... LOOP WHILE exécute un même block instruction tant qu'une condition que vous devez spécifier est évaluée à TRUE. Le block d’instruction inclus dans la boucle cesse d’être exécuter lorsque la condition est évaluée à FALSE. La toute première fois, quelle que soit la condition, le block d’instruction est exécuté. C’est à dire que, dans tous les cas, le block d’instruction est évalué au moins une fois car la condition de test est mise à la fin du block d’instruction à répéter.

Syntaxe :
DO
    block d’instruction
LOOP WHILE condition

où condition est une expression booléenne que vous aurez spécifiée.
et block d’instruction correspond au block d’instruction, pouvant contenir tout instruction du Powerscript, que vous voulez répéter tant que condition est vraie.

Exemple :

Integer li_max , li_element, li_cpt 
Integer li_tab [  ]  // soit un tableau dynamique contenant des 
          // entiers 
FOR li_cpt = 1 TO 10
  
  li_tab [ li_cpt ] = rand (100)  // on remplit le tableau de 10 
            // entiers compris entre 1 et 100
NEXT

li_cpt = 1
// on veut déterminer le plus grand élément du tableau
li_max = UpperBound (li_tab)
li_element = li_tab [1]
DO 
   IF li_element < li_tab [ li_cpt ] THEN
    li_element = li_tab [ li_cpt ]
  END IF
  li_cpt ++
LOOP WHILE li_cpt <= li_Max  // Tant  que li_cpt <= li_MAX
MessageBox ("Le plus grand élément : " + String (li_element))

d-      Format DO... UNTIL LOOP
La structure de boucle DO... UNTIL LOOP exécute un même block instruction jusqu'à ce qu'une condition que vous devez spécifier soit évaluée à TRUE. Tant que la condition est évaluée à FALSE le block d’instruction inclus dans la boucle s’exécute. Le block d’instruction est exécuté au moins une fois car la condition de test est mise à la fin du block d’instruction à répéter.

Syntaxe :
DO
    block d’instruction
LOOP UNTIL condition

où condition est une expression booléenne que vous aurez spécifiée.
et block d’instruction correspond au block d’instruction, pouvant contenir toute instruction du Powerscript, que vous voulez répéter jusqu'à ce que condition soit vraie.

Exemple :

Integer li_max , li_element, li_cpt 
Integer li_tab [  ]  // soit un tableau dynamique contenant des 
        // entiers 
FOR li_cpt = 1 TO 10
  
  li_tab [ li_cpt ] = rand (100)  // on remplit le tableau de 10 
               // entiers compris entre 1 et 100
NEXT

li_cpt = 1
// on veut déterminer le plus grand élément du tableau
li_max = UpperBound (li_tab)
li_element = li_tab [1]
DO 
   IF li_element < li_tab [ li_cpt ] THEN
    li_element = li_tab [ li_cpt ]
  END IF
  li_cpt ++
LOOP UNTIL li_cpt > li_Max  // Jusqu’à ce que li_cpt > li_MAX
MessageBox ("Le plus grand élément : " + String (li_element))

e-      Choix des différentes formes d’instruction de boucle
Comme vous pouvez le constater, les quatre exemples précédents donnent le même résultat. Les quatre différentes formes d’instructions de boucle sont donc, à peu de chose prêt identiques. Cependant, pour des raisons d’efficacité, un format  de boucle peut être préféré à un autre.

Vous utiliserez DO WHILE ou DO UNTIL, lorsque vous voulez que, en tout état de cause, le block d’instruction ne soit exécuté que si la condition est évaluée à TRUE, pour WHILE ou à FALSE, pour UNTIL. En effet DO WHILE et DO UNTIL testent la condition avant d’exécuter le block d’instruction.

Vous utiliserez LOOP  WHILE ou LOOP  UNTIL, lorsque vous voulez que le block d’instruction soit exécuté une fois avant que condition ne soit évaluée. En effet LOOP WHILE et LOOP  UNTIL testent la condition après avoir exécuté le block d’instruction.

· Exit : est utilisée dans les boucles itératives, elle permet de sortir de la boucle.

· Call : permet d’exécuter un scipt lié à un objet ancêtre à partir d’un script lié à un descendant.
Call objet_ancêtre {‘objet de contrôle}:: événement.
Ex : Call w_emp::Open appelle le script sur l’ouverture de la fenêtre ancêtre.
Call w_emp’cb_close::Clicked appelle le script sur l’événement clicked du bouton cd_close dans la fenêtre w_emp.

· Create : permet de créer une instance pour un type donné d’objet.
variable = create <type_objet>
La variable doit avoir le type objet. Ex :
Transaction my_trans
my_trans = create transaction
my_trans.DBMS=‘ODBC’
On référence les attributs de la variable de la même façon que ceux d’un objet.

· Destroy : supprime une variable que vous avez créee avec Create.
Destroy <nom_variable>.
Ex : destroy my_trans

· Halt {close} : permet de quitter l’application. Si on spécifie close, PowerBuilder exécute le script lié à l’événement close de l’application et quitte ensuite l’application.

· Return {expression} : quand elle est utilisée dans un script, Return interrompt l’exécution du script et attend la prochaine action de l’utilisateur.
Dans une fonction, Return{expression} interrompt l’exécution de la fonction et retourne la valeur de <expression>.