AWS Il servizio di modernizzazione del mainframe (esperienza Managed Runtime Environment) non è più aperto a nuovi clienti. Per funzionalità simili a AWS Mainframe Modernization Service (esperienza Managed Runtime Environment), esplora AWS Mainframe Modernization Service (Self-Managed Experience). I clienti esistenti possono continuare a utilizzare il servizio normalmente. [Per ulteriori informazioni, consulta AWS Modifica della disponibilità di Mainframe Modernization.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html) Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Altro/Utilità varie Questa sezione tratta vari programmi di utilità, con scopi vari, che non possono essere collegati a categorie esistenti Nei paragrafi seguenti, `PICTURE` deve essere intesa come la `PICTURE` parola chiave COBOL, utilizzata per descrivere il tipo di dati e i formati dei campi. ## AND/CBL\$1OR/CBL\$1XOR/CBL\$1EQ/CBL\$1IMP/CBLCBL\$1 \$1NON ### Scopo Ciò si riferisce al supporto di operazioni logiche bit per bit sugli elementi di dati, presenti in alcuni dialetti COBOL (Micro Focus). Tieni presente che il refactor automatico con AWS Transform gestisce la trasformazione degli utilizzi degli operatori bit per bit dal dialetto Cobol MF a java (vedi esempi di utilizzo di seguito). Affinché il codice modernizzato funzioni correttamente, l'applicazione di utilità dovrà essere distribuita insieme. Operatori supportati: + Operatore unario: | Operatore unario | details | | --- | --- | | CBL\$1NOT | Complemento bit per bit (\$1target) | + Operatori binari: | Operatori binari | details | | --- | --- | | CBL\$1AND | AND bit per bit (sorgente e destinazione) | | CBL\$1OR | OR bit per bit (fonte \$1 destinazione) | | CBL\$1XOR | OR esclusivo bit per bit (sorgente ^ destinazione) | | CBL\$1EQ | Equivalenza bit per bit (\$1 (source ^ target)) | | CBL\$1IMP | Implicazione bit per bit (\$1source \$1 target) | ### Firma Oltre a CBL\$1NOT che ha un solo operando (target), tutte le altre operazioni hanno almeno due operandi, che sono elementi di dati. Il primo operando è l'origine, il secondo operando è la destinazione. Un argomento opzionale aggiuntivo (length) fornisce il numero di byte da elaborare (da sinistra a destra). Se la lunghezza viene omessa, il valore predefinito è il minimo delle dimensioni di origine e destinazione (in byte). Il risultato dell'operazione viene memorizzato nella destinazione. Il codice restituito dal programma è 0 (a meno che non si verifichi un'eccezione). ### Controlli/Gestione degli errori + Per ogni operatore disponibile, viene verificato il numero di argomenti richiesti. Se il numero minimo di argomenti richiesti non viene soddisfatto, `IllegalArgumentException` verrà generato un. + Viene verificata la positività dell'argomento opzionale relativo alla lunghezza intera. Se la lunghezza fornita è negativa, nei registri verrà visualizzato un messaggio e l'operatore non verrà applicato. ### Esempio di utilizzo + Esempio di operatore unario: Ecco un utilizzo in cobol di CBL\$1NOT: ``` * TARGET: 00000101 * OPERATION: NOT * EXPECTED: 11111010 = 64000 dec (2nd byte unchanged - all 0) MOVE X'0500' to TARGET CALL "CBL_NOT" USING TARGET BY VALUE 1. ``` e la corrispondente modernizzazione java: ``` /* TARGET: 00000101 OPERATION: NOT EXPECTED: 11111010 = 64000 dec (2nd byte unchanged - all 0) */ ctx.getTarget().getTargetReference().setBytes(new byte[]{ 5, 0 }); ctrl.callSubProgram("CBL_NOT", CallBuilder.newInstance() .byReference(ctx.getTarget().getTargetReference()) .byValue(1) .getArguments(), ctx); ``` + Esempio di operatore binario: Vedi ad esempio il seguente codice COBOL che utilizza CBL\$1AND: ``` * SOURCE: 00000011 * OPERATION: AND * TARGET: 00000101 * EXPECTED: 00000001 = 256 dec (2nd byte unchanged - all 0) MOVE X'0300' to SRC MOVE X'0500' to TARGET CALL "CBL_AND" USING SRC TARGET BY VALUE 1. ``` e la sua modernizzazione in java: ``` /* SOURCE: 00000011 OPERATION: AND TARGET: 00000101 EXPECTED: 00000001 = 256 dec (2nd byte unchanged - all 0) */ ctx.getSrc().getSrcReference().setBytes(new byte[]{ 3, 0 }); ctx.getTarget().getTargetReference().setBytes(new byte[]{ 5, 0 }); ctrl.callSubProgram("CBL_AND", CallBuilder.newInstance() .byReference(ctx.getSrc().getSrcReference()) .byReference(ctx.getTarget().getTargetReference()) .byValue(1) .getArguments(), ctx); ``` ## CEE3ABD ### Scopo Questo programma di utilità imita il comportamento del programma legacy con lo stesso nome, il cui ruolo consiste nel terminare un programma con un codice Abend (abnormal end) e una tempistica di pulizia opzionale. Il motore di trasformazione AWS gestisce la modernizzazione automatica delle chiamate verso CEE3 ABD. Affinché il codice modernizzato funzioni correttamente, l'applicazione di utilità dovrà essere distribuita insieme. Il programma arresta l'unità di esecuzione corrente, utilizzando il codice abend fornito. Nei registri viene stampato un messaggio informativo che specifica che è stata richiamata l'uscita dell'utente con il codice fornito. Per ora, il parametro temporale NON viene preso in considerazione, ma viene utilizzato come argomento per ragioni di compatibilità con la modernizzazione. ### Firma Il programma accetta 0 o 2 argomenti. I due argomenti sono: + Il codice Abend (un elemento di dati che deve essere interpretabile come un valore intero positivo) + I tempi di pulizia (un elemento di dati che deve essere interpretabile come un valore intero positivo) sono ignorati Quando non vengono forniti argomenti, vengono utilizzati i seguenti valori predefiniti: + Codice Abend: 0 + Tempo di pulizia: 0 ### Controlli/gestione degli errori + Verifica che vengano forniti 0 o 2 argomenti, altrimenti `IllegalArgumentException` ne verrà generato uno. + Se vengono forniti due argomenti, verifica che: il codice abend sia compreso tra 0 e 4095 (entrambi inclusi); il timing sia compreso tra 0 e 5 (entrambi inclusi) Qualsiasi fallimento di questi test attiverà un. `IllegalArgumentException` ### Esempio di utilizzo Ecco un esempio di utilizzo in un programma COBOL, dall'applicazione Carddemo: ``` 9999-ABEND-PROGRAM. DISPLAY 'ABENDING PROGRAM' MOVE 0 TO TIMING MOVE 999 TO ABCODE CALL 'CEE3ABD'. ``` e il corrispondente codice java modernizzato: ``` public void _9999AbendProgram(final Cbtrn03cContext ctx, final ExecutionController ctrl) { DisplayUtils.display(ctx, ctrl, LOGGER, "ABENDING PROGRAM"); ctx.getTiming().setTiming(0); ctx.getAbcode().setAbcode(999); ctrl.callSubProgram("CEE3ABD", CallBuilder.newInstance() .getArguments(), ctx); } ``` ## CREARE ### Scopo L'utilità CEEDATE converte un numero che rappresenta una data di Lilian (giorni dal 15 ottobre 1582) in una rappresentazione di data basata su caratteri, utilizzando un formato fornito. Imita il comportamento dell'utilità di sistema legacy con lo stesso nome. ### Firma Data la sua natura, l'utilità CEEDATE è pensata piuttosto per essere richiamata dai programmi. Richiede tre o quattro argomenti (l'ultimo argomento è facoltativo): + Il primo argomento obbligatorio è un elemento di dati numerico il cui valore verrà interpretato come una data Lilian + Il secondo argomento obbligatorio è un elemento di dati alfanumerico contenente la stringa utilizzata per la conversione della data in caratteri `PICTURE` + Il terzo argomento obbligatorio è l'elemento di dati alfanumerico di destinazione, che contiene il risultato della conversione del primo argomento utilizzando il secondo argomento come `PICTURE` + Il quarto argomento opzionale è un elemento di dati utilizzato per memorizzare il codice di feedback dell'utilità ### Controlli/Gestione degli errori + Se il numero di argomenti passati all'utilità non è tre o quattro, `BluageWrapperException` verrà generato un + Se il primo argomento numerico fornito non può essere valutato correttamente come data di Lilian (oltre i limiti), verrà registrato un messaggio di errore. Il titolare del codice di feedback opzionale, se presente, riceverà un codice di feedback di gravità 3 e il messaggio numero 2512 + Se si verifica un'eccezione durante la conversione della data a causa di un dato fornito non valido`PICTURE`, verrà registrato un messaggio di errore. Il titolare opzionale del codice di feedback, se presente, riceverà un codice di feedback di gravità 3 e il messaggio numero 2518 + Se, per qualsiasi motivo, la conversione non può avvenire correttamente, l'elemento di dati di output verrà riempito con spazi vuoti + Se la conversione è andata a buon fine, al contenitore opzionale del codice di feedback verrà fornito un codice di feedback di gravità 0 (e nessun messaggio) ### Esempio di utilizzo Ecco un esempio di chiamata da un programma COBOL (la struttura del detentore del codice di feedback FC contiene puntini di sospensione, così come contiene centinaia di voci di condizioni (livello 88) non mostrate qui): ``` WORKING-STORAGE SECTION. 01 LILIANS PIC S9(9) BINARY. 01 TIMESTAMP-OUT PIC X(80). 01 MASK. 05 MASK-LEN PIC S9(4) BINARY. 05 MASK-STR. 10 MASK-CHR PIC X OCCURS 0 TO 256 DEPENDING ON MASK-LEN. 01 ROUTINE-NAMES. 05 CEESECS-ROUTINE PIC X(08) VALUE 'CEESECS '. 05 CEELOCT-ROUTINE PIC X(08) VALUE 'CEELOCT '. 05 CEEDATE-ROUTINE PIC X(08) VALUE 'CEEDATE '. 01 FC. ... * lilian date for 4 June 1990 MOVE SPACES TO MASK-STR MOVE 148887 TO LILIANS. MOVE 23 TO MASK-LEN MOVE 'YYYY-MM-DD-HH:MI:SS.999' TO MASK-STR CALL CEEDATE-ROUTINE USING LILIANS MASK TIMESTAMP-OUT FC. ``` ## CEELOCT ### Scopo L'utilità CEELOCT viene utilizzata per restituire il file locale in tre formati: date/time + Data liliana (numero di giorni dal 14 ottobre 1582) + Lilian secondi (il numero di secondi trascorsi dalle 00:00:00 del 14 ottobre 1582) + Stringa di caratteri gregoriani (nel modulo) `YYYYMMDDHHMISS999` Imita il comportamento dell'utilità di sistema legacy con lo stesso nome. ### Firma Data la sua natura, l'utilità CEELOCT è pensata piuttosto per essere richiamata dai programmi. Richiede tre o quattro argomenti (l'ultimo argomento è facoltativo): + Il primo argomento obbligatorio è un elemento di dati, utilizzato per memorizzare la data di Lilian + Il secondo argomento obbligatorio è un elemento di dati, utilizzato per memorizzare i secondi di Lilian + Il terzo argomento obbligatorio è un elemento di dati, utilizzato per memorizzare la data gregoriana utilizzando il modulo sopra indicato + Il quarto argomento opzionale è un elemento di dati utilizzato per memorizzare il codice di feedback dell'utilità ### Controlli/Gestione degli errori + Se il numero di argomenti passati all'utilità non è tre o quattro, `BluageWrapperException` verrà generato un + Se si verifica un'eccezione durante la gestione della conversione dal formato locale date/time a uno qualsiasi dei formati di output: il primo e il secondo argomento verranno impostati su 0 e il terzo argomento rimarrà invariato; verrà registrato un messaggio di errore; Facoltativamente, al detentore del codice di feedback verrà fornito un codice di feedback con gravità 3 e il messaggio numero 2531 + In caso di successo, tutti e tre gli argomenti verranno compilati con il contenuto corretto e il codice di feedback opzionale verrà fornito con un codice di gravità 0 ### Esempio di utilizzo Ecco un frammento di codice COBOL di esempio che mostra l'utilizzo dell'utilità CEELOCT. La struttura del contenitore del codice di feedback FC non è fornita per intero in quanto contiene centinaia di voci relative alle condizioni (livello 88). ``` WORKING-STORAGE SECTION. 01 LILIANS PIC S9(9) BINARY. 01 GREGORN PIC X(80). 01 SECONDS COMP-2. 01 FC. ... 01 ROUTINE-NAMES. 05 CEESECS-ROUTINE PIC X(08) VALUE 'CEESECS '. 05 CEELOCT-ROUTINE PIC X(08) VALUE 'CEELOCT '. 05 CEEDATE-ROUTINE PIC X(08) VALUE 'CEEDATE '. ... CALL CEELOCT-ROUTINE USING LILIANS SECONDS GREGORN FC. ``` ## CEERAN (0) ### Scopo Il programma CEERAN0 viene chiamato per generare numeri pseudo-casuali, compresi tra 0,0 e 1,0, utilizzando un seme specificato. Si basa sull'algoritmo del metodo moltiplicativo congruenziale, che richiede un seme specificato dall'utente. L'uso di 0 come seme attiva una modalità specifica in cui il seme viene invece calcolato in base all'ora media di Greenwich (al momento dell'esecuzione del programma). Altrimenti, il seme viene usato così com'è. La sequenza pseudo-casuale è prevedibile. ### Firma Il programma CEERAN0 utilizza tre parametri: + il seme (parametro di input), un elemento di dati che può essere interpretato come numero intero positivo (0 incluso) + il numero casuale (parametro di output), un elemento di dati che può essere interpretato come un numero fluttuante a doppia precisione (il cui valore sarà compreso tra 0,0 e 1,0, escluso); è il risultato del programma + il codice di feedback opzionale (parametro di output), un elemento di dati di 12 byte, utilizzato per memorizzare il feedback del programma sul calcolo dei numeri casuali ### Controlli/gestione degli errori + Se il numero di argomenti non è 2 o 3, `IllegalArgumentException` verrà generato un + Il valore del seme deve essere compreso tra 0 e 2147483646, inclusi. Se il valore iniziale non rientra in questi limiti, verrà registrato un messaggio di errore e il codice di feedback verrà impostato sulla gravità 3 e il numero del messaggio su 2524. Il numero casuale risultante verrà impostato su -1,0 (comportamento analogico a quello precedente) + Se il valore iniziale è impostato su 0, ma il sistema non è stato in grado di recuperare l'ora media di Greewich (per qualsiasi motivo), il calcolo verrà eseguito utilizzando il valore 1 come fallback e il codice di feedback verrà impostato sulla gravità 1 e il numero del messaggio su 2523. Il calcolo dei numeri casuali continuerà con il valore iniziale di riserva (analogico al comportamento precedente) ### Esempio di utilizzo Questo è un esempio di java che dimostra come utilizzare il programma CEERAN0, utilizzando tutti i parametri incluso il codice di feedback, con bit provenienti da diversi livelli (entità, servizio): ``` //Entity layer public class Randomin extends RecordEntity { private final Group root = new Group(getData()).named("RANDOMIN"); private final Elementary randomin = new Elementary(root,new BinaryIntegerType(4, true),new BigDecimal("0")).named("RANDOMIN"); ... public class Randomout extends RecordEntity { private final Group root = new Group(getData()).named("RANDOMOUT"); private final Elementary randomout = new Elementary(root,new DoubleFloatingPointType(),new BigDecimal("0")).named("RANDOMOUT"); ... public class Returncode1 extends RecordEntity { private final Group root = new Group(getData()).named("RETURNCODE"); private final Elementary returncode1 = new Elementary(root,new AlphanumericType(12)," ").named("RETURNCODE"); ... // Service layer CallHandler.newInstance(ctrl, ctx, ctx.getErrorContext()) .byReference(ctx.getRandomin().getRandominReference(), ctx.getRandomout().getRandomoutReference(), ctx.getReturncode1().getReturncode1Reference()) .call("CEERAN0"); ``` ## FORMAGGI ### Scopo L'utilità CEESECS converte la rappresentazione di una stringa di timestamp in secondi Lilian (il numero di secondi trascorsi dalle 00:00:00 del 14 ottobre 1582). ### Firma Data la sua natura, l'utilità CEESECS è pensata piuttosto per essere richiamata dai programmi. Richiede tre o quattro argomenti (l'ultimo argomento è facoltativo): + Il primo argomento obbligatorio è un elemento di dati il cui valore verrà interpretato come timestamp + Il secondo argomento obbligatorio è un elemento di dati alfanumerico contenente la `PICTURE` stringa utilizzata per specificare come interpretare il primo argomento + Il terzo argomento obbligatorio è l'elemento di dati, che contiene il risultato della conversione del primo argomento utilizzando il secondo argomento come `PICTURE` + Il quarto argomento opzionale è un elemento di dati utilizzato per memorizzare il codice di feedback dell'utilità ### Controlli/Gestione degli errori + Se il numero di argomenti passati all'utilità non è tre o quattro, `BluageWrapperException` verrà generato un + Se il timestamp passato all'utilità come argomento non è valido, verrà registrato un messaggio di errore e, facoltativamente, al portatore del codice di feedback verrà fornito un codice di feedback di gravità 3 e il messaggio numero 2513 + Se l'immagine passata all'utilità come argomento non è valida, verrà registrato un messaggio di errore e, facoltativamente, al portatore del codice di feedback verrà fornito un codice di feedback di gravità 3 e il messaggio numero 2518 + Se, per qualsiasi motivo, l'output di lilian seconds non può essere calcolato, il terzo argomento (output) verrà impostato su 0 ### Esempio di utilizzo Ecco un esempio di chiamata all'utilità CEESECS in un programma COBOL: ``` WORKING-STORAGE SECTION. 01 SECONDS COMP-2. 01 TIMESTAMP-IN. 05 TIMESTAMP-IN-LEN PIC S9(4) BINARY. 05 TIMESTAMP-IN-STR. 10 TIMESTAMP-IN-CHAR PIC X OCCURS 0 TO 256 DEPENDING ON TIMESTAMP-IN-LEN. 01 MASK. 05 MASK-LEN PIC S9(4) BINARY. 05 MASK-STR. 10 MASK-CHR PIC X OCCURS 0 TO 256 DEPENDING ON MASK-LEN. 01 FC. ... 01 ROUTINE-NAMES. 05 CEESECS-ROUTINE PIC X(08) VALUE 'CEESECS '. 05 CEELOCT-ROUTINE PIC X(08) VALUE 'CEELOCT '. 05 CEEDATE-ROUTINE PIC X(08) VALUE 'CEEDATE '. ... ... * date for lilian second 12,799,191,601.123 MOVE '1988-5-16-19:00:01.123' TO TIMESTAMP-IN-STR MOVE 23 TO MASK-LEN MOVE 'YYYY-MM-DD-HH:MI:SS.999' TO MASK-STR CALL CEESECS-ROUTINE USING TIMESTAMP-IN MASK SECONDS FC. ``` ## ILBOABN0 ### Scopo Lo scopo del programma ILBOABN0 è interrompere l'unità di esecuzione corrente in modo controllato, utilizzando un codice abend (fine anomalo) fornito dall'utente. Spesso utilizzato nella gestione degli errori nei programmi dedicati. L'interruzione dell'unità di funzionamento corrente avviene lanciando un. `StopRunUnitException` ### Firma Il programma ILBOABN0 accetta un singolo argomento obbligatorio che è un elemento di dati contenente il codice abend (che deve essere interpretabile come un numero intero). ### Controlli/Gestione degli errori Durante il lancio di `StopRunUnitException` to interrupt l'esecuzione corrente dell'unità di esecuzione, il programma imposterà il codice di ritorno sul valore fornito come primo argomento. Inoltre, verrà registrato un messaggio informativo. ### Esempio di utilizzo Ecco un esempio di utilizzo in java del programma ILBOABN0, derivante da una modernizzazione COBOL tramite AWS Transform: ``` 77 WS-ABND-CODE COMP PIC S9(4) VALUE +1234. ... ... 1970-ABNDIT. CALL 'ILBOABN0' USING WS-ABND-CODE. ``` e la corrispondente modernizzazione java: ``` //Entity layer private final Group root = new Group(getData()); private final Elementary wsAbndCode = new Elementary(root,new BinaryType(4, 0, "STD", false, false, true),Short.valueOf("1234")); ... //Service layer @Override public void _1970Abndit(final MyPgmContext ctx, final ExecutionController ctrl) { ctrl.callSubProgram("ILBOABN0", CallBuilder.newInstance() .byReference(ctx.getWsAbndCode().getWsAbndCodeReference()) .getArguments(), ctx); ```