A subroutine is a block of code introduced by FORM and concluded by ENDFORM.
|
In ABAP a subroutine is defined as shown above. All the subroutines start with FORM followed by the subroutine name.
For example.
|
A subroutine is called by a PERFORM statement as follows.
PERFORM write_hello.
In the above example no parameters pased to the subroutine. We will now see one more example of a simple subroutine that passes parameters. Now if you want to add two numbers. we need to write the following code.
Data: d_sum type i,
d_num1 type i,
d_num2 type i.
d_num1 = 5.
d_num2 = 10.
perform addnumbers using d_num1
d_num2 .
write:/ d_sum, d_num1, d_num2.
*---------------------------------------------------------------------*
* FORM addnumbers *
*---------------------------------------------------------------------*
* ........ *
*---------------------------------------------------------------------*
* --> NUM1 *
* --> NUM2 *
*---------------------------------------------------------------------*
form addnumbers using num1 num2.
d_sum = num1 + num2.
endform.
For the above code the output would be 15, 5, 10 because the values of the parameters would be as follows.
d_sum = 15,
d_num1 = 5,
d_num2 = 10.
This is because we are passing the parameters by REFERENCE and not by VALUE.
Important: For calling by reference, USING and CHANGING are equivalent.
This means that the value of the actual parameters changes if the value of the formal parameters changes. We will write some code
to demonstrate this point.
Data: d_sum type i,
d_num1 type i,
d_num2 type i.
d_num1 = 5.
d_num2 = 10.
perform pass_ref using d_num1
d_num2.
write:/ d_sum, d_num1, d_num2.
*&---------------------------------------------------------------------*
*& Form pass_ref
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* -->P_D_NUM1 text
* -->P_D_NUM2 text
*----------------------------------------------------------------------*
FORM pass_ref USING P_D_NUM1
P_D_NUM2.
P_D_NUM1 = 100.
P_D_NUM2 = 200.
ENDFORM. " pass_ref
The output of the above program would be 15, 100, 200. This is because the value of actual parameters is changed because the value of the formal parameters also changes.
We will now see how to pass parameters by value. To pass parameters by value we need to explicitly state it in the subroutine. When parameters are passed by VALUE the value of the actual parameters does not change, even if the value of the formal parameters changes.
Sample code.
*&---------------------------------------------------------------------*
*& Form pass_val
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
*
* -->P_D_NUM1 text
*
* -->P_D_NUM2 text
*----------------------------------------------------------------------*
FORM pass_val USING VALUE(P_D_NUM1)
VALUE(P_D_NUM2).
P_D_NUM1 = 1000.
P_D_NUM2 = 2000.
ENDFORM. " pass_val
Please find the code below that demonstrates this concept.
Data: d_sum type i,
d_num1 type i,
d_num2 type i.
d_num1 = 5.
d_num2 = 10.
perform pass_val using d_num1
d_num2.
write:/ d_sum, d_num1, d_num2.
*&---------------------------------------------------------------------*
*& Form pass_val
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
*
* -->P_D_NUM1 text
*
* -->P_D_NUM2 text
*----------------------------------------------------------------------*
FORM pass_val USING VALUE(P_D_NUM1)
VALUE(P_D_NUM2).
P_D_NUM1 = 1000.
P_D_NUM2 = 2000.
ENDFORM. " pass_val
The output of the above program is 15, 5, 10.
We will now see the effect of CHANGING when the PARAMETERS are passed by VALUE. If CHANGING is specified in PARAMETERS that are passed by value then the value of the ACTUAL Parameters also changes. Please see the sample code below.
Data: d_sum type i,
d_num1 type i,
d_num2 type i.
d_num1 = 5.
d_num2 = 10.
perform pass_val_chcg using d_num1
d_num2.
write:/ d_sum, d_num1, d_num2.
*&---------------------------------------------------------------------*
*& Form pass_val_chcg
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* -->P_D_NUM1 text
* -->P_D_NUM2 text
*----------------------------------------------------------------------*
FORM pass_val_chcg USING VALUE(P_D_NUM1)
CHANGING VALUE(P_D_NUM2).
P_D_NUM1 = 1001.
P_D_NUM2 = 2002.
ENDFORM. " pass_val_chcg
The output of the above program would be as follows.
15, 5, 2,002
This is because we have specified CHANGING only for the PARAMETER P_D_NUM2 and hence the actual Parameter d_num2 also changes.
If the subroutine concludes successfully, that is, when the ENDFORM statement occurs, or when the subroutine is terminated through a CHECK or EXIT statement, the current value of the formal parameter is copied into the actual parameter.
If the subroutine terminates prematurely due to an error message, no value is passed.
