PROCEDURE DIVISION Syntax

=======================================================================

PROCEDURE DIVISION Syntax

=======================================================================

PROCEDURE DIVISION  
~~~~~~~~~ ~~~~~~~~   
    [ { USING Subprogram-Argument... | CHAINING Main-Program-Argument... ] 
        ~~~~~                           ~~~~~~~~                       
    [ RETURNING identifier-1 ] .
      ~~~~~~~~~

   [ DECLARATIVES.                 
     ~~~~~~~~~~~~                   
     [ Event-Handler-Routine... . ]  
             
     END DECLARATIVES. ]
     ~~~ ~~~~~~~~~~~~

   [ [ Section-name1 SECTION. ]             
                     ~~~~~~~               
     [ [ paragraph-name-1.  ]       
       [ procedural-sentence-1 ]... . 
                                    ]... 
                                        ]...

 [ Nested-Subprogram... ]

[ END PROGRAM | FUNCTION name-1. ]
  ~~~ ~~~~~~~   ~~~~~~~~

=======================================================================

PROCEDURE DIVISION Subprogram-Argument Syntax

=======================================================================

 [ BY { REFERENCE [ OPTIONAL ]                       } ] identifier-1
      { ~~~~~~~~~   ~~~~~~~~                         }
      { VALUE [ [ UNSIGNED ] SIZE IS { AUTO      } ] }
        ~~~~~     ~~~~~~~~   ~~~~    { ~~~~      }
                                     { DEFAULT   }
                                     { ~~~~~~~   }
                                     { integer-1 }

=======================================================================

PROCEDURE DIVISION Main-Program-Argument Syntax

=======================================================================

 [ BY REFERENCE ] [ OPTIONAL ] identifier-1
      ~~~~~~~~~     ~~~~~~~~

=======================================================================

PROCEDURE DIVISION RETURNING Syntax

=======================================================================

 RETURNING { identifier-1 }
 ~~~~~~~~~ { OMITTED      }
             ~~~~~~~

=======================================================================

DECLARATIVES Syntax

=======================================================================

[ DECLARATIVES.                                          
  ~~~~~~~~~~~~                                           
                                                         
  { section-name-1 SECTION.                              
                   ~~~~~~~                               
    USE statement.                        
    ~~~                                                    
    [ sentence-1 ]...                        
    [ paragraph-name-1. [ sentence-2 ]... ]... }...                  
                                                         
 END DECLARATIVES.                                   ]
 ~~~ ~~~~~~~~~~~~                                      

Where the USE statement can be one of 4 following formats:
 1.FILE EXCEPTIONS procedures,
 2.DEBUGGING procedures,
 3.REPORTING procedures to be executed before the printing of the designated
   Report Group,
 4.EXCEPTION CONDITIONS procedures to be executed after detection of exception
   conditions.

USE { [ GLOBAL ] AFTER STANDARD { EXCEPTION } PROCEDURE ON { INPUT            } }
~~~ {   ~~~~~~                  { ~~~~~~~~~ }              { ~~~~~            } }
    {                           { ERROR     }              { OUTPUT           } }
    {                             ~~~~~                    { ~~~~~~           } }
    {                                                      { I-O              } }
    {                                                      { ~~~              } }
    {                                                      { EXTEND           } }
    {                                                      { ~~~~~~           } }
    {                                                      { {file-name-1 }...} }
    {                                                                           }
    {                                                                           }
    { FOR DEBUGGING ON { procedure-name-1           }                           }
    {     ~~~~~~~~~    { ALL PROCEDURES             }                           }
    {                  { ~~~ ~~~~~~~~~~             }                           }
    {                  { REFERENCES OF identifier-1 }                           }
    {                                                                           }
    { [ GLOBAL ] BEFORE REPORTING identifier-2                                  }
    {  ~~~~~~    ~~~~~~ ~~~~~~~~~                                               }
    {                                                                           }
    { AFTER {EC|EXCEPTION CONDITION} {exception-name-1                        } }
    {        ~~ ~~~~~~~~~ ~~~~~~~~~  {exception-name-2 {FILE file-name-2}...} } }
                                                        ~~~~                   

The AFTER EXCEPTION CONDITION and AFTER EC clauses are syntactically recognized but are otherwise non-functional.

=======================================================================

LENGTH OF Syntax

=======================================================================

 LENGTH OF numeric-literal-1 | identifier-1
 ~~~~~~

=======================================================================

Reference Modifier (Format 1) Syntax

=======================================================================

 identifier-1 [ OF|IN identifier-2 ] [ (subscript...) ] (start:[ length ])
                ~~ ~~

=======================================================================

Reference Modifier (Format 2) Syntax

=======================================================================

 intrinsic-function-reference (start:[ length ])

=======================================================================

Arithmetic-Expression Syntax

=======================================================================

 Unary-Expression-1 { **   } Unary-Expression-2
                    {  *|/ }
                    {  +|- }

=======================================================================

Unary-Expression Syntax

=======================================================================

 { [ +|- ] { ( Arithmetic-Expression-1 )          } }
 {         { [ LENGTH OF ] { identifier-1       } } }
 {         {   ~~~~~~ ~~   { literal-1          } } }
 {         {               { Function-Reference } } }
 { Arithmetic-Expression-2                          }

=======================================================================

Class-Condition Syntax

=======================================================================

 identifier-1 IS [ NOT ] { NUMERIC          }
                   ~~~   { ~~~~~~~          }
                         { ALPHABETIC       }
                         { ~~~~~~~~~~       }
                         { ALPHABETIC-LOWER }
                         { ~~~~~~~~~~~~~~~~ }
                         { ALPHABETIC-UPPER }
                         { ~~~~~~~~~~~~~~~~ }
                         { OMITTED          }
                         { ~~~~~~~          }
                         { class-name-1     }

=======================================================================

Sign-Condition Syntax

=======================================================================

 identifier-1 IS [ NOT ] { POSITIVE }
                   ~~~   { ~~~~~~~~ }
                         { NEGATIVE }
                         { ~~~~~~~~ }
                         { ZERO     }
                           ~~~~

=======================================================================

Relation-Condition Syntax

=======================================================================

 { identifier-1            } IS [ NOT ] RelOp { identifier-2            }
 { literal-1               }      ~~~         { literal-2               }
 { arithmetic-expression-1 }                  { arithmetic-expression-2 }
 { index-name-1            }                  { index-name-2            }

=======================================================================

Boolean-Expression Syntax

=======================================================================

 General Boolean-Expression Syntax

 [ Operand-1 ] { Boolean-Operator } Operand-2

   B-NOT operand-3

 Boolean Operators         Meaning
 B-SHIFT-L                 LEFT operation
 B-SHIFT-LC                Circular Shift Left operation
 B-SHIFT-R                 Shift Right operation
 B-SHIFT-RC                Circular Shift Right operation

 Binary boolean operators  Meaning
 B-AND                     AND operation (boolean conjunction)
 B-OR                      Inclusive OR operation (boolean inclusive disjunction)
 B-XOR                     Exclusive OR operation (boolean exclusive disjunction)

 Unary boolean operator   Meaning
 B-NOT                    Negation operation

=======================================================================

RelOp Syntax

=======================================================================

 { EQUALS TO                 }
 { ~~~~~                     }
 { GREATER THAN              }
 { ~~~~~~~                   }
 { GREATER THAN OR EQUALS TO }
 { ~~~~~~~      ~~ ~~~~~     }
 { LESS THAN                 }
 { ~~~~                      }
 { LESS THAN OR EQUALS TO    }
 { ~~~~      ~~ ~~~~~        }
 { =                         }
 { >                         }
 { >=                        }
 { <                         }
 { <=                        }
 { <>                        }

=======================================================================

Combined Condition Syntax

=======================================================================

   Condition-1  { AND | OR }  Condition-2  
                  ~~~   ~~

=======================================================================

Negated Condition Syntax

=======================================================================

 NOT Condition-1
 ~~~

=======================================================================

ACCEPT FROM CONSOLE Syntax

=======================================================================

  ACCEPT identifier-1  [ FROM mnemonic-name-1 ]  [ END-ACCEPT ]
  ~~~~~~                 ~~~~                      ~~~~~~~~~~

=======================================================================

ACCEPT FROM COMMAND-LINE Syntax

=======================================================================

ACCEPT identifier-1 
~~~~~~              
       FROM { COMMAND-LINE                                                      } 
       ~~~~ { ~~~~~~~~~~~~                                                      }  
            { ARGUMENT-NUMBER                                                   }
            { ~~~~~~~~~~~~~~~                                                   }
            { ARGUMENT-VALUE [ ON EXCEPTION|ESCAPE imperative-statement-1 ]     }  
            { ~~~~~~~~~~~~~~      ~~~~~~~~~ ~~~~~~                              }
            {                [ NOT ON EXCEPTION|ESCAPE imperative-statement-2 ] }
                               ~~~    ~~~~~~~~~ ~~~~~~
