Auxílios do VisualAge Generator

Instruções de atribuição

A Instrução de atribuição especifica cálculo aritmético ou movimentação de dados. Pode ser usada para atribuir o valor de uma expressão aritmética a um item de dados, para atribuir o valor de um item a outro ou para atribuir valores de itens de uma estrutura a itens correspondentes (itens de mesmo nome) de outra estrutura.

>>-resultado--=----+-+-expressão-numérica--+-----+-+-+--;------><
                   | |                     '-(R--' | |
                   | '-operando--------------------' |
                   '-função-invocação----------------'
 

expressão numérica
>>-+-expressão-numérica--operador--expressão-numérica--+-------><
   '---+---+---+-operando-------------+----------------'
       +---+   '-(expressão numérica)-'
       '-+-'
 

Atributo Descrição
resultado O resultado de uma instrução de atribuição aritmética pode ser um item de dados, EZETST, EZEMNO ou EZERCODE. Se for item de dados, pode ser subscrito, qualificado ou ambos e tem que ser numérico, empacotado ou binário.

Para outras instruções de atribuição, o resultado pode ser um item dos dados, registro, mapa ou certas palavras de função especial. Se for um item de dados, o resultado poderá ser subscrito, qualificado ou ambos.

operador Os seguintes operadores aritméticos são suportados:
 +
Os operandos são incluídos.
  -
O segundo operando é subtraído do primeiro operando.
  *
Os operandos são multiplicados.
  /
O primeiro operando é dividido pelo segundo operando.
 //
O resultado é o resto de uma divisão do primeiro operando pelo segundo operando. O operador de resto não pode ser usado com outros operadores.

Todos os operadores, exceto os unários, têm que vir delimitados por um espaço ou linha, a não ser quando precedidos ou seguidos de parênteses.

Não é permitido operadores na atribuição de instruções que envolvam registros, mapas ou dados não-numéricos.

