Language Summary

%{ ACTIVATE } element [ RESCAN   ]... ;
 { ACT      }         [ NORESCAN ]

{ ALLOCATE } allocate-item, ... ;
{ ALLOC    }

allocate-item:

variable-reference [SET(locator-reference)] [IN(area-reference)]

%target = expression;

target, ... = expression;

BEGIN;

CALL entry-name [(argument, ...)];

CLOSE FILE(file-reference) [ENVIRONMENT(option, ...)]
       [,FILE(file-reference) [ENVIRONMENT(option, ...)]] ... ;

%{ DEACTIVATE } element, ...;
 { DEACT      }

element:

{ identifier         }
{ (identifier, ...)  }

%{ DECLARE } element [ FIXED     ]... ;
 { DCL     }         [ CHARACTER ]
                     [ BIT       ]

element:

{ identifier        }
{ (identifier, ...) }

{ DECLARE } [level] declaration [,[level] declaration, ...];
{ DCL     }

declaration:

{ identifier        } [(bound-pair)] [attribute ...]
{ (identifier, ...) }

DELETE FILE(file-reference) [KEY (expression)] [OPTIONS(option, ...)]

%DO;
⋮
%END;

   [reference = expression]
   [TO expression [BY expression]]
DO [REPEAT expression]
   [WHILE(expression)]
   [UNTIL(expression)];

%END;

END [label-reference];

entry-name: ENTRY [(parameter, ...)]
            [ RECURSIVE    ]
            [ NONRECURSIVE ]
            [RETURNS(returns-descriptor)]

%ERROR preprocessor-expression;

%FATAL preprocessor-expression;

label:

FORMAT (format-specification, ...);

FREE variable-reference [IN area-reference], ...;

GET EDIT (input-target, ...) (format-specification, ...)

[ FILE(file-reference)    ] ;
[ [SKIP[(expression)]]    ]
[ [OPTIONS(option, ...)]  ]
[ STRING(expression)      ]

GET LIST (input-target, ...)

[ FILE(file-reference)    ] ;
[ [SKIP [(expression)]]   ]
[ [OPTIONS(option, ...)]  ]
[ STRING(expression)      ]

GET [FILE(file-reference)]* SKIP [(expression)] ;

%GOTO label-reference;

{ GOTO  } label-reference;
{ GO TO }

%IF test-expression %THEN action [%ELSE action];

IF test-expression THEN action [ELSE action];

%INCLUDE { 'file-spec'                    };
         { module-name                    }
         { 'directory-name (module-name)' }

%INFORM preprocessor-expression;

LEAVE [label-reference];

LOCATE based-variable FILE (file-reference)
       [ SET (pointer-reference) ]
       [ KEYFROM (expression) ];

%;

;

ON condition-name { on-unit }
                  { SYSTEM  }

OPEN FILE(file-reference) [file-description-attribute ...]
       (file-reference) [file-description- attribute ...]] ...;

%PAGE;

%label { PROCEDURE } [(parameter-identifier, ...)] [STATEMENT]
       { PROC      }
       RETURNS( { CHARACTER } ); ...
                { FIXED     }
                { BIT       }
       [%]RETURN (preprocessor-expression);
                              ...
       [%]END;

entry-name: { PROCEDURE } [(parameter, ...)]
            { PROC      }
            [OPTIONS(option, ...)]
            [ RECURSIVE    ]
            [ NONRECURSIVE ]
            [RETURNS(value-descriptor)] ;

PUT EDIT (output-source, ...) (format-specification, ...)

[ FILE(file-reference)    ];
[ [PAGE]                  ]
[ [LINE(expression)]      ]
[ [SKIP[(expression)]]    ]
[ [OPTIONS(option, ...)]  ]
[ STRING(reference)       ]

PUT [FILE (file-reference)] LINE (expression);

PUT LIST (output-source,)

[ FILE(file-reference)    ] ;
[ [PAGE]                  ]
[ [LINE (expression)]     ]
[ [SKIP[(expression)]]    ]
[ [OPTIONS(option, ...)]  ]
[ STRING(reference)       ]

PUT [FILE (file-reference)] PAGE;

PUT [FILE (file-reference)] SKIP [(expression)] ;

READ FILE (file-reference)

{ INTO(variable-reference) }
{ SET(pointer-variable)    }
[ KEY(expression)           ]
[ KEYTO(variable-reference) ]
[OPTIONS(option, ...)]
[IGNORE (expression)] ;

%REPLACE identifier BY constant-value;

[%]RETURN (preprocessor-expression);

RETURN [ (return-value) ];

REVERT condition-name, ...;

REWRITE FILE (file-reference)
       [ FROM (variable-reference) [ KEY (expression) ]]
       [ OPTIONS (option, ...) ];

%SBTTL preprocessor-expression

SELECT [(select-expression)];
       [WHEN [ANY | ALL] (case-expression, ...) [action] ; ] ...
       [(OTHERWISE | OTHER) [action] ; ]
END;

SIGNAL condition-name;

STOP;

%TITLE preprocessor-expression

%WARN preprocessor-expression;

WRITE FILE(file-reference) FROM (variable-reference)
       [ KEYFROM (expression) ]
       [ OPTIONS (option, ...) ]; 

The following attributes define arithmetic and string data:

CHARACTER[(length)] [ VARYING    ]
                    [ NONVARYING ]

BIT[(length)] [ ALIGNED   ]
              [ UNALIGNED ]

{ FLOAT }{ BINARY  }[[PRECISION](precision[,scale-factor])]
{ FIXED }{ DECIMAL }
PICTURE 'picture'

These attributes can be specified for all elements of an array and for individual members of a structure.

The following attributes apply to program data that is not used for computation:

AREA
CONDITION
ENTRY [VARIABLE]
FILE [VARIABLE]
LABEL [VARIABLE]
OFFSET
POINTER

The following attributes control the allocation and use of storage for a data variable and define the scope of the variable:

AUTOMATIC [INITIAL(initial-element, ...)]
BASED [(pointer-reference)][INITIAL(initial-element, ...)]
CONTROLLED [INITIAL(initial-element, ...)]
DEFINED(variable-reference) [POSITION(expression)]
STATIC [READONLY] [INITIAL(initial-element, ...)]
PARAMETER
INTERNAL

EXTERNAL [ GLOBALDEF [(psect-name)] [ VALUE    ] ]
         [                          [ READONLY ] ]
         [ GLOBALREF                             ]

The following attributes can be applied to the major or minor members of a structure:

LIKE
MEMBER
REFER
STRUCTURE
TYPE
UNION

The following attributes can be applied to file constants and used in OPEN statements (ENVIRONMENT is valid on OPEN in the dec and ansi dialects only):

ENVIRONMENT(option, ...)
{ RECORD[KEYED] }{ INPUT         }
{ STREAM        }{ OUTPUT[PRINT] }
                 { UPDATE        }
{ DIRECT     }
{ SEQUENTIAL }

The following attributes can be applied to identifiers of entry points:

ENTRY[VARIABLE] [ OPTIONS [ (VARIABLE) ] ]
                [         [ (C)        ] ]
        [RETURNS(returns-descriptor)]
        [BUILTIN]

The following attributes can be applied to data declarations:

ALIGNED
DIMENSION
UNALIGNED