Normally, you use ABAP at a very high level, just think of RAP for example. From time to time, however, it can be useful to remember the absolute basics. Using the example of elementary data objects, let's look at the absolute basis of all data processing and descend to the bits and bytes. This may be helpful for a better understanding of how to handle data in ABAP including an in depth understanding of castings and conversions.
Data Objects and the Meaning of its Data Types
After its declaration, a data object is usable in its context (procedure, class, program) according to its type. For example, a numeric data object can be assigned the result of a calculation:
DATA num TYPE i.
num = 2 * 3 * 5 * 53 * 2267.
cl_demo_output=>display( num ).
After this assignment, the data object
num contains the calculated value
3604530, which is also displayed accordingly with a type-compliant output as, for example,
cl_demo_output=>display. And of course the same can be seen in the display of the variable in the ABAP Debugger when setting a breakpoint at the last statement.
The ABAP Debugger also shows the hexadecimal value
32003700 of the data object. This directly represents the binary value
0011 0010 0000 0000 0011 0111 0000 0000 stored in the 4 bytes allocated to the 4-byte integer number in the memory. This value is platform dependent and for numeric types is defined by the byte order order, where either the most significant (big endian) or least significant (little endian) byte is written to the first memory location. The decimal value of the hexadecimal value
32003700 shown here would be
838874880 and is not the integer value
3604530 that ABAP deals with. This shows the meaning of data types. A data object is a sequence of bytes stored in memory at its address, which is interpreted by the ABAP runtime framework according to the data type. The hexadecimal value is in most cases irrelevant to the programmer.
Let us now consider a character-like field
text with a length of two characters:
DATA text TYPE c LENGTH 2.
text = '2' && '7'.
cl_demo_output=>display( text ).
This field can be assigned the result of a string operation as shown and the result shown by
cl_demo_output=>display as well as in the ABAP Debugger is the character string
27.
Again, it is the data type, that derives the value
27 from the actual hexadecimal content, which is
32003700 as in the previous example! In this case,
32003700 is the encoding of the string
27 in the Unicode character representation UCS-2, which is supported by ABAP in Unicode systems. The Unicode character representation also depends on the platform-dependent byte order.
Only for a byte-type data type does the value as interpreted by ABAP directly correspond to the hexadecimal content. The following lines modify the bits of a byte string
hex with a bit-operation:
DATA hex TYPE x LENGTH 4 VALUE 'CDFFC8FF'.
hex = BIT-NOT hex.
cl_demo_output=>display( hex ).
Here, the output with
cl_demo_output=>display, the value display of the ABAP Debugger as well as the hexadecimal value are the same, namely
32003700.
In the above examples, we presented three data objects that all occupy 4 bytes in memory that have the same hexadecimal value
32003700 (binary value
0011 0010 0000 0000 0011 0111 0000 0000) but are handled differently by ABAP due to their data type. The data type is also responsible for the fact, that different kind of operations (numeric calculation, string concatenation, bit-operation) can be applied to the respective data objects. Using these examples we can have now look at the basic concepts of casting and type conversion and their relation to bits and bytes.
Casting
In ABAP, the term casting means nothing more than treating a data object according to a different data type than the one that is permanently assigned to it. This can be done using field symbols, with which a new (symbolic) name and a new type can be defined for the memory area of a data object. When the memory area is accessed using a field symbol, it is handled according to the type of the field symbol. The following lines show an example.
DATA hex TYPE x LENGTH 4 VALUE '32003700'.
FIELD-SYMBOLS: <num> TYPE i,
<text> TYPE c.
ASSIGN hex TO <num> CASTING.
ASSIGN hex TO <text> CASTING.
cl_demo_output=>new(
)->write_data( hex
)->write_data( <num>
)->write_data( <text> )->display( ).
The bit string in
hex is cast to a numeric field when accessed using the name
<num> and to a text field when accessed using the name
<text>. The outputs are
32003700,
3604530 and
27, clearly showing the effect of the data type on handling one and the same hexadecimal content.
Conversion
In contrast, in a type conversion (or conversion for short), the actual binary content of a data object is converted so that it fits another data type. Type conversions usually occur in assignments between data objects of different data types. The goal of such a conversion is to preserve the type-specific meaning of the content in the source field as far as possible for the data type of the target field. For this purpose, ABAP contains a large set of conversion rules. A simple example is shown here:
TYPES hex TYPE x LENGTH 4.
FIELD-SYMBOLS:
<hex_text> TYPE hex,
<hex_num> TYPE hex.
DATA: text TYPE c LENGTH 2 VALUE '27',
num TYPE i.
num = text.
ASSIGN text TO <hex_text> CASTING.
ASSIGN num TO <hex_num> CASTING.
cl_demo_output=>new(
)->write_data( text
)->write_data( <hex_text>
)->write_data( num
)->write_data( <hex_num> )->display( ).
We are assigning the character-like field
text to the numeric field
num and display the result that can also be checked in the ABAP Debugger.
The ABAP runtime framework recognizes that the character string
27 in
text can be interpreted as the integer number
27, generates the hexadecimal value
1B000000 in which this number is encoded for the numeric type of
num, and assigns it to the memory location of
num. Thus, the actual conversion takes place for the original hexadecimal content
32003700 of
text to the new hexadecimal content
1B000000 of
num. For character strings in text fields, for which no such meaningful conversion is possible, an exception occurs. The field symbols
<hex_text> and
<hex_num> are used to show the hexadecimal content of the fields
text and
num by casting them to a byte-like type.
Hint
For reasons of simplicity this blog is restricted to named elementary variables. Please note that in particular the same holds for literals that are handled internally in such a way as if they were constants of the data type assigned to the literal. In the preceding example,
text can be replaced by a literal
'27' yielding the same results.