Program Flow Logic

The following example demonstrates a simple function module:

• The implementation in the function module represents a calculator. In the function module call, you specify two numbers and an operator.
• The example includes static function module calls, and a dynamic function module call using the PARAMETER-TABLE addition.

To get started quickly with copiable code snippets, you can proceed as follows.

1. Create a function pool.
   • In ADT, you can, for example, right-click the package in which you want to create the function pool and module.
   • Choose New -> Other ABAP Repository Object.
   • In the input field, enter function, select ABAP Function Group (which is the function pool), and choose Next.
   • Make entries in the Name (e.g. Z_DEMO_ABAP_TEST_FUNC_P) and Description Field (e.g. Demo function group) fields, and choose Next.
   • If prompted, select a transport request and choose Finish.
2. Create a function module.
   • In ADT, you can, for example, right-click the package in which you have created the function pool.
   • Choose New -> Other ABAP Repository Object.
   • In the input field, enter function, select ABAP Function Module, and choose Next.
   • Make entries in the Name (e.g. Z_DEMO_ABAP_TEST_FUNC_M), Description Field (e.g. Demo function module), and Function Group (e.g. the previously created Z_DEMO_ABAP_TEST_FUNC_P) fields and choose Next.
   • If prompted, select a transport request and choose Finish.
   • The function module is created and can be filled with an implementation.
   • You can copy and paste the code below to have a sample implementation.
3. To demonstrate the function module, you can create a class, for example, with the name ZCL_DEMO_ABAP_FUNC_TEST, and copy and paste the code below.
   • In ADT, you can run the class by choosing F9. Some output is displayed in the ADT console, demonstrating the result of function module calls.

Code for the function module Z_DEMO_ABAP_TEST_FUNC_M:

FUNCTION z_demo_abap_test_func_m
  IMPORTING
    num1 TYPE i
    operator TYPE string
    num2 TYPE i
  EXPORTING
    result TYPE string
  RAISING
    cx_sy_arithmetic_error.





  "ABAP 'allows' zero division if both operands are 0.
  IF num1 = 0 AND num2 = 0.
    RAISE EXCEPTION TYPE cx_sy_zerodivide.
  ENDIF.

  DATA op TYPE c LENGTH 1.
  op = condense( val = operator to = `` ).

  result = SWITCH #( op
                     WHEN '+' THEN |{ num1 } + { num2 } = { num1 + num2 STYLE = SIMPLE }|
                     WHEN '-' THEN |{ num1 } - { num2 } = { num1 - num2 STYLE = SIMPLE }|
                     WHEN '*' THEN |{ num1 } * { num2 } = { num1 * num2 STYLE = SIMPLE }|
                     WHEN '/' THEN |{ num1 } / { num2 } = { CONV decfloat34( num1 / num2 ) STYLE = SIMPLE }|
                     ELSE `Use one of the operators + - * /` ).

ENDFUNCTION.

Code for the class ZCL_DEMO_ABAP_FUNC_TEST that can be run in ADT choosing F9:

CLASS zcl_demo_abap_func_test DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_demo_abap_func_test IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.

    "Calling a function module
    "For handling a possible wrong operator in the example, you may want to implement
    "a separate exception. The simple example just catches calculation errors
    "and uses a data object of type string for storing the calculation result.
    DATA calculation_result TYPE string.

    TRY.
        CALL FUNCTION 'Z_DEMO_ABAP_TEST_FUNC_M'
          EXPORTING
            num1     = 1
            operator = `+`
            num2     = 2
          IMPORTING
            result   = calculation_result.
      CATCH cx_sy_arithmetic_error INTO DATA(exc).
        calculation_result = exc->get_text( ).
    ENDTRY.

    out->write( calculation_result && |\n\n| ).

    "More calculation examples; calculations are stored in a table
    DATA calculation_result_table TYPE string_table.

    TYPES: BEGIN OF s,
             num1     TYPE i,
             operator TYPE string,
             num2     TYPE i,
           END OF s,
           it_type TYPE TABLE OF s WITH EMPTY KEY.
    DATA(itab) = VALUE it_type( ( num1 = 10 operator = `-` num2 = 12 )
                                ( num1 = 15 operator = `*` num2 = 4 )
                                ( num1 = 7 operator = `/` num2 = 2 )
                                ( num1 = 1 operator = `/` num2 = 0 )
                                ( num1 = 0 operator = `/` num2 = 0 )
                                ( num1 = 9999999 operator = `*` num2 = 9999999 ) ).

    LOOP AT itab INTO DATA(wa).
      TRY.
          CALL FUNCTION 'Z_DEMO_ABAP_TEST_FUNC_M'
            EXPORTING
              num1     = wa-num1
              operator = wa-operator
              num2     = wa-num2
            IMPORTING
              result   = calculation_result.
        CATCH cx_sy_arithmetic_error INTO exc.
          calculation_result = |{ wa-num1 } { wa-operator } { wa-num2 } -> Error: { exc->get_text( ) }|.
      ENDTRY.
      APPEND calculation_result TO calculation_result_table.
    ENDLOOP.

    out->write( calculation_result_table ).
    out->write( |\n\n\n| ).

