Introduzione al free-form RPG

Chi ha imparato l'RPG contando le colonne ha un riflesso comprensibile davanti al free-form: sembra un altro linguaggio. Non lo è. Le operazioni sono le stesse, i file si leggono allo stesso modo, i programmi si compilano con lo stesso comando. Cambia dove si scrivono le cose, e cambiano alcune abitudini che il formato a colonne imponeva.

**FREE e la fine delle posizioni

Dalla 7.1 con i PTF, e nativamente dalla 7.2, un sorgente può iniziare con:

**free

Da quel momento il compilatore smette di badare alle colonne: si scrive dalla posizione 1 alla 80 come in qualsiasi altro linguaggio, con l'indentazione che si preferisce.

È una differenza più profonda di quanto sembri. Nel formato a colonne l'indentazione era decorativa, perché la posizione contava; qui l'indentazione diventa l'unico modo per far vedere la struttura, esattamente come in Java o Python.

Le dichiarazioni

Le vecchie specifiche D diventano istruzioni leggibili:

dcl-s contatore int(10);
dcl-s importo   packed(11:2);
dcl-s nome      char(30);
dcl-s oggi      date;

dcl-ds cliente qualified;
  codice  packed(7:0);
  ragsoc  char(40);
  saldo   packed(11:2);
end-ds;

qualified sulle strutture merita attenzione: obbliga a scrivere cliente.codice invece di codice. Sembra più prolisso, ma elimina alla radice la collisione fra nomi di sottocampi di strutture diverse — un problema che nei programmi lunghi costa ore.

I file si dichiarano con dcl-f:

dcl-f ORDINI  usage(*input) keyed;
dcl-f STAMPA  printer;

Le procedure al posto delle subroutine

È il cambiamento che porta il beneficio maggiore. Una subroutine BEGSR/ENDSR lavora sulle variabili globali del programma: qualsiasi cosa tocchi, la tocca per tutti. Una procedura ha parametri, un valore di ritorno e variabili proprie:

dcl-proc calcolaSconto;
  dcl-pi *n packed(5:2);
    imponibile packed(11:2) const;
    categoria  char(1)      const;
  end-pi;

  dcl-s percentuale packed(5:2);

  select;
    when categoria = 'A';
      percentuale = 15;
    when categoria = 'B';
      percentuale = 10;
    other;
      percentuale = 0;
  endsl;

  return imponibile * percentuale / 100;
end-proc;

Si richiama come una funzione qualsiasi: sconto = calcolaSconto(totale : catCliente);.

const sui parametri dice due cose insieme: che la procedura non modificherà quel valore, e che il chiamante può passare anche un'espressione invece di una variabile. È una piccola dichiarazione che rende il codice molto più facile da usare.

Gli indicatori si possono lasciare indietro

Nel formato a colonne gli indicatori erano l'unico modo di sapere com'era andata un'operazione. In free-form ci sono le funzioni predefinite:

// Invece di leggere l'indicatore 90
read ORDINI;
dow not %eof(ORDINI);
  // elaborazione
  read ORDINI;
enddo;

chain (codiceCliente) CLIENTI;
if %found(CLIENTI);
  // trovato
endif;

%eof, %found, %error dicono la stessa cosa che dicevano *IN90 e compagni, ma la dicono per esteso. Quando fra sei mesi si riapre il programma, la differenza si sente.

Cosa non è cambiato

Il ciclo RPG esiste ancora, ma nei programmi nuovi non si usa quasi più: si scrive dcl-f ... usage(*input) e si controlla il flusso a mano. Le H spec sono diventate ctl-opt:

ctl-opt dftactgrp(*no) actgrp(*caller)
        option(*srcstmt: *nodebugio)
        datedit(*dmy/);

dftactgrp(*no) è quasi obbligatorio nei programmi nuovi: senza, non si possono legare service program né usare gran parte di ILE.

Come cominciare senza riscrivere tutto

Non serve convertire il patrimonio esistente. Il modo più tranquillo è:

1. Scrivere in free-form solo i programmi nuovi.
2. Quando si mette mano a un programma vecchio, portare in free-form la sola parte che si sta toccando — i due formati possono convivere nello stesso sorgente, purché il free-form stia dentro /free ... /end-free nei sorgenti a colonne.
3. Man mano che si accumulano procedure utili, raccoglierle in un service program invece di copiarle da un programma all'altro.

Il punto 3 è quello che alla lunga cambia di più il modo di lavorare, ed è anche il motivo per cui vale la pena fare il passaggio: il free-form da solo è comodità, le procedure e i service program sono un altro modo di organizzare il lavoro.

Su quali versioni funziona

**FREE (free-form completo, dichiarazioni comprese) — introdotto con IBM i 7.2 in modo nativo, e disponibile anche su 7.1 a partire da Technology Refresh 7, con la PTF del compilatore RPG SI51094 o una sua sostituzione successiva. Su 7.1 senza quella PTF, **FREE non viene riconosciuto.

Le specifiche di calcolo free-form (/free ... /end-free) sono molto più antiche: esistevano già da V5R1. È il motivo per cui su sistemi vecchi si incontra spesso codice misto — colonne per le dichiarazioni, free-form solo per i calcoli. Se ti trovi su una release precedente alla 7.1, quella resta la strada:

     D contatore       S             10I 0
     D importo         S             11P 2
     C                   eval      contatore = 0
      /free
       contatore = contatore + 1;
      /end-free

Le dichiarazioni free-form dcl-s, dcl-ds, dcl-f, dcl-proc arrivano insieme al free-form completo: stessa disponibilità, 7.1 TR7 con PTF oppure 7.2 in poi.

dcl-f con usage(*input), %eof, %found — le funzioni predefinite esistono da molto prima del free-form e si possono usare anche nel formato a colonne.

Fonti

• Fully free-form RPG — new in 7.1 and 7.2 — IBM Support
• Fully free-form statements — IBM Documentation 7.2
• Free-form H, F, D and P statements for RPG — IBM Support
• RPG Cafe — IBM Support