Quarta, Dezembro 13, 2017

A instrução CALL transfere o controle de um programa de objeto para outro dentro da unidade de execução.

O programa que contém a instrução CALL é o programa chamador; O programa identificado na instrução CALL é o subprograma chamado. Os programas chamados podem conter instruções CALL; No entanto, somente os programas definidos com a cláusula RECURSIVE podem executar uma instrução CALL que se chama direta ou indiretamente.

>>-CALL--+-identifier-1--------+-------------------------------->
         +-literal-1-----------+   
         +-procedure-pointer-1-+   
         '-function-pointer-1--'   

>--+----------------------------------------------------------------------------+-->
   |        .-----------------------------------------------------------------. |   
   |        |                          .----------------------------------.   | |   
   |        V                          V                                  |   | |   
   '-USING----+-+-------------------+----+-+------------+--identifier-2-+-+-+-+-'   
              | '-+----+--REFERENCE-'    | '-ADDRESS OF-'               |   |       
              |   '-BY-'                 +-file-name-1------------------+   |       
              |                          '-OMITTED----------------------'   |       
              |                  .----------------------------------.       |       
              |                  V                                  |       |       
              +-+----+--CONTENT----+-+------------+--identifier-3-+-+-------+       
              | '-BY-'             | +-ADDRESS OF-+               |         |       
              |                    | '-LENGTH OF--'               |         |       
              |                    +-literal-2--------------------+         |       
              |                    '-OMITTED----------------------'         |       
              |                .----------------------------------.         |       
              |                V                                  |         |       
              '-+----+--VALUE----+-+------------+--identifier-4-+-+---------'       
                '-BY-'           | +-ADDRESS OF-+               |                   
                                 | '-LENGTH OF--'               |                   
                                 '-literal-3--------------------'                   

>--+-------------------------+--| exception-phrases |----------->
   '-RETURNING--identifier-5-'                          

>--+----------+------------------------------------------------><
   '-END-CALL-'   

exception-phrases

|--+-------------------------------------------------------------------------+--|
   +-+-------------------------------------------+--| not-exception-phrase |-+   
   | '-+----+--EXCEPTION--imperative-statement-1-'                           |   
   |   '-ON-'                                                                |   
   '-+----+--OVERFLOW--imperative-statement-3--------------------------------'   
     '-ON-'                                                                      

not-exception-phrase

|--+------------------------------------------------+-----------|
   '-NOT--+----+--EXCEPTION--imperative-statement-2-'   
          '-ON-'                                        

 

identifier-1 , literal-1

literal-1 deve ser um literal alfanumérico. identifier-1 deve ser um alfanumérico, alfabética, ou item de dados numérico descrito com exibir o uso de tal forma que o seu valor pode ser um nome de programa.

As regras de formação de nomes de programas dependem da opção de compilador PGMNAME. Para mais detalhes, consulte a discussão do programa de nomes no parágrafo PROGRAM-ID e também a descrição da opção do compilador pgmname no Guia de Programação Empresa COBOL .

identificador-1 não pode ser um campo de data de janela.

Nota de Uso: Não especifique o nome de uma classe ou método na instrução CALL.

 

procedure-pointer-1

Deve ser definido com USAGE IS PROCEDURE-POINTER e deve ser definido como um ponto de entrada de programa válido; Caso contrário, os resultados da instrução CALL são indefinidos.

Depois que um programa foi cancelado pelo COBOL, lançado por PL / I ou C, ou excluído pelo montador, qualquer procedimento-ponteiros que tinha sido definido para o ponto de entrada do programa não são mais válidos.

 

function-ponteiro-1

Deve ser definido com USAGE IS FUNCTION-POINTER e deve ser definido para uma função válida ou ponto de entrada do programa; Caso contrário, os resultados da instrução CALL são indefinidos.

Depois que um programa foi cancelado pelo COBOL, lançado por PL / I ou C, ou excluído pelo montador, qualquer função-ponteiros que tinha sido definida para essa função ou o ponto de entrada do programa não são mais válidos.

Quando o subprograma chamado é para ser inserido no início da divisão procedimento, literal-1 ou o conteúdo de identificador-1 deve especificar o nome do programa do subprograma chamado.

Quando o subprograma chamado é introduzido através de uma declaração ENTRADA, literal-1 ou o conteúdo de identificador-1 deve ser o mesmo que o nome especificado na declaração de entrada de chamada do subprograma.

Para obter informações sobre como o compilador resolve chamadas para-programa nomes encontrados em vários programas, consulte Convenções para um programa de nomes .

 

USING

A frase USING especifica os argumentos que são passados ​​para o programa de destino.

