OMITTED

Overview

The OMITTED keyword in COBOL is used to indicate that a parameter is intentionally not passed when calling a subprogram. This allows for flexible parameter passing where some arguments can be skipped while maintaining the correct parameter position sequence. It's particularly useful in programs that need to support optional parameters or backward compatibility.

Syntax

CALL program-name USING [BY REFERENCE|BY CONTENT|BY VALUE]
    { parameter-1 | OMITTED }
    { parameter-2 | OMITTED }
    ...
    { parameter-n | OMITTED }

Basic Usage

Simple Parameter Omission

CALL "SUBPROG1" USING 
    WS-PARAM-1
    OMITTED
    WS-PARAM-3.

Omitting the second parameter while passing first and third.

Multiple Omitted Parameters

CALL "CALCULATOR" USING 
    WS-OPERATION
    WS-NUMBER-1
    OMITTED
    OMITTED
    WS-RESULT.

Omitting multiple consecutive parameters.

Subprogram Implementation

Calling Program

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN-PROG.

DATA DIVISION.
WORKING-STORAGE SECTION.
01  WS-NAME         PIC X(30) VALUE "JOHN DOE".
01  WS-ADDRESS      PIC X(50) VALUE "123 MAIN ST".
01  WS-PHONE        PIC X(15) VALUE "555-1234".
01  WS-EMAIL        PIC X(50) VALUE "john@email.com".

PROCEDURE DIVISION.
    CALL "PROCESS-CUSTOMER" USING 
        WS-NAME
        WS-ADDRESS
        OMITTED          *> Skip phone number
        WS-EMAIL.
        
    CALL "PROCESS-CUSTOMER" USING 
        WS-NAME
        OMITTED          *> Skip address
        WS-PHONE
        OMITTED.         *> Skip email
        
    STOP RUN.

Main program calling subprogram with different parameter combinations.

Called Subprogram

IDENTIFICATION DIVISION.
PROGRAM-ID. PROCESS-CUSTOMER.

DATA DIVISION.
LINKAGE SECTION.
01  L-NAME          PIC X(30).
01  L-ADDRESS       PIC X(50).
01  L-PHONE         PIC X(15).
01  L-EMAIL         PIC X(50).

PROCEDURE DIVISION USING 
    L-NAME
    L-ADDRESS
    L-PHONE
    L-EMAIL.

    IF L-NAME NOT = SPACES
        DISPLAY "PROCESSING NAME: " L-NAME
    END-IF.
    
    IF L-ADDRESS NOT = SPACES
        DISPLAY "ADDRESS: " L-ADDRESS
    END-IF.
    
    IF L-PHONE NOT = SPACES
        DISPLAY "PHONE: " L-PHONE
    END-IF.
    
    IF L-EMAIL NOT = SPACES
        DISPLAY "EMAIL: " L-EMAIL
    END-IF.
    
    EXIT PROGRAM.

Subprogram handling potentially omitted parameters.

Parameter Testing

Testing for Omitted Parameters

IDENTIFICATION DIVISION.
PROGRAM-ID. PARAM-TEST.

DATA DIVISION.
LINKAGE SECTION.
01  L-REQUIRED-PARAM    PIC X(20).
01  L-OPTIONAL-PARAM-1  PIC 9(6).
01  L-OPTIONAL-PARAM-2  PIC X(10).

PROCEDURE DIVISION USING 
    L-REQUIRED-PARAM
    L-OPTIONAL-PARAM-1
    L-OPTIONAL-PARAM-2.

    DISPLAY "REQUIRED PARAM: " L-REQUIRED-PARAM.
    
    *> Check if numeric parameter was omitted
    IF L-OPTIONAL-PARAM-1 IS NUMERIC
        DISPLAY "OPTIONAL PARAM 1: " L-OPTIONAL-PARAM-1
    ELSE
        DISPLAY "OPTIONAL PARAM 1 WAS OMITTED"
    END-IF.
    
    *> Check if string parameter was omitted
    IF L-OPTIONAL-PARAM-2 NOT = LOW-VALUES
       AND L-OPTIONAL-PARAM-2 NOT = SPACES
        DISPLAY "OPTIONAL PARAM 2: " L-OPTIONAL-PARAM-2
    ELSE
        DISPLAY "OPTIONAL PARAM 2 WAS OMITTED"
    END-IF.
    
    EXIT PROGRAM.

Checking for omitted parameters in the called program.

By Reference vs By Content with OMITTED

BY REFERENCE with OMITTED

CALL "UPDATE-RECORD" USING 
    BY REFERENCE WS-RECORD-KEY
    BY REFERENCE OMITTED
    BY REFERENCE WS-UPDATE-FLAG.

Using OMITTED with BY REFERENCE parameters.

BY CONTENT with OMITTED

CALL "VALIDATE-DATA" USING 
    BY CONTENT WS-INPUT-DATA
    BY CONTENT OMITTED
    BY CONTENT WS-VALIDATION-LEVEL.

