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á:
- 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.
- 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.