COBOL - A Instrução PERFORM

A Instrução PERFORM em COBOL é usada para executar um conjunto de instruções COBOL.

Existem alguns conjuntos de instruções em um programa que precisam ser executados repetidamente, como ler cada registro de um arquivo até o final. As instruções no programa estão sendo executadas em uma série até ou a menos que alguma instrução executada no fluxo altere a sequência de execução.

A instrução PERFORM pode ser usada para fazer loops em um programa COBOL.

PERFORM é classificado em dois tipos principais:

Execução Inline
Execução Outline

Inline	Outline
Ele executa uma série de instruções ou um bloco de instruções entre PERFORM e END-PERFORM.	Ele também executa uma série de instruções ou blocos de instruções codificados em uma seção ou parágrafo separado que não são codificados junto com a instrução PERFORM.
Ele não requer PARAGRAPH ou SECTION separado que precise ser codificado, que deve ser executado.	Requer um PARAGRAPH ou SECTION separado que precisa ser codificado para instruções que devem ser executadas.
O terminador de escopo (END-PERFORM) é obrigatório.	O terminador de escopo (END-PERFORM) não é necessário.
Sintaxe: PERFORM DISPLAY 'HELLO WORLD' END-PERFORM.	Sintaxe: PERFORM MAIN-PROCESS THRU PROCESS-EXIT.

Vamos ver um exemplo simples para a instrução PERFORM:

IDENTIFICATION DIVISION.
PROGRAM-ID. TSTPERFM.
PROCEDURE DIVISION.
PARAG-A.
   PERFORM DISPLAY 'PARAG-A'
   END-PERFORM.
   PERFORM PARAG-C THRU PARAG-E.

PARAG-B.
   DISPLAY 'PARAG-B'.
   STOP RUN.

PARAG-C.
    DISPLAY 'PARAG-C'.

PARAG-D.
    DISPLAY 'PARAG-D'.

PARAG-E.
    DISPLAY 'PARAG-E'.

Saída:

PARAG-A
PARAG-C
PARAG-D
PARAG-E
PARAG-B

A seguir estão alguns dos tipos PERFORM, dependendo de seu uso:

Inline PERFORM.
Simple PERFORM.
PERFORM TIMES.
PERFORM UNTIL.
PERFORM VARYING…. UNTIL….
PERFORM THRU
PERFORM WITH TEST BEFORE/TEST AFTER

Inline PERFORM:

Executa um conjunto de instruções Cobol entre Perform e END-Perform. Basicamente, isso é para manter uma lógica específica em um limite e executá-la em um loop ou número de vezes ou executar dependendo de uma condição.

Isso é útil se esse conjunto de código for usado apenas uma vez nesse programa. Se for usado várias vezes, 'Desempenho do esboço' é a melhor escolha.

Exemplo:

PERFORM
    COMPUTE TOT = MARK1+MARK2
    DISPLAY 'TOTAL MARKS' TOT
    ......
END-PERFORM

PERFORM simples:

É usado para executar um parágrafo ou seção.

Exemplo:

MAIN-PARA.
   PERFORM PARAG-1
   ...............
   STOP-RUN.
PARAG-1.
  .........
  EXIT.

PERFORM TIMES:

O PERFORM TIMES é usado principalmente para executar o bloco de instruções ou parágrafos/seções repetidamente com o número de vezes especificado.

Sintaxe:

PERFORM PARAG-A 5 TIMES.

Exemplo 1:

PERFORM 100-MAIN-PARA
   THRU 100-MAIN-PARA-X  10 TIMES.

Neste exemplo, o número de vezes que a instrução perform será executada é predeterminado. Portanto, esta instrução perform será executada 10 vezes.

Exemplo 2:

PERFORM WS-CNT
   DISPLAY WS-CNT
   SUBSTRACT 1 FROM WS-CNT
END-PERFORM.

Neste exemplo, o número de vezes que a instrução perform deve ser executada não é predeterminado. Depende do valor da variável WS-INDX.

