2.

Initiating the Debugging

Debugging can be initiated in two ways.

a. Using /h command and executing the transaction.

b. Putting a break-point, at a particular line of the program and executing

the transaction.

As functional consultants , we would be mostly using the 1st option. The 2nd option is used, generally by
ABAPers, where they want to see the behavior of a particular section of the code. Let’s see examples of
each of the above mentioned methods.

Example

a. Using /h command and executing the transactions

Below is the initial screen of a transaction.

First step is to use the command ‘/h’.

A message will be displayed in the bottom of the screen.

The resulting Screen will be as below.

We can see the current control with the yellow arrow.

 As we press ‘F5’, the control proceeds further.

 If we press F8, two things can happen
1. If any Break-point is there, the control will directly flow there.(Break-Points have been discussed
in more detailed way in coming slides)

2. If no break-point is there, the debugging will end and the program will get executed.

 As we move along the program, we may encounter, Subroutines/function modules, which

are nothing but a piece of code within the program, which take inputs and provide a
specific output.
 If we Keep pressing on F5, we will go inside the Subroutines/function modules and go
through each line.
  If we have yet not entered Subroutines/function modules , then by pressing F6 , we will
skip going through the code piece and the Subroutines/function module will be completely
executed.
 If we have entered Subroutines/function modules , then by pressing F7 , we will come out
of the code piece and the Subroutines/function module will be completely executed.
b. Putting a break-point, at a particular line of the program and executing the transaction
This can be done by going in to the source code editor (SE38/37 etc.) and putting the break point at the
desired line. Cursor can be put on the particular line , at which we need the control to stop and click on the
break point button(highlighted in the below screenshot).This will create the breakpoint in the program.

When we execute the program, the control will go to that point and stop.

3. Break-Points
Break-point is the point where the Program execution comes to a halt and from there on we can continue
debugging or straight away execute the program , by pressing F8.

There are various ways, through which we can put a break-point in a program . Two mostly used ways are
as below.

1. During Debugging the program

2. Before Debugging/Executing the program

Lets discuss about each of the ways.

1. During Debugging of the program
During debugging break point can be put in two ways.

a. Jumping to a specific processing block

This is one of the important methods and by far the most useful for functional consultants.

Generally we tend to debug, when we encounter an error message. In that case, we can put the breakpoint,
exactly at the point , where the error originated. And once we execute the program, that will take us
straight to that point.

Let’s take an example of the current program. It takes the input as an AL11 path. The path must be a valid
one. If we put an invalid one, it would ideally end in error. Suppose We encounter such an error, while
executing the transaction in question.

Above is the initial screen and upon execution, we got the below error.

1st thing to do after this is double clicking the error message which will give us the message class and the
message number In the screen below AD is the message class and 010 is the message number and the
message, being in red, indicates that it’s an error message.

We start the debugging, by using /h and then, we put this message class and number in the debugging
screen as mentioned in the following screenshot.
Now executing the program(F8) will take us to the exact point of error, where we can analyze the reason of
the error. In this specific case, the IF statement below says, if the 1st two characters (OFILE_SAVE+0(2))
is not ‘\\’, then issue an error. The input that we provided in the selection screen started with ‘//’ , and
hence it resulted in error. That’s how, we find out the reason of an error, in this method.

b. Using the stop icon, during debugging

Once the debugging screen appears, breakpoint can be put by using the highlighted breakpoint option.

2. Before Debugging/Executing the program

This can be done by putting a breakpoint in the source code editor (SE38/37 etc.). When we execute the
program, the control will go to that point and stop.

In SE38, Cursor can be put on the particular line , at which we need the control to stop and click on the
break point button(highlighted in the below screenshot).
Next when we execute the program or transaction, the control stops at this point.

4. General Tips:
Given below are some general tips, suggestions and terminologies involved in debugging.

 Debugging with the new Debugger Opens a new session. Hence , before debugging,
ensure that we have enough room for the same, else, automatically the old debugger
opens.
 During Debugging, if at any point, we want to see the source-code, we can do so in the
following way.

 During debugging, we come across select statements, which are nothing but the
statements, which fetch data from database table and store in the internal table in the run-
 time. If we click on the table icon(highlighted in the below screenshot) , It opens up the
table in the next window. We can download the table data in an excel format for our
analysis.

Below are few important parameters and terminologies with respect to debugging.

 SY-SUBRC : It’s an indicator, that shows , whether the execution of a “Select statement” ,
“Function Module”, “Subroutine” , “Method”, is successful or not. When sy-subrc is 0, it
indicates that the execution is successful.
 Variable : It’s a temporary storage parameter, that holds a value during the program run-
time.
 Constant: As the name suggests, it holds a constant value, which is hard-coded in the
program.
 Tables : When the control passes through a select statement, up on successful execution,
the table(internal table) gets filled in the run-time.
 Structures : Structure is different than a table. Its just a template, but not a table.
These were some basic information, which can be handy to the functional consultants. Debugging has far
more aspects and we can explore more of them, as we continue to be involved in more of debugging. Your
comments and suggestions are most welcome.