By submitting your email address, you agree to receive emails regarding relevant topic offers from TechTarget and its partners. You can withdraw your consent at any time. Contact TechTarget at 275 Grove Street, Newton, MA.
ABAP Workbench uses include techniques extensively, especially in
Module Pool or Function Pool programs. This should not be new to you
ABAP programmers. However, macros (the other way of structuring your
source code) are used in many SAP standard areas like HR, Business
Object Repository, Web applications, etc. and you need to know what
they are and how they work.
This article focuses on the two particular modularization units
used for structuring the source code - includes and macros.
There are two kinds of modularization units:
Those that allow you to structure tasks and those
that allow you to structure source code.
The modularization units used for performing a task are:
Dialog module (obsolete)
Screen (CALL SCREEN)
Selection screen (CALL SELECTION SCREEN)
GUI Status and title
The modularization units that you can use to structure your source code are:
Let's have a look at the Includes and Macros.
You use include programs to create shared program sections or to
divide programs into smaller parts that are easier to maintain.
The INCLUDE statement has the same effect as copying the source code
of the include program into the main program at the point where it occurs.
When you check the syntax of an include, the system combines the
current contents of the Editor with the contents of the TOP include to
form a unit whose syntax and semantics can be checked sensibly.
Refer to the menu item Program->Check->Main program. This is the only way that
everything is checked (for example, whether a subroutine called using
PERFORM exists). The reason for the otherwise incomplete check is
that the syntax check is optimized for performance. Since subroutines
normally occur in a different include to the PERFORM statements that
call them, a full check will require too many includes to be checked.
Includes are not loaded dynamically at runtime, they are expanded
when the program is generated.
Include programs do not have a parameter interface. They are used in
the main programs of function modules, module pools and more and more
in executable programs (or reports) to group together parts of the program
that logically belong together.
Include programs can not run independently, but must be embedded in
other programs. You can embed includes within other includes, but
recursive calls are not allowed.
You can use the where-used list function in the Repository Browser to find
the programs in which a particular include is used.
You define macros using the following statement block
You must specify full statements between the DEFINE and
END-OF-DEFINITION statements. The statements may contain up to
nine placeholders &1, &2, ?, &9. The definition of a macro must appear
in the program before it is called.
You run a macro using the statement
DATA: result TYPE I.
result = &1 &2 &3.
output &1 &2 &3 result.
WRITE: / 'The result of &1 &2 &3 is', &4.
operation 4+ 3.
operation 2 ** 7.
The output generated by the program will be:
The result of 4 + 3 is 7
The result of 2 ** 7 is 128
When a program is generated, the macro is replaced by the corresponding
statements, and the placeholders &I are replaced by the parameters
Macros may call other macros, but may not call themselves.
The above example contains definitions for two macros,
OPERATION and OUTPUT. OUTPUT is nested within OPERATION.
OPERATION is called twice with different parameters. Note how the
placeholders &1, &2, &3 are replaced.
The disadvantage of macros is that the macro call is difficult to
interpret, especially if the definition and call are a long way apart
in the program. Another disadvantage is that the Debugger does not step
through macros' statements. Instead, it executes them in a single step.
Macros should not be used, since if they become too complicated, you will
be the only person to understand them. Use instead a subroutine. However,
since macros are used in some programs in the SAP standard, you need to
know what they are and how they work.
You'll find a number of macros with their statements in the table TRMAC,
a very well known one being the BREAK macro. Take a look at it, try it in
your program and discover a very personal way of starting the Debugger.
You can learn more about 'include programs' in SAP Classes BC400
(ABAP Workbench Concepts and Tools), BC410 (ABAP Workbench User Dialogues),
and BC425 (Enhancements and Modifications).
For information about these and all other SAP Educational Services
classes, visit us at
SAP Education Online