Inclua a frase USING na instrução CALL somente se houver uma frase USING no cabeçalho de divisão de procedimento ou a instrução ENTRY através da qual o programa chamado é executado. O número de operandos em cada frase USING deve ser idêntico.

Para mais informações sobre a frase usando, veja O cabeçalho divisão procedimento .

A seqüência dos operandos na frase USING da instrução CALL e na frase USING correspondente no cabeçalho de divisão de procedimento do subprograma chamado ou instrução ENTRY determina a correspondência entre os operandos usados ​​pelos programas chamado e chamado. Esta correspondência é posicional.

Os valores dos parâmetros referenciados na frase USING da instrução CALL são disponibilizados para o subprograma chamado no momento em que a instrução CALL é executada. A descrição dos itens de dados no programa chamado deve descrever o mesmo número de posições de caracteres como a descrição dos itens de dados correspondentes no programa de chamada.

As frases BY CONTEÚDO, POR REFERÊNCIA e POR VALOR aplicam-se aos parâmetros que os seguem até que seja encontrada outra frase por CONTEÚDO, POR REFERÊNCIA ou POR VALOR. BY REFERENCE é assumido se você não especificar uma frase BY CONTENT, BY REFERENCE ou BY VALUE antes do primeiro parâmetro.

 

BY REFERENCE

Se a frase BY REFERENCE for especificada ou implícita para um parâmetro, o item de dados correspondente no programa de chamada ocupa a mesma área de armazenamento que o item de dados no programa chamado.

 

Identifier-2

Pode ser qualquer item de dados de qualquer nível na divisão de dados. identificador-2 não pode ser uma função de identificador.

Se ele é definido na seção ligação ou seção do arquivo, você já deve ter fornecido endereçamento para identificador-2 antes da invocação da instrução CALL. Você pode fazer isso codificando um dos seguintes:ADDRESS SET DE identificador-2 PARA ponteiro Ou PROCEDIMENTO / ENTRADA.

 

File-name-1

Um arquivo-nome para um QSAM arquivo. Consulte o Guia de Programação Empresa COBOL para obter detalhes sobre o uso de nome de arquivo com a instrução CALL.

 

ADDRESS OF identifier-2

identifier-2 deve ser um item de nível 01 ou nível-77 definido na secção de ligação.

 

OMITTED

Indica que nenhum argumento é passado.

 

BY CONTENT

Se a frase BY CONTENT for especificada ou implícita para um parâmetro, o programa chamado não pode alterar o valor deste parâmetro como referenciado na frase USING da instrução CALL, embora o programa chamado pode alterar o valor do item de dados referenciado pelo correspondente data- Nome no cabeçalho de divisão de procedimento do programa chamado. Alterações no parâmetro no programa chamado não afetam o argumento correspondente no programa chamador.

 

Identifier-3

Pode ser qualquer item de dados de qualquer nível na divisão de dados. identificador-3 não pode ser um identificador de função.

Se definido na secção de ligação ou seção do arquivo, você já deve ter fornecido endereçamento para identificador-3 antes da invocação da instrução CALL. Você pode fazer isso codificando um dos seguintes:

  • ADDRESS SET DE identificador-3 PARA ponteiro
  • DIVISÃO DE PROCEDIMENTOS UTILIZANDO
  • ENTRY. . . USANDO

Literal-2

Pode ser:

  • Um literal alfanumérico
  • Uma constante figurativa (exceto ALL literal ou NULL / NULLS)
  • Um literal DBCS
  • Um literal nacional

 

LENGTH OF special register

Para obter informações sobre LENGTH OF special register, consulte LENGTH OF .

ADDRESS OF identifier-3

identifier-3 deve ser um item de dados de qualquer nível, excepto 66 ou 88 definida na secção de ligação, a secção de armazenamento de trabalho, ou a secção de armazenamento de local.

OMITTED

Indica que nenhum argumento é passado.

Para literais alfanuméricos, o subprograma chamado deve descrever o parâmetro como PIC X ( n ) exibir o uso, Onde n é o número de caracteres no literal.

Para literais DBCS, o subprograma chamado deve descrever o parâmetro como PIC G ( n ) USO DISPLAY-1, Ou PIC N ( N )Com o uso implícito ou explícito DISPLAY-1, onde n é o comprimento do literal.

Para literais nacionais, o subprograma chamado deve descrever o parâmetro como PIC N ( N )Com o uso implícito ou explícito Nacional, onde n é o comprimento do literal.

 

BY VALUE

A frase BY VALUE aplica-se a todos os argumentos que se seguem até serem substituídos por outra frase REFERENCE ou BY CONTENT.