Using OMITTED with BY CONTENT parameters.

Mixed Parameter Types

CALL "COMPLEX-PROCESS" USING 
    BY REFERENCE WS-INPUT-BUFFER
    BY CONTENT   WS-PROCESS-CODE
    BY REFERENCE OMITTED
    BY VALUE     LENGTH OF WS-INPUT-BUFFER
    BY CONTENT   OMITTED.

Mixing different parameter passing methods with OMITTED.

Advanced Examples

Configuration-Based Processing

IDENTIFICATION DIVISION.
PROGRAM-ID. FLEXIBLE-PROCESSOR.

DATA DIVISION.
WORKING-STORAGE SECTION.
01  WS-CONFIG-FLAGS.
    05  WS-PROCESS-HEADER-FLAG  PIC X VALUE 'Y'.
    05  WS-PROCESS-DETAIL-FLAG  PIC X VALUE 'N'.
    05  WS-PROCESS-FOOTER-FLAG  PIC X VALUE 'Y'.

01  WS-HEADER-DATA     PIC X(100).
01  WS-DETAIL-DATA     PIC X(200).
01  WS-FOOTER-DATA     PIC X(50).

PROCEDURE DIVISION.
    EVALUATE TRUE
        WHEN WS-PROCESS-HEADER-FLAG = 'Y' AND
             WS-PROCESS-DETAIL-FLAG = 'Y' AND
             WS-PROCESS-FOOTER-FLAG = 'Y'
            CALL "PROCESS-ALL" USING 
                WS-HEADER-DATA
                WS-DETAIL-DATA
                WS-FOOTER-DATA
                
        WHEN WS-PROCESS-HEADER-FLAG = 'Y' AND
             WS-PROCESS-DETAIL-FLAG = 'N' AND
             WS-PROCESS-FOOTER-FLAG = 'Y'
            CALL "PROCESS-ALL" USING 
                WS-HEADER-DATA
                OMITTED
                WS-FOOTER-DATA
                
        WHEN OTHER
            CALL "PROCESS-ALL" USING 
                OMITTED
                OMITTED
                OMITTED
    END-EVALUATE.

Using OMITTED for flexible, configuration-driven processing.

Backward Compatibility

      * Old program calls - still work
       CALL "LEGACY-ROUTINE" USING 
           WS-PARAM-1
           WS-PARAM-2.
           
      * New program calls - with additional parameters
       CALL "LEGACY-ROUTINE" USING 
           WS-PARAM-1
           WS-PARAM-2
           WS-NEW-PARAM-3
           OMITTED          *> Reserved for future use
           WS-NEW-PARAM-5.
           
      * Minimal call - only required parameters
       CALL "LEGACY-ROUTINE" USING 
           WS-PARAM-1
           OMITTED.

Maintaining backward compatibility while extending functionality.

Common Patterns

Optional Flag Parameters

      * Call with all options
       CALL "FILE-PROCESSOR" USING 
           WS-FILENAME
           WS-DEBUG-FLAG
           WS-BACKUP-FLAG
           WS-VALIDATE-FLAG.
           
      * Call with minimal options
       CALL "FILE-PROCESSOR" USING 
           WS-FILENAME
           OMITTED          *> No debug
           OMITTED          *> No backup
           OMITTED.         *> No validation

Using OMITTED for optional flag parameters.

Output Parameter Handling

      * Full output requested
       CALL "DATA-ANALYZER" USING 
           WS-INPUT-DATA
           WS-SUMMARY-OUTPUT
           WS-DETAIL-OUTPUT
           WS-ERROR-OUTPUT.
           
      * Only summary needed
       CALL "DATA-ANALYZER" USING 
           WS-INPUT-DATA
           WS-SUMMARY-OUTPUT
           OMITTED          *> No details needed
           OMITTED.         *> No error details needed

Omitting output parameters when not needed.

Usage Guidelines

•OMITTED can be used with any parameter passing method (BY REFERENCE, BY CONTENT, BY VALUE)
•The called program must handle potentially uninitialized linkage section items
•Parameter positions must be maintained - you cannot skip positions arbitrarily
•Omitted parameters may contain unpredictable values in the linkage section
•Test for valid data rather than assuming omitted parameters are initialized

Best Practices

✓Document which parameters are optional in your subprogram interface
✓Always validate parameter contents before use in called programs
✓Use meaningful default behaviors when parameters are omitted
✓Consider using a parameter count or flag to indicate which parameters are valid
✓Design interfaces with required parameters first, optional parameters last

Compiler Considerations

⚠Not all COBOL compilers support the OMITTED keyword - check your compiler documentation
⚠Some compilers may initialize omitted parameters to specific values
⚠Behavior may vary between different COBOL implementations
⚠Test thoroughly when porting code between different systems

Related Concepts

CALL Statement

Primary statement for invoking subprograms

LINKAGE SECTION

Data area for parameters in called programs

BY REFERENCE

Parameter passing method that passes memory address

BY CONTENT

Parameter passing method that passes a copy of data