Se I-CNT for 0 ou negativo, esta instrução perform não será toda executada.

Exemplo 3:

IDENTIFICATION DIVISION.
PROGRAM-ID. TSTPRM03.
PROCEDURE DIVISION.
PARAG-A.
    PERFORM PARAG-B 3 TIMES.
    STOP RUN.
PARAG-B.
    DISPLAY 'PARAG-B'.

Saída:

PARAG-B
PARAG-B
PARAG-B

PERFORM UNTIL:

Um bloco de instruções ou um parágrafo/seção será executado na instrução PERFORM UNTIL até que a condição especificada se torne verdadeira.

No formato de frase UNTIL, o(s) procedimento(s) referido(s) é(ão) executado(s) até que a condição especificada pela frase UNTIL seja verdadeira. O controle é então passado para a próxima instrução executável após a instrução PERFORM.
Aqui a condição é testada antes apenas no início de cada execução por padrão.
Mas esse padrão é substituído pela frase TEST AFTER. Se a frase TEST AFTER for especificada, as instruções a serem executadas serão executadas pelo menos uma vez antes que a condição seja testada (corresponde a DO UNTIL).
Em ambos os casos, se a condição for verdadeira, o controle é transferido para a próxima instrução executável após o final da instrução PERFORM. Se nem a frase TEST BEFORE nem a frase TEST AFTER forem especificadas, a frase TEST BEFORE será assumida.

A condição padrão é ' WITH TEST BEFORE, 'e especifica que a condição é testada antes da execução de instruções em um parágrafo.

Sintaxe:

PERFORM A-PARA UNTIL COUNT=5

PERFORM A-PARA WITH TEST BEFORE UNTIL COUNT=5

PERFORM A-PARA WITH TEST AFTER UNTIL COUNT=5

Exemplo 1:

MOVE 10 TO WS-CNT
PERFORM UNTIL WS-CNT = ZERO
    DISPLAY WS-CNT
    SUBSTRACT 1 FROM WS-CNT
END-PERFORM.

No exemplo acima, as instruções SUBTRACT serão executadas até que o WS-CNT se torne zero. Aqui perform será executado 10 vezes.

Exemplo 2:

IDENTIFICATION DIVISION.
PROGRAM-ID. TSTPRM02.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CNT PIC 9(1) VALUE 0.
PROCEDURE DIVISION.
PARAG-A.
    PERFORM PARAG-B WITH TEST AFTER UNTIL WS-CNT>3.
    STOP RUN.
PARAG-B.
    DISPLAY 'WS-CNT : 'WS-CNT.
    ADD 1 TO WS-CNT.
END-PERFORM.

Saída:

WS-CNT : 0
WS-CNT : 1
WS-CNT : 2
WS-CNT : 3

PERFORM VARYING…. UNTIL….:

Um bloco de uma declaração ou um parágrafo/seção será executado em PERFORM VARYING até que a condição se torne verdadeira na frase UNTIL.

A pós-frase prevê a variação de mais de um identificador.
Se algum dos operandos especificados em cond-1 ou cond-2 for subscrito ou modificado por referência, o subscrito ou modificador de referência será avaliado cada vez que a condição for testada.
Quando TEST BEFORE é indicado, todas as condições especificadas são testadas antes da primeira execução e as instruções a serem executadas são executadas, se for o caso, somente quando todos os testes especificados falham. Quando é indicado TEST AFTER, as instruções a serem executadas são executadas pelo menos uma vez, antes que qualquer condição seja testada.
Alterar os valores de identificadores e/ou nomes de índice nas frases VARYING, FROM e BY durante a execução altera o número de vezes que os procedimentos são executados.

Sintaxe:

PERFORM A-PARA VARYING A FROM 1 BY 1 UNTIL A = 5.

Exemplo 1:

PERFORM 1000-MAIN-PARAG
   THRU 1000-MAIN-PARAG-X
