{"id":1577,"date":"2023-08-08T10:00:00","date_gmt":"2023-08-08T04:30:00","guid":{"rendered":"https:\/\/zmainframes.com\/zlog\/?p=1577"},"modified":"2023-12-05T12:24:48","modified_gmt":"2023-12-05T06:54:48","slug":"exploring-the-call-statement-in-cobol-programming","status":"publish","type":"post","link":"https:\/\/zmainframes.com\/zlog\/exploring-the-call-statement-in-cobol-programming\/","title":{"rendered":"Exploring the CALL Statement in COBOL Programming"},"content":{"rendered":"\r\n

Introduction<\/strong><\/p>\r\n\r\n\r\n\r\n

COBOL<\/strong> (Common Business-Oriented Language) has been a workhorse of the programming world for decades, especially in business and financial applications. One of the key features that makes COBOL a versatile and efficient language is its CALL statement. The CALL statement allows programmers to create modular and organized programs by invoking subprograms, also known as subroutines or procedures, from within a main COBOL program. In this article, we will delve into the intricacies of the CALL statement, exploring its various use cases and scenarios, and provide real-world examples to illustrate its functionality.<\/p>\r\n

\"\"<\/p>\r\n

 <\/p>\r\n\r\n\r\n\r\n

Understanding the CALL Statement<\/strong><\/p>\r\n\r\n\r\n\r\n

The CALL statement in COBOL is used to transfer control from the main program to a specified subprogram. This subprogram can be another COBOL program, a COBOL-DB2 program, or any other type of program that is written in a compatible language. The CALL statement facilitates the creation of modular code, as it enables the reuse of existing subprograms across different parts of an application.<\/p>\r\n\r\n\r\n\r\n

Basic Syntax of the CALL Statement<\/strong><\/p>\r\n\r\n\r\n\r\n

The basic syntax of the CALL statement is as follows:<\/p>\r\n\r\n\r\n\r\n

COBOL<\/span>\r\n
CALL<\/span> 'SUBPROGRAM-NAME'<\/span><code><\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
Where 'SUBPROGRAM-NAME'<\/code> is the name of the subprogram being called. The subprogram can be located within the same source code file or in a separate file altogether.<\/p>\r\n\r\n\r\n\r\n
Scenarios of Calling Subprograms<\/strong><\/p>\r\n\r\n\r\n\r\n
Let’s explore various scenarios of using the CALL statement to invoke subprograms from a main COBOL program.<\/p>\r\n\r\n\r\n\r\n
    \r\n
  1. Calling an Internal Subroutine: In this scenario, we define a subroutine within the same COBOL program and invoke it using the CALL statement. This approach is useful for breaking down a complex task into smaller, more manageable units of code.<\/li>\r\n<\/ol>\r\n\r\n\r\n\r\n
    Example:<\/strong><\/p>\r\n\r\n\r\n\r\n
    COBOL<\/span>\r\n
    IDENTIFICATION DIVISION<\/span>.<\/span><\/span>\r\nPROGRAM-ID<\/span>. <\/span>MAINPROGRAM<\/span>.<\/span><\/span>\r\n\r\nDATA DIVISION<\/span>.<\/span><\/span>\r\nWORKING-STORAGE SECTION<\/span>.<\/span><\/span>\r\n01<\/span> NUM1       <\/span>PIC 9<\/span>(<\/span>3<\/span>) <\/span>VALUE<\/span> 100<\/span>.<\/span><\/span>\r\n01<\/span> NUM2       <\/span>PIC 9<\/span>(<\/span>3<\/span>) <\/span>VALUE<\/span> 200<\/span>.<\/span><\/span>\r\n\r\nPROCEDURE DIVISION<\/span>.<\/span><\/span>\r\n    PERFORM<\/span> CALCULATE-SUM<\/span><\/span>\r\n    DISPLAY<\/span> \"Sum: \"<\/span> NUM1<\/span><\/span>\r\n    STOP RUN<\/span>.<\/span><\/span>\r\n\r\nCALCULATE-SUM.<\/span><\/span>\r\n    ADD<\/span> NUM1 <\/span>TO<\/span> NUM2.<\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
      \r\n
    1. Calling an External Subprogram: In this scenario, we have a separate COBOL program that performs a specific task. The main program calls this external program using the CALL statement to leverage its functionality.<\/li>\r\n<\/ol>\r\n\r\n\r\n\r\n
      Example:<\/strong><\/p>\r\n\r\n\r\n\r\n
      Main Program (MAINPROGRAM.CBL<\/code>):<\/strong><\/p>\r\n\r\n\r\n\r\n
      COBOL<\/span>\r\n
      IDENTIFICATION DIVISION<\/span>.<\/span><\/span>\r\nPROGRAM-ID<\/span>. <\/span>MAINPROGRAM<\/span>.<\/span><\/span>\r\n\r\nDATA DIVISION<\/span>.<\/span><\/span>\r\nWORKING-STORAGE SECTION<\/span>.<\/span><\/span>\r\n01<\/span> AMOUNT     <\/span>PIC 9<\/span>(<\/span>5<\/span>) <\/span>VALUE<\/span> 5000<\/span>.<\/span><\/span>\r\n\r\nPROCEDURE DIVISION<\/span>.<\/span><\/span>\r\n    CALL<\/span> 'CALCSUB'<\/span> <\/span>\r\n    DISPLAY<\/span> \"New Amount: \"<\/span> AMOUNT<\/span><\/span>\r\n    STOP RUN<\/span>.<\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
      Subprogram (CALCSUB.CBL<\/code>):<\/strong><\/p>\r\n\r\n\r\n\r\n
      COBOL<\/span>\r\n
      IDENTIFICATION DIVISION<\/span>.<\/span><\/span>\r\nPROGRAM-ID<\/span>. <\/span>CALCSUB<\/span>.<\/span><\/span>\r\n\r\nDATA DIVISION<\/span>.<\/span><\/span>\r\nLINKAGE SECTION<\/span>.<\/span><\/span>\r\n01<\/span> AMT-IN     <\/span>PIC 9<\/span>(<\/span>5<\/span>).<\/span><\/span>\r\n\r\nPROCEDURE DIVISION<\/span> USING<\/span> AMT-IN.<\/span><\/span>\r\n    MULTIPLY<\/span> AMT-IN <\/span>BY<\/span> 1.1<\/span> GIVING<\/span> AMT-IN.<\/span><\/span>\r\n    EXIT PROGRAM<\/span>.<\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
        \r\n
      1. Calling a COBOL-DB2 Program: COBOL is often integrated with database systems like IBM DB2. You can call a COBOL-DB2 program to perform database operations, such as fetching records, updating data, or executing SQL queries.<\/li>\r\n<\/ol>\r\n\r\n\r\n\r\n
        Example:<\/strong><\/p>\r\n\r\n\r\n\r\n
        Main Program (MAINPROGRAM.CBL<\/code>):<\/strong><\/p>\r\n\r\n\r\n\r\n
        COBOL<\/span>\r\n
        IDENTIFICATION DIVISION<\/span>.<\/span><\/span>\r\nPROGRAM-ID<\/span>. <\/span>MAINPROGRAM<\/span>.<\/span><\/span>\r\n\r\nDATA DIVISION<\/span>.<\/span><\/span>\r\nWORKING-STORAGE SECTION<\/span>.<\/span><\/span>\r\n01<\/span> EMPLOYEE-NAME   <\/span>PIC X<\/span>(<\/span>30<\/span>).<\/span><\/span>\r\n01<\/span> EMPLOYEE-ID     <\/span>PIC 9<\/span>(<\/span>6<\/span>) <\/span>VALUE<\/span> 123456<\/span>.<\/span><\/span>\r\n\r\nPROCEDURE DIVISION<\/span>.<\/span><\/span>\r\n    CALL<\/span> 'DB2SUB'<\/span> USING<\/span> EMPLOYEE-ID EMPLOYEE-NAME<\/span><\/span>\r\n    DISPLAY<\/span> \"Employee: \"<\/span> EMPLOYEE-NAME<\/span><\/span>\r\n    STOP RUN<\/span>.<\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
        COBOL-DB2 Subprogram (DB2SUB.CBL<\/code>):<\/strong><\/p>\r\n\r\n\r\n\r\n
        COBOL<\/span>\r\n
        IDENTIFICATION DIVISION<\/span>.<\/span><\/span>\r\nPROGRAM-ID<\/span>. <\/span>DB2SUB<\/span>.<\/span><\/span>\r\n\r\nDATA DIVISION<\/span>.<\/span><\/span>\r\nLINKAGE SECTION<\/span>.<\/span><\/span>\r\n01<\/span> EMP-ID-IN       <\/span>PIC 9<\/span>(<\/span>6<\/span>).<\/span><\/span>\r\n01<\/span> EMP-NAME-OUT    <\/span>PIC X<\/span>(<\/span>30<\/span>).<\/span><\/span>\r\n\r\nPROCEDURE DIVISION<\/span> USING<\/span> EMP-ID-IN EMP-NAME-OUT.<\/span><\/span>\r\n    EXEC SQL<\/span><\/span>\r\n        SELECT EMP_NAME INTO <\/span>:EMP-NAME-OUT<\/span><\/span>\r\n        FROM EMPLOYEES<\/span><\/span>\r\n        WHERE EMP_ID = <\/span>:EMP-ID-IN<\/span>;<\/span><\/span>\r\n\r\n    EXIT PROGRAM.<\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
          \r\n
        1. Calling a Non-COBOL Program: COBOL can also call programs written in other languages, provided there is interoperability. In this scenario, let’s consider calling a C program from COBOL.<\/li>\r\n<\/ol>\r\n\r\n\r\n\r\n
          Example:<\/strong><\/p>\r\n\r\n\r\n\r\n
          Main COBOL Program (MAINPROGRAM.CBL<\/strong><\/code>):<\/p>\r\n\r\n\r\n\r\n
          COBOL<\/span>\r\n
          IDENTIFICATION DIVISION<\/span>.<\/span><\/span>\r\nPROGRAM-ID<\/span>. <\/span>MAINPROGRAM<\/span>.<\/span><\/span>\r\n\r\nDATA DIVISION<\/span>.<\/span><\/span>\r\nWORKING-STORAGE SECTION<\/span>.<\/span><\/span>\r\n01<\/span> NUM         <\/span>PIC 9<\/span>(<\/span>3<\/span>) <\/span>VALUE<\/span> 50<\/span>.<\/span><\/span>\r\n\r\nPROCEDURE DIVISION<\/span>.<\/span><\/span>\r\n    CALL<\/span> 'CPROG'<\/span> USING<\/span> NUM<\/span><\/span>\r\n    DISPLAY<\/span> \"Squared: \"<\/span> NUM<\/span><\/span>\r\n    STOP RUN<\/span>.<\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
          C Program (CPROG.C<\/code>):<\/strong><\/p>\r\n\r\n\r\n\r\n
          C<\/span>\r\n
          #include<\/span> <stdio.h><\/span><\/span>\r\n\r\nvoid<\/span> cprog_<\/span>(<\/span>int<\/span> *<\/span>num<\/span>) {<\/span><\/span>\r\n    *<\/span>num <\/span>=<\/span> (<\/span>*<\/span>num) <\/span>*<\/span> (<\/span>*<\/span>num);<\/span><\/span>\r\n}<\/span><\/span><\/code><\/pre>\r\n<\/div>\r\n\r\n\r\n\r\n
          Conclusion<\/strong><\/p>\r\n\r\n\r\n\r\n
          The CALL statement is a powerful feature in COBOL that enables modular programming and code reuse. It allows COBOL programs to call internal and external subprograms, including COBOL-DB2 programs and programs written in other languages. By harnessing the capabilities of the CALL statement, developers can create more organized, maintainable, and efficient applications. Whether it’s breaking down complex tasks, integrating with databases, or collaborating with other programming languages, the CALL statement empowers COBOL programmers to build robust and versatile solutions for a wide range of business and technical requirements.<\/p>\r\n","protected":false},"excerpt":{"rendered":"
          Introduction COBOL (Common Business-Oriented Language) has been a workhorse of the programming world for decades, especially in business and financial […]<\/p>\n","protected":false},"author":515,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[27],"tags":[306,465,463,342,41,37,464,462],"class_list":["post-1577","post","type-post","status-publish","format-standard","hentry","category-cobol","tag-cobol-2","tag-cobol-db2","tag-cobol-db2-subprogram","tag-common-business-oriented-language","tag-db2","tag-mainframes","tag-subprogram","tag-understanding-the-call-statement"],"amp_enabled":true,"rttpg_featured_image_url":null,"rttpg_author":{"display_name":"zMainframes","author_link":"https:\/\/zmainframes.com\/zlog\/author\/zmainframes\/"},"rttpg_comment":0,"rttpg_category":"Cobol<\/a>","rttpg_excerpt":"Introduction COBOL (Common Business-Oriented Language) has been a workhorse of the programming world for decades, especially in business and financial […]","_links":{"self":[{"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/posts\/1577","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/users\/515"}],"replies":[{"embeddable":true,"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/comments?post=1577"}],"version-history":[{"count":2,"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/posts\/1577\/revisions"}],"predecessor-version":[{"id":2001,"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/posts\/1577\/revisions\/2001"}],"wp:attachment":[{"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/media?parent=1577"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/categories?post=1577"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/zmainframes.com\/zlog\/wp-json\/wp\/v2\/tags?post=1577"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}