[ END-ACCEPT ]
  ~~~~~~~~~~

=======================================================================

ACCEPT FROM ENVIRONMENT Syntax

=======================================================================

 ACCEPT identifier-1 FROM { ENVIRONMENT { literal-1    } }
 ~~~~~~              ~~~~ { ~~~~~~~~~~~ { identifier-1 } }
                          {                              }
                          { ENVIRONMENT-VALUE            }
                            ~~~~~~~~~~~~~~~~~             

     [ ON EXCEPTION|ESCAPE imperative-statement-1 ]
          ~~~~~~~~~ ~~~~~~
     [ NOT ON EXCEPTION|ESCAPE imperative-statement-2 ]
       ~~~    ~~~~~~~~~ ~~~~~~
 [ END-ACCEPT ]
   ~~~~~~~~~~

=======================================================================

ACCEPT Data-Item Syntax

=======================================================================

ACCEPT { identifier-1 }  [ FROM CRT ] [ MODE IS BLOCK ]
~~~~~~ { OMITTED      }    ~~~~ ~~~     ~~~~    ~~~~~
         ~~~~~~~

       [ { | AT LINE            NUMBER { integer-1               } | } ]
       [ { |    ~~~~                   { identifier-2            } | } ]
       [ { |                           { arithmetic-expression-1 } | } ]
       [ { |                                                       | } ]
       [ { | AT COLUMN|POSITION NUMBER { integer-2               } | } ]
       [ { |    ~~~    ~~~             { identifier-3            } | } ]
       [ { |                           { arithmetic-expression-2 } | } ]
       [ {                                                           } ]
       [ { AT { integer-3    }                                       } ]
       [ { ~~ { identifier-4 }                                       } ]

       [ WITH AUTO|AUTO-SKIP|AUTOTERMINATE|TAB ]
              ~~~~ ~~~~~~~~~ ~~~~~~~~~~~~~ ~~~
       [ WITH [ NO ] BELL|BEEP ]
                ~~   ~~~~ ~~~~
       [ WITH PROMPT [ CHARACTER IS literal-2|identifier-5 ] ]
              ~~~~~~   ~~~~~~~~~
       [ WITH BACKGROUND-COLOR|BACKGROUND-COLOUR IS integer-4|identifier-6 ]
              ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~
       [ WITH FOREGROUND-COLOR|FOREGROUND-COLOUR IS integer-5|identifier-7 ]
              ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~
       [ WITH HIGHLIGHT|LOWLIGHT ]
              ~~~~~~~~~ ~~~~~~~~     
       [ WITH BLINK ] 
              ~~~~~ 
       [ WITH REVERSE-VIDEO|REVERSE|REVERSED ]
              ~~~~~~~~~~~~~ ~~~~~~~ ~~~~~~~~
       [ WITH LEFTLINE ] 
              ~~~~~~~~  
       [ WITH OVERLINE ] 
              ~~~~~~~~         
       [ WITH UNDERLINE ] 
              ~~~~~~~~~ 
       [ WITH REQUIRED|EMPTY-CHECK ] 
              ~~~~~~~~ ~~~~~~~~~~~     
       [ WITH FULL|LENGTH-CHECK ]
              ~~~~ ~~~~~~~~~~~~ 
       [ WITH NO ECHO|NO-ECHO|OFF|SECURE ]
              ~~~~~~~ ~~~~~~~ ~~~ ~~~~~~
       [ WITH LOWER|UPPER ]
              ~~~~~ ~~~~~
       [ WITH SCROLL [ UP   ] [ { integer-6    } LINE|LINES ] ]
       [      ~~~~~~ [ ~~   ] [ { identifier-8 } ~~~~ ~~~~~ ] ]
       [             [ DOWN ]                                 ]
                       ~~~~
       [ { WITH TIMEOUT|TIME-OUT AFTER } { integer-7    } ]
       [ {      ~~~~~~~ ~~~~~~~~       } { identifier-9 } ]
       [ { BEFORE TIME                 }                  ]
                  ~~~~
       [ WITH [ NO ] UPDATE|DEFAULT ] 
                ~~   ~~~~~~ ~~~~~~~       
       [ WITH CONVERSION ] 
              ~~~~~~~~~~ 
       [ WITH CURSOR identifier-10 ]
              ~~~~~~
       [ WITH PROTECTED SIZE IS { integer-8     } ]
       [                ~~~~    { identifier-11 } ]

       [ WITH CONTROL { literal-8     } ]
       [      ~~~~~~~ { identifier-12 } ]

       [ WITH COLOUR|COLOR IS { integer-9     } ]
       [      ~~~~~~ ~~~~~    { identifier-13 } ]

    [ ON EXCEPTION|ESCAPE     imperative-statement-1 ]
         ~~~~~~~~~ ~~~~~~
    [ NOT ON EXCEPTION|ESCAPE imperative-statement-2 ]
      ~~~    ~~~~~~~~~ ~~~~~~
[ END-ACCEPT ]
  ~~~~~~~~~~

The FROM CRT, MODE IS BLOCK and CONVERSION clauses are syntactically recognized but are otherwise non-functional.

=======================================================================

ACCEPT FROM DATE/TIME Syntax

=======================================================================

ACCEPT identifier-1 FROM { DATE [ YYYYMMDD ] } [ END-ACCEPT ]
~~~~~~              ~~~~ { ~~~~   ~~~~~~~~   }   ~~~~~~~~~~
                         { DAY [ YYYYDDD ]   }
                         { ~~~   ~~~~~~~     }
                         { DAY-OF-WEEK       }
                         { ~~~~~~~~~~~       }
                         { TIME              }
                         { ~~~~              }
                         { MICROSECOND-TIME  }
                           ~~~~~~~~~~~~~~~~   

=======================================================================

ACCEPT FROM Screen-Info Syntax

=======================================================================

ACCEPT identifier-1 FROM { LINES|LINE-NUMBER } [ END-ACCEPT ]
~~~~~~              ~~~~ { ~~~~~ ~~~~~~~~~~~ }   ~~~~~~~~~~
                         { COLS|COLUMNS      }
                         { ~~~~ ~~~~~~~      }
                         { ESCAPE KEY        }
                           ~~~~~~ ~~~

=======================================================================

ACCEPT FROM Runtime-Info Syntax

=======================================================================

ACCEPT identifier-1 FROM { EXCEPTION STATUS } [ END-ACCEPT ]
~~~~~~              ~~~~ { ~~~~~~~~~ ~~~~~~ }   ~~~~~~~~~~
                         { USER NAME        }
                           ~~~~ ~~~~

=======================================================================

ACCEPT OMITTED Syntax

=======================================================================

   ACCEPT OMITTED
   ~~~~~~

   1.  For console : See 6.17.1.1 (ACCEPT FROM CONSOLE Syntax)

   2.  For Screen  : See 6.17.1.4 (ACCEPT screen-data-item Syntax)

 [ END-ACCEPT ]
   ~~~~~~~~~~

=======================================================================

ADD TO Syntax

=======================================================================

ADD { identifier-1 }... TO { identifier-2 [ rounded-phrase ] }...
~~~ { literal-1    }     ~~ 

     [ ON SIZE ERROR imperative-statement-1 ]
          ~~~~ ~~~~~
     [ NOT ON SIZE ERROR imperative-statement-2 ]
       ~~~    ~~~~ ~~~~~
[ END-ADD ] 
  ~~~~~~~

=======================================================================

ADD GIVING Syntax

=======================================================================

ADD { identifier-1 }... [ TO { identifier-2 } ] 
~~~ { literal-1    }          { literal-2    }  

         GIVING { identifier-3 [ rounded-phrase ] }...
         ~~~~~~                  

   [ ON SIZE ERROR imperative-statement-1 ]
        ~~~~ ~~~~~
   [ NOT ON SIZE ERROR imperative-statement-2 ]
     ~~~    ~~~~ ~~~~~
[ END-ADD ]
  ~~~~~~~

=======================================================================

ADD CORRESPONDING Syntax

=======================================================================

ADD CORRESPONDING identifier-1 TO identifier-2 [ rounded-phrase ]
~~~ ~~~~                       ~~   

     [ ON SIZE ERROR imperative-statement-1 ]
          ~~~~ ~~~~~
     [ NOT ON SIZE ERROR imperative-statement-2 ]
       ~~~    ~~~~ ~~~~~
[ END-ADD ]
  ~~~~~~~

=======================================================================

ALLOCATE Syntax

=======================================================================

Format 1. Allocate a "BASED" item.

ALLOCATE identifier-1
~~~~~~~~
         [ { INITIALIZED } ]  [ RETURNING identifier-3 ]
           { ~~~~~~~~~~~ }      ~~~~~~~~~
           { INITIALISED }  
             ~~~~~~~~~~~    


Format 2. Allocate a memory block.

ALLOCATE { literal-1               } CHARACTERS
~~~~~~~~ { identifier-2            } ~~~~~~~~~~
         { arithmetic-expression-1 }

         [ { INITIALIZED } [ TO { literal-1    } ] ] RETURNING identifier-3
           { ~~~~~~~~~~~ } [ ~~ { identifier-2 } ]   ~~~~~~~~~
           { INITIALISED }        
             ~~~~~~~~~~~                          

=======================================================================

ALTER Syntax

=======================================================================

 ALTER { procedure-name-1 TO PROCEED TO procedure-name-2 }...
 ~~~~~                    ~~

=======================================================================

CALL Syntax

=======================================================================

CALL [ { STATIC          } ] [ WITH { STDCALL } LINKAGE ] { literal-1    }
~~~~   { ~~~~~~          }     ~~~~ { ~~~~~~~ } ~~~~~~~   { identifier-1 }
       { STDCALL         }          { C       }          
       { ~~~~~~~         }          { ~       }          
       { C               }          { PASCAL  }          
       { ~               }           ~~~~~~            
       { PASCAL          }  
       { ~~~~~~          }  
       { EXTERN          }  
       { ~~~~~~          }  
       { mnemonic-name-1 }  

     [ USING { [ BY { REFERENCE } ]  
       ~~~~~ {      { ~~~~~~~~~ }      
             {      { CONTENT   }      
             {      { ~~~~~~~   }    
             {      { VALUE     }    
                      ~~~~~              
                                     
     { [ UNSIGNED SIZE IS { AUTO      } ] { literal-2    }... } }... ]
     {            ~~~~    { ~~~~      }   { identifier-2 }     } }    
     {                    { integer-1 }                        } }   
     {                                                         } }     
     { OMITTED                                                 } }    
                                                                        
     [ RETURNING|GIVING { INTO identifier-3       } ]
       ~~~~~~~~~ ~~~~~~ { ADDRESS OF identifier-4 }  
                        { ~~~~~~~                 }  
                        { NOTHING                 }  
                        { ~~~~~~~                 }  
                        { NULL                    }  
                        { ~~~~                    }  
                        { OMITTED                 }  
                          ~~~~~~~                   

     [ ON OVERFLOW|EXCEPTION imperative-statement-1 ]
          ~~~~~~~~ ~~~~~~~~~
     [ NOT ON EXCEPTION imperative-statement-2 ]
       ~~~    ~~~~~~~~~
[ END-CALL ]
  ~~~~~~~~

=======================================================================

CANCEL Syntax

=======================================================================

 CANCEL { literal-1    }...
 ~~~~~~ { identifier-1 }

=======================================================================

CLOSE Syntax

=======================================================================

 CLOSE { file-name-1 [ { REEL|UNIT [ FOR REMOVAL ] } ] }...
 ~~~~~                 { ~~~~ ~~~~       ~~~~~~~   }
                       { WITH LOCK                 }
                       {      ~~~~                 }
                       { WITH NO REWIND            }
                              ~~ ~~~~~~

The REEL, LOCK and NO REWIND clauses are syntactically recognized but are otherwise non-functional, except for the CLOSE…NO REWIND statement, which will generate a file status of 07 rather than the usual 00 (but take no other action).

=======================================================================

COMMIT Syntax

=======================================================================

 COMMIT
 ~~~~~~

=======================================================================

COMPUTE Syntax

=======================================================================

COMPUTE { identifier-1 [ rounded-phrase ] }...
~~~~~~~                 
          =|EQUALS arithmetic-expression-1|boolean-expression-1
           ~~~~~
   [ ON SIZE ERROR imperative-statement-1 ]
        ~~~~ ~~~~~
   [ NOT ON SIZE ERROR imperative-statement-2 ]
     ~~~    ~~~~ ~~~~~
[ END-COMPUTE ]
  ~~~~~~~~~~~

=======================================================================

CONTINUE Syntax

=======================================================================

 CONTINUE [ AFTER { literal-1               } SECONDS ]
 ~~~~~~~~   ~~~~~ { identifier-1            } ~~~~~~~   
                  { arithmetic-expression-1 }  

=======================================================================

DELETE Syntax

=======================================================================

Format 1

   DELETE file-name-1 RECORD
   ~~~~~~
      [ INVALID KEY imperative-statement-1 ]
        ~~~~~~~
      [ NOT INVALID KEY imperative-statement-2 ]
        ~~~ ~~~~~~~
 [ END-DELETE ]
   ~~~~~~~~~~


Format 2

   DELETE FILE { file-name-1 }...
   ~~~~~~ ~~~~
      [ ON EXCEPTION imperative-statement-1 ]
           ~~~~~~~~~
      [ NOT ON EXCEPTION imperative-statement-2 ]
        ~~~    ~~~~~~~~~
 [ END-DELETE ]
   ~~~~~~~~~~

=======================================================================

DISPLAY UPON Device Syntax

=======================================================================

DISPLAY { literal-1    }... [ UPON mnemonic-name-1 ] [ WITH NO ADVANCING ]
~~~~~~~ { identifier-1 }       ~~~~                          ~~ ~~~~~~~~~

      [ ON EXCEPTION imperative-statement-1 ]
           ~~~~~~~~~
      [ NOT ON EXCEPTION imperative-statement-2 ]
        ~~~    ~~~~~~~~~
[ END-DISPLAY ]
  ~~~~~~~~~~~

=======================================================================

DISPLAY UPON COMMAND-LINE Syntax

=======================================================================

 DISPLAY { literal-1    } UPON { ARGUMENT-NUMBER | COMMAND-LINE }
 ~~~~~~~ { identifier-1 } ~~~~   ~~~~~~~~~~~~~~~   ~~~~~~~~~~~~

      [ ON EXCEPTION imperative-statement-1 ]
           ~~~~~~~~~
      [ NOT ON EXCEPTION imperative-statement-2 ]
        ~~~    ~~~~~~~~~
 [ END-DISPLAY ]
   ~~~~~~~~~~~

=======================================================================

DISPLAY UPON ENVIRONMENT-NAME Syntax

=======================================================================

 DISPLAY { literal-1    } UPON { ENVIRONMENT-VALUE }
 ~~~~~~~ { identifier-1 } ~~~~ { ~~~~~~~~~~~~~~~~~ }
                               { ENVIRONMENT-NAME  }
                                 ~~~~~~~~~~~~~~~~
      [ ON EXCEPTION imperative-statement-1 ]
           ~~~~~~~~~
      [ NOT ON EXCEPTION imperative-statement-2 ]
        ~~~    ~~~~~~~~~
 [ END-DISPLAY ]
   ~~~~~~~~~~~

=======================================================================

DISPLAY Data-Item Syntax

=======================================================================

DISPLAY { { identifier-1 }   [ UPON CRT|CRT-UNDER ]   [ MODE IS BLOCK ]
~~~~~~~   { literal-1    }     ~~~~ ~~~ ~~~~~~~~~       ~~~~    ~~~~~

          [ { | AT LINE            NUMBER { integer-1               } | } ]
          [ { |    ~~~~                   { identifier-2            } | } ]
          [ { |                           { arithmetic-expression-1 } | } ]
          [ { |                                                       | } ]
          [ { | AT COLUMN|POSITION NUMBER { integer-2               } | } ]
          [ { |    ~~~    ~~~             { identifier-3            } | } ]
          [ { |                           { arithmetic-expression-2 } | } ]
          [ {                                                           } ]
          [ { AT { integer-3    }                                       } ]
          [ { ~~ { identifier-4 }                                       } ]

          [ WITH BELL|BEEP ]
                 ~~~~ ~~~~
          [ WITH BLANK { LINE|SCREEN } ]
                 ~~~~~   ~~~~ ~~~~~~
          [ WITH ERASE { EOL|EOS                   } ]
          [      ~~~~~ { ~~~ ~~~                   } ]
          [            { [ TO END OF ] LINE|SCREEN } ]
                              ~~~      ~~~~ ~~~~~~
          [ WITH BACKGROUND-COLOR|BACKGROUND-COLOUR IS|= integer-4|identifier-5 ]
                 ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~
          [ WITH FOREGROUND-COLOR|FOREGROUND-COLOUR IS|= integer-5|identifier-6 ]
                 ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~
          [ WITH HIGHLIGHT|LOWLIGHT ]  
                 ~~~~~~~~~ ~~~~~~~~           
          [ WITH BLINK ]
                 ~~~~~
          [ WITH REVERSE-VIDEO|REVERSE|REVERSED ]
                 ~~~~~~~~~~~~~ ~~~~~~~ ~~~~~~~~
          [ WITH OVERLINE ] 
                 ~~~~~~~~         
          [ WITH UNDERLINE ] 
                 ~~~~~~~~~ 
          [ WITH SCROLL [ UP   ] [ { integer-6    } LINE|LINES ] ]
          [      ~~~~~~ [ ~~   ] [ { identifier-9 } ~~~~ ~~~~~ ] ]
          [             [ DOWN ]                                 ]
                          ~~~~
          [ WITH CONVERSION ]
                 ~~~~~~~~~~
          [ WITH SIZE IS  { integer-7    } ]
          [      ~~~~     { identifier-8 } ]

          [ WITH CONTROL  { literal-7    } ]
          [      ~~~~~~~  { identifier-7 } ]

          [ WITH COLOUR|COLOR IS { integer-8     } ]
          [      ~~~~~~ ~~~~~    { identifier-10 } ]  }...

      [ ON EXCEPTION     imperative-statement-1 ]
           ~~~~~~~~~
      [ NOT ON EXCEPTION imperative-statement-2 ]
        ~~~    ~~~~~~~~~
[ END-DISPLAY ]
  ~~~~~~~~~~~

The UPON CRT, UPON CRT-UNDER and CONVERSION clauses are syntactically recognized but are otherwise non-functional. They are supported to provide compatibility with COBOL source written for other COBOL implementations.

=======================================================================

DISPLAY data-item (Microsoft format) Syntax

=======================================================================

DISPLAY { position-spec { identifier-1 }... }
~~~~~~~ {               { literal-1    }     }
        {               { ERASE        }     }
        {                 ~~~~~              }
        { ERASE                              }
          ~~~~~                             

        [ WITH [ BELL|BEEP ]
          ~~~~   ~~~~ ~~~~
               [ BLANK LINE|SCREEN ]
                 ~~~~~ ~~~~ ~~~~~~
               [ ERASE { EOL|EOS                   } ]
               [ ~~~~~ { ~~~ ~~~                   } ]
               [       { [ TO END OF ] LINE|SCREEN } ]
                              ~~~      ~~~~ ~~~~~~
               [ BACKGROUND-COLOR|BACKGROUND-COLOUR IS|= integer-4|identifier-5 ]
                 ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~
               [ FOREGROUND-COLOR|FOREGROUND-COLOUR IS|= integer-5|identifier-6 ]
                 ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~
               [ HIGHLIGHT|LOWLIGHT ]
                 ~~~~~~~~~ ~~~~~~~~
               [ BLINK ]
                 ~~~~~
               [ REVERSE-VIDEO|REVERSE|REVERSED ]
                 ~~~~~~~~~~~~~ ~~~~~~~ ~~~~~~~~
               [ OVERLINE ]
                 ~~~~~~~~
               [ UNDERLINE ]
                 ~~~~~~~~~
               [ SCROLL [ UP   ] [ { integer-6    } LINE|LINES ] ]
               [ ~~~~~~ [ ~~   ] [ { identifier-9 } ~~~~ ~~~~~ ] ]
               [        [ DOWN ]                                 ]
                          ~~~~
               [ CONVERSION ]
                 ~~~~~~~~~~
               [ SIZE IS  { integer-7    } ]
               [ ~~~~     { identifier-8 } ]

               [ CONTROL  { literal-7    } ]
               [ ~~~~~~~  { identifier-7 } ]

               [ COLOUR|COLOR IS { integer-8     } ]
               [ ~~~~~~ ~~~~~    { identifier-10 } ]   ] 

[ END-DISPLAY ]
  ~~~~~~~~~~~

     where  position-spec is

     { (position-spec-num, position-spec-num) }
     { (,position-spec-num)                   }
     { (position-spec-num,)                   }

     where  position-spec-num  is

     { identifier-11 } [ +|- integer-10 ]
     { integer-9     } 

=======================================================================

DIVIDE INTO Syntax

=======================================================================

DIVIDE { literal-1    } INTO { identifier-2 [ rounded-phrase ] }... 
~~~~~~ { identifier-1 } ~~~~ 

    [ ON SIZE ERROR imperative-statement-1 ]
         ~~~~ ~~~~~
    [ NOT ON SIZE ERROR imperative-statement-2 ]
      ~~~    ~~~~ ~~~~~
[ END-DIVIDE ]
  ~~~~~~~~~~

For further clarification, the following examples are provided to be used with the various flavours of the DIVIDE statement when using BY, INTO and GIVING.

--------------------------------------+---+-----+--------------+-------------------+
DIVIDE Operation                      | A |  B  |      C       |         D         |
--------------------------------------+---+-----+--------------+-------------------+
DIVIDE A INTO B                       | A | B/A |              |                   |
--------------------------------------+---+-----+--------------+-------------------+
DIVIDE A INTO B GIVING C              | A |  B  |     B/A      |                   |
--------------------------------------+---+-----+--------------+-------------------+
DIVIDE A INTO B GIVING C REMAINDER D  | A |  B  | Integer(B/A) | Integer remainder |
--------------------------------------+---+-----+--------------+-------------------+
DIVIDE A BY   B GIVING C              | A |  B  |     A/B      |                   |
--------------------------------------+---+-----+--------------+-------------------+
DIVIDE A BY   B GIVING C REMAINDER D  | A |  B  | Integer(A/B) | Integer remainder |
--------------------------------------+---+-----+--------------+-------------------+

=======================================================================

DIVIDE INTO GIVING Syntax

=======================================================================

DIVIDE { literal-1    } INTO { literal-2    }  
~~~~~~ { identifier-1 } ~~~~ { identifier-2 }  
  
         GIVING { identifier-3 [ rounded-phrase ] }...
         ~~~~~~ 
  
       [ REMAINDER identifier-4 [ rounded-phrase ] ]
         ~~~~~~~~~                  

  [ ON SIZE ERROR imperative-statement-1 ]
       ~~~~ ~~~~~
  [ NOT ON SIZE ERROR imperative-statement-2 ]
    ~~~    ~~~~ ~~~~~
[ END-DIVIDE ]
  ~~~~~~~~~~ 

=======================================================================

DIVIDE BY GIVING Syntax

=======================================================================

DIVIDE { literal-1    } BY { literal-2    }  
~~~~~~ { identifier-1 } ~~ { identifier-2 }  

         GIVING { identifier-3   [ rounded-phrase ] }...
         ~~~~~~               
  
       [ REMAINDER identifier-4 [ rounded-phrase ] ]
         ~~~~~~~~~                

  [ ON SIZE ERROR imperative-statement-1 ]
       ~~~~ ~~~~~
  [ NOT ON SIZE ERROR imperative-statement-2 ]
    ~~~    ~~~~ ~~~~~
[ END-DIVIDE ]
  ~~~~~~~~~~ 

=======================================================================

ENTRY Syntax

=======================================================================

ENTRY [ { STATIC          } ] [ WITH { STDCALL } LINKAGE ] literal-1   
~~~~~   { ~~~~~~          }     ~~~~ { ~~~~~~~ } ~~~~~~~   
        { STDCALL         }          { C       }          
        { ~~~~~~~         }          { ~       }          
        { C               }          { PASCAL  }          
        { ~               }           ~~~~~~            
        { PASCAL          }  
        { ~~~~~~          }  
        { EXTERN          }  
        { ~~~~~~          }  
        { mnemonic-name-1 }  

      [ USING  { [ BY { REFERENCE } ] { identifier-1 }... }... ] 
        ~~~~~         { ~~~~~~~~~ }         
                      { VALUE     }    
                        ~~~~~              


 Format 2 (Special purpose and for GO TO )

 ENTRY FOR GO TO literal-2
 ~~~~~ ~~~ ~~ ~~

 Note for Fixed format sources, this statement must only be used in area B.

=======================================================================

EVALUATE Syntax

=======================================================================

   EVALUATE Selection-Subject-1 [ ALSO Selection-Subject-2 ]...
   ~~~~~~~~                       ~~~~
    { WHEN Selection-Object-1 [ ALSO Selection-Object-2 ]...
      ~~~~                      ~~~~
           [ imperative-statement-1 ] }...
    [ WHEN OTHER
      ~~~~ ~~~~~
             imperative-statement-other ]

 [ END-EVALUATE ]
   ~~~~~~~~~~~~

=======================================================================

EVALUATE Selection Subject Syntax

=======================================================================

 { TRUE         }
 { ~~~~         }
 { FALSE        }
 { ~~~~~        }
 { expression-1 }
 { identifier-1 }
 { literal-1    }

=======================================================================

EVALUATE Selection Object Syntax

