AWS O Mainframe Modernization Service (experiência em Managed Runtime Environment) não está mais aberto a novos clientes. Para recursos semelhantes ao AWS Mainframe Modernization Service (experiência em Managed Runtime Environment), explore o AWS Mainframe Modernization Service (experiência autogerenciada). Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte Alteração na [disponibilidade AWS da modernização do mainframe](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html). As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Outros//Utilitários diversos Esta seção abrange vários programas utilitários, com finalidades diversas, que não puderam ser anexados às categorias existentes. Nos parágrafos a seguir, `PICTURE` deve ser entendida como a `PICTURE` palavra-chave COBOL, usada para descrever o tipo e os formatos de dados dos campos. ## CBL\_ \_NÃO AND/CBL\_OR/CBL\_XOR/CBL\_EQ/CBL\_IMP/CBL ### Finalidade Isso está relacionado ao suporte de operações lógicas bit a bit em itens de dados, encontradas em alguns dialetos COBOL (Micro Focus). Observe que a refatoração automática com o AWS Transform processa a transformação do uso de operadores bit a bit do dialeto Cobol MF para java (veja exemplos de usos abaixo). Para que o código modernizado seja executado corretamente, o aplicativo utilitário deverá ser implantado paralelamente. Operadores suportados: + Operador unário: | Operador unário | detalhes | | --- | --- | | CBL\_NOT | Complemento bit a bit (\~target) | + Operadores binários: | Operadores binários | detalhes | | --- | --- | | CBL\_AND | AND bit a bit (origem e destino) | | CBL\_OR | OR bit a bit (fonte \| destino) | | CBL\_XOR | OR exclusivo bit a bit (fonte ^ destino) | | CBL\_EQ | Equivalência bit a bit (\~ (fonte ^ alvo)) | | CBL\_IMP | Implicação bit a bit (\~source \| target) | ### Signature Além de CBL\_NOT, que tem apenas um operando (destino), todas as outras operações têm pelo menos dois operandos, que são itens de dados. O primeiro operando é a fonte, o segundo operando é o alvo. Um argumento opcional adicional (comprimento) fornece o número de bytes a serem processados (da esquerda para a direita). Se o comprimento for omitido, o padrão é o mínimo de tamanhos de origem e destino (em bytes). O resultado da operação é armazenado no alvo. O código de retorno do programa é 0 (a menos que ocorra uma exceção). ### Verificações e tratamento de erros + Para cada operador disponível, o número de argumentos necessários é verificado. Se o número mínimo de argumentos necessários não for atendido, um `IllegalArgumentException` será lançado. + O argumento opcional de comprimento inteiro é verificado quanto à positividade. Se o tamanho fornecido for negativo, uma mensagem será exibida nos registros e o operador não será aplicado. ### Uso da amostra + Amostra do operador unário: Aqui está um uso em cobol de CBL\_NOT: ``` * 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 a modernização de java correspondente: ``` /* 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); ``` + Exemplo de operador binário: Veja, por exemplo, o seguinte código COBOL usando CBL\_AND: ``` * 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 sua modernização do 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 ### Finalidade Esse programa utilitário imita o comportamento do programa legado com o mesmo nome, cuja função é encerrar um programa com um código Abend (fim anormal) e um tempo de limpeza opcional. O mecanismo de transformação da AWS gerencia a modernização automática das chamadas para a CEE3 ABD. Para que o código modernizado seja executado corretamente, o aplicativo utilitário deverá ser implantado paralelamente. O programa interrompe a unidade de execução atual, usando o código de abend fornecido. Uma mensagem informativa é impressa nos registros, especificando que uma saída do usuário foi chamada com o código fornecido. Por enquanto, o parâmetro de temporização NÃO é levado em consideração, mas está presente como um argumento para motivos de compatibilidade de modernização. ### Signature O programa aceita 0 ou 2 argumentos. Os dois argumentos são: + O código Abend (um item de dados que deve ser interpretado como um valor inteiro positivo) + O tempo de limpeza (um item de dados que deve ser interpretado como um valor inteiro positivo) -- ignorado Quando nenhum argumento é fornecido, os seguintes valores padrão estão sendo usados: + Alterar código: 0 + Tempo de limpeza: 0 ### Verificações e tratamento de erros + Verifica se 0 ou 2 argumentos estão sendo fornecidos, caso contrário, um `IllegalArgumentException` será lançado. + Se dois argumentos forem fornecidos, verifique se: o código de abend está entre 0 e 4095 (ambos incluídos); o tempo está entre 0 e 5 (ambos incluídos) Qualquer falha nesses testes desencadeará um`IllegalArgumentException`. ### Uso da amostra Aqui está um exemplo de uso em um programa COBOL, do aplicativo Carddemo: ``` 9999-ABEND-PROGRAM. DISPLAY 'ABENDING PROGRAM' MOVE 0 TO TIMING MOVE 999 TO ABCODE CALL 'CEE3ABD'. ``` e o código java modernizado correspondente: ``` 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); } ``` ## CEDER ### Finalidade O utilitário CEEDATE converte um número que representa uma data Lilian (dias desde 15 de outubro de 1582) em uma representação de data com base em caracteres, usando um formato fornecido. Ele imita o comportamento do utilitário de sistema legado com o mesmo nome. ### Signature Dada sua natureza, o utilitário CEEDATE é destinado a ser chamado a partir de programas. São necessários três ou quatro argumentos (o último argumento é opcional): + O primeiro argumento obrigatório é um item de dados numéricos cujo valor será interpretado como uma data Lilian. + O segundo argumento obrigatório é um item de dados alfanumérico contendo a `PICTURE` string usada para a conversão de data em caracteres. + O terceiro argumento obrigatório é o item de dados alfanuméricos de destino, contendo o resultado da conversão do primeiro argumento usando o segundo argumento como `PICTURE` + O quarto argumento opcional é um item de dados usado para armazenar o código de feedback do utilitário. ### Verificações e tratamento de erros + Se o número de argumentos passados para o utilitário não for três ou quatro, um `BluageWrapperException` será lançado + Se o argumento do primeiro número fornecido não puder ser avaliado adequadamente como uma data de Lilian (fora dos limites), uma mensagem de erro será registrada. O titular do código de feedback opcional, se presente, receberá um código de feedback de gravidade 3 e a mensagem número 2512 + Se ocorrer uma exceção durante a conversão de data devido a um fornecimento inválido`PICTURE`, uma mensagem de erro será registrada. O titular do código de feedback opcional, se presente, receberá um código de feedback de gravidade 3 e a mensagem número 2518 + Se, por algum motivo, a conversão não puder ocorrer corretamente, o item de dados de saída será preenchido com espaços em branco + Se a conversão for bem-sucedida, o titular do código de feedback opcional receberá um código de feedback de severidade 0 (e nenhuma mensagem) ### Uso da amostra Aqui está um exemplo de chamada de um programa COBOL (a estrutura do detentor do código de feedback FC contém reticências, pois contém centenas de entradas de condições (nível 88) não mostradas aqui): ``` 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 ### Finalidade O utilitário CEELOCT é usado para retornar o local date/time em três formatos: + Data Lilian (o número de dias desde 14 de outubro de 1582) + Segundos de Lilian (o número de segundos desde 00:00:00 de 14 de outubro de 1582) + Cadeia de caracteres gregorianos (no formato) `YYYYMMDDHHMISS999` Ele imita o comportamento do utilitário de sistema legado com o mesmo nome. ### Signature Dada sua natureza, o utilitário CEELOCT deve ser chamado a partir de programas. São necessários três ou quatro argumentos (o último argumento é opcional): + O primeiro argumento obrigatório é um item de dados, usado para armazenar a data de Lilian + O segundo argumento obrigatório é um item de dados, usado para armazenar os segundos de Lilian + O terceiro argumento obrigatório é um item de dados, usado para armazenar a data gregoriana usando o formulário fornecido acima. + O quarto argumento opcional é um item de dados usado para armazenar o código de feedback do utilitário. ### Verificações e tratamento de erros + Se o número de argumentos passados para o utilitário não for três ou quatro, um `BluageWrapperException` será lançado + Se ocorrer alguma exceção durante o processamento da conversão do formato local date/time para qualquer um dos formatos de saída: o primeiro e o segundo argumentos serão definidos como 0 e o terceiro argumento permanecerão inalterados; uma mensagem de erro será registrada; opcionalmente, o detentor do código de feedback será alimentado com um código de feedback de severidade 3 e a mensagem número 2531 + Em caso de sucesso, todos os três argumentos serão preenchidos com o conteúdo adequado e o código de feedback opcional será alimentado com um código de severidade 0 ### Uso da amostra Aqui está um exemplo de trecho COBOL mostrando o uso do utilitário CEELOCT. A estrutura do suporte do código de feedback FC não é fornecida na íntegra, pois contém centenas de entradas de condições (nível 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. ``` ## CEERAN0 ### Finalidade O programa CEERAN0 é chamado para gerar números pseudo-aleatórios, entre 0,0 e 1,0, usando uma semente especificada. É baseado no algoritmo do método congruencial multiplicativo, que requer uma semente especificada pelo usuário. Usar 0 como semente aciona um modo específico em que a semente é, na verdade, calculada a partir do tempo médio de Greenwich (no momento em que o programa está sendo executado). Caso contrário, a semente é usada como está. A sequência pseudo-aleatória é previsível. ### Signature O programa CEERAN0 usa três parâmetros: + a semente (parâmetro de entrada), um item de dados que pode ser interpretado como inteiro positivo (0 incluído) + o número aleatório (parâmetro de saída), um item de dados que pode ser interpretado como um número flutuante de dupla precisão (cujo valor estará entre 0,0 e 1,0, exclusivo); é o resultado do programa + o código de feedback opcional (parâmetro de saída), um item de dados de 12 bytes, usado para armazenar o feedback do programa sobre o cálculo do número aleatório ### Verificações e tratamento de erros + Se o número de argumentos não for 2 ou 3, um `IllegalArgumentException` será lançado + O valor inicial deve estar entre 0 e 2147483646, inclusive. Se o valor da velocidade estiver fora desses limites, uma mensagem de erro será registrada e o código de feedback será definido como severidade 3 e o número da mensagem como 2524. O número aleatório resultante será definido como -1,0 (comportamento analógico ao legado) + Se o valor inicial for definido como 0, mas o sistema não conseguir recuperar o tempo médio de Greewich (por qualquer motivo), o cálculo será feito usando o valor 1 como alternativa e o código de feedback será definido como severidade 1 e o número da mensagem como 2523. O cálculo de números aleatórios continuará com o valor da semente alternativa (comportamento análogo ao legado) ### Uso da amostra Este é um exemplo de java que demonstra como usar o programa CEERAN0, usando todos os parâmetros, incluindo o código de feedback, com bits de várias camadas (entidade, serviço): ``` //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"); ``` ## QUEIOS ### Finalidade O utilitário CEESECS converte uma representação de string de carimbo de data/hora em segundos Lilian (o número de segundos desde 00:00:00 de 14 de outubro de 1582). ### Signature Dada sua natureza, o utilitário CEESECS deve ser chamado a partir de programas. São necessários três ou quatro argumentos (o último argumento é opcional): + O primeiro argumento obrigatório é um item de dados cujo valor será interpretado como um timestamp. + O segundo argumento obrigatório é um item de dados alfanumérico contendo a `PICTURE` string usada para especificar como interpretar o primeiro argumento. + O terceiro argumento obrigatório é o item de dados, contendo o resultado da conversão do primeiro argumento usando o segundo argumento como `PICTURE` + O quarto argumento opcional é um item de dados usado para armazenar o código de feedback do utilitário. ### Verificações e tratamento de erros + Se o número de argumentos passados para o utilitário não for três ou quatro, um `BluageWrapperException` será lançado + Se o timestamp passado para o utilitário como argumento for inválido, uma mensagem de erro será registrada e, opcionalmente, o detentor do código de feedback receberá um código de feedback de severidade 3 e a mensagem número 2513 + Se a imagem passada para o utilitário como argumento for inválida, uma mensagem de erro será registrada e, opcionalmente, o detentor do código de feedback será alimentado com um código de feedback de severidade 3 e a mensagem número 2518 + Se, por algum motivo, a saída de lilian seconds não puder ser computada, o terceiro argumento (saída) será definido como 0 ### Uso da amostra Aqui está um exemplo de chamada para o utilitário CEESECS em um programa 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 ### Finalidade O objetivo do programa ILBOABN0 é interromper a unidade de execução atual de forma controlada, usando um código abend (fim anormal) fornecido pelo usuário. Frequentemente usado no tratamento de erros em programas dedicados. A interrupção da unidade de execução atual ocorre ao lançar um. `StopRunUnitException` ### Signature O programa ILBOABN0 usa um único argumento obrigatório que é um item de dados contendo o código abend (que deve ser interpretável como um número inteiro). ### Verificações e tratamento de erros Ao lançar o `StopRunUnitException` para interromper a execução da unidade de execução atual, o programa definirá o código de retorno com o valor fornecido como primeiro argumento. Além disso, uma mensagem informativa será registrada. ### Uso da amostra Aqui está um exemplo de uso em java do programa ILBOABN0, resultante de uma modernização do COBOL por meio da transformação da AWS: ``` 77 WS-ABND-CODE COMP PIC S9(4) VALUE +1234. ... ... 1970-ABNDIT. CALL 'ILBOABN0' USING WS-ABND-CODE. ``` e a modernização de java correspondente: ``` //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); ```