Software Sue

Link to Simply Sue
Link to Sustainability Sue
location: software/COBOL procedure division Skip navigation : Home  

COBOL Procedure Division


The Procedure Division consists of one or more procedural sections, which may optionally be preceded by a declaratives section.

The DECLARATIVES section is used to include procedures to be invoked when a condition occurs that the programmer has not been able to test for.

Each (procedural) SECTION may consist of one or more paragraphs, which consist of one or more sentences, which consist of one or more COBOL statements.

Section and paragraph names must not be reserved words and can be up to 30 characters long (A to Z, 0 to 9, embedded hyphens).

Some compilers allow paragrapphs to be empty, which can be useful for documentation.

A COBOL sentence comprises one or more statements followed by a full stop and space. Two statements may be separated by a comma or semicolon (followed by a space) for readability, but these are not necessary.

Statements may be conditional (e.g. IF ....) or imperative (SUBTRACT ...). They may contain reserved words, variables, literals, symbols and paragraph names. Reserved words may be key words, which are obligatory, or optional.


           1          2         3         4         5         6         7        8
123456 7 8901 23456789012345678901234567890123456789012345678901234567890123 34567890
Seq.-ABIdent
   PROCEDURE DIVISION. 
   DECLARATIVES. 
   section_name SECTION. 
         USE {[FOR]{CREATING|CHECKING}[{BEGINNING|ENDING}] 
           LABELS [ON] {OUTPUT|INPUT} [list_of_filenames] | 
           AFTER [STANDARD] ERROR [PROCEDURE ON] filename | 
           BEFORE REPORTING report_group_name }F only.
         statements of subroutine. 
   paragraph_name. 
   END DECLARATIVES. 
         

           1          2         3         4         5         6         7        8
123456 7 8901 23456789012345678901234567890123456789012345678901234567890123 34567890
   paragraph_name. 
       ENTER LINKAGE.*
       ENTRY entry_name [USING list_of_datanames].*
       ENTER COBOL.*
         
       ADD list_of_literals_and_data_names  
         {TO data_name|GIVING data_name} 
       SUBTRACT list_of_literals_and_data_names FROM  
         {data_name [GIVING data_name] | literal GIVING data_name} 
       MULTIPLY {data_name | literal} BY 
         {data_name [GIVING data_name] | literal GIVING data_name} 
       DIVIDE {data_name | literal} INTO 
         {data_name [GIVING data_name] | literal GIVING data_name} 
       COMPUTE data_name =  
         {data_name | literal | arithmetic_expression} 
       ROUNDED. 
       ADD CORRESPONDING data_name TO data_nameF only
         SUBTRACT CORRESPONDING data_name FROM data_nameF only
         [ON] SIZE ERROR  
          {NEXT SENTENCE | sequence_of_imperative statements) 
         

           1          2         3         4         5         6         7        8