*&---------------------------------------------------------------------*
*& Dynamic function module call
*&---------------------------------------------------------------------*

    DATA(func_name) = 'Z_DEMO_ABAP_TEST_FUNC_M'.
    DATA(ptab) = VALUE abap_func_parmbind_tab( ( name  = 'NUM1'
                                                 kind  = abap_func_exporting
                                                 value = NEW i( 3 ) )
                                               ( name  = 'OPERATOR'
                                                 kind  = abap_func_exporting
                                                 value = NEW string( `+` ) )
                                               ( name  = 'NUM2'
                                                 kind  = abap_func_exporting
                                                 value = NEW i( 5 ) )
                                               ( name  = 'RESULT'
                                                 kind  = abap_func_importing
                                                 value = NEW string( ) ) ).

    CALL FUNCTION func_name PARAMETER-TABLE ptab.

    out->write( data = ptab name = `ptab` ).
  ENDMETHOD.

ENDCLASS.

The following demo program illustrates various syntax options for creating and calling subroutines, including:

• FORM and ENDFORM statements: Creating subroutines without parameters, with parameters specified after USING, and with parameters specified after both USING and CHANGING.
• PERFORM statements: Calling subroutines (with and without parameters), using the IN PROGRAM addition (the program uses a potentially non-existing program and the current program via sy-repid), and the IF FOUND additions, as well as dynamic specifications and selecting a subroutine from the list of subroutines in the current program.

PROGRAM.

DATA number1 TYPE i VALUE 10.
DATA number2 TYPE i VALUE 20.
DATA number3 TYPE i VALUE 30.
DATA number4 TYPE i.
DATA number5 TYPE i.
DATA flag TYPE abap_boolean.
DATA text TYPE string.
DATA prog LIKE sy-repid VALUE sy-repid.
DATA subr TYPE string VALUE `SUBR_NO_PARAMS_A`.
DATA error TYPE REF TO cx_root.

START-OF-SELECTION.

*&---------------------------------------------------------------------*
*& Subroutine calls
*&---------------------------------------------------------------------*

  "Syntax variants of the PERFORM statement

  WRITE / `********************** 1) **********************`.
  SKIP.

  "The following PERFORM statements call a subroutine without parameters.

  "Directly specifying the subroutine name.
  PERFORM subr_no_params_a.

  "IN PROGRAM addition: External subroutine call, specifying the subroutine
  "name and the program name.
  "If the program or the subroutine is not found, a catchable exception is raised.
  TRY.
      PERFORM subr_no_params_a IN PROGRAM demo_abap_report.
    CATCH cx_sy_program_not_found INTO error.
      WRITE / error->get_text( ).
      SKIP.
  ENDTRY.

  "IF FOUND addition: Preventing the catchable exception if the subroutine or
  "program is not found
  PERFORM subr_no_params_a IN PROGRAM demo_abap_report IF FOUND.

**********************************************************************

  WRITE / `********************** 2) **********************`.
  SKIP.

  "2) Dynamic subroutine calls with IN PROGRAM
  "Note that the IF FOUND addition is optional.
  "The program and subroutine names can be specified as a literal or as a variable.
  "Variations are possible such as specifying the subroutine name dynamically and
  "the program name directly, or vice versa.
  PERFORM subr_no_params_a IN PROGRAM ('DEMO_ABAP_REPORT') IF FOUND.
  PERFORM subr_no_params_a IN PROGRAM demo_abap_report IF FOUND.
  PERFORM subr_no_params_a IN PROGRAM (prog) IF FOUND.
  PERFORM ('SUBR_NO_PARAMS_A') IN PROGRAM (prog) IF FOUND.

  PERFORM ('SUBR_NO_PARAMS_A') IN PROGRAM (prog) IF FOUND.
  PERFORM (subr) IN PROGRAM (prog) IF FOUND.

  "Note case-sensitivity of the subroutine name.
  TRY.
      PERFORM subr_does_not_exist IN PROGRAM (prog).
    CATCH cx_sy_dyn_call_illegal_form INTO error.
      WRITE / error->get_text( ).
      SKIP.
  ENDTRY.

  "Non-existent subroutine name directly specified
  TRY.
      PERFORM subr_does_not_exist IN PROGRAM (prog).
    CATCH cx_sy_dyn_call_illegal_form INTO error.
      WRITE / error->get_text( ).
      SKIP.
  ENDTRY.