VARYING  WS-I FROM 1 BY 1 UNTIL WS-I > 50
  AFTER WS-J FROM 1 BY 1 UNTIL WS-J > 10.

No exemplo acima, o 1000-MAIN-PARA a 1000-MAIN-PARA-X será executado 500 vezes.
Primeiro com WS-I como 1 e WS-J variando de 1 a 10 na etapa 1, depois WS-I como 2 e novamente WS-J variando de 1 a 10 e assim por diante. Toda vez que WS-I muda de valor, WS-J deve variar de 1 a 10.
Cada vez que o loop variando WS-J é concluído, WS-J é inicializado antes de alterar o valor de WS-I.
Assim, após a execução desta instrução perform, o valor de WS-I será 51 e o de WS-J será 1 e não 11.

Exemplo 2:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-A PIC 9(2) VALUE 0.
PROCEDURE DIVISION.
PARAG-A.
    PERFORM PARAG-B VARYING WS-A FROM 2 BY 2 UNTIL WS-A=12
    STOP RUN.
PARAG-B.
    DISPLAY 'PARAG-B ' WS-A.
    DISPLAY 'PARAG-B'.

Saída:

PARAG-B 02
PARAG-B 04
PARAG-B 06
PARAG-B 08
PARAG-B 10

PERFORM THRU:

É útil para executar um conjunto contínuo de parágrafos/seções.

Exemplo:

PERFORM PARAG-1 THRU PARAG-N
PARAG-1.
....
..
EXIT.
PARAG-2.
...
EXIT.
...
PARAG-N.
...
EXIT.

PERFORM PARAG-1 THRU PARAG-N executa todos os parágrafos entre PARAG-1 e PARAG-N.

PERFORM WITH TEST BEFORE/TEST AFTER:

Com a opção Test Before, o programa verifica primeiro a condição, se a condição for falsa ele executa o trecho de código. Assim, com Test Before existe a possibilidade de não executar o código pelo menos uma vez. Onde como em Test After (que é o padrão) o código é executado pelo menos uma vez.

Exemplo:

PERFORM WITH TEST BEFORE VARYING WW-CNT1 FROM 1
          BY 1 UNTIL WW-CNT1 > WW-TRGT-CNT
....
END-PERFORM.

PERFORM PARAG-1 WITH TEST BEFORE VARYING WW-CNT1
              FROM 1 BY 1 UNTIL WF-END-OF-DATA OR
                    WW-CNT1 > WW-MAX-CNT
END-PERFORM.

Conclusão:

Use a instrução PERFORM para acessar o código que precisa ser executado em mais de um local.
Use a instrução PERFORM para estruturar seu código. Faça uma rotina principal que EXECUTA outras rotinas que por sua vez EXECUTAM outras rotinas que EXECUTAM outras rotinas até que o nível de complexidade das rotinas EXECUTADAS seja facilmente compreendido.
Use a opção WITH TEST AFTER para forçar a execução do código pelo menos uma vez.
Use a opção VARYING ... AFTER para passar por todas as entradas em tabelas multidimensionais.
Se o número de linhas na rotina for relativamente pequeno, use um PERFORM em linha em vez de um parágrafo separado. O próximo programador apreciará não ter que olhar todo o programa para encontrar uma ou duas linhas de código no parágrafo que você executou.

PERFORM - Regras de sobreposição:

Quando os procedimentos executados executam outro PERFORM os procedimentos associados ao PERFORM de 2º nível devem ser totalmente incluídos ou totalmente excluídos dos procedimentos da instrução PERFORM de primeiro nível.
Dois ou mais desses PERFORM ativos não devem ter uma saída comum.

PERFORM regras com Times:

Uma vez que a instrução perform é iniciada, quaisquer alterações no id-1 não terão efeito no número de vezes que o Para deve ser executado.
Se o identificador-1 for zero ou um número negativo no momento em que a instrução PERFORM for iniciada, o controle passará para a instrução após a instrução PERFORM.