🟦 PL/I (IBM) – Guide complet (Années 70/80 → toujours vivant)

Forces PL/I (pratiques)

Runtime & Ops (batch)

• Le pilotage prod se fait souvent via RC, logs, et datasets.
• Rerun safe : outputs temporaires, checkpoints, invariants de totals.
• Perf : I/O patterns + conversions (DEC/BIN/CHAR), compiler options.

Batch flow:
  extract → transform → report/load
Ops:
  RC + totals + diagnostics
        

DCL : déclarer clairement

DCL i FIXED BIN(31);
DCL amount FIXED DEC(15,2);
DCL code CHAR(3);
DCL name CHAR(30) VARYING;
DCL flags BIT(8);
        

Les conversions implicites existent, mais en production, il vaut mieux les contrôler.

Style modulaire “batch”

MAIN: PROC OPTIONS(MAIN);

  CALL init();
  DO WHILE( more_input() );
    CALL process_one();
  END;
  CALL finalize();

END MAIN;
        

Objectif : lisibilité + testabilité + rerun safe.

Compile/build (concepts)

• Options compiler influencent perf, diagnostics, runtime checks.
• En legacy, conventions site : naming, link-edit, load libs.
• Règle : activer les diagnostics en dev/QA, puis durcir en prod.

Think in environments:
  DEV: max diagnostics
  QA: strict + test harness
  PROD: stable options + monitoring
        

DCL a CHAR(10);
DCL b CHAR(30) VARYING;

a = 'ABC';
b = 'HELLO';
b = b || ' WORLD';
            

DCL mask BIT(8);
mask = '10101010'B;
            

Les strings sont une force de PL/I : parsing, formats, manipulation.

Structures (records)

DCL 1 customer,
      2 cust_id FIXED BIN(31),
      2 cust_name CHAR(30) VARYING,
      2 address,
        3 street CHAR(40) VARYING,
        3 city   CHAR(20) VARYING,
        3 zip    CHAR(10);

customer.cust_id = 42;
customer.address.city = 'LYON';
        

Arrays

DCL i FIXED BIN(31);
DCL items(10) FIXED DEC(9,2);

DO i = 1 TO 10;
  items(i) = i * 10.00;
END;
        

Les arrays + DO loops donnent un style “structuré” et lisible.

SUBSTR / INDEX

DCL line CHAR(200) VARYING;
DCL pos FIXED BIN(31);

pos = INDEX(line, ':');
IF pos > 0 THEN DO;
  key = SUBSTR(line, 1, pos-1);
  val = SUBSTR(line, pos+1);
END;
        

Parsing robuste : checklist

• Valider la présence des séparateurs (INDEX).
• Trimmer / normaliser.
• Limiter les longueurs (avoid overflow).
• Tracer les lignes invalides dans un fichier “reject”.

IF pos = 0 THEN DO;
  reject_count = reject_count + 1;
  CALL write_reject(line);
  ITERATE;
END;
        

Formatting (idée)

DCL amount FIXED DEC(15,2);
DCL out CHAR(40) VARYING;

out = 'AMOUNT=' || amount;
PUT SKIP LIST(out);
        

En production, standardiser les formats (longueur, séparateurs, encodage).

Pattern batch : loop + counters

DCL cnt FIXED BIN(31) INIT(0);

DO WHILE( has_more_input() );
  CALL read_one(line);
  cnt = cnt + 1;
  CALL process_one(line);
  CALL write_one(line);
END;

PUT SKIP LIST('COUNT=', cnt);
        

Gestion erreurs I/O

• Capturer exceptions via ON (condition) autour des GET/PUT.
• Tracer le record en erreur + position + totals.
• Écrire un “reject file” plutôt que crasher sans preuve.

ON ENDFILE(in) eof = 1;
ON ERROR CALL handle_io_error();
        

Contracts fichiers : le vrai sujet

SIGNAL / RESIGNAL (concept)

SIGNAL déclenche une condition ; RESIGNAL propage après traitement local.

ON ERROR DO;
  CALL log_context();
  RESIGNAL;
END;
        

Patterns de robustesse

Safe refactor

1. Golden outputs + totals
2. Isoler I/O et formats
3. Modulariser PROC
4. Centraliser ON handlers
5. Shadow runs + compare

Shadow run:
  legacy output A
  new output B
  compare A vs B
  switch only when identical
        

Migration data : pièges

• Conversions DEC/BIN/CHAR (rounding, formats).
• Encodage (EBCDIC/ASCII selon environnements).
• Contrats fichiers : longueur fixe, records, separators.
• Anomalies historiques : valeurs “impossibles” mais présentes en prod.