topic Re: Function modules & subroutines diff in Application Development and Automation Discussions

Function modules & subroutines diff

Former Member — Fri, 02 Nov 2007 06:18:44 GMT

What is the diff betn function modules and subroutines?

Re: Function modules & subroutines diff

Former Member — Fri, 02 Nov 2007 06:21:35 GMT

Fun modules are global programs

where as subroutines are LOCAL to a program

fun modules return values where as subroutines are not

Function Modules are Global ABAP programs created by SAP for reusable purpose.they have IMPORT,EXPORT and TABLE parameters, and EXCEPTIONS to through when error occurs.

You can create them from TCode SE37.

Go through the following doc:

Function modules are cross-program, reusable procedures that are organized into function groups, and whose functions are implemented between the statements FUNCTION and ENDFUNCTION. Function modules and their interfaces are created in the Function Builder.

Function Module Interfaces

The parameter interface of a function module is defined in the Function Builder. It includes the definition of interface parameters and the specification of exceptions that can be triggered by a function module. The Function Builder automatically generates comment lines below the FUNCTION statement in the source code of the function module, which represent the interface of the function module with the following syntax:

Syntax

... [IMPORTING parameters]

[EXPORTING parameters]

[CHANGING parameters]

[TABLES table_parameters]

[{RAISING|EXCEPTIONS} exc1 exc2 ...]

SUBROUTINES

definition

PERFORM FETCH_DATA using p1 p2

tables itab

changing p_v1

...

FORM FETCH_DATA using...tables...changing..

.............

ENDFORM.

Regards

Anji

Message was edited by:

Anji Reddy Vangala

Re: Function modules & subroutines diff

Former Member — Fri, 02 Nov 2007 06:23:49 GMT

Fun modules are defined in SE37 and can be used by anywhre in program

subroutines are definde inside a program and created inside program.

Other program can not call this subrutine.

Both will returen value

Subroutines are procedures that you can define in any ABAP program and also call from any program. Subroutines are normally called internally, that is, they contain sections of code or algorithms that are used frequently locally.

As mentioned, both forms and FMs are reusable modularization units. To distinguish we generally say that forms are used for internal modularization and FMs are used for external modularization.

To decide on which to implement, consider whether you need the content to be used just for a limited program or wheteher it can be called from many independent programs. For the first purpose it is better to implement a form whereas for the second we implement an FM.

However, ABAP does not isolate the usage context. That is; you can call a form from another program within whose code the form is not actually implemented. However, this requires attention since the form may utilize global variables.

The same issue holds for FMs. FMs are encapsulated in function groups and function groups may have global variables that can be globally used by all FMs inside it.

Subroutines are loacl to a progarm.. It cant be extended to other program.

But Function Modules are similar to subroutines but are global in view and can be used in many program.

Subroutine have three types.

pass by value, pass by reference and pass by value and reference similar to pointers but not exactly the same.

Function modules are used in BDC , BAPI etc..

Also there are standard FMs which can be used.

http://help.sap.com/saphelp_nw2004s/helpdata/en/c5/aa575926ad11d2954d0000e8353423/content.htm

http://www.sapbrainsonline.com/FAQs/TECHNICAL/SAP_ABAP_MODULARIZATION_FAQ.html

A subroutine is a block of code introduced by FORM and concluded by ENDFORM.

FORM subr [USING p1 TYPE type

p2 LIKE field

...

VALUE(p3) TYPE type

VALUE(p4) LIKE field

... ]

[CHANGING { {VALUE(p1)}|{p1 [{TYPE type}|{LIKE field}]}

{VALUE(p2)}|{p2 [{TYPE type}|{LIKE field}]}

... } ]

...

ENDFORM.

subr is the name of the subroutine. The optional additions USING and CHANGING define the parameter interface. Like any other processing block, subroutines cannot be nested. You should therefore place your subroutine definitions at the end of the program, especially for executable programs. In this way, you eliminate the risk of non-executable statements occurring by mistake through a subroutine closing an event block at the wrong place.

EXAMPLE :

REPORT demo_mod_tech_data_types .

TYPES word(10) TYPE c.

DATA text TYPE word.

text = '1234567890'. WRITE / text.

PERFORM datatest.

WRITE / text.

FORM datatest.

TYPES word(5) TYPE c.

DATA text TYPE word.

text = 'ABCDEFGHJK'. WRITE / text.

ENDFORM.

FUNCTION MODULES

http://www.erpgenie.com/abap/functions.htm

http://www.sapdevelopment.co.uk/fmodules/fmssap.htm

http://www.erpgenie.com/abap/index.htm

http://www.geocities.com/victorav15/sapr3/abapfun.html

