Skip to content

Instantly share code, notes, and snippets.

@kfowlks

kfowlks/md5algorithm.abap

Forked from PawelJagus/md5algorithm.abap
Last active September 27, 2017 14:38
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save kfowlks/b0fb20b5dddd64b299a2c2eb9b6b5b20 to your computer and use it in GitHub Desktop.
Save kfowlks/b0fb20b5dddd64b299a2c2eb9b6b5b20 to your computer and use it in GitHub Desktop.
Download ZIP
MD5 algorithm in ABAP with Update function
Raw
md5algorithm.abap
*&---------------------------------------------------------------------*
*& Report ZZZ
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*
REPORT zzz.
TYPES:
my_int TYPE x LENGTH 4,
my_int_table TYPE STANDARD TABLE OF my_int WITH NON-UNIQUE KEY table_line,
my_byte_table TYPE STANDARD TABLE OF x WITH NON-UNIQUE KEY table_line.
*----------------------------------------------------------------------*
* CLASS LCL_BITWISE DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_bitwise DEFINITION FINAL CREATE PRIVATE.
*"* public components of class LCL_BITWISE
*"* do not include other source files here!!!
PUBLIC SECTION.
CLASS-METHODS
class_constructor.
CLASS-METHODS left_shift_i
IMPORTING
!value TYPE my_int
!positions TYPE i
RETURNING
value(returning) TYPE my_int.
CLASS-METHODS right_shift_i
IMPORTING
!value TYPE my_int
!positions TYPE i
RETURNING
value(returning) TYPE my_int.
CLASS-METHODS unsigned_right_shift_i
IMPORTING
!value TYPE my_int
!positions TYPE i
RETURNING
value(returning) TYPE my_int.
CLASS-METHODS add_i
IMPORTING
!a TYPE my_int
!b TYPE my_int
RETURNING
value(returning) TYPE my_int.
CLASS-METHODS subtract_i
IMPORTING
!a TYPE my_int
!b TYPE my_int
RETURNING
value(returning) TYPE my_int.
CLASS-METHODS multiply_i
IMPORTING
!a TYPE my_int
!b TYPE my_int
RETURNING
value(returning) TYPE my_int.
*"* protected components of class LCL_BITWISE
*"* do not include other source files here!!!
PROTECTED SECTION.
*"* private components of class LCL_BITWISE
*"* do not include other source files here!!!
PRIVATE SECTION.
CONSTANTS:
h_3fffffff TYPE my_int VALUE '3FFFFFFF',
h_7fffffff TYPE my_int VALUE '7FFFFFFF',
h_40000000 TYPE my_int VALUE '40000000',
h_80000000 TYPE my_int VALUE '80000000'.
CLASS-DATA:
tab_power_of_2 TYPE TABLE OF my_int.
ENDCLASS. "LCL_BITWISE DEFINITION
DEFINE add_power_of_2.
append &1 to tab_power_of_2.
END-OF-DEFINITION.
*----------------------------------------------------------------------*
* CLASS LCL_BITWISE IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_bitwise IMPLEMENTATION.
METHOD class_constructor.
DATA:
l_str_power_of_2 LIKE LINE OF tab_power_of_2.
add_power_of_2 2.
add_power_of_2 4.
add_power_of_2 8.
add_power_of_2 16.
add_power_of_2 32.
add_power_of_2 64.
add_power_of_2 128.
add_power_of_2 256.
add_power_of_2 512.
add_power_of_2 1024.
add_power_of_2 2048.
add_power_of_2 4096.
add_power_of_2 8192.
add_power_of_2 16384.
add_power_of_2 32768.
add_power_of_2 65536.
add_power_of_2 131072.
add_power_of_2 262144.
add_power_of_2 524288.
add_power_of_2 1048576.
add_power_of_2 2097152.
add_power_of_2 4194304.
add_power_of_2 8388608.
add_power_of_2 16777216.
add_power_of_2 33554432.
add_power_of_2 67108864.
add_power_of_2 134217728.
add_power_of_2 268435456.
add_power_of_2 536870912.
add_power_of_2 1073741824.
ENDMETHOD. "class_constructor
* <SIGNATURE>---------------------------------------------------------------------------------------+
* | Static Public Method LCL_BITWISE=>ADD_I
* +-------------------------------------------------------------------------------------------------+
* | [--->] A TYPE I
* | [--->] B TYPE I
* | [<-()] RETURNING TYPE I
* +--------------------------------------------------------------------------------------</SIGNATURE>
METHOD add_i.
" Performs a bitwise addition of integers a and b.
" Note that this method will NOT trigger any integer overflow errors (due to the nature of bitwise operations),
" so if you want to catch integer overflows, you'll have to do such a check before calling this method.
DATA:
carry TYPE my_int,
result TYPE my_int,
shiftedcarry TYPE my_int.
TRY.
result = a + b.
CATCH cx_sy_arithmetic_overflow.
carry = a BIT-AND b.
result = a BIT-XOR b.
WHILE carry <> 0.
shiftedcarry = left_shift_i( value = carry positions = 1 ).
carry = result BIT-AND shiftedcarry.
result = result BIT-XOR shiftedcarry.
ENDWHILE.
ENDTRY.
returning = result.
ENDMETHOD. "add_i
* <SIGNATURE>---------------------------------------------------------------------------------------+
* | Static Public Method LCL_BITWISE=>LEFT_SHIFT_I
* +-------------------------------------------------------------------------------------------------+
* | [--->] VALUE TYPE I
* | [--->] POSITIONS TYPE I
* | [<-()] RETURNING TYPE I
* +--------------------------------------------------------------------------------------</SIGNATURE>
METHOD left_shift_i.
DATA:
byte_value TYPE my_int,
positions_to_shift TYPE i.
FIELD-SYMBOLS:
<fs_power_of_2> LIKE LINE OF tab_power_of_2.
positions_to_shift = positions MOD 32.
byte_value = value.
TRY.
DO positions_to_shift TIMES.
byte_value = byte_value * 2.
positions_to_shift = positions_to_shift - 1.
ENDDO.
CATCH cx_sy_arithmetic_overflow.
" Convert value to bytes - ABAP type I is 4 bytes long (32 bits)
DATA m TYPE my_int.
DO positions_to_shift TIMES.
m = byte_value BIT-AND h_40000000.
byte_value = byte_value BIT-AND h_3fffffff.
byte_value = byte_value * 2.
IF m <> 0.
byte_value = byte_value BIT-OR h_80000000.
ENDIF.
ENDDO.
ENDTRY.
returning = byte_value.
ENDMETHOD. "left_shift_i
* <SIGNATURE>---------------------------------------------------------------------------------------+
* | Static Public Method LCL_BITWISE=>MULTIPLY_I
* +-------------------------------------------------------------------------------------------------+
* | [--->] A TYPE I
* | [--->] B TYPE I
* | [<-()] RETURNING TYPE I
* +--------------------------------------------------------------------------------------</SIGNATURE>
METHOD multiply_i.
" Performs a bitwise multiplication of integers a and b.
" Note that this method will NOT trigger any integer overflow errors (due to the nature of bitwise operations),
" so if you want to catch integer overflows, you'll have to do such a check before calling this method.
DATA:
calc_a TYPE my_int,
calc_b TYPE my_int,
result TYPE my_int,
byte_01 TYPE my_int VALUE '00000001',
byte_b TYPE my_int,
byte_c TYPE my_int,
calc_c TYPE i.
calc_a = a.
calc_b = b.
result = 0.
WHILE calc_b <> 0.
byte_b = calc_b.
byte_c = byte_b BIT-AND byte_01.
calc_c = byte_c.
IF calc_c <> 0.
result = add_i( a = result b = calc_a ).
ENDIF.
calc_a = left_shift_i( value = calc_a positions = 1 ).
calc_b = unsigned_right_shift_i( value = calc_b positions = 1 ).
ENDWHILE.
returning = result.
ENDMETHOD. "multiply_i
* <SIGNATURE>---------------------------------------------------------------------------------------+
* | Static Public Method LCL_BITWISE=>RIGHT_SHIFT_I
* +-------------------------------------------------------------------------------------------------+
* | [--->] VALUE TYPE I
* | [--->] POSITIONS TYPE I
* | [<-()] RETURNING TYPE I
* +--------------------------------------------------------------------------------------</SIGNATURE>
METHOD right_shift_i.
FIELD-SYMBOLS:
<fs_power_of_2> LIKE LINE OF tab_power_of_2.
READ TABLE tab_power_of_2 ASSIGNING <fs_power_of_2> INDEX positions.
returning = value DIV <fs_power_of_2>.
ENDMETHOD. "right_shift_i
* <SIGNATURE>---------------------------------------------------------------------------------------+
* | Static Public Method LCL_BITWISE=>SUBTRACT_I
* +-------------------------------------------------------------------------------------------------+
* | [--->] A TYPE I
* | [--->] B TYPE I
* | [<-()] RETURNING TYPE I
* +--------------------------------------------------------------------------------------</SIGNATURE>
METHOD subtract_i.
" Performs a bitwise subtraction of integers a and b.
" Note that this method will NOT trigger any integer overflow errors (due to the nature of bitwise operations),
" so if you want to catch integer overflows, you'll have to do such a check before calling this method.
" a - b is the same as a + (-1 * b)
DATA bb TYPE my_int.
CONSTANTS x_minus_one TYPE my_int VALUE -1.
bb = multiply_i( a = b b = x_minus_one ).
returning = add_i( a = a b = bb ).
ENDMETHOD. "subtract_i
* <SIGNATURE>---------------------------------------------------------------------------------------+
* | Static Public Method LCL_BITWISE=>UNSIGNED_RIGHT_SHIFT_I
* +-------------------------------------------------------------------------------------------------+
* | [--->] VALUE TYPE I
* | [--->] POSITIONS TYPE I
* | [<-()] RETURNING TYPE I
* +--------------------------------------------------------------------------------------</SIGNATURE>
METHOD unsigned_right_shift_i.
DATA:
positions_to_shift TYPE i,
calc_value TYPE my_int,
a TYPE my_int,
b TYPE my_int.
positions_to_shift = positions MOD 32.
calc_value = value.
a = calc_value BIT-AND h_7fffffff.
a = right_shift_i( value = a positions = positions_to_shift ).
b = calc_value BIT-AND h_80000000.
b = right_shift_i( value = b positions = positions_to_shift ).
returning = a - b.
ENDMETHOD. "unsigned_right_shift_i
ENDCLASS. "LCL_BITWISE IMPLEMENTATION
DEFINE add_i_2.
&1 = lcl_bitwise=>add_i( a = &1 b = &2 ).
END-OF-DEFINITION.
DEFINE add_i_4.
&1 = lcl_bitwise=>add_i( a = &1 b = lcl_bitwise=>add_i( a = &2 b = lcl_bitwise=>add_i( a = &3 b = &4 ) ) ).
END-OF-DEFINITION.
*----------------------------------------------------------------------*
* CLASS lcl_md5state DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_md5state DEFINITION FINAL OPEN FOR PACKAGE.
PUBLIC SECTION.
METHODS:
constructor
IMPORTING
i_rcl_md5state TYPE REF TO lcl_md5state OPTIONAL.
PACKAGE SECTION.
DATA:
h0 TYPE my_int VALUE '67452301',
h1 TYPE my_int VALUE 'EFCDAB89',
h2 TYPE my_int VALUE '98BADCFE',
h3 TYPE my_int VALUE '10325476',
buffer TYPE my_byte_table,
count TYPE i.
ENDCLASS. "lcl_md5state DEFINITION
*----------------------------------------------------------------------*
* CLASS lcl_md5state IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_md5state IMPLEMENTATION.
METHOD constructor.
DO 64 TIMES.
APPEND INITIAL LINE TO buffer.
ENDDO.
IF i_rcl_md5state IS SUPPLIED AND i_rcl_md5state IS BOUND.
me->buffer = i_rcl_md5state->buffer.
me->h0 = i_rcl_md5state->h0.
me->h1 = i_rcl_md5state->h1.
me->h2 = i_rcl_md5state->h2.
me->h3 = i_rcl_md5state->h3.
me->count = i_rcl_md5state->count.
ENDIF.
ENDMETHOD. "constructor
ENDCLASS. "lcl_md5state IMPLEMENTATION
*----------------------------------------------------------------------*
* CLASS lcl_md5 DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_md5 DEFINITION FINAL.
PUBLIC SECTION.
CLASS-METHODS:
class_constructor.
METHODS:
constructor,
init,
update
IMPORTING
i_rcl_state TYPE REF TO lcl_md5state
i_buffer TYPE my_byte_table
i_offset TYPE i
i_length TYPE i,
update_string
IMPORTING
i_string TYPE string,
update_xstring
IMPORTING
i_xstring TYPE xstring,
final
RETURNING value(r_tab_final_bytes) TYPE my_byte_table,
as_hex
RETURNING value(r_hex_string) TYPE string.
PRIVATE SECTION.
CLASS-DATA:
padding TYPE my_byte_table.
DATA:
rcl_state TYPE REF TO lcl_md5state,
rcl_finals TYPE REF TO lcl_md5state.
METHODS:
decode
IMPORTING
buffer TYPE my_byte_table
shift TYPE i
CHANGING
out TYPE my_int_table,
transform
IMPORTING
i_rcl_state TYPE REF TO lcl_md5state
buffer TYPE my_byte_table
shift TYPE i
CHANGING
decode_buf TYPE my_int_table,
encode
IMPORTING
input TYPE my_int_table
len TYPE i
RETURNING value(out) TYPE my_byte_table,
left_shift_i
IMPORTING
value TYPE my_int
positions TYPE i
RETURNING value(returning) TYPE my_int,
right_shift_i
IMPORTING
value TYPE my_int
positions TYPE i
RETURNING value(returning) TYPE my_int,
unsigned_right_shift_i
IMPORTING
value TYPE my_int
positions TYPE i
RETURNING value(returning) TYPE my_int.
ENDCLASS. "lcl_md5 DEFINITION
*----------------------------------------------------------------------*
* CLASS lcl_md5 IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_md5 IMPLEMENTATION.
METHOD class_constructor.
FIELD-SYMBOLS:
<fs_padding> LIKE LINE OF padding.
DO 64 TIMES.
APPEND INITIAL LINE TO padding.
ENDDO.
READ TABLE padding ASSIGNING <fs_padding> INDEX 1.
<fs_padding> = '80'.
ENDMETHOD. "class_constructor
METHOD constructor.
me->init( ).
ENDMETHOD. "constructor
METHOD decode.
CONSTANTS:
l_xff TYPE x VALUE 'FF'.
DATA:
l_operand1 TYPE my_int,
l_operand2 TYPE my_int,
l_operand3 TYPE my_int,
l_operand4 TYPE my_int,
l_tmp_int TYPE i,
l_tmp_x TYPE x,
l_shift TYPE i.
FIELD-SYMBOLS:
<fs_out> LIKE LINE OF out,
<fs_buffer_ptr> LIKE LINE OF buffer.
READ TABLE out ASSIGNING <fs_out> INDEX 1.
l_shift = shift + 1.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 2.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 3.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 4.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 2.
l_shift = shift + 5.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 6.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 7.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 8.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 3.
l_shift = shift + 9.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 10.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 11.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 12.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 4.
l_shift = shift + 13.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 14.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 15.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 16.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 5.
l_shift = shift + 17.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 18.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 19.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 20.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 6.
l_shift = shift + 21.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 22.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 23.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 24.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 7.
l_shift = shift + 25.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 26.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 27.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 28.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 8.
l_shift = shift + 29.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 30.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 31.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 32.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 9.
l_shift = shift + 33.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 34.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 35.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 36.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 10.
l_shift = shift + 37.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 38.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 39.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 40.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 11.
l_shift = shift + 41.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 42.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 43.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 44.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 12.
l_shift = shift + 45.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 46.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 47.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 48.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 13.
l_shift = shift + 49.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 50.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 51.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 52.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 14.
l_shift = shift + 53.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 54.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 55.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 56.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 15.
l_shift = shift + 57.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 58.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 59.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 60.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
READ TABLE out ASSIGNING <fs_out> INDEX 16.
l_shift = shift + 61.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand1 = l_tmp_int.
l_shift = shift + 62.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand2 = l_tmp_int.
l_operand2 = me->left_shift_i( value = l_operand2 positions = 8 ).
l_shift = shift + 63.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr> BIT-AND l_xff.
l_tmp_int = l_tmp_x.
l_operand3 = l_tmp_int.
l_operand3 = me->left_shift_i( value = l_operand3 positions = 16 ).
l_shift = shift + 64.
READ TABLE buffer INDEX l_shift ASSIGNING <fs_buffer_ptr>.
l_tmp_x = <fs_buffer_ptr>.
l_tmp_int = l_tmp_x.
l_operand4 = l_tmp_int.
l_operand4 = me->left_shift_i( value = l_operand4 positions = 24 ).
<fs_out> = l_operand1 BIT-OR l_operand2 BIT-OR l_operand3 BIT-OR l_operand4.
ENDMETHOD. "decode
METHOD encode.
CONSTANTS:
l_xff TYPE my_int VALUE '000000FF'.
DATA:
i TYPE i,
j TYPE i.
FIELD-SYMBOLS:
<fs_out> LIKE LINE OF out,
<fs_input> LIKE LINE OF input.
DATA:
l_temp TYPE my_int.
DO len TIMES.
APPEND INITIAL LINE TO out.
ENDDO.
WHILE j < len.
READ TABLE out ASSIGNING <fs_out> INDEX j + 1.
READ TABLE input ASSIGNING <fs_input> INDEX i + 1.
l_temp = <fs_input> BIT-AND l_xff.
<fs_out> = l_temp+3(1).
READ TABLE out ASSIGNING <fs_out> INDEX j + 2.
l_temp = me->unsigned_right_shift_i( value = <fs_input> positions = 8 ) BIT-AND l_xff.
<fs_out> = l_temp+3(1).
READ TABLE out ASSIGNING <fs_out> INDEX j + 3.
l_temp = me->unsigned_right_shift_i( value = <fs_input> positions = 16 ) BIT-AND l_xff.
<fs_out> = l_temp+3(1).
READ TABLE out ASSIGNING <fs_out> INDEX j + 4.
l_temp = me->unsigned_right_shift_i( value = <fs_input> positions = 24 ) BIT-AND l_xff.
<fs_out> = l_temp+3(1).
i = i + 1.
j = j + 4.
ENDWHILE.
ENDMETHOD. "encode
METHOD transform.
CONSTANTS:
l_x01 TYPE my_int VALUE 'D76AA478',
l_x02 TYPE my_int VALUE 'E8C7B756',
l_x03 TYPE my_int VALUE '242070DB',
l_x04 TYPE my_int VALUE 'C1BDCEEE',
l_x05 TYPE my_int VALUE 'F57C0FAF',
l_x06 TYPE my_int VALUE '4787C62A',
l_x07 TYPE my_int VALUE 'A8304613',
l_x08 TYPE my_int VALUE 'FD469501',
l_x09 TYPE my_int VALUE '698098D8',
l_x10 TYPE my_int VALUE '8B44F7AF',
l_x11 TYPE my_int VALUE 'FFFF5BB1',
l_x12 TYPE my_int VALUE '895CD7BE',
l_x13 TYPE my_int VALUE '6B901122',
l_x14 TYPE my_int VALUE 'FD987193',
l_x15 TYPE my_int VALUE 'A679438E',
l_x16 TYPE my_int VALUE '49B40821',
l_x17 TYPE my_int VALUE 'F61E2562',
l_x18 TYPE my_int VALUE 'C040B340',
l_x19 TYPE my_int VALUE '265E5A51',
l_x20 TYPE my_int VALUE 'E9B6C7AA',
l_x21 TYPE my_int VALUE 'D62F105D',
l_x22 TYPE my_int VALUE '02441453',
l_x23 TYPE my_int VALUE 'D8A1E681',
l_x24 TYPE my_int VALUE 'E7D3FBC8',
l_x25 TYPE my_int VALUE '21E1CDE6',
l_x26 TYPE my_int VALUE 'C33707D6',
l_x27 TYPE my_int VALUE 'F4D50D87',
l_x28 TYPE my_int VALUE '455A14ED',
l_x29 TYPE my_int VALUE 'A9E3E905',
l_x30 TYPE my_int VALUE 'FCEFA3F8',
l_x31 TYPE my_int VALUE '676F02D9',
l_x32 TYPE my_int VALUE '8D2A4C8A',
l_x33 TYPE my_int VALUE 'FFFA3942',
l_x34 TYPE my_int VALUE '8771F681',
l_x35 TYPE my_int VALUE '6D9D6122',
l_x36 TYPE my_int VALUE 'FDE5380C',
l_x37 TYPE my_int VALUE 'A4BEEA44',
l_x38 TYPE my_int VALUE '4BDECFA9',
l_x39 TYPE my_int VALUE 'F6BB4B60',
l_x40 TYPE my_int VALUE 'BEBFBC70',
l_x41 TYPE my_int VALUE '289B7EC6',
l_x42 TYPE my_int VALUE 'EAA127FA',
l_x43 TYPE my_int VALUE 'D4EF3085',
l_x44 TYPE my_int VALUE '04881D05',
l_x45 TYPE my_int VALUE 'D9D4D039',
l_x46 TYPE my_int VALUE 'E6DB99E5',
l_x47 TYPE my_int VALUE '1FA27CF8',
l_x48 TYPE my_int VALUE 'C4AC5665',
l_x49 TYPE my_int VALUE 'F4292244',
l_x50 TYPE my_int VALUE '432AFF97',
l_x51 TYPE my_int VALUE 'AB9423A7',
l_x52 TYPE my_int VALUE 'FC93A039',
l_x53 TYPE my_int VALUE '655B59C3',
l_x54 TYPE my_int VALUE '8F0CCC92',
l_x55 TYPE my_int VALUE 'FFEFF47D',
l_x56 TYPE my_int VALUE '85845DD1',
l_x57 TYPE my_int VALUE '6FA87E4F',
l_x58 TYPE my_int VALUE 'FE2CE6E0',
l_x59 TYPE my_int VALUE 'A3014314',
l_x60 TYPE my_int VALUE '4E0811A1',
l_x61 TYPE my_int VALUE 'F7537E82',
l_x62 TYPE my_int VALUE 'BD3AF235',
l_x63 TYPE my_int VALUE '2AD7D2BB',
l_x64 TYPE my_int VALUE 'EB86D391'.
DATA:
a TYPE my_int,
b TYPE my_int,
c TYPE my_int,
d TYPE my_int,
bit_op_result TYPE my_int,
x LIKE REF TO decode_buf.
FIELD-SYMBOLS:
<fs_x> LIKE LINE OF x->*.
a = i_rcl_state->h0.
b = i_rcl_state->h1.
c = i_rcl_state->h2.
d = i_rcl_state->h3.
GET REFERENCE OF decode_buf INTO x.
me->decode(
EXPORTING
buffer = buffer
shift = shift
CHANGING
out = decode_buf
).
* Round 1
bit_op_result = ( b BIT-AND c ) BIT-OR ( BIT-NOT b BIT-AND d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 1.
add_i_4 a bit_op_result <fs_x> l_x01.
a = me->left_shift_i( value = a positions = 7 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 25 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND b ) BIT-OR ( BIT-NOT a BIT-AND c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 2.
add_i_4 d bit_op_result <fs_x> l_x02.
d = me->left_shift_i( value = d positions = 12 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 20 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND a ) BIT-OR ( BIT-NOT d BIT-AND b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 3.
add_i_4 c bit_op_result <fs_x> l_x03.
c = me->left_shift_i( value = c positions = 17 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 15 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND d ) BIT-OR ( BIT-NOT c BIT-AND a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 4.
add_i_4 b bit_op_result <fs_x> l_x04.
b = me->left_shift_i( value = b positions = 22 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 10 ).
add_i_2 b c.
bit_op_result = ( b BIT-AND c ) BIT-OR ( BIT-NOT b BIT-AND d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 5.
add_i_4 a bit_op_result <fs_x> l_x05.
a = me->left_shift_i( value = a positions = 7 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 25 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND b ) BIT-OR ( BIT-NOT a BIT-AND c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 6.
add_i_4 d bit_op_result <fs_x> l_x06.
d = me->left_shift_i( value = d positions = 12 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 20 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND a ) BIT-OR ( BIT-NOT d BIT-AND b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 7.
add_i_4 c bit_op_result <fs_x> l_x07.
c = me->left_shift_i( value = c positions = 17 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 15 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND d ) BIT-OR ( BIT-NOT c BIT-AND a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 8.
add_i_4 b bit_op_result <fs_x> l_x08.
b = me->left_shift_i( value = b positions = 22 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 10 ).
add_i_2 b c.
bit_op_result = ( b BIT-AND c ) BIT-OR ( BIT-NOT b BIT-AND d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 9.
add_i_4 a bit_op_result <fs_x> l_x09.
a = me->left_shift_i( value = a positions = 7 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 25 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND b ) BIT-OR ( BIT-NOT a BIT-AND c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 10.
add_i_4 d bit_op_result <fs_x> l_x10.
d = me->left_shift_i( value = d positions = 12 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 20 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND a ) BIT-OR ( BIT-NOT d BIT-AND b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 11.
add_i_4 c bit_op_result <fs_x> l_x11.
c = me->left_shift_i( value = c positions = 17 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 15 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND d ) BIT-OR ( BIT-NOT c BIT-AND a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 12.
add_i_4 b bit_op_result <fs_x> l_x12.
b = me->left_shift_i( value = b positions = 22 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 10 ).
add_i_2 b c.
bit_op_result = ( b BIT-AND c ) BIT-OR ( BIT-NOT b BIT-AND d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 13.
add_i_4 a bit_op_result <fs_x> l_x13.
a = me->left_shift_i( value = a positions = 7 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 25 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND b ) BIT-OR ( BIT-NOT a BIT-AND c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 14.
add_i_4 d bit_op_result <fs_x> l_x14.
d = me->left_shift_i( value = d positions = 12 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 20 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND a ) BIT-OR ( BIT-NOT d BIT-AND b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 15.
add_i_4 c bit_op_result <fs_x> l_x15.
c = me->left_shift_i( value = c positions = 17 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 15 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND d ) BIT-OR ( BIT-NOT c BIT-AND a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 16.
add_i_4 b bit_op_result <fs_x> l_x16.
b = me->left_shift_i( value = b positions = 22 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 10 ).
add_i_2 b c.
* Round 2
bit_op_result = ( b BIT-AND d ) BIT-OR ( c BIT-AND BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 2.
add_i_4 a bit_op_result <fs_x> l_x17.
a = me->left_shift_i( value = a positions = 5 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 27 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND c ) BIT-OR ( b BIT-AND BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 7.
add_i_4 d bit_op_result <fs_x> l_x18.
d = me->left_shift_i( value = d positions = 9 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 23 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND b ) BIT-OR ( a BIT-AND BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 12.
add_i_4 c bit_op_result <fs_x> l_x19.
c = me->left_shift_i( value = c positions = 14 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 18 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND a ) BIT-OR ( d BIT-AND BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 1.
add_i_4 b bit_op_result <fs_x> l_x20.
b = me->left_shift_i( value = b positions = 20 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 12 ).
add_i_2 b c.
bit_op_result = ( b BIT-AND d ) BIT-OR ( c BIT-AND BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 6.
add_i_4 a bit_op_result <fs_x> l_x21.
a = me->left_shift_i( value = a positions = 5 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 27 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND c ) BIT-OR ( b BIT-AND BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 11.
add_i_4 d bit_op_result <fs_x> l_x22.
d = me->left_shift_i( value = d positions = 9 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 23 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND b ) BIT-OR ( a BIT-AND BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 16.
add_i_4 c bit_op_result <fs_x> l_x23.
c = me->left_shift_i( value = c positions = 14 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 18 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND a ) BIT-OR ( d BIT-AND BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 5.
add_i_4 b bit_op_result <fs_x> l_x24.
b = me->left_shift_i( value = b positions = 20 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 12 ).
add_i_2 b c.
bit_op_result = ( b BIT-AND d ) BIT-OR ( c BIT-AND BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 10.
add_i_4 a bit_op_result <fs_x> l_x25.
a = me->left_shift_i( value = a positions = 5 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 27 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND c ) BIT-OR ( b BIT-AND BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 15.
add_i_4 d bit_op_result <fs_x> l_x26.
d = me->left_shift_i( value = d positions = 9 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 23 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND b ) BIT-OR ( a BIT-AND BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 4.
add_i_4 c bit_op_result <fs_x> l_x27.
c = me->left_shift_i( value = c positions = 14 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 18 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND a ) BIT-OR ( d BIT-AND BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 9.
add_i_4 b bit_op_result <fs_x> l_x28.
b = me->left_shift_i( value = b positions = 20 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 12 ).
add_i_2 b c.
bit_op_result = ( b BIT-AND d ) BIT-OR ( c BIT-AND BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 14.
add_i_4 a bit_op_result <fs_x> l_x29.
a = me->left_shift_i( value = a positions = 5 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 27 ).
add_i_2 a b.
bit_op_result = ( a BIT-AND c ) BIT-OR ( b BIT-AND BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 3.
add_i_4 d bit_op_result <fs_x> l_x30.
d = me->left_shift_i( value = d positions = 9 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 23 ).
add_i_2 d a.
bit_op_result = ( d BIT-AND b ) BIT-OR ( a BIT-AND BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 8.
add_i_4 c bit_op_result <fs_x> l_x31.
c = me->left_shift_i( value = c positions = 14 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 18 ).
add_i_2 c d.
bit_op_result = ( c BIT-AND a ) BIT-OR ( d BIT-AND BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 13.
add_i_4 b bit_op_result <fs_x> l_x32.
b = me->left_shift_i( value = b positions = 20 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 12 ).
add_i_2 b c.
* Round 3
bit_op_result = b BIT-XOR c BIT-XOR d.
READ TABLE x->* ASSIGNING <fs_x> INDEX 6.
add_i_4 a bit_op_result <fs_x> l_x33.
a = me->left_shift_i( value = a positions = 4 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 28 ).
add_i_2 a b.
bit_op_result = a BIT-XOR b BIT-XOR c.
READ TABLE x->* ASSIGNING <fs_x> INDEX 9.
add_i_4 d bit_op_result <fs_x> l_x34.
d = me->left_shift_i( value = d positions = 11 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 21 ).
add_i_2 d a.
bit_op_result = d BIT-XOR a BIT-XOR b.
READ TABLE x->* ASSIGNING <fs_x> INDEX 12.
add_i_4 c bit_op_result <fs_x> l_x35.
c = me->left_shift_i( value = c positions = 16 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 16 ).
add_i_2 c d.
bit_op_result = c BIT-XOR d BIT-XOR a.
READ TABLE x->* ASSIGNING <fs_x> INDEX 15.
add_i_4 b bit_op_result <fs_x> l_x36.
b = me->left_shift_i( value = b positions = 23 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 9 ).
add_i_2 b c.
bit_op_result = b BIT-XOR c BIT-XOR d.
READ TABLE x->* ASSIGNING <fs_x> INDEX 2.
add_i_4 a bit_op_result <fs_x> l_x37.
a = me->left_shift_i( value = a positions = 4 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 28 ).
add_i_2 a b.
bit_op_result = a BIT-XOR b BIT-XOR c.
READ TABLE x->* ASSIGNING <fs_x> INDEX 5.
add_i_4 d bit_op_result <fs_x> l_x38.
d = me->left_shift_i( value = d positions = 11 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 21 ).
add_i_2 d a.
bit_op_result = d BIT-XOR a BIT-XOR b.
READ TABLE x->* ASSIGNING <fs_x> INDEX 8.
add_i_4 c bit_op_result <fs_x> l_x39.
c = me->left_shift_i( value = c positions = 16 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 16 ).
add_i_2 c d.
bit_op_result = c BIT-XOR d BIT-XOR a.
READ TABLE x->* ASSIGNING <fs_x> INDEX 11.
add_i_4 b bit_op_result <fs_x> l_x40.
b = me->left_shift_i( value = b positions = 23 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 9 ).
add_i_2 b c.
bit_op_result = b BIT-XOR c BIT-XOR d.
READ TABLE x->* ASSIGNING <fs_x> INDEX 14.
add_i_4 a bit_op_result <fs_x> l_x41.
a = me->left_shift_i( value = a positions = 4 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 28 ).
add_i_2 a b.
bit_op_result = a BIT-XOR b BIT-XOR c.
READ TABLE x->* ASSIGNING <fs_x> INDEX 1.
add_i_4 d bit_op_result <fs_x> l_x42.
d = me->left_shift_i( value = d positions = 11 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 21 ).
add_i_2 d a.
bit_op_result = d BIT-XOR a BIT-XOR b.
READ TABLE x->* ASSIGNING <fs_x> INDEX 4.
add_i_4 c bit_op_result <fs_x> l_x43.
c = me->left_shift_i( value = c positions = 16 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 16 ).
add_i_2 c d.
bit_op_result = c BIT-XOR d BIT-XOR a.
READ TABLE x->* ASSIGNING <fs_x> INDEX 7.
add_i_4 b bit_op_result <fs_x> l_x44.
b = me->left_shift_i( value = b positions = 23 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 9 ).
add_i_2 b c.
bit_op_result = b BIT-XOR c BIT-XOR d.
READ TABLE x->* ASSIGNING <fs_x> INDEX 10.
add_i_4 a bit_op_result <fs_x> l_x45.
a = me->left_shift_i( value = a positions = 4 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 28 ).
add_i_2 a b.
bit_op_result = a BIT-XOR b BIT-XOR c.
READ TABLE x->* ASSIGNING <fs_x> INDEX 13.
add_i_4 d bit_op_result <fs_x> l_x46.
d = me->left_shift_i( value = d positions = 11 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 21 ).
add_i_2 d a.
bit_op_result = d BIT-XOR a BIT-XOR b.
READ TABLE x->* ASSIGNING <fs_x> INDEX 16.
add_i_4 c bit_op_result <fs_x> l_x47.
c = me->left_shift_i( value = c positions = 16 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 16 ).
add_i_2 c d.
bit_op_result = c BIT-XOR d BIT-XOR a.
READ TABLE x->* ASSIGNING <fs_x> INDEX 3.
add_i_4 b bit_op_result <fs_x> l_x48.
b = me->left_shift_i( value = b positions = 23 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 9 ).
add_i_2 b c.
* Round 4
bit_op_result = c BIT-XOR ( b BIT-OR BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 1.
add_i_4 a bit_op_result <fs_x> l_x49.
a = me->left_shift_i( value = a positions = 6 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 26 ).
add_i_2 a b.
bit_op_result = b BIT-XOR ( a BIT-OR BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 8.
add_i_4 d bit_op_result <fs_x> l_x50.
d = me->left_shift_i( value = d positions = 10 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 22 ).
add_i_2 d a.
bit_op_result = a BIT-XOR ( d BIT-OR BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 15.
add_i_4 c bit_op_result <fs_x> l_x51.
c = me->left_shift_i( value = c positions = 15 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 17 ).
add_i_2 c d.
bit_op_result = d BIT-XOR ( c BIT-OR BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 6.
add_i_4 b bit_op_result <fs_x> l_x52.
b = me->left_shift_i( value = b positions = 21 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 11 ).
add_i_2 b c.
bit_op_result = c BIT-XOR ( b BIT-OR BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 13.
add_i_4 a bit_op_result <fs_x> l_x53.
a = me->left_shift_i( value = a positions = 6 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 26 ).
add_i_2 a b.
bit_op_result = b BIT-XOR ( a BIT-OR BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 4.
add_i_4 d bit_op_result <fs_x> l_x54.
d = me->left_shift_i( value = d positions = 10 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 22 ).
add_i_2 d a.
bit_op_result = a BIT-XOR ( d BIT-OR BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 11.
add_i_4 c bit_op_result <fs_x> l_x55.
c = me->left_shift_i( value = c positions = 15 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 17 ).
add_i_2 c d.
bit_op_result = d BIT-XOR ( c BIT-OR BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 2.
add_i_4 b bit_op_result <fs_x> l_x56.
b = me->left_shift_i( value = b positions = 21 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 11 ).
add_i_2 b c.
bit_op_result = c BIT-XOR ( b BIT-OR BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 9.
add_i_4 a bit_op_result <fs_x> l_x57.
a = me->left_shift_i( value = a positions = 6 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 26 ).
add_i_2 a b.
bit_op_result = b BIT-XOR ( a BIT-OR BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 16.
add_i_4 d bit_op_result <fs_x> l_x58.
d = me->left_shift_i( value = d positions = 10 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 22 ).
add_i_2 d a.
bit_op_result = a BIT-XOR ( d BIT-OR BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 7.
add_i_4 c bit_op_result <fs_x> l_x59.
c = me->left_shift_i( value = c positions = 15 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 17 ).
add_i_2 c d.
bit_op_result = d BIT-XOR ( c BIT-OR BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 14.
add_i_4 b bit_op_result <fs_x> l_x60.
b = me->left_shift_i( value = b positions = 21 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 11 ).
add_i_2 b c.
bit_op_result = c BIT-XOR ( b BIT-OR BIT-NOT d ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 5.
add_i_4 a bit_op_result <fs_x> l_x61.
a = me->left_shift_i( value = a positions = 6 ) BIT-OR me->unsigned_right_shift_i( value = a positions = 26 ).
add_i_2 a b.
bit_op_result = b BIT-XOR ( a BIT-OR BIT-NOT c ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 12.
add_i_4 d bit_op_result <fs_x> l_x62.
d = me->left_shift_i( value = d positions = 10 ) BIT-OR me->unsigned_right_shift_i( value = d positions = 22 ).
add_i_2 d a.
bit_op_result = a BIT-XOR ( d BIT-OR BIT-NOT b ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 3.
add_i_4 c bit_op_result <fs_x> l_x63.
c = me->left_shift_i( value = c positions = 15 ) BIT-OR me->unsigned_right_shift_i( value = c positions = 17 ).
add_i_2 c d.
bit_op_result = d BIT-XOR ( c BIT-OR BIT-NOT a ).
READ TABLE x->* ASSIGNING <fs_x> INDEX 10.
add_i_4 b bit_op_result <fs_x> l_x64.
b = me->left_shift_i( value = b positions = 21 ) BIT-OR me->unsigned_right_shift_i( value = b positions = 11 ).
add_i_2 b c.
add_i_2 i_rcl_state->h0 a.
add_i_2 i_rcl_state->h1 b.
add_i_2 i_rcl_state->h2 c.
add_i_2 i_rcl_state->h3 d.
ENDMETHOD. "transform
METHOD init.
CREATE OBJECT me->rcl_state.
FREE me->rcl_finals.
ENDMETHOD. "init
METHOD update.
CONSTANTS:
l_0x3f TYPE my_int VALUE '0000003F'.
DATA:
index TYPE i,
partlen TYPE i,
i TYPE i,
start TYPE i,
l_length TYPE i,
l_xcount TYPE my_int,
l_decode_buf TYPE my_int_table,
l_index1 TYPE i,
l_index2 TYPE i.
FIELD-SYMBOLS:
<fs_buffer1> LIKE LINE OF me->rcl_state->buffer,
<fs_buffer2> LIKE LINE OF i_buffer.
FREE me->rcl_finals.
l_length = i_length.
IF l_length - i_offset > lines( i_buffer ).
l_length = lines( i_buffer ) - i_offset - 1.
ENDIF.
l_xcount = i_rcl_state->count.
l_xcount = l_xcount BIT-AND l_0x3f.
index = l_xcount.
i_rcl_state->count = i_rcl_state->count + l_length.
partlen = 64 - index.
IF l_length >= partlen.
DO 16 TIMES.
APPEND INITIAL LINE TO l_decode_buf.
ENDDO.
IF partlen = 64.
partlen = 0.
ELSE.
DO partlen TIMES.
i = sy-index.
l_index1 = i + index.
l_index2 = i + i_offset.
READ TABLE i_rcl_state->buffer ASSIGNING <fs_buffer1> INDEX l_index1.
READ TABLE i_buffer ASSIGNING <fs_buffer2> INDEX l_index2.
<fs_buffer1> = <fs_buffer2>.
ENDDO.
me->transform(
EXPORTING
i_rcl_state = i_rcl_state
buffer = i_rcl_state->buffer
shift = 0
CHANGING
decode_buf = l_decode_buf
).
ENDIF.
i = partlen.
WHILE i + 63 < l_length.
me->transform(
EXPORTING
i_rcl_state = i_rcl_state
buffer = i_buffer
shift = i + i_offset
CHANGING
decode_buf = l_decode_buf
).
i = i + 64.
ENDWHILE.
index = 0.
ELSE.
i = 0.
ENDIF.
IF i < l_length.
start = i.
WHILE i < l_length.
l_index1 = index + i - start + 1.
l_index2 = i + i_offset + 1.
READ TABLE i_rcl_state->buffer ASSIGNING <fs_buffer1> INDEX l_index1.
READ TABLE i_buffer ASSIGNING <fs_buffer2> INDEX l_index2.
<fs_buffer1> = <fs_buffer2>.
i = i + 1.
ENDWHILE.
ENDIF.
ENDMETHOD. "update
METHOD update_string.
DATA:
l_length TYPE i,
l_xstring TYPE xstring,
l_xc TYPE x,
l_offset TYPE sy-index,
l_tab_byte_table TYPE my_byte_table.
CALL FUNCTION 'SCMS_STRING_TO_XSTRING'
EXPORTING
text = i_string
* MIMETYPE = ' '
* ENCODING =
IMPORTING
buffer = l_xstring
EXCEPTIONS
failed = 1
OTHERS = 2.
ASSERT sy-subrc = 0.
l_length = xstrlen( l_xstring ).
DO l_length TIMES.
l_offset = sy-index - 1.
l_xc = l_xstring+l_offset(1).
APPEND l_xc TO l_tab_byte_table.
ENDDO.
me->update( i_rcl_state = me->rcl_state i_buffer = l_tab_byte_table i_offset = 0 i_length = l_length ).
ENDMETHOD. "update_string
METHOD update_xstring.
DATA:
l_length TYPE i,
l_xc TYPE x,
l_offset TYPE sy-index,
l_tab_byte_table TYPE my_byte_table.
l_length = xstrlen( i_xstring ).
DO l_length TIMES.
l_offset = sy-index - 1.
l_xc = i_xstring+l_offset(1).
APPEND l_xc TO l_tab_byte_table.
ENDDO.
me->update( i_rcl_state = me->rcl_state i_buffer = l_tab_byte_table i_offset = 0 i_length = l_length ).
ENDMETHOD. "update_xstring
METHOD final.
CONSTANTS:
l_x3f TYPE my_int VALUE '0000003F'.
DATA:
bits TYPE my_byte_table,
index TYPE my_int,
padlen TYPE i,
fin TYPE REF TO lcl_md5state,
count_ints TYPE my_int_table,
l_xvalue TYPE my_int,
l_state TYPE my_int_table.
FIELD-SYMBOLS:
<fs_count_ints> LIKE LINE OF count_ints,
<fs_state> LIKE LINE OF l_state.
IF me->rcl_finals IS NOT BOUND.
CREATE OBJECT fin
EXPORTING
i_rcl_md5state = me->rcl_state.
APPEND INITIAL LINE TO count_ints ASSIGNING <fs_count_ints>.
l_xvalue = fin->count.
<fs_count_ints> = me->left_shift_i( value = l_xvalue positions = 3 ).
APPEND INITIAL LINE TO count_ints ASSIGNING <fs_count_ints>.
<fs_count_ints> = me->right_shift_i( value = l_xvalue positions = 29 ).
bits = me->encode( input = count_ints len = 8 ).
index = l_xvalue BIT-AND l_x3f.
IF index < 56.
padlen = 56 - index.
ELSE.
padlen = 120 - index.
ENDIF.
me->update( i_rcl_state = fin i_buffer = padding i_offset = 0 i_length = padlen ).
me->update( i_rcl_state = fin i_buffer = bits i_offset = 0 i_length = 8 ).
me->rcl_finals = fin.
APPEND INITIAL LINE TO l_state ASSIGNING <fs_state>.
<fs_state> = me->rcl_finals->h0.
APPEND INITIAL LINE TO l_state ASSIGNING <fs_state>.
<fs_state> = me->rcl_finals->h1.
APPEND INITIAL LINE TO l_state ASSIGNING <fs_state>.
<fs_state> = me->rcl_finals->h2.
APPEND INITIAL LINE TO l_state ASSIGNING <fs_state>.
<fs_state> = me->rcl_finals->h3.
r_tab_final_bytes = me->encode( input = l_state len = 16 ).
ENDIF.
ENDMETHOD. "final
METHOD as_hex.
DATA:
l_tab_final_bytes TYPE my_byte_table.
FIELD-SYMBOLS:
<fs_str_final_byte> LIKE LINE OF l_tab_final_bytes.
l_tab_final_bytes = me->final( ).
LOOP AT l_tab_final_bytes ASSIGNING <fs_str_final_byte>.
r_hex_string = r_hex_string && <fs_str_final_byte>.
ENDLOOP.
ENDMETHOD. "as_hex
METHOD left_shift_i.
returning = lcl_bitwise=>left_shift_i( value = value positions = positions ).
ENDMETHOD. "left_shift_i
METHOD right_shift_i.
returning = lcl_bitwise=>right_shift_i( value = value positions = positions ).
ENDMETHOD. "right_shift_i
METHOD unsigned_right_shift_i.
returning = lcl_bitwise=>unsigned_right_shift_i( value = value positions = positions ).
ENDMETHOD. "unsigned_right_shift_i
ENDCLASS. "lcl_md5 IMPLEMENTATION
*----------------------------------------------------------------------*
* CLASS lcl_md5_test DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_md5_test DEFINITION FOR TESTING
DURATION SHORT RISK LEVEL HARMLESS.
PRIVATE SECTION.
METHODS:
setup,
simple_test FOR TESTING,
lorem_ipsum_test FOR TESTING,
several_update_test FOR TESTING,
add_i_test FOR TESTING,
left_shift_i_test FOR TESTING,
check_with_calc_hash_for_char FOR TESTING.
DATA:
rcl_md5 TYPE REF TO lcl_md5.
ENDCLASS. "lcl_md5_test DEFINITION
*----------------------------------------------------------------------*
* CLASS lcl_md5_test IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_md5_test IMPLEMENTATION.
METHOD setup.
CREATE OBJECT me->rcl_md5.
ENDMETHOD. "setup
METHOD simple_test.
DATA:
l_md5sum_expected TYPE string VALUE '0CBC6611F5540BD0809A388DC95A615B',
l_md5sum_actual TYPE string.
me->rcl_md5->update_string(
i_string = 'Test'
).
l_md5sum_actual = me->rcl_md5->as_hex( ).
cl_aunit_assert=>assert_equals( exp = l_md5sum_expected act = l_md5sum_actual ).
ENDMETHOD. "simple_test
METHOD lorem_ipsum_test.
DATA:
l_md5sum_expected TYPE string VALUE '0044EE4BCE953EE92C01BBDC6CEA6338',
l_md5sum_actual TYPE string,
l_string TYPE string.
CONCATENATE
'Nemo enim ipsam voluptatem, quia voluptas sit, aspernatur aut odit aut fugit,'
'sed quia consequuntur magni dolores eos, qui ratione voluptatem sequi nesciunt,'
'neque porro quisquam est, qui dolorem ipsum, quia dolor sit amet, consectetur, adipisci[ng] velit,'
'sed quia non numquam [do] eius modi tempora inci[di]dunt, ut labore et dolore magnam'
'aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis'
'suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit,'
'qui in ea voluptate velit esse, quam nihil molestiae consequatur,'
'vel illum, qui dolorem eum fugiat, quo voluptas nulla pariatur?'
INTO l_string SEPARATED BY space.
me->rcl_md5->update_string(
i_string = l_string
).
l_md5sum_actual = me->rcl_md5->as_hex( ).
cl_aunit_assert=>assert_equals( exp = l_md5sum_expected act = l_md5sum_actual ).
ENDMETHOD. "lorem_ipsum_test
METHOD several_update_test.
DATA:
l_md5sum_expected TYPE string VALUE '0044EE4BCE953EE92C01BBDC6CEA6338',
l_md5sum_actual TYPE string,
l_xspace TYPE x VALUE '20',
l_string_space TYPE string.
DATA: loc_conv TYPE REF TO cl_abap_conv_in_ce.
CALL METHOD cl_abap_conv_in_ce=>create
EXPORTING
input = l_xspace
encoding = 'UTF-8'
replacement = '?'
ignore_cerr = abap_true
RECEIVING
conv = loc_conv.
CALL METHOD loc_conv->read
IMPORTING
data = l_string_space.
me->rcl_md5->update_string(
i_string = 'Nemo enim ipsam voluptatem, quia voluptas sit, aspernatur aut odit aut fugit,'
).
me->rcl_md5->update_string(
i_string = l_string_space
).
me->rcl_md5->update_string(
i_string = 'sed quia consequuntur magni dolores eos, qui ratione voluptatem sequi nesciunt,'
).
me->rcl_md5->update_string(
i_string = l_string_space
).
me->rcl_md5->update_string(
i_string = 'neque porro quisquam est, qui dolorem ipsum, quia dolor sit amet, consectetur, adipisci[ng] velit,'
).
me->rcl_md5->update_string(
i_string = l_string_space
).
me->rcl_md5->update_string(
i_string = 'sed quia non numquam [do] eius modi tempora inci[di]dunt, ut labore et dolore magnam'
).
me->rcl_md5->update_string(
i_string = l_string_space
).
me->rcl_md5->update_string(
i_string = 'aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis'
).
me->rcl_md5->update_string(
i_string = l_string_space
).
me->rcl_md5->update_string(
i_string = 'suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit,'
).
me->rcl_md5->update_string(
i_string = l_string_space
).
me->rcl_md5->update_string(
i_string = 'qui in ea voluptate velit esse, quam nihil molestiae consequatur,'
).
me->rcl_md5->update_string(
i_string = l_string_space
).
me->rcl_md5->update_string(
i_string = 'vel illum, qui dolorem eum fugiat, quo voluptas nulla pariatur?'
).
l_md5sum_actual = me->rcl_md5->as_hex( ).
cl_aunit_assert=>assert_equals( exp = l_md5sum_expected act = l_md5sum_actual ).
ENDMETHOD. "several_update_test
METHOD add_i_test.
DATA:
a1 TYPE my_int VALUE '2080F522',
a2 TYPE my_int VALUE 'DEAF2242',
a3 TYPE my_int VALUE '80732073',
a4 TYPE my_int VALUE 'FFFF5BB1',
exp TYPE my_int VALUE '7FA29388'.
add_i_4 a1 a2 a3 a4.
cl_aunit_assert=>assert_equals( exp = exp act = a1 ).
ENDMETHOD. "add_i_test
METHOD left_shift_i_test.
DATA:
i TYPE i VALUE 2,
x_i TYPE my_int,
expected TYPE i VALUE 4,
actual TYPE i,
x_actual TYPE i.
x_i = i.
x_actual = lcl_bitwise=>left_shift_i( value = x_i positions = 1 ).
actual = x_actual.
cl_aunit_assert=>assert_equals( exp = expected act = actual ).
ENDMETHOD. "left_shift_i_test
METHOD check_with_calc_hash_for_char.
CONSTANTS:
l_string_to_be_hashed TYPE string VALUE 'Test'.
DATA:
l_expected_hash TYPE hash160x,
l_actual_hash TYPE hash160x.
CALL FUNCTION 'CALCULATE_HASH_FOR_CHAR'
EXPORTING
alg = 'MD5'
data = l_string_to_be_hashed
* LENGTH = 0
IMPORTING
* HASH =
* HASHLEN =
hashx = l_expected_hash
* HASHXLEN =
EXCEPTIONS
unknown_alg = 1
param_error = 2
internal_error = 3
OTHERS = 4.
cl_aunit_assert=>assert_subrc( exp = 0 act = sy-subrc ).
rcl_md5->update_string( l_string_to_be_hashed ).
l_actual_hash = rcl_md5->as_hex( ).
cl_aunit_assert=>assert_equals( exp = l_expected_hash act = l_actual_hash ).
ENDMETHOD. "check_with_calc_hash_for_char
ENDCLASS. "lcl_md5_test IMPLEMENTATION
*----------------------------------------------------------------------*
* CLASS lcl_main DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_main DEFINITION FINAL CREATE PRIVATE.
PUBLIC SECTION.
CLASS-METHODS:
main
IMPORTING
i_file TYPE string.
ENDCLASS. "lcl_main DEFINITION
*----------------------------------------------------------------------*
* CLASS lcl_main IMPLEMENTATION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS lcl_main IMPLEMENTATION.
METHOD main.
DATA:
l_buffer TYPE xstring,
l_rcl_md5 TYPE REF TO lcl_md5,
l_hex_string TYPE string.
IF NOT i_file IS INITIAL.
OPEN DATASET i_file IN BINARY MODE FOR INPUT.
IF sy-subrc = 0.
CREATE OBJECT l_rcl_md5.
DATA:
start TYPE sy-uzeit.
GET TIME.
start = sy-uzeit.
DO.
READ DATASET i_file INTO l_buffer MAXIMUM LENGTH 4096.
IF sy-subrc <> 0.
EXIT.
ENDIF.
l_rcl_md5->update_xstring( l_buffer ).
ENDDO.
CLOSE DATASET i_file.
l_hex_string = l_rcl_md5->as_hex( ).
WRITE: / 'Start', start.
GET TIME.
WRITE: / 'End', sy-uzeit.
start = sy-uzeit - start.
WRITE: / 'Runtime', start.
WRITE: / 'Calculated hash', l_hex_string.
ENDIF.
ENDIF.
ENDMETHOD. "main
ENDCLASS. "lcl_main IMPLEMENTATION
PARAMETERS:
p_file TYPE string OBLIGATORY LOWER CASE.
END-OF-SELECTION.
lcl_main=>main(
EXPORTING
i_file = p_file
).
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment