%EDITC

Éditer un nombre avec un code d'édition

Présente un nombre sous forme de texte de largeur fixe, avec séparateurs de milliers, signe ou CR, remplissage ou symbole monétaire, selon un code d'édition.

Syntaxe

%EDITC(nombre : code)
%EDITC(nombre : code : *ASTFILL)
%EDITC(nombre : code : *CURSYM)
%EDITC(nombre : code : symbole)

nombre: Une zone ou une expression numérique.
code: Une lettre entre apostrophes ('A', 'J', 'Z'…) qui choisit la présentation : séparateurs de milliers, façon d'écrire le signe, suppression des zéros.
troisième paramètre: Facultatif. *ASTFILL remplace les blancs de tête par des étoiles, *CURSYM ajoute le symbole monétaire courant ($ ici), et un caractère unique entre apostrophes ('$') sert de symbole. Une chaîne de plusieurs caractères comme 'EUR' est refusée à la compilation (RNF0349).
Résultat: Une chaîne de caractères dont la longueur ne dépend que de la déclaration de la zone, pas de la valeur : 14 caractères pour un packed(9:2) avec le code A. Les blancs de tête et de queue font partie du résultat.

À quoi ça sert

Pour un état, un écran ou une ligne de message alignée, il faut que les montants aient tous la même largeur et se lisent bien : séparateurs de milliers, signe à droite, zéros de tête remplacés par des blancs. Le code d'édition fait tout cela en un seul appel, comme le mot-clé EDTCDE d'un fichier d'impression.

Le résultat a toujours la même largeur pour une zone donnée : c'est ce qui permet de colonner des montants dans un état ou un message.

Exemple 1 : Les codes d'édition sur un montant

**free
// %EDITC : les principaux codes d'edition sur un montant positif et un montant negatif.
ctl-opt dftactgrp(*no) actgrp(*new);

dcl-s facture packed(9:2) inz(1234567.89);
dcl-s avoir   packed(9:2) inz(-1234.50);
dcl-s zero    packed(9:2) inz(0);

snd-msg 'A positif : [' + %editc(facture : 'A') + ']';
snd-msg 'A negatif : [' + %editc(avoir : 'A') + ']';
snd-msg 'B positif : [' + %editc(facture : 'B') + ']';
snd-msg 'C positif : [' + %editc(facture : 'C') + ']';
snd-msg 'C negatif : [' + %editc(avoir : 'C') + ']';
snd-msg 'D positif : [' + %editc(facture : 'D') + ']';
snd-msg 'D negatif : [' + %editc(avoir : 'D') + ']';
snd-msg 'J negatif : [' + %editc(avoir : 'J') + ']';
snd-msg 'K negatif : [' + %editc(avoir : 'K') + ']';
snd-msg 'L negatif : [' + %editc(avoir : 'L') + ']';
snd-msg 'M negatif : [' + %editc(avoir : 'M') + ']';
snd-msg 'N negatif : [' + %editc(avoir : 'N') + ']';
snd-msg 'Z positif : [' + %editc(facture : 'Z') + ']';
snd-msg 'A zero    : [' + %editc(zero : 'A') + ']';
snd-msg 'B zero    : [' + %editc(zero : 'B') + ']';

*inlr = *on;

Résultat réel, compilé et exécuté sur IBM i 7.5 :

A positif : [1,234,567.89  ]
A negatif : [    1,234.50CR]
B positif : [1,234,567.89  ]
C positif : [1234567.89  ]
C negatif : [   1234.50CR]
D positif : [1234567.89  ]
D negatif : [   1234.50CR]
J negatif : [    1,234.50-]
K negatif : [    1,234.50-]
L negatif : [   1234.50-]
M negatif : [   1234.50-]
N negatif : [    -1,234.50]
Z positif : [123456789]
A zero    : [         .00  ]
B zero    : [              ]

Le code A met des virgules de milliers, laisse deux blancs à droite pour CR et écrit CR quand le montant est négatif (1,234.50CR). B fait comme A mais affiche des blancs pour zéro (dernière ligne) : A donne .00 pour zéro, B ne donne que des blancs. Avec C et D, plus de séparateur de milliers.

