ABAP Keyword Documentation → ABAP - Reference → Obsolete Language Elements → Obsolete Processing of Internal Data → Obsolete Calculation Statements

# COMPUTE

Other versions:
7.31 | **7.40** | 7.54

## Obsolete Syntax

`COMPUTE [EXACT] lhs =|?= rhs.`

### Effect

The keyword `COMPUTE`

can be written before every
assignment with an
assignment operator
`=`

or `?=`

, except when an
inline declaration or a
writable expression
is made on the left side. The keyword `COMPUTE`

is ignored by the assignment unless the addition `EXACT`

is specified.

If the addition `EXACT`

is specified, the statement works as follows:

`lhs = EXACT #( rhs ).`

In this case, `COMPUTE`

performs a
lossless calculation in accordance with the same rules as apply when using the
lossless operator `EXACT`

for
arithmetic expression. Only the
simplified arithmetic expressions described
here can be specified for `rhs`

and `lhs`

cannot have the type `f`

. If a rounding raises an exception, the target variable is not modified.

Note

The keyword `COMPUTE`

is a relic and was originally designed for arithmetic calculations where the right side is an arithmetic expression:

`COMPUTE [EXACT] result = arith_exp.`

Strictly speaking, the statement applies only in this case; more loosely, it applies even if a string expression or bit expression is specified as a different form of calculation expression on the right side.

Alongside the introduction using a calculation expression on the right side, the following variants also exist:

`COMPUTE destination = dobj.`

`dobj`

is specified on the right side, `COMPUTE`

functions like an assignment of data objects.
`COMPUTE destination_ref =|?= source_ref.`

`COMPUTE`

functions like an up cast or down cast.
`COMPUTE destination = meth( ) | func( ) | constr_expr`

`COMPUTE`

works like an
assignment of return values.
`COMPUTE destination1 = destination2 = ... = destination = rhs.`

`COMPUTE`

works like a multiple assignment.
This means that the keyword `COMPUTE`

does not produce a calculation. More specifically, `COMPUTE`

does not modify the way a
calculation type is chosen:

- When a data object is assigned to a target object, the type of the source object is always converted to the type of the target object, even if prefixed with
`COMPUTE`

.

- When an arithmetic
expression is assigned, the calculation type is always determined from all operands involved, including the left side, even if not prefixed with
`COMPUTE`

.

For this reason, it is not advisable to specify the keyword `COMPUTE`

before
assignments. If the right side is not a calculation expression, the keyword produces false information. If the right side is a calculation expression, the keyword is ignored if specified.