expressão numérica Quando a expressão é um cálculo aritmético é verdadeiro que:
  • A expressão pode consistir em 1 a 255 operandos. Até 500 caracteres são aceitos usando o Gabarito de Instrução de Atribuição.
  • O número de implícitos em uma instrução aritmética é limitado a 16.
  • Os operadores aritméticos podem ser os cinco operadores binários (+, -, *, /, //). Esses operadores requerem dois operandos.
  • Os operadores aritméticos podem ser um dos dois operadores unários (+, -). Esses operadores precedem seus operandos.
  • Os parênteses podem ser usados para especificar a seqüência em que a expressão aritmética é calculada. Quando uma expressão aritmética contém parênteses encadeados, a expressão encadeada é interpretada antes da expressão que a contém.

    O número de parênteses de abertura e de fechamento devem corresponder-se, exceto para o símbolo da opção de arredondamento, (R. Um parênteses de fechamento não é permitido para o símbolo de opção de arredondamento. Se você especificar a opção de arredondamento, você deve codificá-la após o último parênteses de fechamento.

  • Quando não se usam parênteses, aplica-se a seguinte ordem de interpretação:
    • Operadores monádicos são executados primeiro.
    • Multiplicação e divisão são executadas a seguir.
    • Soma e subtração são executadas por último.
    • Dentro de uma instrução, as operações são executadas de acordo com a prioridade que elas são encontradas na instrução a partir da esquerda para a direita. Todas as operações de prioridade primária são executadas antes de quaisquer operações de prioridade secundária.
Nota:Não use o operador de resto com outros operadores aritméticos ou com a opção de arredondamento.

operando No caos de instruções de atribuição aritméticas, o operando pode ser um item de dados, um literal numérico ou qualquer palavra de função especial numérica. Se for item de dados, poderá ser subscrito, qualificado ou ambos e terá que ser numérico, empacotado ou binário.

Qualquer item de dados de registro pode ser especificado como argumento em chamadas de função de cadeia. E os literais numéricos podem ser especificados em chamadas para algumas palavras de função de cadeia. Consulte "Palavras EZE de Função da Cadeia" para determinar se os literais numéricos poderão ser utilizados com uma determinada função da cadeia.

(R No caso de instruções de atribuição aritméticas, use (R para arredondar os resultados ao final de todos os cálculos aritméticos. Quando não se especifica opção de arredondamento, o resultado é truncado.
Nota:A opção de arredondamento não pode ser usada com o operador de restos.

Embora o comprimento máximo aceito seja 18, o comprimento máximo de um item de dados utilizado como resultado da opção de arredondamento é 17. O motivo é o fato de se acrescentado internamente um dígito à precisão do item de dados original quando a opção de arredondamento é executada. Qualquer violação em itens numéricos e decimais compactados é detectada no momento que precede o processamento. Nenhuma detecção ocorre para itens de campo de mapa binários e numéricos se mais do que 17 dígitos forem usados no cálculo aritmético arredondado. Em vez disso, um estouro ocorre durante a execução. Implícitos numéricos são criados com um comprimento de 17 em vez de 18 quando usados como itens de dados de resultado de uma operação arredondada.

Se você definir uma instrução aritmética com mais de uma operação, todas as operações intermediárias são efetuadas sem a opção de arredondamento. Somente o resultado da última operação é arredondado. Isto é feito somando cinco ao dígito na precisão de um acima da precisão do resultado, e depois truncando.

Conseguindo resultados compatíveis em todos os ambientes

Devido à truncação dos resultados intermediários, os programas COBOL podem ter resultados diferentes da GUI ou dos programas C++ para as mesmas instruções aritméticas.

Para garantir resultados consistentes em todos os ambientes, use apenas um operador binário por instrução. Operadores múltiplos de adição ou subtração podem ser associados com segurança se o número de casas decimais definido para o item de resultado for maior ou igual ao número de casas decimais de qualquer um dos operandos.

O operador de resto pode produzir resultados inconsistentes se o resultado ou qualquer dos operandos estiver definido com um número de casas decimais superior a zero. Para obter um resto consistente com o número de casas decimais, use o seguinte algoritmo em vez do operador de resto:

      quotient = dividend / divisor ;
     remainder = dividend - (quotient * divisor) ;

Condições de estouro

As condições de estouro resultantes de cálculos aritméticos podem ser testadas e controladas por meio as palavras de função especial EZEOVER e EZEOVERS.

Compatibilidade com a aritmética CSP/AE

Clientes que levam programas do CSP/AE para o VisualAge Generator podem especificar /MATH=CSPAE ao gerar os programas para ambientes COBOL do host para ter certeza de que os resultados de expressões aritméticas são os mesmos no COBOL e quando são executados sob o CSP/AE. Se a aritmética COBOL padrão for satisfatória, use a opção padrão /MATH=COBOL para aumentar o desempenho.

A compatibilidade com CSP/AE não é suportada no dispositivo de teste, na GUI e nos programas C++ gerados.

Instruções CSP/AE que seguem as diretrizes de compatibilidade da seção anterior fornecem resultados consistentes em todos os ambientes.

Ambientes de Destino para atribuição

Suportado em todos os ambientes sem considerações de compatibilidade.

Exemplos para atribuição

Eis alguns exemplos que usam a Instrução de atribuição como expressão aritmética ou instrução MOVE:

Uma expressão aritmética com parênteses

O exemplo a seguir mostra uma expressão aritmética que usa parênteses.

    PERCENT-CHANGE = (NEW-VALUE - OLD-VALUE) * 100 / OLD-VALUE;

A ordem de processamento do exemplo dado é determinada pelo parênteses e pela precedência dos operadores:

    1st   intermediate result1 = (NEW-VALUE minus OLD-VALUE)
    2nd   intermediate result2 = intermediate result1 multiplied by 100
    3rd   PERCENT-CHANGE = intermediate result2 divided by OLD-VALUE

Uma instrução de atribuição para mover ou inicializar dados

Quando uma instrução de atribuição envolve movimentação de dados e a expressão fonte consiste em um operando, a instrução de atribuição trabalha exatamente como a instrução MOVE.

O exemplo abaixo mostra como usar a instrução de atribuição para movimentar ou inicializar dados:

        OLD-VALUE = NEW-VALUE;

Exemplo de instruções aritméticas válidas

Exemplos de instruções aritméticas válidas:

OP1 = OP2 + OP3 *
OP4;     /* Precisam de espaço em torno de *, /, +, -, //
OP1 = OP2 * (OP3 + OP4);   /* Parênteses forçam soma primeiro.
OP1 = OP2 - -OP3;          /* Podem existir brancos entre sinais unitários
OP1 = OP2 + -OP3;          /*   e o operando.
OP1 = OP2 - -(OP + OP);    /* Sinal unitário antes de parênteses é válido.
OP1 = OP2 + -(-OP3);       /* OP3 é um operando, (-OP3) é um
                           /*   operando.
OP1 = -OP2 + OP3;          /* Você pode iniciar com unitário menos.
OP1 = OP2 + OP3(R);        /* (R) é um subscrito.
OP1 = (OP2) (R;            /* Você pode arredondar um operando individual.
OP1 = OP2 /(OP3 + OP4);    /* Nenhum espaço necessário entre / e (.

Exemplo de instruções aritméticas que não são válidas

Os seguintes exemplos de instrução aritmética não são válidos:

OP1 = OPERAND1 - - -OPERAND2;  /* Dois sinais consecutivos não permitidos.
OP1 = OP2+OP3*OP4;             /* Requer espaços em torno de + e *.
OP1 = OP2 (- OP3);             /* Operador faltando.
OP1 = OP2 *(OP3 +(OP4 / OP5);  /* Parênteses não correspondentes.
OP1 = OP2 + OP3 * OP5 (R);     /* Nenhum espaço permitido antes de subscrito,
                               /*   nenhum parêntese direito permitido
                               /*   após a opção de arredondamento.

Exemplo de instruções de atribuição válidas

Eis alguns exemplos de instruções de atribuição:

MESSAGE_FIELD = 'Enter option';   /* Configurar mensagem.
MESSAGE-NUMBER = 007;             /* Inicializar número da mensagem.
INIT-MAP = CUST-INFO-RECORD;      /* Inicializar campos de mapa.

Exemplo de instrução de atribuição que não é válida

A instrução de atribuição a seguir não é válida:

MESSAGE_FIELD = ('Enter option'); /* Não use ()s com dados de
caractere

Instrução aritmética arredondada com múltiplas operações

O exemplo a seguir usa a opção /MATH=CSPAE:

RESULT = OP1 + OP2 + OP3 (R;

Onde:

Nome do  Casas
Campo    Decimais Comprim.  Valor
 
RESULT    2         4
OP1       4         5       1.2345
OP2       3         4       5.678
OP3       4         4        .1169

Essa instrução é executada como a seguir:

HOLD = OP1 + OP2 = 1.234 + 5.678 = 6.912
RESULT = HOLD + OP3 = 6.912 + .116 = 7.028
RESULT = 7.028 + 0.005 = 7.033
RESULT = 7.03

Sem arredondar, a instrução é executada como a seguir:

HOLD = OP1 + OP2 = 1.23 + 5.67 = 6.90
RESULT = HOLD + OP3 = 6.90 + .11 = 7.01
Nota:O truncamento ocorre nos operandos para corresponder às características do campo RESULT.

Instrução aritmética com um número negativo

O exemplo a seguir usa a opção /MATH=CSPAE.

Sem
arredondamento:
A = B - C;
 
Em que: A tem 2 casas decimais e comprimento 3
 
B = 1.111
C = 3.888
 
A = -2.78
Nota:Se o número for negativo, o arredondamento é aplicado no valor absoluto.

Quando você usa a opção de arredondamento, uma condição de estouro de variável pode ocorrer, dependendo do valor e do número definido de caracteres do item de resultado.

Instrução aritmética com um estouro de variável

O exemplo a seguir usa a opção /MATH=CSPAE:

Sem
arredondamento:
A = B + C;
 
Em que: A tem 2 casas decimais e comprimento 3
   B = 8.888
   C = 1.111
 
   A = 9.99 sem estouro
 
 
Com arredondamento:
   A = B + C (R;
 
Em que: A tem 2 casas decimais e comprimento 3
   B = 8.888
   C = 1.111
 
   A = 0.00 com estouro

A possibilidade de estouro de valor máximo aumenta porque o valor do operando é incrementado.

Instrução aritmética com divisão com um resto

O exemplo a seguir usa a opção /MATH=CSPAE.

Use números inteiros na parte do operando e do resultado da instrução ao dividir para resto. Para obter restos ao tratar com números outros que não inteiros, use o comprimento e o número de casas decimais para o resultado do resto.

A seguinte fórmula é usada ao calcular o resto:

REMAINDER = DIVIDEND - (DIVISOR * QUOTIENT);
Nota:Na formula anterior, o valor no QUOTIENT possui o mesmo comprimento e número de casas decimais que o REMAINDER, como ilustrado no seguinte exemplo:
    Nome      Tipo   Comprimento Dec
 
REMAINDER1   #     8       3
REMAINDER2   #     8       0
 
A. REMAINDER1 = 12345 // 10000 = 5.000
   QUOTIENT1 = 12345 / 10000 = 1.234
 

O exemplo A é calculado como a seguir:

   REMAINDER1 = 12345 - (10000 * 1.234) = 5.000
 
 
B. REMAINDER2 = 12345 // 10000 = 2345
   QUOTIENT2 = 12345 / 10000 = 1
 

O exemplo B é calculado como a seguir:

   REMAINDER2 = 12345 - (10000 * 1) = 2345
 


[ Início da Página | Página Anterior | Próxima Página | Índice ]