**********************************************************************

  WRITE / `********************** 3) **********************`.
  SKIP.

  "3) Selecting a subroutine from a list of subroutines of the current program
  "It is only possible to specify subroutines without parameter list.
  "The IN PROGRAM and IF FOUND additions cannot be specified.
  PERFORM 1 OF subr_no_params_a subr_no_params_b.
  PERFORM 2 OF subr_no_params_a subr_no_params_b.

  DO.
    TRY.
        PERFORM sy-index OF subr_no_params_a subr_no_params_b.
      CATCH cx_sy_dyn_call_illegal_form INTO DATA(err).
        WRITE / err->get_text( ).
        SKIP.
        EXIT.
    ENDTRY.
  ENDDO.

**********************************************************************

  WRITE / `********************** 4) **********************`.
  SKIP.

  "4) Subroutines with parameters
  "The examples cover the additions USING and CHANGING.
  "The additions are also reflected in the subroutine definition.
  "Assignment of parameters is done by position, not by name.
  "If both USING and CHANGING are specified, the USING parameters must be specified first.

  "Subroutine with only USING parameters.
  "All of the parameters are passed by reference.
  number1 = 1.
  number2 = 10.
  number3 = 100.

  PERFORM subr_using USING number1
                           number2
                           number3.

  "Subroutine with USING and CHANGING parameters.
  number1 = 1.
  number2 = 10.
  number3 = 100.

  PERFORM subr_using_change USING number1
                                  number2
                            CHANGING number3.

  WRITE / |number3 = "{ number3 }"|.
  SKIP.

  "Subroutine with USING parameter and defining RAISING
  DO 3 TIMES.
    CASE sy-index.
      	WHEN 1.
        		number1 = 10.
        		number2 = 2.
      	WHEN 2.
        		number1 = 10.
        		number2 = 0.
      	WHEN 3.
        		number1 = 0.
        		number2 = 0.
    ENDCASE.

    TRY.
        PERFORM subr_using_raising USING number1
                                         number2.
      CATCH cx_sy_zerodivide INTO error.
        		WRITE / error->get_text( ).		
    		ENDTRY.
    		SKIP.
  ENDDO.

  "The following example subroutine demonstrates various parameter definitions
  "Both USING and CHANGING additions, as well as RAISING are defined.
  "The parameters passed to the subroutine are passed by value and by reference,
  "respectively. Note that a parameter without explicit typing is implicitly typed
  "with the fully generic type 'any'.

  number1 = 1.
  number2 = 10.
  number3 = 100.
  number4 = 1000.
  flag = abap_false.
  "Passing by reference: number1, number3, error, text
  "Passing by value: number2, number4
  PERFORM subr_pass_by_val_ref USING number1 number2 error
                               CHANGING number3 number4 text.

  WRITE / `--- Values after subroutine call ---`.
  WRITE / |number1 after subroutine call = "{ number1 }"|.
  WRITE / |number2 after subroutine call = "{ number2 }"|.
  WRITE / |text = "{ text }"|.
  WRITE / |number4 = "{ number4 }"|.
  SKIP.

  "Demonstrating that the actual parameter of a CHANGING parameters passed by value
  "is not changed when the subroutine is ended by an exception.
  number1 = 1.
  number2 = 10.
  number3 = 100.
  number4 = 1000.
  flag = abap_true.
  TRY.
      PERFORM subr_pass_by_val_ref USING number1 number2 error
                                   CHANGING number3 number4 text.
    CATCH cx_sy_zerodivide.
  ENDTRY.
  WRITE / `--- Values after subroutine call ---`.
  WRITE / |number1 after subroutine call = "{ number1 }"|.
  WRITE / |number2 after subroutine call = "{ number2 }"|.
  WRITE / |text = "{ text }"|.
  WRITE / |number4 = "{ number4 }"|.
  SKIP.

  "The following example subroutine calls illustrate that it is advisable to specify
  "the additions USING and CHANGING in the PERFORM statement according to the subroutine
  "definition for program documentation purposes.
  "Although the syntax does not show any errors for all statements, only the fourth statement
  "is recommended because it is the only one that documents the interface of the called subroutine.
  number1 = 1.
  number2 = 10.
  number3 = 100.
  number4 = 1000.

  PERFORM subr_call_demo USING number1 number2 number3 number4.
  PERFORM subr_call_demo CHANGING number1 number2 number3 number4.
  PERFORM subr_call_demo USING number1 CHANGING number2 number3 number4.
  "The following statement is a valid call according to the subroutine definition,
  "documenting the interface of the called subroutine.
  PERFORM subr_call_demo USING number1 number2 CHANGING number3 number4.
  PERFORM subr_call_demo USING number1 number2 number3 CHANGING number4.