Se a frase BY VALUE for especificada ou implícita para um argumento, o valor do argumento será passado, não uma referência ao item de dados de envio. O programa chamado pode modificar o parâmetro formal que corresponde ao argumento BY VALUE, mas essas alterações não afetam o argumento porque o programa chamado tem acesso a uma cópia temporária do item de dados de envio.

Embora os argumentos BY VALUE sejam principalmente destinados à comunicação com programas não COBOL (como C), eles também podem ser usados ​​para chamadas COBOL-to-COBOL. Nesse caso, BY VALUE deve ser especificado ou implícito tanto para o argumento na frase CALL USING como para o parâmetro formal correspondente na divisão de procedimento USING frase.

Identifier-4

Deve ser um item de dados elementar na divisão de dados. Deve ser um dos seguintes:

  • Binário (USAGE BINARY, COMP, COMP-4 ou COMP-5)
  • Ponto flutuante (USAGE COMP-1 ou COMP-2)
  • Função-ponteiro (USING FUNCTION-POINTER)
  • Ponteiro (PONTEIRO DE USO)
  • Ponteiro de procedimento (USER PROCEDURE-POINTER)
  • Referência de objeto (USAGE OBJECT REFERENCE)
  • Um caractere alfanumérico de um único byte (como PIC X ou PIC A)
  • Um carácter nacional (PIC N), descrito como um elemento elementar de dados da categoria nacional.

O seguinte também pode ser passado por valor:

  • Item de referência do item de uso e comprimento 1
  • Item de uso de referência nacional e comprimento 1
  • SHIFT-IN e SHIFT-OUT registros especiais
  • LINAGE-COUNTER registro especial quando é binário de uso

 

ADDRESS OF identifier-4

identifier-4 deve ser um item de dados de qualquer nível, excepto 66 ou 88 definida na secção de ligação, a secção de armazenamento de trabalho, ou a secção de armazenamento de local.

LENGTH OF special register

Um LENGTH OF special register passado BY VALUE é tratado como um PIC 9 (9) binário. Para obter informações sobre o comprimento do registro especial, consulte COMPRIMENTO DE .

Literal-3

Deve ser um dos seguintes:

  • Um literal numérico
  • Uma constante figurativa ZERO
  • Um literal alfanumérico de um caractere
  • Um literal nacional de um caractere
  • Um personagem simbólico
  • Uma constante figurativa de um único byte
    • SPACE
    • QUOTE
    • HIGH-VALUE
    • LOW-VALUE

ZERO é tratado como um valor numérico; Um zero binário fullword é passado.

Se literal-3 é um ponto fixo literal numérico, ele deve ter uma precisão de nove ou menos dígitos. Nesse caso, uma representação binária fullword do valor literal é passada.

Se literal-3 é um ponto flutuante literal numérico, um flutuante de ponto interno de 8 bytes (COMP-2) representação do valor é passado.

literal-3 não deve ser um DBCS literal.

 

RETURNING

Identifier-5

O item de dados RETURN, que pode ser qualquer item de dados definido na divisão de dados. O valor de retorno do programa chamado implicitamente é armazenado em identificador-5 .

Você pode especificar a frase RETURNING para chamadas para funções escritas em COBOL, C ou em outras linguagens de programação que usam convenções de vinculação C. Se você especificar a expressão RETURN em uma CALL para um subprograma COBOL:

  • O subprograma chamado deve especificar a frase RETURNING em seu cabeçalho de divisão de procedimento.
  • identificador-5 ea divisão procedimento correspondente RETORNO identificador no programa de destino deve ter o mesmo quadro, USO, sinal, SYNCHRONIZE, justificados e branco quando ZERO cláusulas (exceto essa cláusula PICTURE símbolos de moeda pode ser diferente, e pontos e vírgulas podem ser intercambiados Devido à cláusula DECIMAL POINT IS COMMA).

Quando os retornos alvo, seu valor de retorno é atribuído a identificador-5 usando as regras para a declaração SET se identificador-6 é de utilização do índice, ponteiro, função ponteiro, procedimento de ponteiro, ou referência de objeto. Quando identificador-5 é de qualquer outro uso, são utilizadas as regras para a declaração MOVE.

O item de dados CALL ... RETURNING é um parâmetro somente de saída. Ao entrar no programa chamado, o estado inicial do item de dados RETURN da DIVISÃO DE PROCEDIMENTOS tem um valor indefinido e imprevisível. Você deve inicializar o item de dados PROCURAR DIVISEste terminador de escopo explícito serve para delimitar o escopo da instrução CALL. END-CALL permite que uma instrução CALL condicional seja aninhada em outra instrução condicional. END-CALL também pode ser usado com uma instrução CALL imperativa. ou em outras linguagens de programação que usam convenções de vinculação C. Se você especificar a expressão RETURN em uma CALL para um subprograma COBOL:ÃO DEVOLUÇÃO no programa chamado antes de referência seu valor. O valor que é passado de volta para o programa de chamada é o valor final do item de dados de DIVISÃO DE PROCEDIMENTO VOLTAR quando o programa chamado retorna.