Les codes J à N écrivent le signe moins : J et K derrière le nombre avec séparateurs, L et M derrière le nombre sans séparateurs, N devant. Le code Z donne les chiffres seuls, sans point décimal : 123456789 pour 1234567,89.

Exemple 2 : Étoiles, symbole monétaire, date

**free
// %EDITC : remplissage par des etoiles, symbole monetaire, DECEDIT et date (code Y).
ctl-opt dftactgrp(*no) actgrp(*new);

dcl-s cheque packed(9:2) inz(1250.5);
dcl-s petit  packed(9:2) inz(0.5);
dcl-s date   packed(8:0) inz(30092026);
dcl-s trop   packed(9:2) inz(1234567.89);

snd-msg 'Etoiles       : [' + %editc(cheque : 'A' : *astfill) + ']';
snd-msg 'Symbole $     : [' + %editc(cheque : 'A' : '$') + ']';
snd-msg 'Symbole *CURSYM : [' + %editc(cheque : 'A' : *cursym) + ']';
snd-msg 'Date code Y   : [' + %editc(date : 'Y') + ']';
snd-msg '0.5 code A    : [' + %editc(petit : 'A') + ']';
snd-msg '0.5 code J    : [' + %editc(petit : 'J') + ']';
snd-msg '0.5 %CHAR     : [' + %char(petit) + ']';
snd-msg 'Longueur 1234567.89 : ' + %char(%len(%editc(trop : 'A')));
snd-msg 'Longueur 0.5        : ' + %char(%len(%editc(petit : 'A')));
snd-msg 'Longueur du %CHAR    : ' + %char(%len(%char(petit)));

*inlr = *on;

Résultat réel, compilé et exécuté sur IBM i 7.5 :

Etoiles       : [****1,250.50  ]
Symbole $     : [    $1,250.50  ]
Symbole *CURSYM : [    $1,250.50  ]
Date code Y   : [30/09/2026]
0.5 code A    : [         .50  ]
0.5 code J    : [         .50 ]
0.5 %CHAR     : [.50]
Longueur 1234567.89 : 14
Longueur 0.5        : 14
Longueur du %CHAR    : 3

Le troisième paramètre remplit le début de la zone avec des étoiles (chèques) ou ajoute un symbole. Le code Y édite un nombre de la forme JJMMAAAA en date 30/09/2026.

Regardez le zéro avant la virgule : 0,5 donne .50 avec le code A comme avec J. La dernière partie montre que la longueur reste 14 pour 1234567,89 comme pour 0,5, alors que %CHAR donne juste 3 caractères.

Exemple 3 : Virgule décimale avec DECEDIT

**free
// %EDITC avec DECEDIT('0,') : virgule decimale et zero avant la virgule.
ctl-opt dftactgrp(*no) actgrp(*new) decedit('0,');

dcl-s facture packed(9:2) inz(1234567.89);
dcl-s petit   packed(5:2) inz(0.5);
dcl-s zero    packed(9:2) inz(0);

snd-msg 'A facture : [' + %editc(facture : 'A') + ']';
snd-msg 'A 0,5     : [' + %editc(petit : 'A') + ']';
snd-msg 'J 0,5     : [' + %editc(petit : 'J') + ']';
snd-msg 'A zero    : [' + %editc(zero : 'A') + ']';

*inlr = *on;

Résultat réel, compilé et exécuté sur IBM i 7.5 :

A facture : [1.234.567,89  ]
A 0,5     : [  0,50  ]
J 0,5     : [  0,50 ]
A zero    : [        0,00  ]

Avec decedit('0,') dans ctl-opt, le séparateur de milliers devient le point et le séparateur décimal la virgule (1.234.567,89), et le zéro avant la virgule apparaît : 0,50 au lieu de .50, et 0,00 pour zéro.

Le piège

Par défaut, un nombre inférieur à 1 perd son zéro et le séparateur est le point anglo-saxon. 0,5 donne .50, 1 234,50 donne 1,234.50 : peu lisible pour un utilisateur français. La solution est le mot-clé decedit('0,') de ctl-opt, qui s'applique à tout le programme (1.234.567,89, 0,50).

Deuxième surprise : le résultat contient des blancs, à gauche (alignement) et à droite (réservés au CR ou au signe). Pour l'insérer dans une phrase, appliquer %TRIM. Et le code Z supprime le point décimal sans rien dire.