**********************************************************************
**********************************************************************
**********************************************************************

*&---------------------------------------------------------------------*
*& Subroutines
*&---------------------------------------------------------------------*

  "Notes:
  "- The additions in FORM statements define the formal parameters.
  "- Class-based exceptions can also be specified.
  "- Within FORM ... ENDFORM., local data types and objects can be declared.
  "  Global data types and objects can be used within.
  "- Actual parameters passed to formal parameters of USING and CHANGING can
  "  be passed by value or reference.
  "- Passing by reference: Any changes made to the formal parameter also change
  "    the value of the actual parameter. Used in combination with USING, actual
  "    parameters passed by reference should not be changed in the subroutine.
  "    For this purpose, CHANGING should be used.
  "  - Pass by value: A local data object with the same data type is created. Any
  "    changes made to the formal parameter do not directly change the value of the
  "    actual parameter.

FORM subr_no_params_a.
  WRITE / |subr_no_params_a called at { utclong_current( ) }|.
  SKIP.
ENDFORM.

FORM subr_no_params_b.
  WRITE / |subr_no_params_b called at { utclong_current( ) }|.
  SKIP.
ENDFORM.

FORM subr_call_demo USING num1 TYPE i
                          num2 TYPE i
          CHANGING VALUE(num3) TYPE i
                   VALUE(num4) TYPE i.

  num4 = num1.
  num3 = num2.

  WRITE / |subr_call_demo called at { utclong_current( ) }|.
ENDFORM.

"Subroutines demonstrating the USING and CHANGING additions. The parameters passed to the
"subroutines are passed by reference.
FORM subr_using
  USING num1 TYPE i
        num2 TYPE i
        num3 TYPE i.
  WRITE / |subr_using called at { utclong_current( ) }|.
  WRITE / |num1 = '{ num1 }', num2 = '{ num2 }', num1 = '{ num3 }'|.
  SKIP.
ENDFORM.

FORM subr_using_change
  USING    num1 TYPE i
           num2 TYPE i
  CHANGING result  TYPE i.
  WRITE / |subr_using_change called at { utclong_current( ) }|.
  result = num1 + num2.
  WRITE / |{ num1 } + { num2 } = { result }|.
  SKIP.
ENDFORM.

FORM subr_using_raising
  USING num1 TYPE i
        num2 TYPE i
  RAISING cx_sy_zerodivide.
  WRITE / |subr_using_raising of program { prog } called at { utclong_current( ) }|.

  IF num1 = 0 AND num2 = 0. "ABAP 'allows' zero division
    RAISE EXCEPTION TYPE cx_sy_zerodivide.
  ELSE.
    WRITE / |{ num1 } / { num2 } = { num1 / num2 }|.
  ENDIF.	
ENDFORM.


"The following subroutine demonstrates the use of both USING and CHANGING additions
"in a single subroutine definition. The parameters passed to the subroutine are passed
"by value and by reference, respectively. Note that a parameter without explicit typing is
"implicitly typed with the fully generic type 'any'.

