Compilation Conditionnelle

de la compilation et uniquement par le compilateur pendant qu’il génère votre programme. Les variables du programme lui-même ne sont utilisées que durant l’exécution du programme.

Pour l’essentiel, chaque condition est comme un indicateur ou un flag nommé. Ce peut être DEFINED ou UNDEFINED (c’est-à-dire, on ou off). Les conditions permettent de contrôler quelles lignes de votre programme sont compilées et lesquelles ne le sont pas. Ainsi, considérez le fragment de code de la figure 3. Quand ce code sera compilé, il déclarera « int » comme un champ 20I 0 parce que la condition LARGE_INTEGER a été définie. Si je changeais la première ligne en « /undefine LARGE_INTEGER » ou si je supprimais purement et simplement cette ligne, la condition ne serait pas définie et donc elle ferait de int un champ 10I 0.

Le fait est que je contrôle quelles lignes de ma source le compilateur est en train de compiler. Quand LARGE_ INTEGER est défini, le compilateur compilera une ligne de code ; quand cette même condition n’est pas définie, il compilera l’autre ligne.

L’un des aspects les plus intéressants de cette technique est que, au lieu d’utiliser /DEFINE dans le code du programme, vous pouvez aussi utiliser le mot-clé DEFINE sur les commandes CRTBNDRPG ou CRTRPGMOD pour définir une condition. Par exemple, la figure 4 montre comment je pourrais injecter du code supplémentaire dans mon programme RPG pour faciliter son débogage.

A présent, je peux compiler mon programme de la manière suivante et je pourrai voir la valeur de x. Quand je veux le compiler pour l’utiliser sur une machine de production, où je ne veux pas que le DSPLY soit utilisé, il me suffit d’omettre le mot-clé DEFINE :

CRTBNDRPG PGM(MYPGM)
SRCFILE(xxx/QRPGLESRC) DEFINE(DEBUG)

Cette même technique permet de désactiver une grande section de code. Il est beaucoup plus facile de mettre un /IF DEFINED devant le début du code et un /ENDIF à la fin, que de commenter chaque ligne individuellement !

On trouve aussi couramment des conditions define dans des membres /COPY. Quand vous voulez n’inclure qu’une partie d’un membre copy, ou être certains qu’une partie ne sera pas incluse deux fois, vous pouvez utiliser des conditions /DEFINE à cet effet. Supposons que j’aie un membre copy appelé ERRNO_H qui contient des définitions utilisées pour le traitement des erreurs. Chaque fois que je voudrai utiliser ces définitions, j’amènerai ERRNO_H dans mon programme RPG, comme le montre la figure 5.

A présent, j’ai les définitions, ce qui convient parfaitement, mais si ce copybook est inclus deux fois, comme dans :

/copy ERRNO_H
/copy ERRNO_H

mon programme ne se compilera pas en raison de champs en double définis. Je devine votre pensée : « Pourquoi diable quelqu’un ferait-il cela ? » Et bien, il ne le ferait pas – en tout cas pas ainsi.

Mais supposons que j’aie un programme de service pour des routines d’achat qui ont toujours besoin de définitions ERRNO_H pour s’exécuter. Pour que cela fonctionne, je mettrais /COPY ERRNO_H dans le copybook pour le programme de service d’achat. Autrement dit, j’aurais un membre appelé PURCH_H et sa première ligne de code serait /COPY ERRNO_NO. Désormais, mon code RPG pourrait se présenter ainsi :

/copy PURCH_H
/copy ERRNO_H

Et, à nouveau, j’obtiendrais des définitions de champs en double et mon programme ne se compilerait pas. Pour être certain qu’il n’y aurait jamais d’erreurs, j’inclurais le code suivant au début de ERRNO_H :

/if defined(ERRNO_H_DEFINED)
/eof
/endif
/define ERRNO_H_DEFINED

La première fois que ce copybook sera inclus dans mon programme, ERRNO_H_DEFINED ne sera pas défini et donc le code sera copié. La fois suivante, il sera défini de sorte qu’il exécutera l’instruction /EOF (qui ordonne au compilateur d’ignorer le reste du copybook). Ainsi je n’aurai jamais de symboles en double.