=======================================================================

 { ANY                                                }
 { ~~~                                                }
 { TRUE                                               }
 { ~~~~                                               }
 { FALSE                                              }
 { ~~~~~                                              }
 { partial-expression-1                               }
 {                                                    }
 { { expression-2 } [ THRU|THROUGH { expression-3 } ] }
 { { identifier-2 }   ~~~~ ~~~~~~~ { identifier-3 }   }
 { { literal-2    }                { literal-3    }   }

=======================================================================

EXAMINE Syntax

=======================================================================

EXAMINE identifier-1
~~~~~~~
     { TALLYING  { ALL          } literal-1 [ REPLACING BY literal-2 ] }
     { ~~~~~~~~  { ~~~          }             ~~~~~~~~~ ~~             }
     {           { LEADING      }                                      }
     {           { ~~~~~~~      }                                      }
     {           { UNTIL FIRST  }                                      }
     {             ~~~~~ ~~~~~                                         }
     {                                                                 }
     { REPLACING { ALL             } literal-3 BY literal-4            }
     { ~~~~~~~~~ { ~~~             }           ~~                      }
     {           { LEADING         }                                   }
     {           { ~~~~~~~         }                                   }
     {           { [ UNTIL ] FIRST }                                   }
                     ~~~~~   ~~~~~                                       

=======================================================================

EXHIBIT Syntax

=======================================================================

 EXHIBIT [CHANGED][NAMED] [position-spec] [ERASE] {identifier-1 | literal-1} ...
 ~~~~~~~  ~~~~~~~  ~~~~~                   ~~~~~
         [UPON mnemonic-name-1]
          ~~~~

 where position-spec is

   {(position-spec-num, position-spec-num)}
   {(, position-spec-num)                 }
   {(position-spec-num, )                 }

 where position-spec-num is

   {identifier-2} [{+} integer-2]
   {integer-1   } [{-}          ]

=======================================================================

EXIT Syntax

=======================================================================

 EXIT  [ { PROGRAM  [ RETURNING|GIVING { identifier-1 } ] } ]
 ~~~~    { ~~~~~~~~   ~~~~~~~~~ ~~~~~~ { literal-1    }   } 
         {                                                }
         {                                                }               
         { FUNCTION                                       }
         { ~~~~~~~~                                       }       
         {                                                }    
         { PERFORM [ CYCLE ]                              }                                      
         { ~~~~~~~   ~~~~~                                }                               
         {                                                } 
         { SECTION                                        }                              
         { ~~~~~~~                                        }                            
         { PARAGRAPH                                      }                                  
           ~~~~~~~~~

=======================================================================

FREE Syntax

=======================================================================

 FREE { [ ADDRESS OF ] identifier-1 }...
 ~~~~     ~~~~~~~

=======================================================================

GENERATE Syntax

=======================================================================

  GENERATE { report-name-1 }
  ~~~~~~~~ { identifier-1  }

=======================================================================

GOBACK Syntax

=======================================================================

 GOBACK [ RETURNING|GIVING { literal-1    } ]
 ~~~~~~   ~~~~~~~~~ ~~~~~~ { identifier-1 }

=======================================================================

Simple GO TO Syntax

=======================================================================

 GO TO procedure-name-1
 ~~
 
 GO TO ENTRY literal-1
 ~~    ~~~~~

=======================================================================

GO TO DEPENDING ON Syntax

=======================================================================

 GO TO {procedure-name-1}... DEPENDING ON identifier-1
 ~~                           ~~~~~~~~~
                             
 GO TO ENTRY {literal-1}... DEPENDING ON identifier-1
 ~~    ~~~~~                 ~~~~~~~~~
                              
                             

=======================================================================

IF Syntax

=======================================================================

   IF conditional-expression
   ~~
   THEN { imperative-statement-1 }
        { NEXT SENTENCE          }
          ~~~~ ~~~~~~~~
 [ ELSE { imperative-statement-2 } ]
   ~~~~ { NEXT SENTENCE          }
          ~~~~ ~~~~~~~~
 [ END-IF ]
   ~~~~~~

=======================================================================

INITIALIZE Syntax

=======================================================================

  INITIALIZE|INITIALISE identifier-1...
  ~~~~~~~~~~ ~~~~~~~~~~
      [ WITH FILLER ]
             ~~~~~~
      [ { category-name-1 } TO VALUE ]
        { ALL             }    ~~~~~
          ~~~
      [ THEN REPLACING { category-name-2 DATA BY
             ~~~~~~~~~                        ~~
            [ LENGTH OF ] { literal-1    } }... ]
              ~~~~~~      { identifier-1 }

      [ THEN TO DEFAULT ]
                ~~~~~~~

=======================================================================

INITIATE Syntax

=======================================================================

 INITIATE { report-name-1 }...
 ~~~~~~~~

=======================================================================

INSPECT Syntax