FORM subr_pass_by_val_ref
  USING using_pass_by_ref_num TYPE i
        VALUE(using_pass_by_value_num) TYPE i
        using_param
  CHANGING changing_pass_by_ref_num TYPE i
           VALUE(changing_pass_by_value_num) TYPE i
           changing_param
  RAISING cx_sy_zerodivide.
  WRITE / |subr_pass_by_val_ref called at { utclong_current( ) }|.

  "Using the value of the parameter in read position
  DATA(num1) = using_pass_by_value_num + 1.
  WRITE / |num1 = "{ num1 }"|.
  "Actual parameters passed by value can be changed in the subroutine.
  "A change to the parameter in the subroutine does not change the actual value.
  "Even after the subroutine has ended, the actual parameter retains its
  "original value.
  using_pass_by_value_num += 2.
  WRITE / |Value of using_pass_by_value_num changed in subroutine (number2) = "{ using_pass_by_value_num }"|.

  "Using the value of the parameter in read position
  DATA(num2) = using_pass_by_ref_num + 3.
  WRITE / |num2 = "{ num2 }"|.
  "Actual parameters passed by reference specified with USING should not be changed in the subroutine.
  "A syntax warning is displayed if CHANGING parameters are specified at the same time
  "for the subroutine.
  "using_pass_by_ref_num += 4.

  "The following assignment circumvents the syntax warning, and changes the value.
  "The demonstration purpose is that a change does not change the value of the actual
  "parameter. Even after the subroutine has ended, the actual parameter retains its
  "original value.
  ASSIGN using_pass_by_ref_num TO FIELD-SYMBOL(<fs>).
  <fs> += 5.
  WRITE / |Value of using_pass_by_ref_num changed in subroutine (number1) = "{ using_pass_by_ref_num }"|.


  "using_param is implicitly typed with the fully generic type 'any'.
  "The data type of the actual parameter is determined at runtime.
  DATA(type_info) = cl_abap_typedescr=>describe_by_data( using_param ).
  changing_param = SWITCH string( type_info->kind WHEN cl_abap_typedescr=>kind_elem THEN `elementary`
                                                    WHEN cl_abap_typedescr=>kind_class THEN `class`
                                                    WHEN cl_abap_typedescr=>kind_intf THEN `interface`
																										WHEN cl_abap_typedescr=>kind_ref THEN `reference`
																										WHEN cl_abap_typedescr=>kind_struct THEN `structure`
																										WHEN cl_abap_typedescr=>kind_table THEN `table`
																										ELSE `unknown` ).

  "Changing parameters passed by reference
  changing_pass_by_ref_num = 987.
  WRITE / |changing_pass_by_ref_num = "{ changing_pass_by_ref_num }"|.

  "Changing parameters passed by value
  "When ending the subroutine with ENDFORM, RETURN, CHECK, or EXIT, the
  "value of the formal parameter is assigned to the actual parameter.
  "However, if the subroutine is ended by a message or an exception,
  "the actual parameter is not changed.
  changing_pass_by_value_num = 123.
  WRITE / |changing_pass_by_value_num = "{ changing_pass_by_value_num }"|.
  IF flag = abap_true.
    SKIP.
    RAISE EXCEPTION TYPE cx_sy_zerodivide.
  ENDIF.
  SKIP.
ENDFORM.

The following demo program illustrates the use of obsolete subroutines and related syntax in the context of a basic calculator:

• It allows users to perform standard arithmetic operations (addition, subtraction, multiplication, and division) on two input numbers.
• The program tracks and displays a history of all calculations and maintains statistics for each operation type.
• Users can use the result of the previous calculation as the first input for a new operation.
  • This is enabled by storing data in the ABAP memory so that it can be reused between runs of the report. For that purpose, IMPORT and EXPORT statement are included.
• The calculation history can appear as either a classic list or an ALV grid. You can also select the option to clear the calculation history.

PROGRAM.

*&---------------------------------------------------------------------*
*& Program-global types and data objects
*&---------------------------------------------------------------------*
DATA:
  operator          TYPE c LENGTH 1,
  result            TYPE decfloat34,
  last_result       TYPE decfloat34,
  calculation_count TYPE i,
  additions         TYPE i,
  subtractions      TYPE i,
  multiplications   TYPE i,
  divisions         TYPE i,
  alv               TYPE REF TO cl_salv_table,
  operators         TYPE vrm_values.

"Calculation history
TYPES:
  BEGIN OF history,
    calculation_no TYPE i,
    number1        TYPE decfloat34,
    operator       TYPE c LENGTH 1,
    number2        TYPE decfloat34,
    result         TYPE decfloat34,
    calculation    TYPE string,
    date           TYPE sy-datum,
    time           TYPE sy-uzeit,
  END OF history.

DATA history TYPE STANDARD TABLE OF history WITH EMPTY KEY.

*&---------------------------------------------------------------------*
*& Selection screen
*&---------------------------------------------------------------------*

SELECTION-SCREEN BEGIN OF BLOCK calculator WITH FRAME TITLE title1.
  SELECTION-SCREEN BEGIN OF LINE.
    SELECTION-SCREEN COMMENT 1(20) cnum1.
    PARAMETERS number1 TYPE decfloat34.
  SELECTION-SCREEN END OF LINE.
  SELECTION-SCREEN SKIP.
  SELECTION-SCREEN BEGIN OF LINE.
    SELECTION-SCREEN COMMENT 1(20) cop.
    PARAMETERS op TYPE c LENGTH 1 AS LISTBOX VISIBLE LENGTH 20.
  SELECTION-SCREEN END OF LINE.
  SELECTION-SCREEN SKIP.
  SELECTION-SCREEN BEGIN OF LINE.
    SELECTION-SCREEN COMMENT 1(20) cnum2.
    PARAMETERS number2 TYPE decfloat34.
  SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN END OF BLOCK calculator.
