Structure of ABAP program

hi SDNs,
           what is the typical structure of an ABAP program?
           thanks and regards,
               aravind.

hi
plz check the structure of ABAP Program under..
http://help.sap.com/saphelp_47x200/helpdata/en/d3/2e974d35c511d1829f0000e829fbfe/frameset.htm
below the typical structure...
1.data declaration
2.selection-screen declartion
3.data validation
4.output.
Cheers
Abdul Hakim

Similar Messages

  • Regarding structure of abap program

    hi,
    can any one exaplain to me what is the structure of the abap program.
    thank&regards,
    ramnaresh

    Hi..
    This is the Structure of ABAP program.
    REPORT <NAME>.
    **Global Data definitions
    TYPES:
    DATA:
    **Selection Screen Definition
    SELECT-OPTIONS
    PARAMETERS
    **Event Blocks
    INITIALIZATION .
       perform X.
    START-OF-SELECTION.
       perform Y.
    ****Form routines definition
    FORM X.
    ENDFORM.
    FORM Y.
    ENDFORM.
    <b><REMOVED BY MODERATOR></b>
    Message was edited by:
            Alvaro Tejada Galindo

  • How to use structure in ABAP program

    I developing a report in smartforms but i want some fields to be display on the report but unable to find the relvent table as the field is show in structure.i can not find the actual table . is there any specfic way to find the table .or is there any way to use the fields defind in structure in my ABAP program.

    Hi,
      May be iam not clear with the question. But why you want to use structure. In report you can define your own structure, also you can declare your fields directly using standard datatypes.
    Hope this will help!!!
    Amol

  • Updating A Structure using ABAP Program

    Hi,
    V r using a structure...IOOPCOMP, in COOIS Transaction.
    its fetching data from MARA, and other tables too. V want a new Field included in IOOPCOMP, from MARA, and get it Updated.
    There's no user exit available for COOIS.
    Its urgent.
    Pls Do let us know How to proceed.
    Regards,
    Ajaz

    Hi Ajaz
    There is an Append Structure <b>ZRESB</b>. Try inserting your new field with the same name as in MARA to it. However, I am not sure whether it wil be filled.
    Hope this solves your problem.
    Kind Regards
    *--Serdar
    [email protected]

  • Abap program standards

    hi all,
         i need to design flow chart for checking for a program whether it satifies the abap coding standards or not. who to do it. if possible send me graphical representations [flow charts]  or links to find programming standards.
    some of my requirements in that folw chart are
      1. how to recognize a blank space in a given program,
      2. how to recognize a comment,
      3. how to check wheteher a keyword is used or not,
      4. how to identify the ' :' symbol
    thanks & regards,
    suresh babu aluri.

    plz go through this documementaion,
    i think its helpful.
    ABAP Programming StandardsContents
    1.     Objective     5
    2.     Naming Conventions     5
    2.1     Codes for naming conventions     5
    2.1.1     Module Codes     5
    2.1.2     Free text     6
    2.2     Naming Convention of Development Objects     6
    2.2.1     Package     6
    2.2.2     Executable Program     6
    2.2.3     BSP Application     7
    2.2.4     Logical Database     8
    2.2.5     SAP Scripts /Smartforms     9
    2.2.6     Idocs     9
    2.2.7     Transaction Code     10
    2.2.8     Function Groups     10
    2.2.9     Dictionary Objects     11
    2.2.10     Message Class     11
    2.2.11     Enhancement Projects (User Exits)     11
    2.2.12     LSMW Objects     12
    2.2.13     Classes     12
    2.2.14     BOR Object Types     13
    2.2.15     Screen / Transaction Variants     13
    2.2.16     Area Menu     13
    2.3     Naming of Sub-Objects     13
    2.3.1     Program Sub-Objects     13
    2.3.2     SAP Script /Smartform sub-objects     14
    3.     General Programming Guidelines     14
    3.1     Modification Logs     14
    3.2     Program Organization     15
    3.2.1     Executable Programs     15
    3.2.2     Dialog Programs     15
    3.3     Package     15
    3.3.1     Adding Components to existing objects     15
    3.3.2     Creation of New Objects     15
    3.4     Program Messages     15
    3.4.1     Adding Messages to existing landscapes     15
    3.4.2     Creation of New Objects     16
    3.5     Dictionary Objects     16
    4.     Structure of ABAP Programs     16
    4.1     Type     16
    4.2     Status     18
    4.3     Authority Check     18
    4.4     Program Structure     19
    4.4.1     Declaration data for global data, classes and selection screens     19
    4.4.2     Container for Processing Blocks     19
    4.4.3     Calling Processing Blocks     20
    4.5     Screen Flow Logic (Dialog Programs)     20
    4.5.1     Place the AT EXIT COMMAND at the beginning of the flow logic.     20
    4.5.2     Use FIELD and CHAIN statements to keep fields in error open for correction.     20
    4.6     Main Program     20
    4.6.1     Events     20
    5.     General Coding Standards     21
    5.1     One command per line     21
    5.2     Indented Source Code     21
    5.3     Extended Syntax Check     21
    5.4     Reusability and Modularity     21
    5.5     Text Handling     21
    5.6     Usage of System Variables     22
    5.7     Chaining Statements     22
    5.8     Common Routines     22
    5.9     Dialog Messages     22
    5.10     Function Keys     23
    5.11     Enqueuing and Dequeuing Data Objects     23
    5.12     Error Handling (SY-SUBRC)     23
    5.13     General Conventions and Hints     24
    5.14     Parameters in Sub-Routines     24
    6.     Performance Standards     25
    6.1     General Tips on Performance Tuning     25
    6.1.1     Avoid Redundant code     25
    6.1.2     Subroutine Usage     25
    6.1.3     Case vs. Nested IF     25
    6.1.4     Using the MOVE Statement     25
    6.1.5     SELECT Queries     25
    6.1.6     Using the READ statement     27
    6.1.7     Hashed table     27
    6.1.8     Transporting     28
    6.1.9     Using LDB     28
    6.1.10     Append Lines of     28
    6.1.11     Use WHILE     28
    6.1.12     DELETE <itab> WHERE     28
    6.1.13     Using WHERE clause in LOOP…….ENDLOOP     28
    1.     Objective
    The objective of this document is to describe general programming guidelines, methodologies, Naming conventions and performance guidelines for all the programs developed for SAP Project.
    2.     Naming Conventions
    This chapter describes the naming conventions to be followed for naming the programming objects for SAP project.
    2.1      Codes for naming conventions
    The variable portion of naming convention is given with Code ID given in angle brackets(<>). Use the following tables for replacing code IDs with codes in the object naming.
    2.1.1     Module Codes
    Code ID:  mm
    Code     Description
    FI     Finance
    CO     Controlling Module
    MM     Materials Management
    PP      Production Planning
    SD     Sales & Distribution
    QM      Quality Management
    PM     Plant Maintenance
    IM     Inventory Management
    WM     Warehouse Management
    BC     Basis Module
    BW     Business Warehouse
    WF     Workflows (Master Data Management)
    HR     Human Resources
    EBP     EBP
    PS     Project Systems
    PCP     Synpro: Product Costing
    PAP     Synpro: COPA
    DP     APO :  Demand Planning
    SP     APO :  Supply Network Planning
    DS      APO : Production Planning & Detailed Scheduling
    AT     APO : Global ATP
    TP     APO : Transportation Planning/Vehicle Scheduling
    CI     Core Interface
    LC     Live Cache
    2.1.2     Free text
    Code ID: ffff
    Developer should replace ‘ffff’ with meaningful text. The text can be multiple words separated by underscore.
    2.2     Naming Convention of Development Objects
    2.2.1     Package
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with Module codes given in section 2.1.1 above.
    2.     Replace <ffff> with the sub-landscape of the Module that this Message Class caters to as illustrated in examples below.
    3.     The maximum permissible length for development class is 30 characters
    Examples:
    Dev. Class     Description
    ZFI_AR     FI: Account Receivables
    ZCO_CCA     CO: Cost Center Accounting
    2.2.2     Executable Program
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text as illustrated in examples below.
    3.     The maximum permissible length for program name is 30 characters. However, the name should be restricted to 25 characters to accommodate appropriate Include naming as described in 2.2.2.
    Examples:
    Program Name     Description
    ZFI_VAT_RET     FI:  Report for VAT Return
    ZMM_AUTO_GR     MM: Automated Goods Receipt
    ZSD_XX_STCK_SHORTAGE     SD: Stock shortage report for stock allocation
    2.2.2.1     Includes for executable programs
    Naming Convention: Z<mm>_<ffff>_<Inn>.
    Notes:
    1.     All includes of executable program will be prefixed by Z, followed by the same program name as described in 2.2.2 above.
    2.     Replace <Inn> with include type and sequence number. Use the following table for includes.
    Include Type ID     Description
    TOP     Top Include.
    Fnn     Subroutine pool (Forms)
    Inn     PAI Modules
    Onn     PBO Modules
    Xnn     Other Includes
    The maximum permissible length for Include name is 30 characters.
    Examples:
    Include Name     Main Program Name     Description
    ZFI_VAT_RET_TOP     ZFI_VAT_RET     FI:  Report for VAT Return – Top Include
    ZFI_VAT_RET_F01     ZFI_VAT_RET     FI:  Report for VAT Return – Forms
    ZMM_AUTO_GR_TOP     ZMM_FR_AUTO_GR     MM: – Automated Goods Receipt – Top include
    ZMM_AUTO_GR_F01     ZMM_FR_AUTO_GR     MM:– Automated Goods Receipt – Forms
    2.2.3     BSP Application
    2.2.3.1     Main Application
    Naming Convention: BSP Applications shall follow the same Naming Convention as Executable Programs i.e. Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text as illustrated in examples below.
    2.2.3.2     Pages & Controllers
    Naming Convention: <ffff>
    Notes:
    1.     Replace <ffff> with meaningful text, that adequately describes the function of the page/controller
    2.2.3.3     Theme
    Naming Convention: Z_<ffff>.
    Notes:
    1.     Replace <ffff> with meaningful text
    2.2.3.4     Mime Objects:
    Naming Convention: <ffff>
    1.     A MIME Object can be logo for the company.
    2.     Replace <ffff> with meaningful text, that adequately describes the function of the MIME objects
    2.2.3.5     Controller and Handler Classes:
    See section Classes (Section 2.2.133)
    2.2.3.6     BSP Extension
    Naming Convention: Z_<ffff>
    Notes:
    1.     Replace <ffff> with meaningful text
    2.2.3.7     BSP Layout elements id
    Label:     lb_fffff
    Input field:     if_fffff
    Button:     b_fffff
    Text Edit:     te_fffff
    Text View:     tv_fffff
    Radio button Group:     rbg_fffff
    Radio button:     rb_fffff
    Check Box Group:     cbg_fffff
    Check Box     cb_fffff
    Tray     tr_fffff
    Tabstrip     ts_fffff
    Tableview      tab_fffff
    1.  Replace <fffff> with meaningful text
    2.2.4     Logical Database
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text
    3.     The maximum permissible length for LDB name is 20 characters. However, the name should be restricted to 15 characters to accommodate appropriate Include naming
    4.     LDB Program and LDB Program Includes shall follow the naming convention Auto-Generated by SAP
    2.2.5     SAP Scripts /Smartforms
    Naming Convention: ZF<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with module codes given in section 2.1.1 above.
    2.     Replace <ffff> with meaningful text as illustrated in examples below.
    Examples:
    Form Name     Description
    ZFFI_EMP_CONF     Employee Confirmation Letter
    ZFFI_ANN_TO     Annual Turnover Letter To Customers and Vendors
    2.2.6     Idocs
    2.2.6.1     Idoc Types
    Basic Type :
    Naming Convention : ZB<FFFF>NN
    Notes:
    1.Replace <NN> with sequence number.
    3.     Replace <ffff> with meaningful text.
    Extension Type : ZX<Basic type name>_NN
    Notes:
    1.     Replace <NN> with sequence number .
    2.2.6.2     Message Types
    Naming Convention :  ZM<mm><ffff>.
    Notes :
    1.   Replace <mm> with module codes given in section 2.1.1 above.
    2.  Replace <ffff> with meaningful text .
    2.2.6.3      Process Code
    Naming Convention :  Z<ffff>.
    Notes :
    1.     Replace <ffff> with meaningful text ..
    2.2.6.4     IDOC Segments
    Naming Convention :  Z1<ffff>.
    Notes :
    1.Replace <ffff> with meaningful text as illustrated in examples below.
    2.2.7     Transaction Code
    Notes:
    1.     The tcode name is provided by SAP TIN The Developer must write a mail to SAP Tin asking for the T-Code name with a filled form.
    The form can be found at :
    2.2.8     Function Groups
    Naming Convention: Z<mm><ffff>
    Notes:
    1.     Replace <mm> with relevant module code as given above
    2.     Replace <ffff> with meaningful text.
    2.2.8.1     Function Group Include Programs
    Naming Convention: LZ<Function Group><Inn>.
    Notes:
    1.     All includes of Function Group program will be prefixed by LZ, followed by the Function Group name
    2.     Replace <Inn> with include type and sequence number. Use the values from the table given in 2.2.2.1
    Examples:
    Include Name     Function Group Name     Description
    SAPLZMMPURCHASING     ZMMPURCHASING     F.Group-Purchasing: Main Program
    LZMMPURCHASINGO01     ZMMPURCHASING     F.Group-Purchasing: PBO
    LZMMPURCHASINGI01     ZMMPURCHASING     F.Group-Purchasing: PAI
    LZMMPURCHASINGF01     ZMMPURCHASING     F.Group-Purchasing: Forms
    LZMMPURCHASINGTOP     ZMMPURCHASING     F.Group-Purchasing: Data Declarations
    2.2.8.2     Function Modules
    2.2.8.2.1     Normal Function Modules
    Convention: Z_<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with relevant module code as given above.
    2.     Replace <ffff> with meaningful text.
    2.2.8.2.2     IDOC Function Modules
    Convention: Z_IDOC_<mode>_<msg type>.
    Notes:
    1.     Replace <mode> with INPUT or OUTPUT depending on whether the function processes incoming or outgoing IDOC.
    2.     Replace <msg type> with the IDOC message type.
    2.2.9     Dictionary Objects
    Tables:      Z<mm><ffff>
    Structures:      ZS<mm><ffff>
    Views:      ZV<mm><ffff>
    Data Element:      ZDE<mm><ffff>
    Domain:      ZDO<mm><ffff>
    Table Type:      ZTT<mm><ffff>
    Type Group:      Z<ffff>
    Search Help:      ZSH<mm><ffff>
    Lock Object:      EZ<mm><ffff>
    Notes:
    1.     Replace <mm> with module code given above.
    2.     Replace <ffff> with meaningful text.
    2.2.10     Message Class
    Naming Convention: Z<mm>_<ffff>.
    Notes:
    1.     Replace <mm> with Module codes given in section 2.1.1 above.
    2.     Replace <ffff> with the sub-landscape of the Module that this Message Class caters to as illustrated in examples below.
    3.     The maximum permissible length for development class is 30 characters
    Examples:
    Msg. Class     Description
    ZFI_AR     FI: Account Receivables
    ZCO_CCA     CO: Cost Center Accounting
    2.2.11     Enhancement Projects (User Exits)
    Convention: Z<XX><nn>.
    Notes:
    1.     XX is the application area code e.g. for sales it is SD etc.
    2.     'nn'  is one up number for one application area. It starts with 001.
    3.     Maximum length of the Project name is 8.
    Example:  The name of the SD enhancement project can be ZSD001.
    2.2.12     LSMW Objects
    2.2.12.1     Project
    Naming Convention: ZM_<ffff>.
    Notes:
    1.     1.     Replace <ffff> with meaningful text
    2.     The maximum permissible length for Project name is 16 characters. But please limit it to 12.
    Example : ZM_VENDOR
    2.2.12.2     SubProject
    Naming Convention: ZM_<ffff>_<n>.
    Notes:
         Suffix Project name with a running sequence no.
    Example : ZM_VENDOR_1
    2.2.12.3     Object
    Naming Convention: ZM_<ffff>_<n><n>.
    Notes:
         Suffix Subproject name with a running sequence no.
    Example : ZM_VENDOR_11
    2.2.13     Classes
    Naming Convention: ZCL_[IM/DF/BSPCO/BSPHN/BADI]_<ffff>.
    1.     IM: Implementation Class;
    DF: Definition Class
    BSPCO: BSP Controller class
    BSPHN: BSP Handler class
    BADI : BADI implementation
    2.     Replace <ffff> with meaningful text: In case of Implementation classes, it should preferably be the same as that of the Definition Class
    3.     Example:
    IMPLEMENTATION Class: ZCL_IM_REBATE_SETTL
    DEFINITION: ZCL_DF_REBATE_SETTL
    2.2.14     BOR Object Types
    Object     Convention     Example
    Supertype     Z<ffff>     ZLVAPPL
    SubType     Z<SuperType><nn>     ZZLVAPPL01
    Program     <Subtype>     ZZLVAPPL01
    1.     Replace <nn> with a running 2 digit serial Number
    2.     Replace <ffff> with meaningful text
    2.2.15     Screen / Transaction Variants
    Naming Convention: <tcode>_<ffff>
    Where:
    1.     Replace <tcode> with the t-code that will be assigned to this Variant
    2.     Replace ffff with a meaningful text
    E.g.:
    For an SE16 variant for table KONA that will be used by T-Code Z_CH_SD_001:
    Z_CH_SD_001_KONA
    2.2.16     Area Menu
    Naming Convention: Z<mm>_<Main Menu>_<Sub Menu>…<ffff>
    Where:
    1.     Replace <mm> with the Module code
    2.     Followed by the hierarchical position of the immediate parent of this Area Menu
    3.     Followed by a Meaningful text for this Menu
    E.g.:
    ZSD
    ZSD_TAB
    ZSD_TAB_VIEW
    ZSD_TAB_UPDT
    Notes:
    1.     Clusters of Transactions should be introduced as Sub-Menus rather than as Folders
    2.     As a gradual process, the current Clusters that exist as Folders should also be replaced with Sub-Menus
    2.3     Naming of Sub-Objects
    2.3.1     Program Sub-Objects
    Naming of all the internal components of a program will be consistent across the project.
    Naming Convention: <Prefix>ffff.
    Notes:
    1.     Replace <Prefix> with the component prefix values given in the table below.
    Program Component     Prefixed by
    Program Constants     C_
    Global Variables     W_
    Types Definition     T_
    Global Structures     WA_
    Global Internal Tables     I_
    Select-Options     SO_
    Parameters     PO_
    Table Type     TT_
    Field Symbols     FS_
    Ranges     R_
    Local Constants     LC_
    Local Variables     L_
    Local Static Variables     LS_
    Local Internal Tables     LI_
    Local Work Area     LWA_
    Local Range     LR_
    Field Groups     FG_
    Container      CO_
    Macro     MA_
    Important: The Same sequence as above must be followed in the Data declaration part of all the ABAP/4 programs.
    2.3.2     SAP Script /Smartform sub-objects
    Naming of all the internal components of a SAPScript/SmartForm shall follow the same convention as for Programs (2.2.2), with the addition of the Field Label on the FRS. E.g. if the FRS has labeled a field for Sales Order Number as Field 27 on the Layout, the variable name should be W_27_VBELN.
    3.     General Programming Guidelines
    3.1     Modification Logs
    At the top of every ABAP Object Modified by a Developer, there should be a Modification Log Every Line Created/Changed by the developer should be Identifiable by the TR Number.
    ABAP Patterns: Following Patterns should be used for Uniform ModLogs:
    Nature of Change     Pattern to Use
    New Development     ZZNEWPROG
    In-Line Logs     ZZLINE
    Modification Logs at the Top of Object     ZZMODLOG
    3.2     Program Organization
    All the programs will be organized as described below.
    3.2.1     Executable Programs
    TOP Include: For global data declarations
    Form Include: For definition of all the FORMs.
    3.2.2     Dialog Programs
    TOP Include: For global data declarations
    Form Include: For definition of all the FORMs.
    PBO Include: Include for PBO Modules
    PAI Include: Include for PAI Modules
    3.3     Package
    All the related objects within a sub-module of SAP will be developed under a single Package.
    3.3.1     Adding Components to existing objects
    When adding new workbench components to existing Objects, the same Package will be used as has been used for the existing Components
    3.3.2     Creation of New Objects
    When creating new Objects or new Sub-lanscapes, Packages used should have the Naming convention as in Section 2 Above
    3.4     Program Messages
    All the messages within a sub-module of SAP will be grouped under a single Message Class.
    3.4.1     Adding Messages to existing landscapes
    When adding new messages for existing Objects, the same Message Class will be used as has been used for the existing Objects
    3.4.2     Creation of New Objects
    When creating new Objects or new Sub-landscapes, Message classes used should have the Naming convention as in Section 2 Above
    3.5     Dictionary Objects
    Whenever you create a Z table in  system always include MANDT field as the first field, except when the table contains client independent data. Also create the table with attribute Data Class as USER.
    4.     Structure of ABAP Programs
    4.1     Type
    •     When an ABAP program is run, its processing blocks are called. ABAP programs are controlled from outside the program itself by the processors in the current work process. For the purposes of program flow, we can summarize the screen processor and ABAP processor into the ABAP runtime environment. The runtime environment controls screens and ABAP processing blocks. It contains a range of special control patterns that call screens and processing blocks in certain orders. These sections are also called processors. When a ABAP program is run, the control passes between various processors.
    •     In the R/3 System, there are various types of ABAP program. The program type determines the basic technical attributes of the program, and must be set when created. The main difference between the different program types is the way in which the runtime environment calls its processing blocks.
    •     When an application program is run, it must at least call the first processing block from outside the program, that is, from the runtime environment. This processing block can then either call further processing blocks or return control to the runtime environment. When an ABAP program is started, the runtime environment starts a processor (dependent on the program type), which calls the first ABAP processing block.
    •     The following program types are relevant to application programming:
    Type 1
    •     Type 1 programs have the important characteristic that they do not have to be controlled using user-defined screens. Instead, they are controlled by the runtime environment, which calls a series of processing blocks (and selection screens and lists where necessary) in a fixed sequence. User actions on screens can then trigger further processing blocks.
    Type M
    •     The most important technical attribute of a type M program is that it can only be controlled using screen flow logic and run via a transaction code which is linked to the program and one of its screens (initial screen).
    •     ABAP programs with type M contain the dialog modules belonging to the various screens. They are therefore known as module pools.
    Type F
    •     Type F programs are containers for function modules, and cannot be started using a transaction code or by entering their name directly.
    •     Type F programs are known as function groups. Function modules may only be programmed in function groups. The Function Builder is a tool in the ABAP Workbench that is used to create function groups and function modules. Apart from function modules, function groups can contain global data declarations and subroutines. These are visible to all function modules in the group. They can also contain event blocks for screens in function modules.
    Type K
    •     Type K programs are containers for global classes in ABAP Objects. Type K programs are known as class definitions. The Class Builder is a tool in the ABAP Workbench that can be used to create class definitions.     
    Type J
    •     Type J programs are containers for global interface in ABAP Objects. Type J programs are known as interface definitions and are created in the Class Builder.
    Type I
    •     Type I programs - called includes - are a means of dividing up program code into smaller, more manageable units. The coding of an include program can be inserted at any point in another ABAP program using the INCLUDE statement. There is no technical relationship between include programs and processing blocks. Includes are more suitable for logical programming units, such as data declarations, or sets of similar processing blocks. The ABAP Workbench has a mechanism for automatically dividing up module pools and function groups into include programs.
    4.2     Status
    P = SAP standard production program
    K = Customer production program
    S = System program
    T = Test program
    Application
    •     Categorize the program according to the purpose it fulfills.
    4.3     Authority Check
    Authority checks will be carried out as given in the respective FRS’s.
    4.4     Program Structure
    ABAP programs are responsible for data processing within the individual dialog steps (ie. events) of an application program. This means that the program cannot be constructed as a single sequential unit, but must be divided into sections that can be assigned to the individual dialog steps. To meet this requirement, ABAP programs should have a modular structure. Each module is called a processing block. A processing block consists of a set of ABAP statements. When a program is run, effectively a series of processing blocks is called. Therefore, they should not be nested but modularized.
    •     Each ABAP program consists of the following two parts:
    4.4.1     Declaration data for global data, classes and selection screens
    •     The first part of an ABAP program is the declaration part for global data, classes, and selection screens. This consists of:
    •     All declaration statements for global data. Global data is visible in all internal  processing   blocks and should be defined using declarative statements that appear before the first processing block, in dialog modules, or in event blocks. Local data should not be declared in dialog modules or event blocks.
    •     All selection screen definitions.
    •     All local class definitions (CLASS DEFINITION statement). Local classes are part of ABAP Objects, the object-oriented extension of ABAP.
    •     Declaration statements which occur in procedures (methods, subroutines, function modules) form the declaration part for local data in those processing blocks. This data is only visible within the procedure in which it is declared.
    4.4.2     Container for Processing Blocks
    •     The second part of an ABAP program contains all of the processing blocks for the program. The following types of processing blocks are allowed:
    1.     Dialog modules (no local data area)
    2.     Event blocks (no local data area)
    3.     Procedures (methods, subroutines and function modules with their own local data area).
    •     Whereas dialog modules and procedures are enclosed in the ABAP keywords which define them, event blocks are introduced with event keywords and concluded implicitly by the beginning of the next processing block.
    •     All ABAP statements (except declarative statements in the declaration part of the program) are part of a processing block. Non-declarative ABAP statements, which occur between the declaration of global data and a processing block are automatically assigned to the START-OF-SELECTION processing block.
    4.4.3     Calling Processing Blocks
    •     Processing blocks can be called from either the ABAP program or using ABAP commands which are themselves part of a processing block. Dialog modules and event blocks are called from outside the ABAP program. Procedures are called using ABAP statements in ABAP programs.
    •     Calling event blocks is different from calling other processing blocks for the following reasons:
    •     An event block call is triggered by an event. User actions on selection screens and lists, and the runtime environment trigger events that can be processed in ABAP programs. Define event blocks for the events that the program needs to react to (whereas a subroutine call, for example, must have a corresponding subroutine). This ensures that while an ABAP program may react to a particular event, it is not forced to do so.
    4.5     Screen Flow Logic (Dialog Programs)
    4.5.1     Place the AT EXIT COMMAND at the beginning of the flow logic.
    Example:
    PROCESS AFTER INPUT
       MODULE EXIT_1170 AT EXIT-COMMAND.
       MODULE PAINT_1170.
    4.5.2     Use FIELD and CHAIN statements to keep fields in error open for correction.
    Example:
       PROCESS AFTER INPUT.
       MODULE EXIT_1170 AT EXIT-COMMAND.
       CHAIN.
          FIELD BTCH1170-JOBNAME.
          FIELD BTCH1170-USERNAME.
          FIELD BTCH1170-FROM_DATE.
          FIELD BTCH1170-FROM_TIME.
          MODULE PAINT_1170.
       ENDCHAIN.
    4.6     Main Program
    4.6.1     Events
    The Program MUST NOT be coded without the use of Proper Coding blocks
    •     Initializations
    •     Top-of-page during line-selection
    •     At Selection-Screen
    •     At Line-Selection
    •     At User-Command
    •     At Pfn
    •     Start-Of-Selection
    •     Top-Of-Page
    •     Get
    •     End-Of-Page
    •     End-Of-Selection
    NOTE: The coding for each event should be logically split into forms (subroutines). That is to say, each event will comprise mostly of ‘PERFORM’ statements.
    5.     General Coding Standards
    5.1     One command per line
    Each ABAP/4 command consists of a sentence ending with a period. Multiple commands can be on one line; however, as a standard start each new command on a new line. This will allow for easier deleting, commenting, and debugging.
    5.2     Indented Source Code
    The ABAP/4 editor has a "Pretty Printer" command to indent by 2 positions specific lines of code and add subroutine comments. Event keywords are typically not indented.
    5.3     Extended Syntax Check
    Extended Program Check (EPC) to be done on each object to make sure the code is Syntactically correct. There should be no Error/warning messages in the code.
    5.4     Reusability and Modularity
    If a block of code is executed more than once, it should be placed in a subroutine at the bottom of the code. This makes the code more readable, requires less indentation, and is easier to debug since the debugger can jump through an entire subroutine via a PF key. Also, when possible parameters should be passed to and from subroutines to make the purpose easier to understand and reduce the need for global variables. Always document the purpose of each parameter.
    5.5     Text Handling
    Text elements must be used to display any text messages.
    5.6     Usage of System Variables
    The system variables should be used wherever possible. The SY-SUBRC is to be checked after any function call, selection operation, etc.
    5.7     Chaining Statements
    •     Consecutive sentences with an identical beginning shall be combined into a chained statement.
    Example:
    Instead of the statements
    MOVE SY-MANDT TO D00001-MANDT.
    MOVE SY-LANGU TO D00001-SPRAS.
    A chained statement shall be used
    MOVE:
                 SY-MANDT TO D00001-MANDT,
                 SY-LANGU TO D00001-SPRAS,
                 SY-UNAME TO D00001-BNAME.
    5.8     Common Routines
    •     Standard sub-routines should be implemented as FUNCTION's rather than a FORM (ie. SUBROUTINE). A FUNCTION is easier to maintain and can be easily tested without a calling program. Standard SAP function modules are also available and the function library should be used to check if function modules already exist for a function that needs to be performed i.e.POPUP_TO_CONFIRM_LOSS_OF_DATA etc.
    •     Includes can also be created for re-usable or common code e.g. common data declaration statements.
    5.9     Dialog Messages
    Dialogue messages are stored in table T100. Programmers shall check to see if an appropriate message exists before adding a new message. Programs shall use the message-id which corresponds to the SAP module that the program most relates to.
    5.10     Function Keys
    PF-keys should be programmed to execute functions where required. SAP Standard function keys should be used where appropriate. The most commonly used buttons should be displayed as pushbuttons in the application toolbar.
    5.11     Enqueuing and Dequeuing Data Objects
    •     All database objects being processed by a program, for purposes other than for display, shall be enqueued before such processing is executed. If the enqueue is unsuccessful, then a message shall be returned stating why the enqueue was unsuccessful.
    •     Enqueue and Dequeue objects should be created via the data dictionary.
    5.12     Error Handling (SY-SUBRC)
    •     Return codes shall always be checked immediately after an event which returns a code.  
    Eg. Function calls, Select statements, Updates etc.
    •     The value of SY-SUBRC is 0 when successful and generally produces a value of 4 when unsuccessful (there are a few exceptions).
    Therefore, rather check SY-SUBRC with:
               IF SY-SUBRC <> 0
    than with
             IF SY-SUBRC = 4  (which is redundant and makes the system do a double check)
    •     Error messages displayed to the user must be clear and descriptive.
    •     Remember to group related / dependant steps together and to Rollback all changes for steps in that group should any one of them fail, thus maintaining the integrity of the system.
    •     Check whether an Error Log, (file), must be produced by your program and if so check on the format of the file.
    •     If any Error Logging is done to a custom table in the database then make sure this table is maintained and monitored correctly. (Dev. Note)
    •     Transaction SE91 provides the facility to create and utilize messages in their appropriate message class. Elaborate on the message if necessary, using the long text documentation for that message number.
    5.13     General Conventions and Hints
    •     There should be NO hard coding of values in programs – easy maintainability
    •     For amounts, use the CURRENCY command in write statements to automatically convert fields into their correct decimal format. The currency specified in the write statement is treated as a key for the table TCURX. If no entry exists for the currency specified, the system assumes two decimal places.
    •     For quantities, use the UNIT command in write statements to automatically convert fields into their correct decimal format. The contents of the unit specified are used on table T006. If no entry exists for the unit specified, the formatting has no effect.
    •     Use the ‘LIKE’ statement as often as possible to declare ‘DATA’ variables instead of an explicit ‘TYPE’ declarations.
    •     Try to use the ‘INCLUDE’ statement with standard SAP structures and tables for your structures and internal tables where possible.  If you use the include statement to include other program components in your code then document what those components are, what they do and how to use them.
    •     Try to make use of standard SAP Function Modules wherever possible rather than building your own. Use the pull down functionality in transaction SE37 to find suitable standard function modules.
    •     Make use of the SAP PATTERN tool to automatically insert the standard code for:
    •     CALL FUNCTION
    •     MESSAGE ID
    •     SELECT*FROM
    •     PERFORM
    •     AUTHORITY-CHECK
    •     WRITE
    •     CASE
    •     CALL DIALOG
    •     The standard date format to use is ‘DD/MM/YYYY’. (Dev. Note)
    The standard time format to use is ‘HH:MM:SS’.
    5.14     Parameters in Sub-Routines
    Naming convention for Parameters in subroutine is P_
    6.     Performance Standards
    6.1     General Tips on Performance Tuning
    6.1.1     Avoid Redundant code
    Avoid leaving "dead" code in the program. Comment out variables that are not referenced and code that is not executed. To analyze the program, use the Program Analysis function in SE38 -> Utilities -> Program Analysis.
    6.1.2     Subroutine Usage
    For good modularization, the decision of whether or not to execute a subroutine should be made before the subroutine is called.
    Example:
    IF f1 NE 0.
      PERFORM sub1.
    ENDIF.
    FORM sub1.
    ENDFORM.
    6.1.3     Case vs. Nested IF
    When testing fields "equal to" something, one can use either the nested IF or the CASE statement. The CASE is better for two reasons. It is easier to read and after about five nested IFs the performance of the CASE is more efficient.
    6.1.4     Using the MOVE Statement
    When records a and b have the exact same structure, it is more efficient to MOVE a TO b than to MOVE-CORRESPONDING a TO b.
    6.1.5     SELECT Queries
    The performance of  any ABAP program mainly depends on the ABAP Queries used in it. More optimum the queries , better the performance. Take care of the points mentioned nin the following sections while writing any ABAP queries.
    6.1.5.1     Using all the keys in SELECT statement
    When using the SELECT statement, study the key and always provide as much of the left-most part of the key as possible. The SELECT * command is to be avoided everywhere.
    6.1.5.2     Fetching Single Record
    If the entire key can be qualified, code a SELECT SINGLE not just a SELECT. If all the keys are not available, we should use SELECT UPTO 1 ROWS if we are interested only in the first record.
    6.1.5.3     Avoid SELECT-ENDSELECT
    Selecting data into an internal table using an array fetch versus a SELECT-ENDELECT loop will give at least a 2x performance improvement.  After the data has been put into the internal data, then row-level processing can be done.  
    Example:
    select ... from table <..>
               into <itab>
               where ...
    loop at <itab>
      <do the row-level processing here>
    endloop.
    6.1.5.4     Using Indexs
    Use indexes wherever possible. Tune the Query so that optimum Indexing will happen.
    6.1.5.5     Provide all the keys
    Give as many keys as possible in the WHERE clause to optimize the database fetching. Use the Index fields in the first position to optimize performance.
    6.1.5.6     Avoid “INTO CORRESPONDING”
    Avoid using INTO CORESPONDING FIELDS of Table. Instead, explicitly mention the fields. Else, The Table Fields should be in the same sequence as the selection
    6.1.5.7     SELECT statement inside LOOP
    Do not write SELECT statements inside the loop. Instead, use the FOR ALL ENTRIES Command
    Before using FOR ALL ENTRIES command, check that the
    1.     Corresponding Internal table is not empty. If the Internal table is empty, the statement will select ALL the entries in the Database
    2.     The Internal table is sorted by the Filed used in the Where Clause: This makes selection faster
    6.1.5.8     Nested SELECT statement
    Avoid Using nested SELECT statements. Instead, make use of different internal tables to fetch the data, and Use Nested LOOPS to read them.
    6.1.5.9     Select Distinct
    Whenever its possible avoid SELECT DISTINCT, instead select data into internal table, sort and use DELETE ADJACENT DUPLICATES
    6.1.5.10     Use of OR in Where Clause
    Do not use OR when selecting data from DB table using an index because The optimizer generally stops if the WHERE condition contains an OR expression.
    e.g.
    Instead of
         SELECT * FROM spfli WHERE carrid = ‘LH’
                                   AND (cityfrom = ‘FRANKFURT’ OR
                 city from = ‘NEWYORK’)
    Use
         SELECT * FROM spfli WHERE (carrid = ‘LH’ AND cityfrom = ‘FRANKFURT’)
                                      OR (carrid = ‘LH’ AND cityfrom = ‘NEWYORK’).
    6.1.5.11     Order By
    ORDER BY will Bypass buffer. So, performance will decrease. If you want to sort data, it is efficient to SORT them in INTERNAL TABLE rather than using ORDER BY. Only use an ORDER BY in your SELECT if the order matches the index, which should be used.
    6.1.6     Using the READ statement
    When reading a single record in an internal table, the READ TABLE WITH KEY is not a direct READ. The table needs to be sorted by the Key fields and the command READ TABLE WITH KEY BINARY SEARCH is to be used.
    6.1.7     Hashed table
    If the number of entries in the Internal Table is high then use Hashed Table with Keys to access the table.
    6.1.8     Transporting
    With READ or MODIFY Statements use TRANSPORTING
    6.1.9     Using LDB
    In order to improve performance in case of an LDB, individual tables can be excluded from selection. Under the section ‘Table Selection’ in the Documentation of LDB the fields with proper description has been given those fields can be set in the application report at the time of INITIALIZATION or at the START OF SELECTION. This can enhance the performance.
    6.1.10     Append Lines of
    Whenever it is possible use APPEND LINES OF to append the internal Tables instead of using loop and then APPEND Statement.
    6.1.11     Use WHILE
    Use WHILE instead of a DO+EXIT-construction, as WHILE is easier to understand and faster to execute
    6.1.12     DELETE <itab> WHERE
    Use DELETE <itab> WHERE…for deleting records from an internal table.
    e.g.
    Instead of
    LOOP AT <itab> WHERE <field> = ‘0001’
         DELETE <itab>.
    ENDLOOP.
    Use
    DELETE <itab>  WHERE <field> = ‘0001’.
    6.1.13     Using WHERE clause in LOOP…….ENDLOOP
    Use:
    Sort ITAB by NAME.
    Loop at itab where name EQ SY-UNAME
    Endloop.
    Instead Of:
    Read itab with key name = SY-UNAME.
    L_tabix = sy-tabix.
    Loop at itab from l_tabix.
    If name eq ‘bijoy’
    Endif.
    Endloop.

  • Creating abap program to develop and activate a global table type and global structure.

    Hi friends,
    I want to create and activate a global structure and global table type by coding in ABAP editor only. so can I do that anyhow.
    Please help me.
    Thanks in advance.

    Thanks guys for your fruitful replies, as most of you asked the main purpose of my question, the answer is as follows:
    in fact my purpose to do so is to create a function module that can fetch data dynamically from different database tables based on the codings in different abap program.
    for example: in one abap program i am coding as follows:
    tables: kna1.
    types: begin of itab,
              kunnr type kna1-kunnr,
              name1 type kna1-name1,
              end of itab.
    data: it_tab type standard table of itab,
             wa_tab type itab.
    similarly in other program i am coding as follows:
    tables: vbrp.
    types: begin of itab,
              posnr type vbrp-posnr,
              matnr type vbrp-matnr,
              arktx type vbrp-arktx,
              end of itab.
    data: it_tab type standard table of itab,
             wa_tab type itab.
    so now for both programs i want to call the same function module and fetch data as required in relative programs as mentioned above. in that case how to create that function module?

  • ABAP program to make a Hierarchy flatfile structure?

    Hi,
    Is there any ABAP program by which we can make a flat file structure in the conventional format ? ( Nodeid,Infoobject,Nodename etc---)
    Because here i just cannot make the flat file manually as the document i have is huge one, having somany nodes and levels that it is almost impossible to write down on a paper too!
    Any suggestions?
    Thanks,
    Ravi

    Hi,
    I have used the following function modules to breakdown the hierarchy. You can write a simple abap program and download the heirarchy breakdown.
    CLAF_CLASSIFICATION_OF_OBJECTS - this function module will return the class information for the hierarchy.
    Use the internal table i_class (filled by the above function module) and pass the relevant fields to the FM CC_LS_GET_CLASS_HIER_STRUCTURE.
    The entire hierarchy then becomes available in the table 'class_structure'. Use appropriate methods to download to the presentation ( FM WS_DOWNLOAD GUI_DOWNLOAD) / application servers (OPEN Dataset/Transfer Dataset/CLose dataset).

  • How to create Inbound Idocs in a ABAP program? Any function Module?

    Hello Experts,
    My requirement is : I have sales order data which I extracted from third party system in my internal tables. In the same box I need to create inbound Idocs and then consequently create sales orders.
    I have used the function module IDOC_INBOUND_WRITE_TO_DB to create inbound Idocs from Sales Orders data in internal tables. I have populated all the data records with correct PSGNUM and HLEVEL values. My plan is to create inbound idocs with this function module and send those to IDOC_INPUT_ORDERS function module which creates Sales Orders.
    If a sales order in the internal table in ABAP program contains only one item, then I am getting correct idocs. But if more than one item exists for a sales order then the line item segments which got repeated in Idoc are having PSGNUM and HLEVEL values as zero when I checked in WE02. As a result the hierarchy from the second item segment is getting disturbed and getting the status 60.
    I populated T_EDIDD with data records from  IDOC_INBOUND_WRITE_TO_DB.
    To the function module IDOC_INPUT_ORDERS,  T_EDIDC and T_EDIDD are the input. I observed that in T_EDIDD also the PSGNUM and HLEVEL values are blank.
    I am getting Status 60 with message 'EDI: Syntax error in IDoc (segment cannot be identified)' for idocs which have more than one item.
    I need to extract sales data from third party and create inbound idocs and create sales orders in one ABAP program only. I need to display corresponding Idoc numbers for the corresponding third party sales order number in a listoutput.
    Can anybody please provide inputs?
    Regards.

    Hi Anjali,
    Thanks for the response.
    I have passed the PSGNUM and HLEVEL values while populating the data records. Then I sent the data records and control record information to the function module IDOC_INBOUND_WRITE_TO_DB. Inside this function module there is code to clear the PSGNUM values and HLEVEL values.
    for compatibility: clear administration data of data records
               perform data_records_wipe
                                      tables
                                          t_data_records.
    FORM DATA_RECORDS_WIPE
                      TABLES
                          T_DATA_RECORDS_IN  STRUCTURE EDIDD.
      LOOP AT  T_DATA_RECORDS_IN.
        CLEAR: T_DATA_RECORDS_IN-MANDT,
               T_DATA_RECORDS_IN-DOCNUM,
               T_DATA_RECORDS_IN-SEGNUM,
               T_DATA_RECORDS_IN-PSGNUM,
               T_DATA_RECORDS_IN-HLEVEL.
        modify t_data_records_in.
      ENDLOOP.
    ENDFORM.                               " DATA_RECORDS_WIPE
    This is the code which is clearing all the PSGNUM and HLEVEL values. After coming out of this function module we are getting the error idocs created with disturbed hierarchy.
    I need to create INBOUND Idocs with the data in ABAP program.
    Please let me know if any inputs? Is there any function module existing to create Inbound Idocs inside an ABAP program?
    Regards

  • Error in executing ABAP program. Error occurred when creating dataset

    hi,
    when I use LKM SAP ERP to Oracle (SQLLDR) to extract data from SAP ERP server. I execute my interface, and it's stop at extract data step.
    This is message:
    java.lang.RuntimeException: Error occured in open tool execute method...Error in executing ABAP program...Error in executing ABAP program...Error occurred when creating dataset/abc/ZODI_13001_6001_GLOBAL.txt
    I tried others path name, tried slash or backslash. This is content in code tab
    OdiSAPAbapExecute "-UPLOAD=1" "-EXECUTE=1" "-EXECUTEBASE_RKM=0" "-ZRFC_RUN_INSTALL=1" "-ABAP_PROGRAM_NAME=ZODI_13001_6001" "-HOST=10.86.87.24" "-USER=sv_hoa" "-PASSWORD=<@=snpRef.getInfo("SRC_PASS") @>" "-SAP_CLIENT=800" "-SAP_LANGUAGE=EN" "-SAP_SYSTEM_NUMBER=02" "-SAP_FUNCTION_GROUP_NAME=ZODI_FGR_13001" "-CONNECTION_POOL_NAME=SAP_ODI_ERP_POOL_10.86.87.24" "-CONNECTION_POOL_SIZE=10" "-FILE_DELIMITER=<@=""+(char)8@>" "-FILE_NAME=ZODI_13001_6001_GLOBAL.txt" "-FTP_HOST=10.86.82.108" "-FTP_USER=anh" "-FTP_PASSWORD=<@=sFtpPassword@>" "-FTP_PASSIVE_MODE=1" "-FTP_TRANSFER_TIMEOUT=100000" "-ODI_VARIABLE_NAMES=" "-ODI_VARIABLE_VALUES=" "-USER_ABAP_PARAMETER_NAMES=IV_DELIMITER,CHAR3;IV_FILENAME,CHAR255;IV_USER,CHAR35;IV_PWD,CHAR35;IV_HOST,CHAR35;IV_HASHVALUE,CHAR35;IV_PATH,CHAR35;IV_MAX_ROW_CNT,SYTABIX;IV_FETCH_BATCH_SIZE,SYTABIX;" "-USER_ABAP_PARAMETER_VALUES=<Value>" "-USER_ABAP_PARAMETER_SEPARATOR=<Value>" "-ABAP_TABLE_PARAMETERS=RETURN,BAPIRETURN;ET_FILE_RETURN,BAPIRET2" "-ABAP_EXPORT_PARAMETERS=ERRORMESSAGE;SY-MSGV1" "-LOG_FILE_NAME=C:\Users\anh\AppData\Local\Temp\SapAbapExecuteOpenTool_13001.log" "-FTP_PATH=/abc/" "-DEV_CLASS=ZODI_DEVCLASS" "-MAX_ROW_COUNT=" "-FETCH_BATCH_SIZE=100000" "-HASH_VALUE_MARKER=HVM" "-ABAP_PROGRAM_BODY=
    *Final Type declarations
    TYPES : BEGIN OF ty_final,
    Y03HOCSINH_HOCSINH_ID TYPE
    Y03HOCSINH-HOCSINH_ID,
    Y03HOCSINH_MA_HOC_SINH TYPE
    Y03HOCSINH-MA_HOC_SINH,
    Y03HOCSINH_TEN_HOC_SINH TYPE
    Y03HOCSINH-TEN_HOC_SINH,
    Y03HOCSINH_GIOI_TINH TYPE
    Y03HOCSINH-GIOI_TINH,
    Y03HOCSINH_DIA_CHI TYPE
    Y03HOCSINH-DIA_CHI,
    Y03HOCSINH_GHI_CHU TYPE
    Y03HOCSINH-GHI_CHU,
    END OF ty_final.
    *Final Temp Type Declarations
    TYPES : BEGIN OF ty_final_tmp,
    Y03HOCSINH_HOCSINH_ID TYPE
    Y03HOCSINH-HOCSINH_ID ,
    Y03HOCSINH_MA_HOC_SINH TYPE
    Y03HOCSINH-MA_HOC_SINH ,
    Y03HOCSINH_TEN_HOC_SINH TYPE
    Y03HOCSINH-TEN_HOC_SINH ,
    Y03HOCSINH_GIOI_TINH TYPE
    Y03HOCSINH-GIOI_TINH ,
    Y03HOCSINH_DIA_CHI TYPE
    Y03HOCSINH-DIA_CHI ,
    Y03HOCSINH_GHI_CHU TYPE
    Y03HOCSINH-GHI_CHU ,
    END OF ty_final_tmp.
    *Final Target Type Declarations
    TYPES : BEGIN OF ty_final_target,
    C0_Y03HOCSINH_HOCSINH_ID TYPE
    Y03HOCSINH-HOCSINH_ID,
    C1_Y03HOCSINH_MA_HOC_SINH TYPE
    Y03HOCSINH-MA_HOC_SINH,
    C2_Y03HOCSINH_TEN_HOC_SINH TYPE
    Y03HOCSINH-TEN_HOC_SINH,
    C3_Y03HOCSINH_GIOI_TINH TYPE
    Y03HOCSINH-GIOI_TINH,
    C4_Y03HOCSINH_DIA_CHI TYPE
    Y03HOCSINH-DIA_CHI,
    C5_Y03HOCSINH_GHI_CHU TYPE
    Y03HOCSINH-GHI_CHU,
    END OF ty_final_target.
    * Table type for Y03HOCSINH
    TYPES : BEGIN OF ty_Y03HOCSINH,
    HOCSINH_ID TYPE
    Y03HOCSINH-HOCSINH_ID,
    MA_HOC_SINH TYPE
    Y03HOCSINH-MA_HOC_SINH,
    TEN_HOC_SINH TYPE
    Y03HOCSINH-TEN_HOC_SINH,
    GIOI_TINH TYPE
    Y03HOCSINH-GIOI_TINH,
    DIA_CHI TYPE
    Y03HOCSINH-DIA_CHI,
    GHI_CHU TYPE
    Y03HOCSINH-GHI_CHU,
    END OF ty_Y03HOCSINH.
    TYPES: BEGIN OF gs_text,
    line(843) TYPE c,
    END OF gs_text.
    *Structure Declarations
    DATA: wa_final_string TYPE string,
    wa_final TYPE ty_final,
    wa_final_target TYPE ty_final_target,
    wa_Y03HOCSINH TYPE ty_Y03HOCSINH,
    *Table Declarations
    tt_final TYPE STANDARD TABLE OF ty_final,
    tt_Y03HOCSINH TYPE STANDARD TABLE OF ty_Y03HOCSINH,
    tt_final_target TYPE STANDARD TABLE
    OF ty_final_target,
    tt_final_tmp TYPE STANDARD TABLE OF ty_final_tmp,
    tt_final_tmp1 TYPE STANDARD TABLE OF ty_final,
    gt_result TYPE STANDARD TABLE OF gs_text,
    *Variable Declarations
    lv_path TYPE string,
    lv_flag TYPE char1,
    C0_Y03HOCSINH_HOCSINH_ID TYPE
    STRING,
    C1_Y03HOCSINH_MA_HOC_SINH TYPE
    STRING,
    C2_Y03HOCSINH_TEN_HOC_SINH TYPE
    STRING,
    C3_Y03HOCSINH_GIOI_TINH TYPE
    STRING,
    C4_Y03HOCSINH_DIA_CHI TYPE
    STRING,
    C5_Y03HOCSINH_GHI_CHU TYPE
    STRING,
    wa_final_tmp TYPE ty_final_tmp,
    lv_file TYPE string,
    lv_datum TYPE sy-datum,
    lv_date TYPE char10,
    wa_result TYPE string,
    lv_delimiter type string,
    lv_cnt TYPE sytabix,
    *-Cursor Declaration
    lv_Y03HOCSINH_dbcur TYPE cursor,
    lv_tabix_frm TYPE sy-tabix.
    lv_delimiter = iv_delimiter.
    IF iv_hashvalue = 'HVM'.
    *Open/delete output file
    CONCATENATE iv_path iv_filename INTO lv_path.
    *Check for file existence, if found, delete it
    OPEN DATASET lv_path FOR INPUT
    IN TEXT MODE
    ENCODING DEFAULT.
    IF sy-subrc EQ 0.
    DELETE DATASET lv_path.
    ENDIF.
    *Open/create output file
    OPEN DATASET lv_path FOR APPENDING
    IN TEXT MODE
    ENCODING DEFAULT.
    IF sy-subrc EQ 0.
    *Batch Processing
    OPEN CURSOR WITH HOLD lv_Y03HOCSINH_dbcur FOR
    SELECT HOCSINH_ID
    MA_HOC_SINH
    TEN_HOC_SINH
    GIOI_TINH
    DIA_CHI
    GHI_CHU
    FROM Y03HOCSINH.
    DO.
    *Check for the counter, only for first batch
    *process new line is required...
    lv_cnt = lv_cnt + 1.
    REFRESH tt_Y03HOCSINH.
    FETCH NEXT CURSOR lv_Y03HOCSINH_dbcur
    APPENDING TABLE tt_Y03HOCSINH
    PACKAGE SIZE IV_FETCH_BATCH_SIZE.
    IF NOT tt_Y03HOCSINH IS INITIAL.
    ELSE.
    EXIT.
    ENDIF.
    LOOP AT tt_Y03HOCSINH INTO wa_Y03HOCSINH.
    MOVE wa_Y03HOCSINH-HOCSINH_ID
    TO wa_final_tmp-Y03HOCSINH_HOCSINH_ID.
    MOVE wa_Y03HOCSINH-MA_HOC_SINH
    TO wa_final_tmp-Y03HOCSINH_MA_HOC_SINH.
    MOVE wa_Y03HOCSINH-TEN_HOC_SINH
    TO wa_final_tmp-Y03HOCSINH_TEN_HOC_SINH.
    MOVE wa_Y03HOCSINH-GIOI_TINH
    TO wa_final_tmp-Y03HOCSINH_GIOI_TINH.
    MOVE wa_Y03HOCSINH-DIA_CHI
    TO wa_final_tmp-Y03HOCSINH_DIA_CHI.
    MOVE wa_Y03HOCSINH-GHI_CHU
    TO wa_final_tmp-Y03HOCSINH_GHI_CHU.
    APPEND wa_final_tmp TO tt_final_tmp.
    ENDLOOP.
    free : tt_Y03HOCSINH.
    LOOP AT tt_final_tmp INTO wa_final_tmp.
    MOVE wa_final_tmp-Y03HOCSINH_HOCSINH_ID
    TO wa_final_target-C0_Y03HOCSINH_HOCSINH_ID.
    MOVE wa_final_tmp-Y03HOCSINH_MA_HOC_SINH
    TO wa_final_target-C1_Y03HOCSINH_MA_HOC_SINH.
    MOVE wa_final_tmp-Y03HOCSINH_TEN_HOC_SINH
    TO wa_final_target-C2_Y03HOCSINH_TEN_HOC_SINH.
    MOVE wa_final_tmp-Y03HOCSINH_GIOI_TINH
    TO wa_final_target-C3_Y03HOCSINH_GIOI_TINH.
    MOVE wa_final_tmp-Y03HOCSINH_DIA_CHI
    TO wa_final_target-C4_Y03HOCSINH_DIA_CHI.
    MOVE wa_final_tmp-Y03HOCSINH_GHI_CHU
    TO wa_final_target-C5_Y03HOCSINH_GHI_CHU.
    Append wa_final_target to tt_final_target.
    ENDLOOP.
    free : tt_final_tmp.
    Clear wa_final_target.
    IF NOT iv_max_row_cnt IS INITIAL.
    Loop at tt_final_target into
    wa_final_target TO iv_max_row_cnt.
    MOVE wa_final_target-C0_Y03HOCSINH_HOCSINH_ID
    TO C0_Y03HOCSINH_HOCSINH_ID.
    MOVE wa_final_target-C1_Y03HOCSINH_MA_HOC_SINH
    TO C1_Y03HOCSINH_MA_HOC_SINH.
    MOVE wa_final_target-C2_Y03HOCSINH_TEN_HOC_SINH
    TO C2_Y03HOCSINH_TEN_HOC_SINH.
    MOVE wa_final_target-C3_Y03HOCSINH_GIOI_TINH
    TO C3_Y03HOCSINH_GIOI_TINH.
    MOVE wa_final_target-C4_Y03HOCSINH_DIA_CHI
    TO C4_Y03HOCSINH_DIA_CHI.
    MOVE wa_final_target-C5_Y03HOCSINH_GHI_CHU
    TO C5_Y03HOCSINH_GHI_CHU.
    CONCATENATE
    C0_Y03HOCSINH_HOCSINH_ID
    C1_Y03HOCSINH_MA_HOC_SINH
    C2_Y03HOCSINH_TEN_HOC_SINH
    C3_Y03HOCSINH_GIOI_TINH
    C4_Y03HOCSINH_DIA_CHI
    C5_Y03HOCSINH_GHI_CHU
    INTO wa_final_string
    SEPARATED BY lv_delimiter.
    IF sy-tabix EQ 1 AND lv_cnt EQ 1.
    CONCATENATE wa_final_string
    lv_delimiter INTO wa_final_string.
    ELSE.
    CONCATENATE '<@=""+(char)8@>' lv_delimiter wa_final_string
    lv_delimiter INTO wa_final_string.
    ENDIF.
    APPEND wa_final_string TO gt_result.
    CLEAR : C0_Y03HOCSINH_HOCSINH_ID,
    C1_Y03HOCSINH_MA_HOC_SINH,
    C2_Y03HOCSINH_TEN_HOC_SINH,
    C3_Y03HOCSINH_GIOI_TINH,
    C4_Y03HOCSINH_DIA_CHI,
    C5_Y03HOCSINH_GHI_CHU.
    ENDLOOP.
    ELSE.
    Loop at tt_final_target into wa_final_target.
    MOVE wa_final_target-C0_Y03HOCSINH_HOCSINH_ID
    TO C0_Y03HOCSINH_HOCSINH_ID.
    MOVE wa_final_target-C1_Y03HOCSINH_MA_HOC_SINH
    TO C1_Y03HOCSINH_MA_HOC_SINH.
    MOVE wa_final_target-C2_Y03HOCSINH_TEN_HOC_SINH
    TO C2_Y03HOCSINH_TEN_HOC_SINH.
    MOVE wa_final_target-C3_Y03HOCSINH_GIOI_TINH
    TO C3_Y03HOCSINH_GIOI_TINH.
    MOVE wa_final_target-C4_Y03HOCSINH_DIA_CHI
    TO C4_Y03HOCSINH_DIA_CHI.
    MOVE wa_final_target-C5_Y03HOCSINH_GHI_CHU
    TO C5_Y03HOCSINH_GHI_CHU.
    CONCATENATE
    C0_Y03HOCSINH_HOCSINH_ID
    C1_Y03HOCSINH_MA_HOC_SINH
    C2_Y03HOCSINH_TEN_HOC_SINH
    C3_Y03HOCSINH_GIOI_TINH
    C4_Y03HOCSINH_DIA_CHI
    C5_Y03HOCSINH_GHI_CHU
    INTO wa_final_string
    SEPARATED BY lv_delimiter.
    IF sy-tabix EQ 1 AND lv_cnt EQ 1.
    CONCATENATE wa_final_string
    lv_delimiter INTO wa_final_string.
    ELSE.
    CONCATENATE '<@=""+(char)8@>' lv_delimiter wa_final_string
    lv_delimiter INTO wa_final_string.
    ENDIF.
    APPEND wa_final_string TO gt_result.
    CLEAR : C0_Y03HOCSINH_HOCSINH_ID,
    C1_Y03HOCSINH_MA_HOC_SINH,
    C2_Y03HOCSINH_TEN_HOC_SINH,
    C3_Y03HOCSINH_GIOI_TINH,
    C4_Y03HOCSINH_DIA_CHI,
    C5_Y03HOCSINH_GHI_CHU.
    ENDLOOP.
    ENDIF.
    free : tt_final_target.
    IF NOT gt_result IS INITIAL.
    CLEAR wa_result.
    LOOP AT gt_result INTO wa_result.
    TRANSFER wa_result TO lv_path.
    ENDLOOP.
    ENDIF.
    REFRESH gt_result.
    *End of main loop for batching
    ENDDO.
    *Close dataset
    CLOSE DATASET lv_path.
    CLOSE CURSOR lv_Y03HOCSINH_dbcur.
    ELSE.
    DATA: lv_mesg TYPE string.
    CLEAR et_file_return.
    et_file_return-type = 'E'.
    CONCATENATE
    'Error occurred when creating dataset' lv_path
    INTO lv_mesg.
    et_file_return-message = lv_mesg.
    Append et_file_return.
    ENDIF.
    ELSE.
    CLEAR et_file_return.
    et_file_return-type = 'E'.
    et_file_return-message =
    'Installed ABAP program does not match interface definition'.
    APPEND et_file_return.
    ENDIF.
    Thanks for help

    r u able to figure it out..........i got the same error .......can someone help me fix this issue

  • How do we call smartforms in abap program or web services

    how do we call smartforms in abap program or web services
    How many types of smartforms are there?
    points will be rewarded

    Hi
    See this sample program
    Using the fun module smartform is called from the program
    Calling SMARTFORMS from your ABAP program
    REPORT ZSMARTFORM.
    Calling SMARTFORMS from your ABAP program.
    Collecting all the table data in your program, and pass once to SMARTFORMS
    SMARTFORMS
    Declare your table type in :-
    Global Settings -> Form Interface
    Global Definintions -> Global Data
    Main Window -> Table -> DATA
    http://sapr3.tripod.com
    TABLES: MKPF.
    DATA: FM_NAME TYPE RS38L_FNAM.
    DATA: BEGIN OF INT_MKPF OCCURS 0.
    INCLUDE STRUCTURE MKPF.
    DATA: END OF INT_MKPF.
    SELECT-OPTIONS S_MBLNR FOR MKPF-MBLNR MEMORY ID 001.
    SELECT * FROM MKPF WHERE MBLNR IN S_MBLNR.
    MOVE-CORRESPONDING MKPF TO INT_MKPF.
    APPEND INT_MKPF.
    ENDSELECT.
    At the end of your program.
    Passing data to SMARTFORMS
    <b>call function 'SSF_FUNCTION_MODULE_NAME'
    exporting
    formname = 'ZSMARTFORM'</b>
    VARIANT = ' '
    DIRECT_CALL = ' '
    IMPORTING
    FM_NAME = FM_NAME
    EXCEPTIONS
    NO_FORM = 1
    NO_FUNCTION_MODULE = 2
    OTHERS = 3.
    if sy-subrc <> 0.
    WRITE: / 'ERROR 1'.
    MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
    WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
    endif.
    call function <b>FM_NAME</b>
    EXPORTING
    ARCHIVE_INDEX =
    ARCHIVE_INDEX_TAB =
    ARCHIVE_PARAMETERS =
    CONTROL_PARAMETERS =
    MAIL_APPL_OBJ =
    MAIL_RECIPIENT =
    MAIL_SENDER =
    OUTPUT_OPTIONS =
    USER_SETTINGS = 'X'
    IMPORTING
    DOCUMENT_OUTPUT_INFO =
    JOB_OUTPUT_INFO =
    JOB_OUTPUT_OPTIONS =
    TABLES
    GS_MKPF = INT_MKPF
    EXCEPTIONS
    FORMATTING_ERROR = 1
    INTERNAL_ERROR = 2
    SEND_ERROR = 3
    USER_CANCELED = 4
    OTHERS = 5.
    if sy-subrc <> 0.
    MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
    WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
    endif.
    <b>Reward points for useful Answers</b>
    Regards
    Anji

  • How to execute an SQL query present in a string inside an ABAP program?

    hello,
    How to execute an SQL query present in a string inside an ABAP program

    Raut,
    You can execute Native SQl statements.
    Ex: To use a Native SQL statement, you must precede it with the EXEC SQL statement, and follow it with the ENDEXEC statement as follows:
    EXEC SQL [PERFORMING <form>].
      <Native SQL statement>
    ENDEXEC.
    There is no period after Native SQL statements. Furthermore, using inverted commas (") or an asterisk (*) at the beginning of a line in a native SQL statement does not introduce a comment as it would in normal ABAP syntax. You need to know whether table and field names are case-sensitive in your chosen database.
    In Native SQL statements, the data is transported between the database table and the ABAP program using host variables. These are declared in the ABAP program, and preceded in the Native SQL statement by a colon (:). You can use elementary structures as host variables. Exceptionally, structures in an INTO clause are treated as though all of their fields were listed individually.
    If the selection in a Native SQL SELECT statement is a table, you can pass it to ABAP line by line using the PERFORMING addition. The program calls a subroutine <form> for each line read. You can process the data further within the subroutine.
    As in Open SQL, after the ENDEXEC statement, SY-DBCNT contains the number of lines processed. In nearly all cases, SY-SUBRC contains the value 0 after the ENDEXEC statement. Cursor operations form an exception: After FETCH, SY-SUBRC is 4 if no more records could be read. This also applies when you read a result set using EXEC SQL PERFORMING.
    EXEC SQL PERFORMING loop_output.
      SELECT connid, cityfrom, cityto
      INTO   :wa
      FROM   spfli
      WHERE  carrid = :c1
    ENDEXEC.
    Pls. Mark If useful

  • Issue in Dynamic Structure and Component Program

    Hi,
      I have a requirement of creating an inbound idoc program and populating dynamic structures. The program for the dynamic structure creation is as follows: ( I have been referencing Heilmans Blog ): The part for the inbound idoc creation works fine. The data will come in a flat file with Table name and 15 characterstcis. The table name is known at runtime. I need to create the dynamic table, find out the components and then populate the custom table with the dynamically created structures.
    Custom table: 4 components
    Internal table from file: 15 components with value.
    There could be more than one table in the flat file and not all components or char in the flat file is mapped to the table. I would need some expertise in coding the OO part of the program.
    Any inputs will be apprciated:
    <removed 6845 lines of code (forum software cut off at this point, there was more!) - did you actually expect anyone to read that? Also, please use code tags (the "<>" icon on the toolbar)>
    Edited by: Mike Pokraka on Aug 3, 2008 6:15 PM

    Hi,
    The program works fine fo creating inbound idocs. It is the dynamic structure population that seems to be the problem mentioned earlier: Here is the code:
    *& Report  /FACTGLB/GTDMI_VARTAB_IDOCS02                               *
    PROGRAM DESCRIPTION: Variant Table and Content Upload Interface.
              DEVELOPER: Aveek Ghose
          CREATION DATE: 2008-04-18
             RDD NUMBER: DCDD027
    TRANSPORT NUMBER(S): RD2K902769
    *-- REVISION HISTORY -
              DEVELOPER:
           DATE APPLIED: YYYY-MM-DD
             SCR NUMBER: <Scope Change Request ID>
             RDD NUMBER: <Toolset Object ID>
    TRANSPORT NUMBER(S):
            DESCRIPTION:
    REPORT  ZGTDMI_VARTAB_IDOCS_DYNAMIC
            NO STANDARD PAGE HEADING
            LINE-SIZE   150
            LINE-COUNT  55
            MESSAGE-ID  zfactglb.
    **Include for Global Data Declaration
    *INCLUDE /FACTGLB/GTDMI_VARTAB_TOP02.
    **Include for Selection Screen
    *INCLUDE /FACTGLB/GTDMI_VARTAB_SEL02.
    **Include for Sub Routines
    *INCLUDE /FACTGLB/GTDMI_VARTAB_FORMS02.
    *&  Include           /FACTGLB/GTDMI_VARTAB_TOP02                      *
    *&  Include           /FACTGLB/GTDMI_VARTAB_TOP02                      *
    *&  Include           /FACTGLB/GTDMI_VARTAB_TOP
    *&  Include           /FACTGLB/GTDMI_VARTAB_TOP
    PROGRAM DESCRIPTION: Variant Table and Content Upload Interface.
              DEVELOPER: Aveek Ghose
          CREATION DATE: 2008-04-18
             RDD NUMBER: DCDD027
    TRANSPORT NUMBER(S): RD2K902769
    *-- REVISION HISTORY -
              DEVELOPER:
           DATE APPLIED: YYYY-MM-DD
             SCR NUMBER: <Scope Change Request ID>
             RDD NUMBER: <Toolset Object ID>
    TRANSPORT NUMBER(S):
            DESCRIPTION:
    TYPE POOLS
    *Type declaration for ALV display
    TYPE-POOLS : slis.
    Include .
    type-pools: col,                                            "#EC *
                icon,                                           "#EC *
                sym,                                            "#EC *
                abap.                                           "#EC *
    Target structure definitions
    tables:
      E1CUVTM,                                                  "#EC *
      E1DATEM,                                                  "#EC *
      E1CUV1M,                                                  "#EC *
      edp21,                                                    "#EC *
      edi_dc40,                                                 "#EC *
      edi_dd40,                                                 "#EC *
      edi_ds40.                                                 "#EC *
    GLOBAL TYPES
    TYPES : BEGIN OF ty_vartab.
            include structure E1CUVTM.
    TYPES:  END OF ty_vartab.
    TYPES : BEGIN OF ty_vartabdate.
            INCLUDE STRUCTURE E1DATEM.
    TYPES : END OF ty_vartabdate.
    *Structure for data retreived
    TYPES : BEGIN OF ty_vardetails.
            INCLUDE STRUCTURE E1CUV1M.
    TYPES : END OF ty_vardetails.
    *Structure for data retreived from table tabinput.
    TYPES : BEGIN OF ty_tabinput,
              lines type string,
            END OF ty_tabinput.
    *Structure for data retreived from Table dsn_input.
    TYPES : BEGIN OF ty_dsninput,                               "#EC *
              LINE(101) type c,
            END OF ty_dsninput.
    *Structure for data retreived from Table dsn_input.
    TYPES : BEGIN OF ty_newinput,                               "#EC *
              LINE(101) type c,
              flag(1) type c,
            END OF ty_newinput.
    *Structure for keeping the values of all the custom tables
    TYPES : BEGIN OF ty_custom_tabs,
              matnr   TYPE matnr,    "Material Number
              werks   TYPE werks_d,  "Plant
              lgort   TYPE lgort_d,  "Storage Location
              qunty   TYPE P DECIMALS 2, "Standard Order Quantity
              det_loc TYPE CHAR6, "Detail Location
              class   TYPE CHAR2,   "Class
              rate    TYPE P DECIMALS 2,    "Rate
            END OF ty_custom_tabs.
    *Type declared for the internal table and work area which will store
    *fields for error log
    TYPES : BEGIN OF ty_error_log,
              matnr TYPE matnr,       "Material Number
              mtart TYPE mtart,       "Material Type
              sel_data TYPE char10,   "No of selectyed data
            END OF ty_error_log.
    *Structure for keeping the output data
    TYPES : BEGIN OF ty_final,
              VTNAM(018) type C,
              CHAR1(030) type C,
              CHAR2(030) type C,
              CHAR3(030) type C,
              CHAR4(030) type C,
              CHAR5(030) type C,
              CHAR6(030) type C,
              CHAR7(030) type C,
              CHAR8(030) type C,
              CHAR9(030) type C,
              CHAR10(030) type C,
              CHAR11(030) type C,
              CHAR12(030) type C,
              CHAR13(030) type C,
              CHAR14(030) type C,
              CHAR15(030) type C,
              FLAG(001) type C,
            END OF ty_final.
    TYPES: begin of TY_CONTENTHD,
              VTNAM(018) type C,
              FLAG(001) type C,
      end of TY_CONTENTHD.
    TYPES: begin of TY_CONTENT,
              VTNAM(018) type C,
              CHAR1(030) type C,
              CHAR2(030) type C,
              CHAR3(030) type C,
              CHAR4(030) type C,
              CHAR5(030) type C,
              CHAR6(030) type C,
              CHAR7(030) type C,
              CHAR8(030) type C,
              CHAR9(030) type C,
              CHAR10(030) type C,
              CHAR11(030) type C,
              CHAR12(030) type C,
              CHAR13(030) type C,
              CHAR14(030) type C,
              CHAR15(030) type C,
              FLAG(001) type C.
    TYPES: end of TY_CONTENT.
    TYPES: BEGIN OF TY_E1CUVTM,
              MSGFN       TYPE MSGFN,
              VAR_TAB       TYPE APITABL,
              STATUS       TYPE RCUTBST,
              VTGROUP       TYPE RCUTBGR,
              AUTHSTRUC       TYPE RCUTBBE,
              AUTHENTRY       TYPE RCUFNBI,
              FLDELETE       TYPE FLLKENZ,
              DBTABNAME       TYPE TABNAME16,
              DBCONACTIVE TYPE DBCON_ACTI,
              PRESDEC       TYPE VTDCT,
           END OF TY_E1CUVTM.
    TYPES: BEGIN OF TY_E1CUV1M,
              MSGFN     TYPE MSGFN,
              VTLINENO     TYPE VTLINENO,
              VTCHARACT     TYPE ATNAM,
              ATWRT     TYPE ATWRT,
              ATFLV     TYPE ATFLV,
              ATAWE     TYPE MSEHI,
              ATFLB     TYPE ATFLB,
              ATAW1     TYPE MSEHI,
              ATCOD     TYPE ATCOD,
              ATTLV     TYPE ATTLV,
              ATTLB     TYPE ATTLB,
              ATPRZ     TYPE ATPRZ,
              ATINC     TYPE ATINC,
              VTLINENO5     TYPE VTLINENO5,
           END OF TY_E1CUV1M.
    TYPES: BEGIN OF TY_E1DATEM,
              MSGFN       TYPE MSGFN,
              KEY_DATE       TYPE SYDATUM,
              AENNR       TYPE AENNR,
              EFFECTIVITY TYPE      CC_MTEFF,
           END OF TY_E1DATEM.
    TYPES: BEGIN OF ty_vtnam,
             vtint TYPE vtint,  " Internal number of variant table
             vtnam TYPE vtnam,  " Name of variant table
             error  TYPE char1,  " Indicates error in data format
             reas   TYPE char50, " Reason for failure
           END OF ty_vtnam.
    Get data type for characteristic
    TYPES: BEGIN OF ty_cabn,
            atinn  TYPE atinn,       "Internal characteristic
            atnam  TYPE atnam,       "Characteristic Name
            atfor  TYPE atfor,       "Data type of characteristic
            atson  TYPE atson,       "Indicator: Additional Values
            atprt  TYPE atprt,       "Check table
            atprr  TYPE atprr,       "Name of Check Report Program
            atprf  TYPE atprf,       "Function Module for Checking Values
            anzdz  TYPE anzdz,       "Number of Decimal Places
            check  TYPE char1,       "Indicates check required or not
           END OF ty_cabn.
    Get field names of variant table
    TYPES: BEGIN OF ty_cuvtab_fld,
             vtint TYPE vtint,   " Internal number of variant table
             atinn TYPE atinn,   " Internal characteristic
             vtpos TYPE vtpos,   " Item number of characteristic in variant
             exist TYPE char1,   " X Indictaes characteristic is part of fil
           END OF ty_cuvtab_fld.
    Store all data in internal table
    TYPES: BEGIN OF ty_file,
              vtnam TYPE vtnam,
              char1 TYPE atwrt,
              char2 TYPE atwrt,
              char3 TYPE atwrt,
              char4 TYPE atwrt,
              char5 TYPE atwrt,
              char6 TYPE atwrt,
              char7 TYPE atwrt,
              char8 TYPE atwrt,
              char9 TYPE atwrt,
              char10 TYPE atwrt,
              char11 TYPE atwrt,
              char12 TYPE atwrt,
              char13 TYPE atwrt,
              char14 TYPE atwrt,
              char15 TYPE atwrt,
              flag   TYPE char1,
              error  TYPE char50,
           END OF ty_file.
    To check for duplicates
    TYPES: BEGIN OF ty_dupl,
              vtnam TYPE vtnam,
              char1 TYPE atwrt,
              char2 TYPE atwrt,
              char3 TYPE atwrt,
              char4 TYPE atwrt,
              char5 TYPE atwrt,
              char6 TYPE atwrt,
              char7 TYPE atwrt,
              char8 TYPE atwrt,
              char9 TYPE atwrt,
              char10 TYPE atwrt,
              char11 TYPE atwrt,
              char12 TYPE atwrt,
              char13 TYPE atwrt,
              char14 TYPE atwrt,
              char15 TYPE atwrt,
              slnid  TYPE  slnid,
            END OF ty_dupl.
    Get previously loaded characteristic values for internal table (CHAR)
    TYPES: BEGIN OF ty_cuvtab_valc,
            vtint  TYPE  vtint,   " Internal number of variant table
            slnid  TYPE  slnid,   " Key for value combination in variant tab
            atinn  TYPE  atinn,   " Internal characteristic
            valc   TYPE  atwrt,   " Characteristic Value
          END OF ty_cuvtab_valc.
    Get previously loaded characteristic values for internal table (NUM)
    TYPES: BEGIN OF ty_cuvtab_valn,
            vtint  TYPE  vtint,      " Internal number of variant table
            slnid  TYPE  slnid,      " Key for value combination in variant tab
            atinn  TYPE  atinn,      " Internal characteristic
            val_from  TYPE  atflv,   " Internal floating point from
           END OF ty_cuvtab_valn.
    Store column positions of characteristics
    TYPES: BEGIN OF ty_col_pos,
             vtint  TYPE vtint,   " Internal number of variant table
             vtnam  TYPE vtnam,   " Variant table name
             atinn  TYPE atinn,   "Internal characteristic
             atnam  TYPE atnam,   "Characteristic Name
             field  TYPE fieldname,   "Field name
             req    TYPE char1,       " Required or not
             vtpos  TYPE vtpos,       " Item number of characteristics
           END OF ty_col_pos.
    Store valid values for characteristics
    TYPES: BEGIN OF ty_cawn,
              atinn TYPE atinn,   " Internal characteristic
              atzhl TYPE atzhl,   " Int counter
              atwrt TYPE atwrt,   " Characteristic Value
              atflv TYPE atflv,   " Internal floating point from
              lkenz TYPE lkenz,   " Deletion indicator
          END OF ty_cawn.
    Store error messages for individual lines
    TYPES: BEGIN OF ty_error,
             vtnam  TYPE vtnam,       " Variant table name
             fname  TYPE fieldname,   " Fieldname
             atnam  TYPE atnam,       " Characteristic name
             atwrt  TYPE atwrt,       " Characteristic value
             row    TYPE char5,       " Row id
          END OF ty_error.
    Begin TPR# 4618
    To store unique number for variant
    TYPES: BEGIN OF ty_vnt_ma,
            vtnam     TYPE vtnam,
            unique_no TYPE ZGTDM_UNQN,
            no_chr    TYPE ZGTDM_NO_CHR,
          END OF ty_vnt_ma.
    To find out concatenated number for
    TYPES: BEGIN OF ty_split,
            f1 TYPE char6,
          END OF ty_split.
    TYPES: BEGIN OF ty_charval,
            char TYPE char30,
          END OF ty_charval.
    TYPES: BEGIN OF TY_DATA,
           name TYPE string,
           value(15) type c,
          END OF TY_DATA.
    DATA: I_DATATAB TYPE STANDARD TABLE OF TY_DATA.
    TYPES:
      TUMLS_MESSTYPE type /SAPDMC/LS_MESSTYPE,
      TUMLS_MESSTYPETXT type EDI_TEXT60,
      TUMLS_MESSCODE type EDIPMESCOD.
    TYPES:
      TUMLS_TABNAME TYPE TABNAME,                               "#EC *
      TUMLS_SEGMENT TYPE TABNAME.                               "#EC *
    TYPES:
      TUMLS_PATHFILE TYPE /SAPDMC/LS_FILENAME,
      TUMLS_FILENAME TYPE /SAPDMC/LS_FILENAME,
      TUMLS_FILETEXT TYPE /SAPDMC/LS_FILETEXT.
    TYPES:
      BEGIN OF type_errorline,
         msgty type SYMSGTY,
         id type SYMSGID,
         msgno type symsgno,
         par1 type symsgv,
         par2 type symsgv,
         par3 type symsgv,
         par4 type symsgv,
      END OF type_errorline.
    TYPES:
      type_errortab TYPE SORTED TABLE
                    OF type_errorline
                    WITH NON-UNIQUE KEY id msgno par1 par2 par3 par4.
    DATA:
        LV_INDEX TYPE SY-INDEX,
        LV_INDEX2 TYPE SYINDEX,
        LV_TABLE1 TYPE REF TO DATA,
        LV_TABLE2 TYPE REF TO DATA,
        LV_TABLE3 TYPE REF TO DATA,
        LV_TABLE4 TYPE REF TO DATA,
        LV_LINE1  TYPE REF TO DATA,
        LV_LINE2  TYPE REF TO DATA,
        LV_LINE3  TYPE REF TO DATA,
        LV_LINE4  TYPE REF TO DATA,
        LV_OFFSET1 TYPE SYTABIX,
        ST_IS_LAYOUT_ALV TYPE SLIS_LAYOUT_ALV,
        L_IT_FCATLOG_ALV TYPE SLIS_T_FIELDCAT_ALV,
        L_IT_FLDCAT TYPE LVC_T_FCAT.
    GLOBAL INTERNAL TABLES
    DATA : i_newinput TYPE STANDARD TABLE OF ty_newinput INITIAL SIZE 0."#EC *
    DATA : i_contentheader1 TYPE STANDARD TABLE OF ty_contenthd INITIAL SIZE 0."#EC *
    DATA : i_contenttab1 TYPE STANDARD TABLE OF ty_content INITIAL SIZE 0."#EC *
    DATA : i_contenttab2 TYPE STANDARD TABLE OF ty_content INITIAL SIZE 0."#EC *
    DATA : i_contenttab3 TYPE STANDARD TABLE OF ty_content INITIAL SIZE 0."#EC *
    DATA : i_contenttab4 TYPE STANDARD TABLE OF ty_content INITIAL SIZE 0."#EC *
    DATA : i_E1CUV1M TYPE STANDARD TABLE OF E1CUV1M INITIAL SIZE 0."#EC *
    DATA : i_errortab TYPE STANDARD TABLE OF solisti1 INITIAL SIZE 0."#EC *
    GLOBAL WORK AREAS
    **Internal Table for the structure TY_T001L
    DATA : wa_vartab TYPE ty_vartab.                            "#EC *
    DATA : wa_vartabdate TYPE ty_vartabdate.                    "#EC *
    DATA : wa_vardetails TYPE ty_vardetails.                    "#EC *
    DATA : wa_tabinput TYPE ty_tabinput.                        "#EC *
    DATA : wa_dsninput TYPE ty_dsninput.                        "#EC *
    DATA : wa_newinput TYPE ty_newinput.                        "#EC *
    DATA : wa_gnewinput TYPE ty_newinput.                       "#EC *
    DATA : wa_ginput_data TYPE ty_newinput.                     "#EC *
    DATA : wa_final TYPE ty_final.                              "#EC *
    DATA : wa_content TYPE ty_content.                          "#EC *
    DATA : wa_contenthd TYPE ty_contenthd.                      "#EC *
    DATA : wa_contentheader type ty_contenthd.                  "#EC *
    DATA : wa_contenttab TYPE ty_content.                       "#EC *
    DATA : wa_content1 TYPE ty_content.                         "#EC *
    DATA : wa_contenthd1 TYPE ty_contenthd.                     "#EC *
    DATA : wa_contentheader1 type ty_contenthd.                 "#EC *
    DATA : wa_contenttab1 TYPE ty_content.                      "#EC *
    DATA : wa_contenttab2 TYPE ty_content.                      "#EC *'
    DATA : wa_contenttab3 TYPE ty_content.                      "#EC *
    DATA : wa_contenttab4 TYPE ty_content.                      "#EC *
    DATA : wa_E1CUVTM TYPE E1CUVTM.                             "#EC *
    DATA : wa_E1CUV1M TYPE E1CUV1M.                             "#EC *
    DATA : wa_E1DATEM TYPE E1DATEM.                             "#EC *
    DATA : wa_error_tab TYPE solisti1.                          "#EC *
    INTERNAL TABLES AND WORK AREAS FOR BDC
    *Internal Table to store the data to display the error message
    DATA : i_errormsg TYPE STANDARD TABLE OF solisti1 INITIAL SIZE 0."#EC *
    *Internal Table to store the data to display the error message
    DATA : i_error TYPE STANDARD TABLE OF solisti1 INITIAL SIZE 0."#EC *
    DATA : itab_error TYPE STANDARD TABLE OF solisti1 INITIAL SIZE 0."#EC *
    **Work area to store the data to display the error message
    DATA : wa_errormsg TYPE solisti1.                           "#EC *
    **Internal table which will store data for the error log
    DATA:i_error_log TYPE STANDARD TABLE OF ty_error_log INITIAL SIZE 0."#EC *
    GLOBAL VARIABLES
    DATA:  G_FILE TYPE string.                                  "#EC *
    DATA : g_ctr_input_recs(5) type c.                          "#EC *
    DATA:  g_ctr_output_recs(5) type p.                         "#EC *
    data : g_msg(100) type c.                                   "#EC *
    data:  g_struct_file TYPE string.                           "#EC *
    data:  g_login type FILEINTERN.                             "#EC *
    data:  g_phyin type string.                                 "#EC *
    DATA:  g_lprnt type RSPOPSHORT.                             "#EC *
    DATA:  g_FNAME1 TYPE STRING.                                "#EC *
    DATA : g_repid TYPE repid,                                  "#EC *
           g_exit(1) TYPE C,                                    "#EC *
           gx_variant  type disvariant.                         "#EC *
    DATA : g_lines    TYPE i .                                  "#EC *
    data : g_save(1) type c.                                    "#EC *
    DATA : g_splid     TYPE rspoid .                            "#EC *
    data:  p_login type FILEINTERN.                             "#EC *
    data:  p_phyin type string.                                 "#EC *
    DATA:
      go_table         TYPE REF TO cl_salv_table,
      go_sdescr        TYPE REF TO cl_abap_structdescr,
      go_tdescr        TYPE REF TO cl_abap_tabledescr,
      gdo_data         TYPE REF TO data,
      gdo_handle       TYPE REF TO data,
      gs_comp          TYPE abap_componentdescr,
      gt_components    TYPE abap_component_tab.
    FIELD-SYMBOLS:
           TYPE table.
    GLOBAL CONSTANTS
    CONSTANTS c_msgar   TYPE rslgarea   VALUE 'F8'.             "#EC *
    CONSTANTS c_msgid   TYPE rslgsubid  VALUE 'E'.              "#EC *
    CONSTANTS c_urgnc   TYPE char04     VALUE 'HIGH'.           "#EC *
    CONSTANTS C_X(1)       TYPE C          VALUE 'X'.           "#EC *
    CONSTANTS C_Y(1)       TYPE C          VALUE 'Y'.           "#EC *
    CONSTANTS C_Z(1)       TYPE C          VALUE 'Z'.           "#EC *
    CONSTANTS C_E(1)       TYPE C          VALUE 'E'.           "#EC *
    CONSTANTS C_SAP(3)     TYPE C          VALUE 'SAP'.         "#EC *
    CONSTANTS C_MOD(3)     TYPE C          VALUE 'MOD'.         "#EC *
    CONSTANTS C_MD1(3)     TYPE C          VALUE 'MD1'.         "#EC *
    CONSTANTS C_MD2(3)     TYPE C          VALUE 'MD2'.         "#EC *
    CONSTANTS C_MD3(3)     TYPE C          VALUE 'MD3'.         "#EC *
    constants:   c_000001(6)  type c value '000001',            "#EC *
                 c_e1cuv1m(7) type c value 'E1CUV1M',           "#EC *
                 c_02(2)  type c value '02',                    "#EC *
                 c_009(3)   type c value '009',                 "#EC *
                 c_0001(4) type c value '0001'.                 "#EC *
    constants:  c_e1datem(7) type c value 'E1DATEM'.            "#EC *
    constants:  c_e1cuvtm(7) type c value 'E1CUVTM'.            "#EC *
    GLOBAL INTERNAL TABLES FOR ALV DISPLAY
    *Internal tables for ALV Field cat
    DATA :
    i_fieldcat_ov  TYPE STANDARD TABLE OF slis_fieldcat_alv INITIAL SIZE 0,"#EC *
    i_fieldcat_dtl TYPE STANDARD TABLE OF slis_fieldcat_alv INITIAL SIZE 0,"#EC *
    i_fieldcat_ov1 TYPE lvc_t_fcat,                             "#EC *
    i_events       TYPE slis_t_event.                           "#EC *
    GLOBAL WORK AREAS FOR ALV DISPLAY
    *Work area for ALV Field layout
    DATA : wa_layout TYPE slis_layout_alv.                      "#EC *
    *Work area for Field Cat. Table
    DATA : wa_fieldcat TYPE slis_fieldcat_alv.                  "#EC *
    GLOBAL VARIABLES FOR ALV DISPLAY
    DATA : g_event  TYPE slis_t_event.                          "#EC *
    DATA : g_top_of_page TYPE slis_t_listheader.                "#EC *
    DATA : g_ok_code     TYPE char4.                            "#EC *
    DATA : g_variant     type disvariant.                       "#EC *
    GLOBAL CONSTANTS FOR ALV DISPLAY
    BAL handling
    data: iv_log_handle type BALLOGHNDL.                        "#EC *
    data: is_log_header type bal_s_log.                         "#EC *
    data: iv_object     type bal_s_log-object    value 'CAPI'.  "#EC *
    data: iv_subobject  type bal_s_log-subobject value 'CAPI_LOG'."#EC *
    data: iv_tcode      type bal_s_log-altcode   value 'SE38'.  "#EC *
    *MOD-005
    RANGES:
        R_MESTYP FOR EDIDC-MESTYP,                              "#EC *
        R_CREDAT FOR EDIDC-CREDAT,                                  "#EC *
        R_CRETIM FOR EDIDC-CRETIM,                              "#EC *
        R_SNDPRT FOR EDIDC-SNDPRT,                              "#EC *
        R_SNDPRN FOR EDIDC-SNDPRN.                              "#EC *
    DATA:
        L_MESSTYPE TYPE TUMLS_MESSTYPE.                         "#EC *
    *MOD-005
    data:        p_sndprn TYPE EDI_SNDPRN,                      "#EC *
                 p_sndprt TYPE EDI_SNDPRT,                      "#EC *
                 p_sndpor TYPE EDI_SNDPOR.                      "#EC *
    data:        p_rcvprn TYPE EDI_RCVPRN,                      "#EC *
                 p_rcvprt TYPE EDI_RCVPRT,                      "#EC *
                 p_rcvpor TYPE EDI_RCVPOR.                      "#EC *
    data:
      init_E1CUVTM type E1CUVTM,                                "#EC *
      prev_E1CUVTM type E1CUVTM,                                "#EC *
      init_E1DATEM type E1DATEM,                                "#EC *
      prev_E1DATEM type E1DATEM,                                "#EC *
      init_E1CUV1M type E1CUV1M,                                "#EC *
      prev_E1CUV1M type E1CUV1M.                                "#EC *
    Source structure definitions
    data:
      begin of LSMW_TAB_CONTENT,                                "#EC *
        VTNAM(018) type C,
        CHAR1(030) type C,
        CHAR2(030) type C,
        CHAR3(030) type C,
        CHAR4(030) type C,
        CHAR5(030) type C,
        CHAR6(030) type C,
        CHAR7(030) type C,
        CHAR8(030) type C,
        CHAR9(030) type C,
        CHAR10(030) type C,
        CHAR11(030) type C,
        CHAR12(030) type C,
        CHAR13(030) type C,
        CHAR14(030) type C,
        CHAR15(030) type C,
        FLAG(001) type C,
      end of LSMW_TAB_CONTENT.
    Counters
    data:
      g_cnt_VAR_TAB  type i,                                    "#EC *
      g_cnt_TAB_CONTENT  type i.                                "#EC *
    Counter ct_xxxxxxxxxx: number of transferred records
    data:
      ct_edi_dc40 type i,                                       "#EC *
      cs_edi_dc40 type i,                                       "#EC *
      ct_E1CUVTM  type i,                                       "#EC *
      cs_E1CUVTM  type i,                                       "#EC *
      ct_E1DATEM  type i,                                       "#EC *
      cs_E1DATEM  type i,                                       "#EC *
      ct_E1CUV1M  type i,                                       "#EC *
      cs_E1CUV1M  type i.                                       "#EC *
    Global data definitions and data declarations
    DATA: wa_cabn TYPE ty_cabn,
          wa_cawn TYPE ty_cawn,
          wa_file TYPE ty_file,
          wa_vtnam TYPE ty_vtnam,
          wa_cuvtab_fld TYPE ty_cuvtab_fld,
          wa_cuvtab_valn TYPE ty_cuvtab_valn,
          wa_cuvtab_valc TYPE ty_cuvtab_valc,
          wa_col_pos     TYPE ty_col_pos,
          wa_error       TYPE ty_error,
          wa_dupl        TYPE ty_dupl,
          wa_dupl_file   TYPE ty_dupl.
    DATA: wa_vnt_ma TYPE ty_vnt_ma,
          wa_split  TYPE ty_split.
    DATA: wa_charval TYPE ty_charval.                           "#EC *
    Internal table
    DATA: i_cabn        TYPE STANDARD TABLE OF ty_cabn,         "#EC *
          i_cabn_temp   TYPE STANDARD TABLE OF ty_cabn,         "#EC *
          i_cabn_atinn  TYPE STANDARD TABLE OF ty_cabn,         "#EC *
          i_file        TYPE STANDARD TABLE OF ty_file,         "#EC *
          i_file_tmp    TYPE STANDARD TABLE OF ty_file,         "#EC *
          i_vtnam       TYPE STANDARD TABLE OF ty_vtnam,        "#EC *
          i_cuvtab      TYPE STANDARD TABLE OF ty_vtnam,        "#EC *
          i_cuvtab_fld  TYPE STANDARD TABLE OF ty_cuvtab_fld,   "#EC *
          i_cuvtab_valn TYPE STANDARD TABLE OF ty_cuvtab_valn,  "#EC *
          i_cuvtab_valc TYPE STANDARD TABLE OF ty_cuvtab_valc,  "#EC *
          i_col_pos     TYPE STANDARD TABLE OF ty_col_pos,      "#EC *
          i_cawn        TYPE STANDARD TABLE OF ty_cawn,         "#EC *
          i_cawn_n      TYPE STANDARD TABLE OF ty_cawn,         "#EC *
          i_cawn_c      TYPE STANDARD TABLE OF ty_cawn,         "#EC *
          i_cawn_i      TYPE STANDARD TABLE OF ty_cawn,         "#EC *
          i_cuv_error   TYPE STANDARD TABLE OF ty_vtnam,        "#EC *
          i_dupl        TYPE STANDARD TABLE OF ty_dupl.         "#EC *
    DATA: i_vnt_ma TYPE STANDARD TABLE OF ty_vnt_ma,            "#EC *
          i_split  TYPE STANDARD TABLE OF ty_split.             "#EC *
    DATA: i_dupl_file TYPE STANDARD TABLE OF ty_dupl.           "#EC *
    DATA: i_charval TYPE STANDARD TABLE OF ty_charval.          "#EC *
    Constants
    CONSTANTS: c_char TYPE atfor VALUE 'CHAR',                  "#EC *
               c_date TYPE atfor VALUE 'DATE',                  "#EC *
               c_time TYPE atfor VALUE 'TIME',                  "#EC *
               c_varcond TYPE atnam VALUE 'Z_VARCOND'.          "#EC *
    Field Symbols
    FIELD-SYMBOLS:  TYPE ANY.
    Variables
    DATA: g_raw(500)  TYPE c,                                   "#EC *
          g_invalid   TYPE char1,                               "#EC *
          g_error     TYPE char1,                               "#EC *
          g_message   TYPE char50,                              "#EC *
          g_slnid_c    TYPE slnid,                              "#EC *
          g_slnid_n    TYPE slnid,                              "#EC *
          g_row        TYPE char5.                              "#EC *
    DATA: g_varcond TYPE varcond, "Variant condition "#EC NEEDED
          g_split_var TYPE i.                                   "#EC *
    Types: begin of ty_charname,
             name type atnam,
           end of ty_charname.
    data: wa_charname type ty_charname,                         "#EC *
          i_charname type standard table of ty_charname.        "#EC *
    data: cnt_i type i,                                         "#EC *
          g_tabix type char10.                                  "#EC *
    Types: begin of ty_itab_zedidc40.
            include structure edi_dc40.
    TYPES:       end of ty_itab_zedidc40.
    Types: begin of ty_itab_zedidd40.
            include structure edi_dd40.
    TYPES: end of ty_itab_zedidd40.
    DATA: itab_zedidc40 type standard table of
                      ty_itab_zedidc40 initial size 0.          "#EC *
    DATA: itab_zedidd40 type standard table of
                      ty_itab_zedidd40 initial size 0.          "#EC *
    DATA: wa_itab_zedidc40 type ty_itab_zedidc40.
    DATA: wa_itab_zedidd40 type ty_itab_zedidd40.
    *MOD-009
    data: itab_ze1cuvtm type e1cuvtm,                           "#EC *
          itab_ze1datem type e1datem,                           "#EC *
          itab_ze1cuv1m type e1cuv1m.                           "#EC *
    data: wdocnum(16) type n value 0.                           "#EC *
    data: wsegnum(6)  type n value 0.                           "#EC *
    data: witemno(10) type n value 0.                           "#EC *
    data: witemno_new(10)  type n value 0.                      "#EC *
    data: witemno_gst(10)  type n value 0.                      "#EC *
    data: witemno_qst(10)  type n value 0.                      "#EC *
    TYPES: BEGIN OF ty_input_data1,                             "#EC *
              line(560) type c,
              flag(1) type c,
           END OF ty_input_data1.
    DATA: i_input_data type standard table of
                      ty_input_data1 initial size 0. "with header line.
    DATA: i_input_data1 type standard table of
                      ty_input_data1 initial size 0. "with header line.
    DATA: wa_input_data type ty_input_data1.                    "#EC *
    DATA: g_cnt_input_recs type i.                              "#EC *
    DATA: g_flg_error type c.                                   "#EC *
    DATA: l_lines type i.                                       "#EC *
    DATA: l_tabix type i.                                       "#EC *
    DATA: wa_input_data1 type ty_input_data1.                   "#EC *
    DATA: FILE TYPE STRING.
    Fields that are made available to the user:
    DATA:
      g_cnt_records_read TYPE i,                                "#EC *
      g_cnt_records_transferred TYPE i,                         "#EC *
      g_cnt_transactions_read TYPE i,                           "#EC *
      g_cnt_transactions_transferred TYPE i,                    "#EC *
      g_cnt_idocs_package TYPE i.                               "#EC *
    data: v_log_handle type balloghndl.                         "#EC *
    DATA: gt_curr_edi_dc40 TYPE STANDARD TABLE OF edi_dc40 initial size 0."#EC *
    DATA: gt_curr_edi_dd40 TYPE STANDARD TABLE OF edi_dd40 initial size 0."#EC *
    DATA: wa_curr_edi_dc40 TYPE edi_dc40.                       "#EC *
    DATA: wa_curr_edi_dd40 TYPE edi_dd40.                       "#EC *
    internal table for error messages during conversion
    DATA: g_error_tab TYPE type_errortab,                       "#EC *
          wa_errortab TYPE type_errorline.                      "#EC *
    DATA:  g_edidd_segnam type EDI4SEGNAM,                      "#EC *
           g_edidd_hlevel type EDI4HLEVEC.                      "#EC *
    DATA: g_segnum(6) TYPE n.
    DATA: g_objecttype(2) type C.
    DATA: P_FNAME(128) TYPE C VALUE '/usr/sap/trans/vartabheader'. " MODIF ID MD1 OBLIGATORY.
    DATA: P_FNAME1(128) TYPE C VALUE '/usr/sap/trans/vartabcontent'. " MODIF ID MD1 OBLIGATORY.
    DATA: alv_fldcat TYPE slis_t_fieldcat_alv,
          it_fldcat TYPE lvc_t_fcat.
    field-symbols: .
    data: dy_table type ref to data,
          dy_line  type ref to data,
          xfc type lvc_s_fcat,
          ifc type lvc_t_fcat.
    data: l_wa_data TYPE TY_CONTENT,
          itab_data TYPE standard table of TY_CONTENT.
    DECLARATION FOR SELECTION SCREEN
    *selection-screen skip 1.
    *For all the input field entries
    SELECTION-SCREEN BEGIN OF BLOCK bl1 WITH FRAME TITLE text-001.
    *Parameter for Input File Name:
    PARAMETERS:   p_inpt   TYPE RLGRAP-FILENAME MODIF ID MOD . " Presentation server File Variant table
    PARAMETERS:   p_inpt1  TYPE RLGRAP-FILENAME MODIF ID MOD . " Presentation server File variant Content
    SELECTION-SCREEN END OF BLOCK bl1.
    IDoc creation
    selection-screen begin of block idocpars
                     with frame title text-006.
    parameters:
       p_trfcpt as checkbox default C_X MODIF ID MD3,
       p_packge(5) type n default 1 MODIF ID MD3.
    selection-screen end of block idocpars.
    SELECTION-SCREEN BEGIN OF BLOCK bl3 WITH FRAME TITLE text-032.
    Radio Buttons :
    parameters:
      rb_apsrv RADIOBUTTON GROUP RB1 DEFAULT 'X' USER-COMMAND UCOM,
      rb_convt RADIOBUTTON GROUP RB1,
      rb_idoc RADIOBUTTON GROUP RB1,
      rb_proc RADIOBUTTON GROUP RB1.
    SELECTION-SCREEN END OF BLOCK bl3.
    INITIALIZATION
    INITIALIZATION.
    Check selection-screen entries *
    *AT SELECTION-SCREEN.
    PERFORM sub_get_physical_file USING p_fpath p_fname.
    PERFORM sub_get_physical_file1 USING p_fpath1 p_fname1.
    AT SELECTION SCREEN
    *AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_fname.
    PERFORM sub_get_file. " CHANGING p_fname.         "#EC *
    *AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_fname1.
    PERFORM sub_get_file1. " CHANGING p_fname1.       "#EC *
    AT SELECTION-SCREEN ON VALUE-REQUEST FOR P_INPT.
      CALL FUNCTION 'KD_GET_FILENAME_ON_F4'
        EXPORTING
          STATIC        = C_X
        CHANGING
          FILE_NAME     = P_INPT
        EXCEPTIONS
          MASK_TOO_LONG = 1
          OTHERS        = 2.
      IF SY-SUBRC <> 0.
        MESSAGE e241.
      ENDIF.
    AT SELECTION-SCREEN ON VALUE-REQUEST FOR P_INPT1.
      CALL FUNCTION 'KD_GET_FILENAME_ON_F4'
        EXPORTING
          STATIC        = C_X
        CHANGING
          FILE_NAME     = P_INPT1
        EXCEPTIONS
          MASK_TOO_LONG = 1
          OTHERS        = 2.
      IF SY-SUBRC <> 0.
        MESSAGE e241.
      ENDIF.
    At Selection Screen Output
    AT SELECTION-SCREEN OUTPUT.
    IF rb_apsrv = 'X'.
       LOOP AT SCREEN.
         IF SCREEN-GROUP1 = c_mod.
           SCREEN-INPUT = 0.
         ENDIF.
         IF SCREEN-GROUP1 = c_md2.
           SCREEN-INPUT = 0.
         ENDIF.
         IF SCREEN-GROUP1 = c_md3.
           SCREEN-INPUT = 0.
         ENDIF.
         MODIFY SCREEN.
       ENDLOOP.
    endif.
    IF rb_apsrv = 'X'.
      LOOP AT SCREEN.
        IF SCREEN-GROUP1 = c_md1.
          SCREEN-INPUT = 0.
        ENDIF.
        IF SCREEN-GROUP1 = c_md2.
          SCREEN-INPUT = 0.
        ENDIF.
        IF SCREEN-GROUP1 = c_md3.
          SCREEN-INPUT = 0.
        ENDIF.
        MODIFY SCREEN.
      ENDLOOP.
    endif.
    START-OF-SELECTION
    START-OF-SELECTION.
    *Subroutines for start of selection event
      PERFORM sub_start_selection.
      IF rb_apsrv = 'X'.
        PERFORM sub_upload_data_app.
        MESSAGE i256.
        LEAVE LIST-PROCESSING.
        EXIT.
      ELSE.
        PERFORM sub_upload_data.
      ENDIF.
    PERFORM sub_upload_data.
    Get characteristic details
      PERFORM sub_get_cabn.
    Get value for characteristics
      PERFORM sub_get_cawn.
      perform sub_convert_transaction.
    END-OF-SELECTION.
    END OF SELECTION
    *MOD-012
    Final message
      perform sub_final_message_idoc.
    Display errorneous variant tables.
      perform sub_display_variant.
    Display lines with incorrect data
      perform sub_display_errorlines.
    *Subroutines for end of selection event
      PERFORM sub_end_selection.
      perform sub_clear_source_tables.
    *MOD-012
    *&  Include           /FACTGLB/GTDMI_VARTAB_FORMS02                    *
    *&  Include           /FACTGLB/GTDMI_VARTAB_FORMS02                    *

  • WD Service Call ABAP program generation error in 2004s

    Hi,
    I create a 'service call' by using the wizard and I select my existing 'component controller' as a controller. The service type I use is a (custom) function module. The function module has 1 import parameter, an export structure and 6 tables.
    In the 'adapt context' step I choose all fields and structures to be stored in the context. Then I generate the code.
    After generating the code there is a syntax error in the code of the created method. The method code under comment 'store output to context' binds the rfc structure to the context BUT it seems to think that it is a table instead of a structure.
    the code:
    node_Contract->bind_Structure(Stru_C_Contract[] )
    Of course I can remove the '[]' signs manually but I think it is strange that the wizard produces wrong code.
    Please let me know if this is a bug or something else.

    Values in variants are not converted.  You can use the same variant in your ABAP program, but you need to change the value in the parameter for logical system in each system you transport the change to.  The only alternative is to create a logical system name in SM59 that is the same in all your BW systems but it refers to the local R/3 system.
    In other words, you will have two logical systems in your BWD system pointing to your R/3 Dev.  Let's call them R3DCLNT100 and R3SYSTEM, where R3DCLNT100 is also the source system (in RSA1).  You can use R3SYSTEM in your variant for your ABAP program.  In your BWQ (test system), you will have two logical systems also, R3QCLNT100 and R3SYSTEM, where R3QCLNT100 is also your source system.
    Does this help.

  • Call an ABAP program or a function module from command prompt/python script

    Dear All,
    I want to call a function module/ABAP program from command prompt or a python script.
    Let me explain with an example.
    There is a function module "z_add" that takes  two integers as input parameters and generates their sum.
    the sum is the output parameter.
    Now i want to call this function module from command prompt / python script and pass parameters to this function module.
    In return i must get the sum(i.e. the output of function module).
    I tried using STARTRFC ,was able to call the FM but could not get the return value(output) from FM.
    Can you please provide me the code of such a function module and the method to call it thereby passing parameters and getting the sum.
    Thanks and regards,
    Gaurav
    Edited by: gauravkec2005 on Mar 4, 2010 7:41 AM

    thank you both!  helpful answers! :o)
    anyway! 
    i have written the program which is called from the SAPScript:
        /:       PERFORM GET_VATNUMBER IN PROGRAM ZFI_F140_OPERATIONS
        /:       USING &BKPF-BUKRS&
        /:       CHANGING &VATNUMBER&
        CE       VAT Registration No : &VATNUMBER&
        REPORT zfi_f140_operations.
        FORM get_vatnumber TABLES in_par  STRUCTURE itcsy
                                  out_par STRUCTURE itcsy.
          DATA: lv_co_code TYPE bukrs,
                lv_vat_no  TYPE stceg.
          READ TABLE in_par WITH KEY name = 'BKPF-BUKRS'.
          MOVE in_par-value TO lv_co_code.
          SELECT SINGLE stceg FROM t001
            INTO lv_vat_no WHERE bukrs = lv_co_code.
          out_par-name = 'VATNUMBER'.
          WRITE lv_vat_no TO out_par-value.
          CONDENSE out_par-value.
          MODIFY out_par INDEX 1.
        ENDFORM.              
    it is not working and i cannot work out why... 
    i have not been ABAPing for very long but have had a go.... 
    any thoughts as to what i have done wrong?
    or point me where i should be looking?  thank you!

  • How to read data from an excel using abap program?

    Hi
    I have to write an abap program to read the contents of ms excel across various
    sheets. Can any one help me regarding this
    Thanks in advance
    Satish

    Hai Satish,
    <b>You save  all your Excel sheets as Text Tab Delimited.</b>
    And then for each teext file can be uploaded into your daabase table.
    See the Report that  i have done.
    REPORT Z_UPLOAD_TO_DATABASE_TABLE.
    TABLES:
      ZDETMAST.                        " Database table to be uploaded
    Data declaration of the structure to hold ZDETMAST(zdetcode) data  *
    DATA:
      BEGIN OF FS_ZDETMAST,
        CNT(3)      TYPE C,                " Client
        DETCODE(15) TYPE C,                " Det Code
        DETCAT(1)   TYPE C,                " Det category
        DETTYPE(2) TYPE  N,                " Det type
        DETDESC(30) TYPE C,                " Det description
        PFLAG(1)   TYPE C,                " Det Flag
        TOTALDR(10) TYPE C,                " Total DR
        TOTALCR(10) TYPE C,                " Total CR
      END OF FS_ZDETMAST.
    Internal table to hold ZDETMAST(zdetcode) data                     *
    DATA:
      T_ZDETMAST LIKE STANDARD TABLE OF FS_ZDETMAST.
    Function Module to upload ZDETMAST Data
    CALL FUNCTION 'GUI_UPLOAD'
       EXPORTING
         FILENAME                      = 'D:/ZDETMAST_2.TXT'
         FILETYPE                      = 'ASC'
         HAS_FIELD_SEPARATOR           = 'X'
        HEADER_LENGTH                 = 0
        READ_BY_LINE                  = 'X'
        DAT_MODE                      = 'DAT'
        CODEPAGE                      = ' '
        IGNORE_CERR                   = ABAP_TRUE
        REPLACEMENT                   = '#'
        CHECK_BOM                     = ' '
        VIRUS_SCAN_PROFILE            =
      IMPORTING
        FILELENGTH                    =
        HEADER                        =
        TABLES
          DATA_TAB                      = T_ZDETMAST
       EXCEPTIONS
         FILE_OPEN_ERROR               = 1
         FILE_READ_ERROR               = 2
         NO_BATCH                      = 3
         GUI_REFUSE_FILETRANSFER       = 4
         INVALID_TYPE                  = 5
         NO_AUTHORITY                  = 6
         UNKNOWN_ERROR                 = 7
         BAD_DATA_FORMAT               = 8
         HEADER_NOT_ALLOWED            = 9
         SEPARATOR_NOT_ALLOWED         = 10
         HEADER_TOO_LONG               = 11
         UNKNOWN_DP_ERROR              = 12
         ACCESS_DENIED                 = 13
         DP_OUT_OF_MEMORY              = 14
         DISK_FULL                     = 15
         DP_TIMEOUT                    = 16
         OTHERS                        = 17
    IF SY-SUBRC <> 0.
    MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
    WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
    ENDIF.                                 " IF SY-SUBRC <> 0.
    LOOP AT T_ZDETMAST INTO FS_ZDETMAST.
      WRITE:
        / FS_ZDETMAST-CNT,
         FS_ZDETMAST-DETCODE,
         FS_ZDETMAST-DETCAT,
         FS_ZDETMAST-DETTYPE,
         FS_ZDETMAST-DETDESC,
         FS_ZDETMAST-PFLAG,
         FS_ZDETMAST-TOTALDR,
         FS_ZDETMAST-TOTALCR.
    ENDLOOP.                               " LOOP AT T_ZDETMAST ...
    LOOP AT  T_ZDETMAST INTO ZDETMAST.
       IF SY-TABIX GE 2.
         INSERT ZDETMAST.
        DELETE ZDETMAST.
       ENDIF.                              " IF SY-TABIX EQ 2
    ENDLOOP.                               " LOOP AT  T_ZDETMAST
    Hope this helps you a lot.
    <b>You can also use ALSM_EXCEL_TO_INTERNAL_TABLE FM to have excel data in ITAB AND THEN YOU CAN INSERT DATA INTO DATABASE TABLE.</b>
    <b>Reward points if it helps you.</b>
    Regds,
    Rama chary.Pammi