=======================================================================

 INSPECT { literal-1            }
 ~~~~~~~ { identifier-1         }
         { function-reference-1 }

  [ TALLYING { identifier-2 FOR { ALL|LEADING|TRAILING { literal-2    } }
    ~~~~~~~~                ~~~ { ~~~ ~~~~~~~ ~~~~~~~~ { identifier-3 } }
                                { CHARACTERS                            }
                                  ~~~~~~~~~~
               [ | { AFTER|BEFORE } INITIAL { literal-3    } | ] }... ]
                 |   ~~~~~ ~~~~~~           { identifier-4 } |

  [ REPLACING { { { ALL|FIRST|LEADING|TRAILING { literal-4    } }
    ~~~~~~~~~   { { ~~~ ~~~~~ ~~~~~~~ ~~~~~~~~ { identifier-5 } }
                { CHARACTERS                                    }
                { ~~~~~~~~~~                                    }

                 BY { [ ALL ] literal-5 }
                 ~~ {   ~~~             }
                    { identifier-6      }

               [ | { AFTER|BEFORE } INITIAL { literal-6    } | ] }... ]
                 |   ~~~~~ ~~~~~~           { identifier-7 } |

  [ CONVERTING { { literal-7    } TO { literal-8    }
    ~~~~~~~~~~   { identifier-8 } ~~ { identifier-9 }

               [ | { AFTER|BEFORE } INITIAL { literal-9     } | ] ]
                 |   ~~~~~ ~~~~~~           { identifier-10 } |

=======================================================================

JSON GENERATE Syntax

=======================================================================

JSON GENERATE identifier-1 FROM identifier-2
~~~~ ~~~~~~~~              ~~~~
   [ COUNT IN identifier-3 ]
     ~~~~~
   [ NAME OF {identifier-4 IS literal-1}... ]
     ~~~~
   [ SUPPRESS {identifier-5}... ]
     ~~~~~~~~
   [ ON EXCEPTION imperative-statement-1 ]
     ~~ ~~~~~~~~~
   [ NOT ON EXCEPTION imperative-statement-2 ]
     ~~~    ~~~~~~~~~
[ END-JSON ]
  ~~~~~~~~

=======================================================================

JSON PARSE Syntax

=======================================================================

   JSON PARSE identifier-1 INTO identifier-2
   ~~~~ ~~~~~              ~~~~
      [ WITH DETAIL ]
             ~~~~~~
      [ NAME OF {identifier-3 IS literal-1}... ]
        ~~~~
      [ SUPPRESS {identifier-4}... ]
        ~~~~~~~~
      [ ON EXCEPTION imperative-statement-1 ]
           ~~~~~~~~~
      [ NOT ON EXCEPTION imperative-statement-2 ]
        ~~~    ~~~~~~~~~
 [ END-JSON ]
   ~~~~~~~~

=======================================================================

MERGE Syntax

=======================================================================

MERGE sort-file-1 { ON { ASCENDING  } KEY { identifier-1 }... }...
~~~~~                  { ~~~~~~~~~  }
                       { DESCENDING }
                        ~~~~~~~~~~
   [ WITH DUPLICATES IN ORDER ]
          ~~~~~~~~~~
   [ COLLATING SEQUENCE IS alphabet-name-1 ]
               ~~~~~~~~
     USING file-name-1 { file-name-2 }...
     ~~~~~
   { GIVING { file-name-3 }...                       }
   { ~~~~~~                                                                 }
   { OUTPUT PROCEDURE IS procedure-name-1 [THRU|THROUGH procedure-name-2 ]  }
     ~~~~~~ ~~~~~~~~~                      ~~~~ ~~~~~~~

The DUPLICATES clause is syntactically recognized but is otherwise non-functional.

=======================================================================

Simple MOVE Syntax

=======================================================================

 MOVE { literal-1    } TO { identifier-2 }...
 ~~~~ { identifier-1 } ~~

=======================================================================

MOVE CORRESPONDING Syntax

=======================================================================

 MOVE CORRESPONDING identifier-1 TO { identifier-2 }...
 ~~~~ ~~~~                       ~~

=======================================================================

MULTIPLY BY Syntax

=======================================================================

MULTIPLY { literal-1    } BY { identifier-2 [ rounded-phrase ] }... 
~~~~~~~~ { identifier-1 } ~~     

  [ ON SIZE ERROR imperative-statement-1 ]
       ~~~~ ~~~~~
  [ NOT ON SIZE ERROR imperative-statement-2 ]
    ~~~    ~~~~ ~~~~~
[ END-MULTIPLY ]
  ~~~~~~~~~~~~

=======================================================================

MULTIPLY GIVING Syntax

=======================================================================

MULTIPLY { literal-1    } BY { literal-2    } 
~~~~~~~~ { identifier-1 } ~~ { identifier-2 }

           GIVING { identifier-3 [ rounded-phrase ] }...
           ~~~~~~    
  
  [ ON SIZE ERROR imperative-statement-1 ]
       ~~~~ ~~~~~
  [ NOT ON SIZE ERROR imperative-statement-2 ]
    ~~~    ~~~~ ~~~~~
[ END-MULTIPLY ]
  ~~~~~~~~~~~~

=======================================================================

NEXT SENTENCE Syntax

=======================================================================

 NEXT SENTENCE
 ~~~~ ~~~~~~~~

=======================================================================

OPEN Syntax

=======================================================================

OPEN {[ EXCLUSIVE ] { INPUT  } [sharing-mode] {file-name-1 [open-options]}... }...
~~~~                { ~~~~~  }
                    { OUTPUT }
                    { ~~~~~~ }
                    { I-O    }
                    { ~~~    }
                    { EXTEND }
                      ~~~~~~

where "sharing-mode" is:

      [ SHARING WITH { ALL OTHER } ]
      [  ~~~~~~~     { ~~~       } ]
      [              { NO OTHER  } ]
      [              { ~~        } ]
      [              { READ ONLY } ]
                       ~~~~ ~~~~    

where "open-options" are:

      [ [ WITH ] { LOCK      } ] [ WITH NO REWIND ]
      [ [ FOR  ]   ~~~~        ] [      ~~ ~~~~~~ ]
      [                        ] [ REVERSED       ]
      [ ALLOWING { ALL       } ]   ~~~~~~~~    
      [ ~~~~~~~~ { ~~~       } ] 
      [          { READERS   } ]
      [          { ~~~~~~~   } ]       
      [          { UPDATERS  } ] 
      [          { ~~~~~~~   } ] 
      [          { WRITERS   } ]
      [          { ~~~~~~~   } ]
      [          { NO OTHERS } ]
                   ~~          

The NO REWIND, and REVERSED clauses are syntactically recognized but are otherwise non-functional.

=======================================================================

Procedural PERFORM Syntax

=======================================================================

PERFORM procedure-name-1 [ THRU|THROUGH procedure-name-2 ]
~~~~~~~                    ~~~~ ~~~~~~~

    [ { { literal-1    } TIMES                                        } ]
      { { identifier-1 } ~~~~~                                        }
      {                                                               }
      { [ WITH TEST { BEFORE } ] { VARYING-Clause                   } } 
      {        ~~~~ { ~~~~~~ }   {                                  } }
      {             { AFTER  }   { UNTIL { conditional-expression-1 } }
      {               ~~~~~      { ~~~~~ { EXIT                     } }
      {                                    ~~~~                       }
      {  FOREVER                                                      }
         ~~~~~~~       

=======================================================================

Inline PERFORM Syntax

=======================================================================

PERFORM
~~~~~~~

    [ { { literal-1    } TIMES                                        } ]
      { { identifier-1 } ~~~~~                                        }
      {                                                               }
      { [ WITH TEST { BEFORE } ] { VARYING-Clause                   } } 
      {        ~~~~ { ~~~~~~ }   {                                  } }
      {             { AFTER  }   { UNTIL { conditional-expression-1 } }
      {               ~~~~~      { ~~~~~ { EXIT                     } }
      {                                    ~~~~                       }
      {  FOREVER                                                      }
         ~~~~~~~       

    imperative-statement-1

END-PERFORM
~~~~~~~~~~~

=======================================================================

VARYING Syntax

=======================================================================

 VARYING identifier-2 FROM { literal-2    } [ BY { literal-3    } ]
 ~~~~~~~              ~~~~ { identifier-3 }   ~~ { identifier-4 }
           UNTIL conditional-expression-1  
           ~~~~~
 [ AFTER identifier-5 FROM { literal-4    } [ BY { literal-5    } ]
   ~~~~~              ~~~~ { identifier-6 }   ~~ { identifier-7 }
           UNTIL conditional-expression-2   ]...
           ~~~~~

=======================================================================

Sequential READ Syntax

=======================================================================

   READ file-name-1 [ { NEXT|PREVIOUS } ] RECORD [ INTO identifier-1 ]
   ~~~~               { ~~~~ ~~~~~~~~ }            ~~~~
    [ { IGNORING LOCK    } ]
      { ~~~~~~~~ ~~~~    }
      { WITH [ NO ] LOCK }
      {        ~~   ~~~~ }
      { WITH KEPT LOCK   }
      {      ~~~~ ~~~~   }
      { WITH IGNORE LOCK }
      {      ~~~~~~ ~~~~ }
      { WITH WAIT        }
             ~~~~
    [ AT END imperative-statement-1 ]
         ~~~
    [ NOT AT END imperative-statement-2 ]
      ~~~    ~~~
 [ END-READ ]
   ~~~~~~~~

=======================================================================

Random READ Syntax

=======================================================================

   READ file-name-1 RECORD [ INTO identifier-1 ]
   ~~~~                      ~~~~
    [ { IGNORING LOCK    } ]
      { ~~~~~~~~ ~~~~    }
      { WITH [ NO ] LOCK }
      {        ~~   ~~~~ }
      { WITH KEPT LOCK   }
      {      ~~~~ ~~~~   }
      { WITH IGNORE LOCK }
      {      ~~~~~~ ~~~~ }
      { WITH WAIT        }
             ~~~~
    [ KEY IS identifier-2 ]
      ~~~
    [ INVALID KEY imperative-statement-1 ]
      ~~~~~~~
    [ NOT INVALID KEY imperative-statement-2 ]
      ~~~ ~~~~~~~
 [ END-READ ]
   ~~~~~~~~

=======================================================================

READY TRACE Syntax

=======================================================================

 READY TRACE
 ~~~~~ ~~~~~

=======================================================================

RELEASE Syntax

=======================================================================

 RELEASE record-name-1 [ FROM { literal-1    } ]
 ~~~~~~~                 ~~~~ { identifier-1 }

=======================================================================

RESET TRACE Syntax

=======================================================================

 RESET TRACE
 ~~~~~ ~~~~~

=======================================================================

RETURN Syntax

=======================================================================

   RETURN sort-file-name-1 RECORD
   ~~~~~~
    [ INTO identifier-1 ]
      ~~~~
      AT END imperative-statement-1
         ~~~
    [ NOT AT END imperative-statement-2 ]
      ~~~    ~~~
 [ END-RETURN ]
   ~~~~~~~~~~

=======================================================================

REWRITE Syntax

=======================================================================

  REWRITE { record-name-1   [ FROM { identifier-1 } ] }
  ~~~~~~~ {                 [ ~~~~ { literal-1    } ] }
          {                                           }
          { FILE file-name-1  FROM { identifier-1 }   }
          { ~~~~              ~~~~ { literal-1    }   }

      [ WITH [ NO ] LOCK ]
               ~~   ~~~~
      [ INVALID KEY imperative-statement-1 ]
        ~~~~~~~
      [ NOT INVALID KEY imperative-statement-2 ]
        ~~~ ~~~~~~~
 [ END-REWRITE ]

=======================================================================

ROLLBACK Syntax

=======================================================================

 ROLLBACK
 ~~~~~~~~

=======================================================================

SEARCH Syntax

=======================================================================

 SEARCH identifier-1 [ VARYING { identifier-2 } ]
 ~~~~~~                ~~~~~~~ { index-name-1 }
 
      [ AT END imperative-statement-1 ]
           ~~~
      { WHEN conditional-expression-1 imperative-statement-2 }...
        ~~~~

 [ END-SEARCH ]
   ~~~~~~~~~~

=======================================================================

SEARCH ALL Syntax

=======================================================================

 SEARCH ALL identifier-1
 ~~~~~~ ~~~
 
       [ AT END imperative-statement-1 ]
           ~~~
        WHEN { data-name-1 IS EQUALS|= TO { identifier-2            }  
        ~~~~ {                ~~~~~       { literal-1               }
             {                            { arithmetic-expression-1 }      
             { condition-name-1                                     }

      [ AND  { data-name-2 IS EQUALS|= TO { identifier-3            } ]...
        ~~~~ {                ~~~~~       { literal-2               }
             {                            { arithmetic-expression-2 }    
             { condition-name-2                                     }

     imperative-statement-2

 [ END-SEARCH ]
   

=======================================================================

SET ENVIRONMENT Syntax

=======================================================================

 SET ENVIRONMENT { literal-1    } TO { literal-2    }
 ~~~ ~~~~~~~~~~~ { identifier-1 } ~~ { identifier-2 }

=======================================================================

SET Program-Pointer Syntax

=======================================================================

 SET program-pointer-1 TO ENTRY { literal-1    }
 ~~~                   ~~ ~~~~~ { identifier-1 }

=======================================================================

SET ADDRESS Syntax

=======================================================================

 SET [ ADDRESS OF ] { pointer-name-1 }... TO { [ ADDRESS OF ] { pointer-name-2 } }
 ~~~   ~~~~~~~      { identifier-1   }     ~~ {   ~~~~~~~      { identifier-2   } }
                                              {   NULLS                           }
                                                  ~~~~

=======================================================================

SET Index Syntax

=======================================================================

 SET index-name-1 TO { literal-1    }
 ~~~              ~~ { identifier-2 }

=======================================================================

SET UP/DOWN Syntax

=======================================================================

 SET  { identifier-1 }... { UP   } BY  [ LENGTH OF ] { integer-1    }
 ~~~                       { ~~   } ~~    ~~~~~~ ~~   { identifier-2 }
                           { DOWN }
                             ~~~~

=======================================================================

SET Condition Name Syntax

=======================================================================

 SET { { condition-name-1 }... TO { TRUE  } }...
 ~~~                            ~~ { ~~~~  }
                                   { FALSE }
                                     ~~~~~

=======================================================================

SET Switch Syntax

=======================================================================

 SET { { mnemonic-name-1 }... TO { ON  } } ...
 ~~~                           ~~ { ~~  }
                                  { OFF }
                                    ~~~

=======================================================================

SET ATTRIBUTE Syntax

=======================================================================

 SET identifier-1 ATTRIBUTE { { BELL | BEEP   } { ON  }  } ...
 ~~~              ~~~~~~~~~   { ~~~~   ~~~~   } { ~~  }
                              { BLINK         } { OFF }
                              { ~~~~~         }   ~~~
                              { HIGHLIGHT     }
                              { ~~~~~~~~~     }
                              { LEFTLINE      }
                              { ~~~~~~~~      }
                              { LOWLIGHT      }
                              { ~~~~~~~~      }
                              { OVERLINE      }
                              { ~~~~~~~~      }
                              { REVERSE-VIDEO }
                              { ~~~~~~~~~~~~~ }
                              { UNDERLINE     }
                                ~~~~~~~~~

=======================================================================

SET LAST EXCEPTION Syntax

=======================================================================

 SET LAST EXCEPTION TO OFF 
 ~~~ ~~~~ ~~~~~~~~~ ~~ ~~~

=======================================================================

SET Indentifier Syntax

=======================================================================

 SET { identifier-1 }...  TO { identifier-2 }
 ~~~                        ~~ { integer-1    }
                               { literal-1    }

=======================================================================

SET FCD and KEY DEFINITION BLOCK Syntax

=======================================================================

SET ADDRESS OF { identifier-1 }... TO ADDRESS OF { FH--FCD    } OF indexedfilename
~~~ ~~~~~~~ ~~                      ~~ ~~~~~~~ ~~ { ~~~~~~~    } ~~
                                                  { FH--KEYDEF }
                                                    ~~~~~~~~~~

=======================================================================

SET TO SIZE OF Syntax

=======================================================================

 SET {identifier-1}... TO SIZE OF {identifier-2 | literal-1 }
 ~~~                       ~~~~

=======================================================================

SET LOCALE Syntax

=======================================================================

 Format 1. SET LOCALE

 SET LOCALE { LC-ALL       } TO { identifier-1   }
            { LC_COLLATE   }    { locale-name    }
            { LC_CTYPE     }    { USER-DEFAULT   }
            { LC_MESSAGES  }    { SYSTEM-DEFAULT }
            { LC_MONETARY  }
            { LC_NUMERIC   }
            { LC_TIME      }
            { USER-DEFAULT }

 Format 2. SET to save LOCALE

 SET identifier-1 TO LOCALE { LC-ALL       }
     ~~~~~~~~~~~~    ~~~~~~ { ~~~~~~       }
                            { USER-DEFAULT }
                            { ~~~~~~~~~~~~ }

=======================================================================

File-Based SORT Syntax

=======================================================================

SORT sort-file-1 { ON { ASCENDING  } KEY { identifier-1 }... }...
~~~~                  { ~~~~~~~~~  }
                      { DESCENDING }
                        ~~~~~~~~~~
    [ WITH DUPLICATES IN ORDER ]
           ~~~~~~~~~~
    [ COLLATING SEQUENCE IS alphabet-name-1 ]
      ~~~~~~~~~

    { USING { file-name-1 }...                         }
    { ~~~~~                                                                     }
    { INPUT PROCEDURE IS procedure-name-1 [ THRU|THROUGH procedure-name-2 ]     }
      ~~~~~ ~~~~~~~~~                       ~~~~ ~~~~~~~                    

    { GIVING { file-name-2 }...                        }
    { ~~~~~~                                                                   }
    { OUTPUT PROCEDURE IS procedure-name-3 [ THRU|THROUGH procedure-name-4 ]   }
      ~~~~~~ ~~~~~~~~~                       ~~~~ ~~~~~~~                     

The DUPLICATES clause is syntactically recognized but is otherwise non-functional.

=======================================================================

Table SORT Syntax

=======================================================================

SORT table-name-1 { ON { ASCENDING  } KEY identifier-1... }...
~~~~                   { ~~~~~~~~~  }
                       { DESCENDING }
                         ~~~~~~~~~~
  [ WITH DUPLICATES IN ORDER ]
         ~~~~~~~~~~
  [ COLLATING SEQUENCE IS alphabet-name-1 ]
    ~~~~~~~~~

The DUPLICATES clause is syntactically recognized but is otherwise non-functional.

=======================================================================

START Syntax

=======================================================================

START file-name-1
~~~~~
      [ { FIRST                                                     } ]
        { ~~~~~                                                     }
        {                                                           }
        { KEY IS { EQUALS TO                         } identifier-1 }
        { ~~~    { ~~~~~                             }              }
        {        { =                                 }              }
        {        {                                   }              }
        {        { [ NOT ] LESS THAN                 }              }
        {        {   ~~~   ~~~~                      }              }
        {        { [ NOT ] <                         }              }
        {        {   ~~~                             }              }
        {        { [ NOT ] LESS THAN OR EQUALS TO    }              }
        {        {   ~~~   ~~~~      ~~ ~~~~~        }              }
        {        { [ NOT ] <=                        }              }
        {        {   ~~~                             }              }
        {        { [ NOT ] GREATER THAN              }              }
        {        {   ~~~   ~~~~~~~                   }              }
        {        { [ NOT ] >                         }              }
        {        {   ~~~                             }              }
        {        { [ NOT ] GREATER THAN OR EQUALS TO }              }
        {        {   ~~~   ~~~~~~~      ~~ ~~~~~     }              }
        {        { [ NOT ] >=                        }              }
        {            ~~~                                            }
        {        [ WITH { SIZE   } { literal-1                } ]   }
        {        [      { ~~~~   } { identifier-2             } ]   }
        {        [      { LENGTH } { arithmetic-expression-1  } ]   }
        {                 ~~~~~~                                    }
        {                                                           }
        { LAST                                                      }
          ~~~~    
  [ INVALID KEY imperative-statement-1 ]
    ~~~~~~~
  [ NOT INVALID KEY imperative-statement-2 ]
    ~~~ ~~~~~~~
[ END-START ]
   ~~~~~~~~~

=======================================================================

STOP Syntax

=======================================================================

 STOP { RUN [ { RETURNING|GIVING { literal-1    }           } ] }
 ~~~~ { ~~~ [ { ~~~~~~~~~ ~~~~~~ { identifier-1 }           } ] }
      {     [ {                                             } ] }
      {     [ { WITH { ERROR  } STATUS [ { literal-2    } ] } ] }
      {     [ {      { ~~~~~  }        [ { identifier-2 } ] } ] }
      {     [ {      { NORMAL }                             } ] }
      {     [ {        ~~~~~~                               } ] }
      {     [ {                                             } ] }
      {     [ { literal-4|identifier-4                      } ] }
      {                                                         }
      { literal-3|identifier-3                                  }
      { ERROR                                                   }
        ~~~~~

=======================================================================

STRING Syntax

=======================================================================

STRING { { literal-1    }... [ DELIMITED BY { SIZE         } ] }...
~~~~~~   { identifier-1 }       ~~~~~~~~~    { ~~~~         }
                                             { literal-2    }
                                             { identifier-2 }

        INTO identifier-3 [ WITH POINTER identifier-4 ]
        ~~~~                     ~~~~~~~

    [ ON OVERFLOW imperative-statement-1 ]
         ~~~~~~~~
    [ NOT ON OVERFLOW imperative-statement-2 ]
      ~~~    ~~~~~~~~
[ END-STRING ]
  ~~~~~~~~~~

=======================================================================

SUBTRACT FROM Syntax

=======================================================================

SUBTRACT { identifier-1 }... FROM { identifier-2 [ rounded-phrase ] }... 
~~~~~~~~ { literal-1    }     ~~~~           

   [ ON SIZE ERROR imperative-statement-1 ]
        ~~~~ ~~~~~
   [ NOT ON SIZE ERROR imperative-statement-2 ]
     ~~~    ~~~~ ~~~~~
[ END-SUBTRACT ]
  ~~~~~~~~~~~~

=======================================================================

SUBTRACT GIVING Syntax

=======================================================================

SUBTRACT { identifier-1 }...  FROM { identifier-2 }  
~~~~~~~~ { literal-1    }       ~~~~ { literal-2    }  

           GIVING { identifier-3 [ rounded-phrase ] }...
           ~~~~~~            

   [ ON SIZE ERROR imperative-statement-1 ]
        ~~~~ ~~~~~
   [ NOT ON SIZE ERROR imperative-statement-2 ]
     ~~~    ~~~~ ~~~~~
[ END-SUBTRACT ]
  ~~~~~~~~~~~~

=======================================================================

SUBTRACT CORRESPONDING Syntax

=======================================================================

SUBTRACT CORRESPONDING identifier-1 FROM identifier-2 [ rounded-phrase ]
~~~~~~~~ ~~~~                       ~~~~                   

   [ ON SIZE ERROR imperative-statement-1 ]
        ~~~~ ~~~~~
   [ NOT ON SIZE ERROR imperative-statement-2 ]
     ~~~    ~~~~ ~~~~~
[ END-SUBTRACT ]
  ~~~~~~~~~~~~

=======================================================================

SUPPRESS Syntax

=======================================================================

 SUPPRESS PRINTING
 ~~~~~~~~

=======================================================================

TERMINATE Syntax

=======================================================================

 INITIATE { report-name-1 }...
 ~~~~~~~~

=======================================================================

TRANSFORM Syntax

=======================================================================

 TRANSFORM identifier-1 CHARACTERS FROM { literal-1    } TO { literal-2    }
 ~~~~~~~~~                         ~~~~ { identifier-2 } ~~ { identifier-3 }

=======================================================================

UNLOCK Syntax

=======================================================================

 UNLOCK filename-1 RECORD|RECORDS
 ~~~~~~

=======================================================================

UNSTRING Syntax

=======================================================================

UNSTRING { literal-0    }
~~~~~~~~ { identifier-1 }

  [ DELIMITED BY [ ALL ] { literal-1    } [ OR [ ALL ] { literal-2    } ]... ]
    ~~~~~~~~~      ~~~   { identifier-2 }   ~~   ~~~   { identifier-3 }

   INTO { identifier-4 [ DELIMITER IN identifier-5 ] [ COUNT IN identifier-6 ] }...
   ~~~~                  ~~~~~~~~~                     ~~~~~
  [ WITH POINTER identifier-7 ]
         ~~~~~~~
  [ TALLYING IN identifier-8 ]
    ~~~~~~~~
  [ ON OVERFLOW imperative-statement-1 ]
       ~~~~~~~~
  [ NOT ON OVERFLOW imperative-statement-2 ]
    ~~~    ~~~~~~~~
[ END-UNSTRING ]
  ~~~~~~~~~~~~

=======================================================================

WRITE Syntax

=======================================================================

Format 1. For Sequential and Line Sequential files:

WRITE { record-name-1   [ FROM { identifier-1 } ] }
~~~~~ {                 [ ~~~~ { literal-1    } ] }
      {                                           }
      { FILE file-name-1  FROM { identifier-1 }   }
      { ~~~~              ~~~~ { literal-1    }   }

      [ { BEFORE } ADVANCING { { literal-2    } LINE|LINES } ]
      [ { ~~~~~~ }           { { identifier-2 }            } ]
      [ { AFTER  }           { PAGE                        } ]
      [   ~~~~~              { ~~~~                        } ]
      [                      { mnemonic-name-1             } ]

      [ WITH [ NO ] LOCK ]
               ~~   ~~~~
      [ AT END-OF-PAGE|EOP imperative-statement-1 ]
           ~~~~~~~~~~~ ~~~
      [ NOT AT END-OF-PAGE|EOP imperative-statement-2 ]
        ~~~    ~~~~~~~~~~~ ~~~
[ END-WRITE ]
  ~~~~~~~~~

Format 2. For Indexed and Relative files:

WRITE { record-name-1   [ FROM { identifier-1 } ] }
~~~~~ {                 [ ~~~~ { literal-1    } ] }
      {                                           }
      { FILE file-name-1  FROM { identifier-1 }   }
      { ~~~~              ~~~~ { literal-1    }   }

      [ WITH [ NO ] LOCK ]
               ~~   ~~~~
      [ INVALID KEY imperative-statement-3 ]
        ~~~~~~~
      [ NOT INVALID KEY imperative-statement-4 ]
        ~~~ ~~~~~~~
[ END-WRITE ]
  ~~~~~~~~~

=======================================================================

XML GENERATE Syntax

=======================================================================

XML GENERATE identifier-1 FROM identifier-2
~~~ ~~~~~~~~              ~~~~
     [COUNT IN identifier-3]
      ~~~~~
    [ WITH ENCODING codepage ]
           ~~~~~~~~
    [ WITH  XML-DECLARATION ]
            ~~~~~~~~~~~~~~~
    [ WITH ATTRIBUTES ]
           ~~~~~~~~~~
    [NAMESPACE IS {identifier-4 }[ NAMESPACE-PREFIX IS {identifier-5 }]
     ~~~~~~~~~    {literal-4    }  ~~~~~~~~~~~~~~~~    {literal-5    }]]

    [NAME OF   {identifier-6 IS literal-6 } ... ]
     ~~~~
    [TYPE OF   {identifier-7 IS {ATTRIBUTE|ELEMENT|CONTENT}} ... ]
     ~~~~                        ~~~~~~~~~ ~~~~~~~ ~~~~~~~

    [SUPPRESS  {identifier-8 [when-phrase] }  ... ]
     ~~~~~~~~  {generic-suppression-phrase }

    [ ON EXCEPTION imperative-statement-1 ]
         ~~~~~~~~~
    [ NOT ON EXCEPTION imperative-statement-2 ]
      ~~~    ~~~~~~~~~
[ END-XML ]
  ~~~~~~~

when-phrase Format

   WHEN   {     ZERO    }   [ [ OR ] {     ZERO    }  ] ...
   ~~~~   {    ZEROES   }            {    ZEROES   }
          {     ZEROS   }            {     ZEROS   }
          {     SPACE   }            {     SPACE   }
          {    SPACES   }            {    SPACES   }
          {  LOW-VALUE  }            {  LOW-VALUE  }
          {  LOW-VALUES }            {  LOW-VALUES }
          {  HIGH-VALUE }            {  HIGH-VALUE }
          { HIGH-VALUES }            { HIGH-VALUES }

Generic-suppression-phrase Format

   [[EVERY  {NUMERIC    [ATTRIBUTE|ELEMENT|CONTENT] } ]  when-phrase  ]
            {NONNUMERIC [ATTRIBUTE|ELEMENT|CONTENT] }
            {ATTRIBUTE                              }
            {CONTENT                                }
            {ELEMENT                                }

=======================================================================

XML PARSE Syntax

=======================================================================

  XML PARSE identifier-1
  ~~~ ~~~~~
      [ WITH ENCODING codepage ]
             ~~~~~~~~
      [ RETURNING NATIONAL ]
        ~~~~~~~~~ ~~~~~~~~
      [ VALIDATING WITH identifier-2 ]
        ~~~~~~~~~~
      PROCESSING PROCEDURE IS procedure-name-1 [ { THROUGH } procedure-name-2 ]
      ~~~~~~~~~~ ~~~~~~~~~                     [ { ~~~~~~~ }                  ]
                                               [ { THRU    }                  ]
                                                   ~~~~
     [ ON EXCEPTION imperative-statement-1     ]
          ~~~~~~~~~
     [ NOT ON EXCEPTION imperative-statement-2 ]
       ~~~    ~~~~~~~~~
  [ END-XML ]
    ~~~~~~~