SELECTION-SCREEN BEGIN OF BLOCK options WITH FRAME TITLE title2.
  SELECTION-SCREEN BEGIN OF LINE.
    PARAMETERS use_last TYPE abap_boolean AS CHECKBOX DEFAULT abap_false.
    SELECTION-SCREEN COMMENT 4(55) cuselast.
  SELECTION-SCREEN END OF LINE.
  SELECTION-SCREEN BEGIN OF LINE.
    PARAMETERS use_alv TYPE abap_boolean AS CHECKBOX DEFAULT abap_false.
    SELECTION-SCREEN COMMENT 4(55) cusealv.
  SELECTION-SCREEN END OF LINE.
  SELECTION-SCREEN BEGIN OF LINE.
    PARAMETERS clearhis TYPE abap_boolean AS CHECKBOX DEFAULT abap_false.
    SELECTION-SCREEN COMMENT 4(55) cclrhis.
  SELECTION-SCREEN END OF LINE.
SELECTION-SCREEN END OF BLOCK options.

*&---------------------------------------------------------------------*
*& INITIALIZATION event block
*&---------------------------------------------------------------------*

INITIALIZATION.
  "Selection screen texts
  title1   = 'Calculator'.
  title2   = 'Options'.
  cnum1    = 'First number'.
  cop      = 'Operator'.
  cnum2    = 'Second number'.
  cuselast = 'Use last result as Number 1'.
  cusealv  = 'Display history as ALV grid'.
  cclrhis  = 'Clear calculation history'.

  operators = VALUE #(
      ( key = '+' text = '+' )
      ( key = '-' text = '-' )
      ( key = '*' text = '*' )
      ( key = '/' text = '/' )
    ).
  CALL FUNCTION 'VRM_SET_VALUES'
    EXPORTING
      id     = 'OP'
      values = operators.

*&---------------------------------------------------------------------*
*& AT SELECTION-SCREEN OUTPUT event block
*&---------------------------------------------------------------------*

AT SELECTION-SCREEN OUTPUT.

  "The example includes the functionality to store the last result
  "of a calculation and other information. This data is stored in the
  "ABAP memory so that they can be reused between runs of the report.
  "When the 'use_last' checkbox is selected, returning to the selection
  "screen initializes the operator and number 2, and number 1 is
  "initialized with the last result.
  IMPORT
    last_result       = last_result
    calculation_count = calculation_count
    additions         = additions
    subtractions      = subtractions
    multiplications   = multiplications
    divisions         = divisions
    history           = history
    FROM MEMORY ID 'DEMO_MEM_ID'.

  IF sy-subrc = 0.
    IF calculation_count > 0 AND use_last = abap_true.
      number1 = last_result.
      CLEAR: op, number2.
    ELSE.
      CLEAR: op, number1, number2.
    ENDIF.
  ENDIF.

*&---------------------------------------------------------------------*
*& AT SELECTION-SCREEN event block
*&---------------------------------------------------------------------*

AT SELECTION-SCREEN.

  IF op IS INITIAL.
    MESSAGE 'Please select an operator.' TYPE 'E'.
  ENDIF.

  IF op = '/' AND number2 = 0.
    MESSAGE 'Division by zero is not allowed.' TYPE 'E'.
  ENDIF.

*&---------------------------------------------------------------------*
*& START-OF-SELECTION event block
*&---------------------------------------------------------------------*

START-OF-SELECTION.

  PERFORM get_data.
  PERFORM clear_history.
  PERFORM calculate USING number1
                          number2
                    CHANGING result.
  PERFORM save_history USING number1
                             number2
                             result.
  PERFORM save_state.

  "The example includes the functionality to display the calculation
  "history in an ALV grid if the 'use_alv' checkbox is selected.
  "Otherwise, a classic list output is used to display the history
  "and statistics.
  IF use_alv = abap_true.
    PERFORM display_history_alv.
  ELSE.
    PERFORM display_result.
    PERFORM display_history.
    PERFORM display_statistics.
  ENDIF.

*&---------------------------------------------------------------------*
*& Subroutine get_data
*&---------------------------------------------------------------------*

FORM get_data.
  operator = op.
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine save_state
*&---------------------------------------------------------------------*

"Persists the complete calculator state (history and statistics)
"in the ABAP memory so that it is available with the next program runs.

FORM save_state.
  EXPORT
    last_result       = last_result
    calculation_count = calculation_count
    additions         = additions
    subtractions      = subtractions
    multiplications   = multiplications
    divisions         = divisions
    history           = history
    TO MEMORY ID 'DEMO_MEM_ID'.
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine clear_history
*&---------------------------------------------------------------------*