Maybe you are looking for

  • Error in webAS SR1 upgrade to SP 11

    Hi, When updating a webAS 6.40 ABAP+Java SR1 to SP11, it fails due to an error on step 17/21 (Deploy via SDM/J2EE). The sapinst log states: <i>MUT-02041 SDM call of deploySdaList ends with returncode  4. See output of logfile /sapinst/webas_ps11/call

  • Calling spclientcontext.executeQueryAsync works on the first call, but fails on the second call

    I have a webpart that I'm using to display a tree of folders and files from a SharePoint list. When a folder is clicked, some client side code is used to expand the contents of the folder (the code queries the SharePoint list for any child items of t

  • How do I save video from iMessage?

    How do I save a video, that has been sent via text msg, on my MacBook pro? I have opened the file on my macbook pro through I message using quicktime but I cant figure out how to save the video. Help please:)

  • How to Access a class outside a package which is friendly to the package

    Hi All, i hav a class which has friendly scope in package X. how do i access it from a class in package Y without declaring it as public. Rgds,

  • Invoking BPEL from Webservice

    Hello, I'm trying to change BPEL process state from webservice. The code: public void switchProcessOf(String name) throws Exception Hashtable contextProps = new Hashtable(); contextProps.put(javax.naming.Context.INITIAL_CONTEXT_FACTORY, "com.evermind