A subroutine is a block of code introduced by FORM and concluded by ENDFORM.

FORM <subr> [USING ... [VALUE(]<pi>[)] [TYPE <t>|LIKE <f>]... ]

[CHANGING... [VALUE(]<pi>[)] [TYPE <t>|LIKE <f>]... ].

...

ENDFORM.

<subr> is the name of the subroutine. The optional additions USING and CHANGING define the parameter interface. Like any other processing block, subroutines cannot be nested. You should therefore place your subroutine definitions at the end of the program, especially for executable programs (type 1). In this way, you eliminate the risk of accidentally ending an event block in the wrong place by inserting a FORM...ENDFORM block.

You call subroutines using the statement

PERFORM... [USING ... <pi>... ]

[CHANGING... <pi>... ].

Subroutines can call other subroutines (nested calls) and may also call themselves (recursive calls). Once a subroutine has finished running, the calling program carries on processing after the PERFORM statement. You can use the USING and CHANGING additions to supply values to the parameter interface of the subroutine.

Subroutines are modularization techniques. They make program easy to understand. We can keep a set of stmts which must be performed repeatedly as a set and call them using a single stmt wherever we require. This is the simple concept of the subroutines. This reduces the program size and also makes it easy to understand. For ex. in my program i have to select some data from a table, do some modifications to the data and then display it in the output. Then it can be done like this

..............

...........

start-of-selection.

perform fetch_data.

perform modify_data.

perform display_data.

end-of-selection.

form fetch_data.

.............

...........

endform.

form modify_data.

...........

............

endform.

form display_data.

............

endform.

In the above program it can be easily understood that first the subroutine for fetching data is called. Then subroutine for modifying data is called. Then subroutine for displaying data is called. Here perform stmts are for calling the subroutines named after perform and the actual action to be done i.e., the abap stmts for that particular task is given between form -- endform stmt. This block refers a subroutine body. similarly each form -- endform will refer to one subroutine body. Here the advantage is that it makes program easy to understand and also if we have to do same actions repeatedly like displaying data repeatedly after doing some modifications in the same manner, then we can simply call the subroutine with single stmt instead of writing the entire code repeatedly.

Hope u understood.

there are more options like using some parameters in the perform stmt like ' using ', etc.

Function Modules are the advanced modularization techniques of subroutines.

Rewards if useful.......

Minal Nampalliwar

Re: Function modules & subroutines diff

Former Member — Fri, 02 Nov 2007 06:24:29 GMT

Subroutines are the piece of code of block of codes written in report.

Exam

Perform calculate...

here calculate is subroutine name...

if you click on calculate it will open beneath that code

form calculate

...here write your code

a = b + c...

endform

Function modules are standard function modules or we can create.

we can call the function modules in program and we pass value to it and it will return some value.

for example i want to know sales document number.

then call function module like bapi_salesorder_create...

you pass sales document number and you get all details of sales document.

Re: Function modules & subroutines diff

Former Member — Fri, 02 Nov 2007 06:26:53 GMT

FMs and Subroutines are both modularization techniques but there are a few differences...

FMs have a global scope, that means they can be used by any program in the system. Subroutines are however more local in scope, they are generally specific to a particular program. Generally, you write all subroutines in an include program and then include this program in a report.

FMs do return values but Subroutines do not.

FMs can be called from other systems also (RFCs) but this is not the case with subroutines.

There is a function group to which each function module is associated. A function group contains related function modules. On calling a function module, the entire function group of that module gets loaded in the memory, thereby making the global variables in the function group available to the program that calls the function modules. There is no such concept associated with subroutines.

regards,

Priyank

Re: Function modules & subroutines diff

Former Member — Fri, 02 Nov 2007 06:27:35 GMT

Hi,

Subroutines are program modules, which can be called from other ABAP/4 programs or within the same program.

There are 2 types of Subroutine

Internal Subroutines: The source code of the internal subroutines will be in the same ABAP/4 program as the calling procedure (internal call).

External Subroutines: The source code of the external subroutines will be in an ABAP/4 program other than the calling procedure.

Function modules are procedures that are defined in special ABAP programs only, so-called function groups, but can be called from all ABAP programs. Function groups act as containers for function modules that logically belong together. You create function groups and function modules in the ABAP Workbench using the Function Builder SE37.

Unlike subroutines, you do not define function modules in the source code of your program. Instead, you use the Function Builder. The actual ABAP interface definition remains hidden from the programmer. You can define the input parameters of a function module as optional. You can also assign default values to them. Function modules also support exception handling. This allows you to catch certain errors while the function module is running. You can test function modules without having to include them in a program using the Function Builder.

Regards,

Ruthra