Se ocorrer uma exceção ou estouro, identificador-5 não é alterado. identificador-5 não deve ser modificado por referência.

O registo especial RETURN-CODE não é definido pela execução de instruções CALL que incluem a frase RETURN.

 

ON EXCEPTION

Uma condição de exceção ocorre quando o subprograma chamado não pode ser disponibilizado. Nesse momento, uma das duas ações a seguir ocorrerá:

  1. Se a frase exceção no for especificado, o controle é transferido para imperativa-statement-1 . Execução em seguida, continua de acordo com as regras de cada instrução especificada no imperativo-statement-1 . Se um procedimento ramificação ou declaração condicional que faz com que a transferência explícita de controle é executado, controle é transferido de acordo com as regras para essa declaração. Caso contrário, após a conclusão da execução do imperativo-statement-1 , o controle é transferido para o fim da instrução de chamada ea frase excepção, não ON, se especificado, é ignorado.
  2. Se a frase ON EXCEPTION não for especificada na instrução CALL, a frase NOT ON EXCEPTION, se especificada, será ignorada.

 

NOT ON EXCEPTION

Se uma condição de exceção não ocorrer (isto é, o subprograma chamado pode ser disponibilizado), controle é transferido para o programa chamado. Após o controle ser retornado do programa chamado, o controle é transferido para:

  • imperative-statement-2 , se a frase excepção, não ON for especificado.
  • O final da instrução CALL em qualquer outro caso. (Se a frase ON EXCEPTION for especificada, ela será ignorada.)

Se o controle é transferido para imperative-statement-2 , a execução continua de acordo com as regras de cada instrução especificada no imperativo-statement-2 . Se um procedimento ramificação ou declaração condicional que faz com que a transferência explícita de controle é executado, controle é transferido de acordo com as regras para essa declaração. Caso contrário, depois de concluída a execução dos imperativo-declaração-2 , o controlo é transferido para o final da instrução de chamada.

 

ON OVERFLOW

A ON OVERFLOW tem o mesmo efeito que ON EXCEPTION.

 

END-CALL

Este terminador de escopo explícito serve para delimitar o escopo da instrução CALL. END-CALL permite que uma instrução CALL condicional seja aninhada em outra instrução condicional. END-CALL também pode ser usado com uma instrução CALL imperativa.

A Historia do cobol

A Historia do cobol

COBOL significa Common Business Oriented Language, isto é, Linguagem Comum Orientada para o Comércio. O Cobol é um subconjunto de palavras da língua inglesa, ou seja, um número limitado de palavras inglesas sujeita a uma sintaxe própria. É uma linguagem que lida com problemas comerciais, envolvendo arquivos de dados de apreciáveis proporções (Seqüências/Vsam/Banco de dados DB2).   História: Criado por um comitê de investigadores de várias instituições civis e governamentais durante o segundo semestre de 1959. As especificações eram em grande parte inspiradas na linguagem de programação FLOW-MATIC inventada pela Grace Hopper - referida como "a mãe da língua COBOL." Em 8 de abril de...

Vagas

Em breve estaremos divulgando vagas de COBOL/CICS/DB2

Camisetas

IDENTIFICATION DIVISION

IDENTIFICATION DIVISION: Possui informações documentais, como nome do programa, quem o codificou e quando essa codificação foi realizada.    PROGRAM-ID nome do programa. (Obrigatório) AUTHOR nome do desenvolvedor. (Obrigatório) INSTALLATION nome da empresa ou local de geração do...

ENVIRONMENT DIVISION

ENVIRONMENT DIVISION: é a segunda divisão de um programa COBOL. Descreve o computador e os periféricos que serão utilizados pelo programa, fazendo ligação com o ambiente operacional onde o programa...

DATA DIVISION

DATA DIVISION: É a terceira divisão de um programa COBOL, descreve os arquivos de entrada e saída que serão usadas pelo programa. Também define as áreas de trabalho e constantes...

PROCEDURE DIVISION

PROCEDURE DIVISION: Contém o código que irá manipular os dados descritos na DATA DIVISION. É nesta divisão que o desenvolvedor descreverá a lógica do programa. Consiste em instruções executáveis ​​usando...

Comandos