FORM clear_history.
  IF clearhis = abap_true.
    CLEAR: history,
          calculation_count,
          additions,
          subtractions,
          multiplications,
          divisions,
          last_result,
          alv.
    clearhis = abap_false.

    "Clearing the stored data
    FREE MEMORY ID 'DEMO_MEM_ID'.
  ENDIF.
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine calculate
*&---------------------------------------------------------------------*

"Perfoms the calculation based on the selected operator and input numbers.
FORM calculate
  USING    number1 TYPE decfloat34
           number2 TYPE decfloat34
  CHANGING result  TYPE decfloat34.
  CLEAR result.
  TRY.
      CASE operator.
        WHEN '+'.
          result = number1 + number2.
          additions += 1.
        WHEN '-'.
          result = number1 - number2.
          subtractions += 1.
        WHEN '*'.
          result = number1 * number2.
          multiplications += 1.
        WHEN '/'.
          result = number1 / number2.
          divisions += 1.
        WHEN OTHERS.
          MESSAGE 'Invalid operator.' TYPE 'E'.
      ENDCASE.
    CATCH cx_sy_arithmetic_error INTO DATA(error).
      MESSAGE error->get_text( ) TYPE 'E'.
  ENDTRY.
  last_result = result.
  calculation_count += 1.
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine save_history
*&---------------------------------------------------------------------*

FORM save_history
  USING number1 TYPE decfloat34
        number2 TYPE decfloat34
        result  TYPE decfloat34.

  DATA(calculation) = |{ number1 } { operator } { number2 } = { result }|.

  APPEND VALUE #( calculation_no = calculation_count
                  number1        = number1
                  operator       = operator
                  number2        = number2
                  result         = result
                  calculation    = calculation
                  date           = sy-datum
                  time           = sy-uzeit ) TO history.
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine display_result
*&---------------------------------------------------------------------*

"Used to display the result of the calculation in a classic list
FORM display_result.
  DATA(calculation) = |{ number1 } { operator } { number2 } = { result }|.

  "Input
  FORMAT COLOR COL_NORMAL.
  WRITE: / |  Number 1    : { number1 }|.
  WRITE: / |  Operator    : { operator }|.
  WRITE: / |  Number 2    : { number2 }|.
  FORMAT RESET.

  "Result
  WRITE: /.
  FORMAT COLOR COL_POSITIVE INTENSIFIED ON.
  WRITE: / |  RESULT      : { result }|.
  FORMAT RESET.

  IF use_last = abap_true.
    WRITE: /.
    WRITE: / '  The result will be available as Number 1 value when going back.'.
  ENDIF.
  WRITE: /.
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine display_history
*&---------------------------------------------------------------------*

"Used to display the history in a classic list output
FORM display_history.
  WRITE: /.
  FORMAT COLOR COL_HEADING INTENSIFIED.
  WRITE: / '  Calculation History'.
  WRITE: / '  ==================='.
  FORMAT RESET.
  WRITE: /.
  IF history IS INITIAL.
    FORMAT COLOR COL_NEGATIVE INTENSIFIED.
    WRITE: / '  No calculations available.'.
    FORMAT RESET.
    RETURN.
  ENDIF.

  "Table heading for the history
  WRITE:
      /(5) 'No.',
        8    'Date',
        20   'Time',
        32   'Calculation'.
  WRITE: / repeat( val = '-' occ = 80 ).

  "Displaying the history table content
  LOOP AT history INTO DATA(history_line).
    IF history_line-calculation_no = calculation_count.
      FORMAT COLOR COL_POSITIVE INTENSIFIED ON.
    ELSE.
      FORMAT COLOR COL_NORMAL.
    ENDIF.

    "Truncating the calculation if it would run past the screen.
    "The calculation starts at column 32, so the available width is
    "the list line size (sy-linsz) minus the leading columns. A
    "too-long calculation is cut and the last 3 characters are
    "replaced by 3 dots to indicate the truncation.
    DATA(available) = sy-linsz - 31.
    DATA(calculation) = history_line-calculation.
    IF available > 3 AND strlen( calculation ) > available.
      calculation = |{ substring( val = calculation
                                  len = available - 3 ) }...|.
    ENDIF.
    WRITE: /(5) history_line-calculation_no,
            8    history_line-date,
            20   history_line-time,
            32   calculation.
    FORMAT RESET.
  ENDLOOP.
  WRITE: / repeat( val = '-' occ = 80 ).
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine display_history_alv
*&---------------------------------------------------------------------*