123456 7 8901 23456789012345678901234567890123456789012345678901234567890123 34567890
       Conditional statements: 
       IF condition  
         [THEN] {NEXT SENTENCE | sequence_of_imperative_statements) 
         [{ELSE|OTHERWISE} {NEXT SENTENCE | sequence_of_statements)] 
       Nested IF statements in COBOL F only: 
       IF condition  
         [THEN] {NEXT SENTENCE | sequence_of_statements) 
         [{ELSE|OTHERWISE} {NEXT SENTENCE | sequence_of_statements)] 
         types of condition: 
         1. Relation test: 
         {data_name | literal | arithmetic_expression} IS [NOT] 
          {= | EQUAL TO | > | GREATER [THAN] | < | LESS [THAN] 
          {data_name | literal | arithmetic_expression} 
         2. Sign test: 
         {data_name | arithmetic_expression} IS [NOT]  
          {POSITIVE | NEGATIVE | ZERO} 
         3. Class test: 
         data_name IS [NOT] {NUMERIC | ALPHABETIC}  
         4. Condition name test: 
         condition_name 
         

           1          2         3         4         5         6         7        8
123456 7 8901 23456789012345678901234567890123456789012345678901234567890123 34567890
       PERFORM statements: 
         Simple PERFORM: 
       PERFORM procedure_name [THRU procedure_name] 
         PERFORM...VARYING...UNTIL statement: 
       PERFORM procedure_name [THRU procedure_name] 
         VARYING data_name FROM {literal|data_name} 
          BY {literal|data_name} UNTIL condition 
         AFTER data_name FROM {literal|data_name} 
          BY {literal|data_name} UNTIL condition 
         PERFORM...UNTIL statement: 
       PERFORM procedure_name [THRU procedure_name] 
         UNTIL condition 
         PERFORM...TIMES statement: 
       PERFORM procedure_name [THRU procedure_name]  
          {integer | data_name} TIMES 
   procedure_name. 
         ... 
   procedure_name. 
       EXIT. 
          
       GO TO procedure_name. 
         GO TO list_of_procedure_names DEPENDING ON data_name. 
         ALTER procedure_name TO PROCEED TO procedure_name 
   procedure_name. 
       GO TO procedure_name. 
       MOVE {data_name | literal} TO list_of_data_names 
       MOVE CORRESPONDING data_name TO data_names.F only.
       READ file_name [RECORD] [INTO data_name] 
         {[AT] END|INVALID [KEY]} sequence_of_imperative statements. 
       WRITE record_name [FROM data_name]  
         [{INVALID [KEY] sequence_of_imperative_statements |  
         AFTER [ADVANCING] {data_name | integer} LINES}] 
       REWRITE record_name [FROM data_name] 
         [INVALID [KEY] sequence_of_imperative_statements] 
       OPEN  
         {[INPUT] file_name [[WITH] NO REWIND] [REVERSED] | 
         [OUTPUT] file_name [[WITH] NO REWIND] | 
         [I-O] file_name])  
         [{[INPUT] file_name [[WITH] NO REWIND] [REVERSED] | 
         [OUTPUT] file_name [[WITH] NO REWIND] | 
         [I-O] file_name]) ....] etc.  
       CLOSE file_name [{REEL | UNIT}] [[with] {NO REWIND|LOCK}] 
         [file_name etc...] 
       ACCEPT data_name [FROM {mnemonic_name (F only) | CONSOLE}] 
       DISPLAY list_of_literals and/or data_names  
         [UPON {mnemonic_name | CONSOLE | SYSPUNCH}] 
       STOP literal 
       STOP RUN 
       NOTE explanatory_remarks 
       INITIATE {ALL | list_of_report_names}F only.
       GENERATE {report_name | report_group_name}F only.
       TERMINATE {ALL | list_of_report_names}F only.
       release RECORD_NAME 
       SORT sort_file_name {DESCENDING | ASCENDING} data_nameF only.
         ...[{DESCENDING | ASCENDING} data_name]... 
         ...{USING filename | INPUT PROCEDURE section_name} 
         {GIVING file_name | OUTPUT PRECEDURE section_name} 
       RERUN record_name [AT] END sequence_of_imperative_statements.F only.
       EXAMINE data_name 
         {TALLYING {ALL | LEADING | UNTIL FIRST} 'any_character' 
          [REPLACING BY 'any_character'] | 
          REPLACING {ALL | LEADING | UNTIL FIRST | FIRST} 
          'any_character' BY 'any_character'} 
       TRANSFORM data_name [CHARACTERS] FROM 
         {figurative_constant | non-numeric_literal | data_name} TO 
         {figurative_constant | non-numeric_literal | data_name}. 
       ENTER LINKAGE. 
       CALL entry_name [USING list_of_data_names]. 
       ENTER COBOL. 
          
       ENTER LINKAGE.*
       RETURN.*
       ENTER COBOL.*
          
          

* all subprograms except the control subprogram.