"Used to display the history in an ALV grid output
FORM display_history_alv.
  IF history IS INITIAL.
    RETURN.
  ENDIF.
  PERFORM setup_alv.
  alv->display( ).
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine setup_alv
*&---------------------------------------------------------------------*

"Used to set up the ALV grid output for the history display.
"The ALV object is created and configured only once.
FORM setup_alv.
  IF alv IS BOUND.
    RETURN.
  ENDIF.
  TRY.
      cl_salv_table=>factory(
              IMPORTING
                r_salv_table = alv
              CHANGING
                t_table      = history
            ).

      "Using standard ALV functions
      DATA(functions) = alv->get_functions( ).
      functions->set_all( abap_true ).

      "Column setup
      DATA(columns) = alv->get_columns( ).
      DATA(column) = columns->get_column( 'CALCULATION_NO' ).
      column->set_short_text( 'No.' ).
      column->set_medium_text( 'Calculation' ).
      column->set_long_text(  'Calculation Number' ).

      column = columns->get_column( 'NUMBER1' ).
      column->set_short_text( 'Number 1' ).
      column->set_medium_text( 'First Number' ).
      column->set_long_text(  'First Number' ).

      column = columns->get_column( 'OPERATOR' ).
      column->set_short_text( 'Op.' ).
      column->set_medium_text( 'Operator' ).
      column->set_long_text(  'Arithmetic Operator' ).

      column = columns->get_column( 'NUMBER2' ).
      column->set_short_text( 'Number 2' ).
      column->set_medium_text( 'Second Number' ).
      column->set_long_text(  'Second Number' ).

      column = columns->get_column( 'RESULT' ).
      column->set_short_text( 'Result' ).
      column->set_medium_text( 'Result' ).
      column->set_long_text(  'Calculation Result' ).

      column = columns->get_column( 'CALCULATION' ).
      column->set_technical( abap_true ).

      column = columns->get_column( 'DATE' ).
      column->set_short_text( 'Date' ).
      column->set_medium_text( 'Date' ).
      column->set_long_text(  'Calculation Date' ).

      column = columns->get_column( 'TIME' ).
      column->set_short_text( 'Time' ).
      column->set_medium_text( 'Time' ).
      column->set_long_text(  'Calculation Time' ).

      "Optimize columns
      columns->set_optimize( abap_true ).

      "Sort descending by calculation number so that the latest
      "result is displayed first.
      DATA(sorts) = alv->get_sorts( ).
      sorts->add_sort( columnname = 'CALCULATION_NO'
                       sequence   = if_salv_c_sort=>sort_down ).

      "Display settings
      DATA(display_settings) = alv->get_display_settings( ).
      display_settings->set_list_header( |Calculation History - { calculation_count } calculations| ).
    CATCH cx_root INTO DATA(error).
      MESSAGE error->get_text( ) TYPE 'E'.
  ENDTRY.
ENDFORM.

*&---------------------------------------------------------------------*
*& Subroutine display_statistics
*&---------------------------------------------------------------------*

"Used to display the statistics in a classic list output
FORM display_statistics.
  WRITE: /.
  FORMAT COLOR COL_HEADING INTENSIFIED.
  WRITE: / '  Calculation Statistics'.
  WRITE: / '  ======================'.
  FORMAT RESET.
  WRITE: /.
  FORMAT COLOR COL_NORMAL.
  WRITE: / '  Total calculations :', |{ calculation_count }|.
  WRITE: / |  Additions          : { additions }  ( { COND decfloat34( WHEN calculation_count > 0
                                                                       THEN CONV decfloat34( additions * 100 ) / calculation_count
                                                                       ELSE 0 ) DECIMALS = 1 }% )|.
  WRITE: / |  Subtractions       : { subtractions }  ( { COND decfloat34( WHEN calculation_count > 0
                                                                          THEN CONV decfloat34( subtractions * 100 ) / calculation_count
                                                                          ELSE 0 ) DECIMALS = 1 }% )|.
  WRITE: / |  Multiplications    : { multiplications }  ( { COND decfloat34( WHEN calculation_count > 0
                                                                             THEN CONV decfloat34( multiplications * 100 ) / calculation_count
                                                                             ELSE 0 ) DECIMALS = 1 }% )|.
  WRITE: / |  Divisions          : { divisions }  ( { COND decfloat34( WHEN calculation_count > 0
                                                                       THEN CONV decfloat34( divisions * 100 ) / calculation_count
                                                                       ELSE 0 ) DECIMALS = 1 }% )|.
  FORMAT RESET.
  WRITE: /.
ENDFORM.