VS COBOL II grammar Version 1.0.3

This grammar has been been recovered from IBM's VS COBOL II Reference Summary (Document Number: SX26-3721-05) in a semi-automatic, formal process. In this unique process, many problems in the IBM document have been detected and fixed in a traceable way. The process is described by the authors of the grammar in the paper Semi-automatic Grammar Recovery (HTML, Postscript, Pdf). The process builds upon previous work of the authors in the field of program transformation, reverse engineering and specification environments. Note that the grammar should be regarded as a specification (of context-free syntax + lexical syntax) rather than a realistic parser + scanner description. So, for example, issues usually handled by a pre-processor are not covered by the formal definition. Also, the grammar specification is still ambigious. However, from this grammar we automatically derived a prototype parser. The grammar has been tested for large test sets of COBOL code: 8 test sets from different countries with 1.819.765 LOC (before preprocessing: 1.631.825) or 109.697.736 BYTES (before preprocessing: 113.481.950).

If you have any remark or a question, contact the authors of this grammar: Ralf Lämmel (CWI, Amsterdam, Email: ralf@cwi.nl) & Chris Verhoef (WINS, Universiteit van Amsterdam, Email: x@wins.uva.nl). This is Version 1.0.3 of the grammar. It has been released on May, 2nd, 2000. Version 1.0 (i.e., the first version) of the grammar has been released on December, 3rd, 1999. Refer to the ChangeLog for details. This document is maintained by Ralf Lämmel.

Acknowledgement
Many thanks to Bob Diertens for helping us with preprocessing the test sets. Many thanks to Peter Aarnoutse for the answers to our COBOL questions. The system LDL supporting language-centric software protoyping has been used for nearly all aspects of specification/implementation in this project, namely grammar recovery, parsing test sets, generation of the actual browsable grammar.

Contents

• How to use this browsable grammar ...
• Summary
• Context-free syntax
• Lexical syntax
• All sorts
• Top sorts
• Bottom sorts
• Keywords
• Diagrams
• Copyright

Summary

• Number of rules: 231
• Number of sorts: 202
• Number of top sorts: 2
• Number of bottom sorts: 0
• Number of lexical sorts: 17
• Number of keywords: 363

Context-free syntax

Lexical syntax

The following lexical definition serves as a tendentious description of the terminals in the context-free syntax. It has been derived manually from IBM's VS COBOL II Application Programming Language Reference (Document Number: GC26-4047-07). Note that this lexical definition is not claimed to reflect the actual scanner we use to test the grammar. Note also that preprocessing issues (e.g., continuation lines and copy book expansion) are not addressed by this definition. This lexical definition is written using some standard notation for regular expressions in the spirit of the LEX notation. Details of the notation are explained elsewhere.

/*
 Some kinds of user-defined words are required to contain at least one
 alphabetic. A corresponding class of character-strings is defined below.
*/

alphabetic-user-defined-word = ([0-9]+ [\-]*)* [0-9]* [A-Za-z] [A-Za-z0-9]* ([\-]+ [A-Za-z0-9]+)*

/*
 From the reference:
;  A COBOL word is a character-string of not more than 30 characters which
;  forms a user-defined word, a system-name, or a reserved word.  Except for
;  arithmetic operators and relation characters, each character of a COBOL
;  word is selected from the set of letters, digits, and the hyphen; the
;  hyphen cannot appear as the first or last character in such words.  Each
;  lowercase letter is considered to be equivalent to its corresponding
;  uppercase letter.
 We do not enforce the constraint on the maximum length of COBOL words.
*/

cobol-word = [A-Za-z0-9]+ ([\-]+ [A-Za-z0-9]+)*

/*
 From the reference:
;  A comment is a character-string that can contain any combination of
;  characters from the character set of the computer.
 We do not provide a lexical definition because we prefer to regard the
 problem of recognizing comment entries as a preprocessing issue.
*/

comment-entry = ...

/*
 DBCS literals are not specified in this version.
*/

dbcs = ...

/*
 From the reference:
;  In this manual, the word integer appearing in a format represents a
;  numeric literal of nonzero value that contains no sign and no decimal
;  point; any other restrictions are included with the description of the
;  format.
 It is actually questionable, if we should forbid nonzero values at the
 lexical level. Moreover, for some uses of integer, zero is actually allowed
 in contrast to the above rule.
*/

integer = [0]* [1-9] [0-9]*

/*
 From the reference:
;  Level-numbers: 01-49,66,77,88.
;  Each word must be a 1-digit or 2-digit integer.
*/

level-number = 

 ( [0]? [1-9]

 | [1-4] [0-9]

 | "66"

 | "77"

 | "88" )

/*
 From the reference:
;  A nonnumeric literal is a character-string enclosed in quotation marks
;  ("), and can contain any allowable character from the character set of the
;  computer.  The maximum length of a nonnumeric literal is 160 characters.

;  The enclosing quotation marks are excluded from the literal when the
;  program is compiled.  An embedded quotation mark must be represented by a
;  pair of quotation marks ("").  For example,      "THIS ISN""T WRONG"

;x A nonnumeric literal can be enclosed in apostrophes (').  If the APOST
;x option is specified, these apostrophes are excluded from the literal when
;x the program is compiled.  An embedded apostrophe must be represented by a
;x pair of apostrophes ('').  For example,     'THIS ISN''T WRONG'

 ...

;x Hexadecimal notation can be used for nonnumeric literals.  This
;x hexadecimal notation has the following format:

;x  ___ Hexadecimal Notation Format for Nonnumeric Literals ________________
;  |                                                                        |
;x | X"hexadecimal_digits"                                                  |
;  |                                                                        |
;  |________________________________________________________________________|

;x X"
;x     The opening delimiter for hexadecimal notation of a nonnumeric literal
;x     (If the compiler option APOST is specified, the opening delimiter is
;x     X'.)

;x "
;x     The closing delimiter for the hexadecimal notation of a nonnumeric
;x     literal.  (If the compiler option APOST is specified, the closing
;x     delimiter is '.)

 Nonnumeric literals with double-byte characters are not supported in this
 version of this lexical definition.
*/

nonnumeric = 

 ( [\"] (~[\"] | [\"] [\"])* [\"]

 | [\'] (~[\'] | [\'] [\'])* [\']

 | [Xx] [\"] hexdigits [\"]

 | [Xx] [\'] hexdigits [\'] )

auxiliaries

 begin

  hexdigits = [0-9A-Fa-f]+

 end

/*
 From the reference:
;  A numeric literal is a character-string whose characters are selected from
;  the digits 0 through 9, a sign character (+ or -), and the decimal point.
;  If the literal contains no decimal point, it is an integer.  (In this
;  manual, the word integer appearing in a format represents a numeric
;  literal of nonzero value that contains no sign and no decimal point; any
;  other restrictions are included with the description of the format.)  The
;  following rules apply:

;  o   One through 18 digits are allowed.

;  o   Only one sign character is allowed.  If included, it must be the
;      leftmost character of the literal.  If the literal is unsigned, it is
;      positive in value.

;  o   Only one decimal point is allowed.  If a decimal point is included, it
;      is treated as an assumed decimal point (that is, as not taking up a
;      character position in the literal).  The decimal point can appear
;      anywhere within the literal except as the rightmost character.

 We do not enforce the constraint on the length of numeric literals in the
 definition below. We omit a definition of floating-point literal values
 available as an IBM extension.
*/

numeric = [\+\-]? ([0-9]* [\.] [0-9]+ | [0-9]+)

/*
 options-list is meant to model compiler options for the CBL (PROCESS)
 Statement. We consider this compiler directing statement as a preprocessing
 problem. Thus, we omit a definition.
*/

options-list = ...

/*
 From the reference:
;  A PICTURE character-string is composed of the fcurrency symbol and certain
;  combinations of characters in the COBOL character set.  PICTURE
;  character-strings are delimited only by the separator space, separator
;  comma, separator semicolon, or separator period.

;  Any punctuation character that appears as part of the specification of a
;  PICTURE character-string is not considered as a punctuation character, but
;  rather as a symbol used in the specification of that PICTURE
;  character-string.
 There are various rules on the order and the valid combination of
 characters. We do not enforce these constraints in the following
 simplified definition. The definition of picture character-strings is
 definitely subject to improvement.
*/

picture-string = currency? (picchar+ repeat?)+ (punctuation (picchar+ repeat?)+)*

auxiliaries

 begin

  currency = ~[0-9ABCDPRSVXZa-z\*\+\-\/\,\.\;\(\)\=\'\"\ \n]

  picchar = 

   ( [ABEGPSVXZabegpsvxz90\+\-\*\$]

   | "CR"

   | "DB" )

  repeat = "(" [0-9]+ ")"

  punctuation = [\/\,\.\:]

 end

/*
 From the reference:
   Priority-numbers:  00-99
   Each word must be a 1-digit or 2-digit integer.
*/

priority-number = [0-9] [0-9]

/*
 From the reference:
;  pseudo-text
;      A sequence of character-strings and/or separators bounded by, but not
;      including, pseudo-text-1 delimiters (==).  Both characters of each
;      pseudo-text-1 delimiter must appear on one line; however,
;      character-strings within pseudo-text-1 can be continued.
*/

quoted-pseudo-text = "==" ~[\=]* "=="

/*
 Sequence numbers are needed for compiler-directing statements.
 These preprocessing issues are not addressed in the version.
*/

sequence-number = ...

/*
 See sequence-number.
*/

sequence-number-field = ...

/*
 From the reference:

;  A system-name is a character string that is defined by IBM to have a
;  specific meaning to the system.  There are three types of system-names:

;| o   computer-name
;| o   language-name
;| o   implementor-name.

;  There are two types of implementor-names:

;| o   environment-name
;| o   assignment-name.

 If we abstract from the problem to reject reserved words as user-defined
 words, user-defined words are COBOL words.
*/

system-name = cobol-word

/*
 From the reference:

;| Within a source program the following rules apply for all COBOL words:

;| o   A reserved word cannot be used as a user-defined word or as a
;|     system-name.

;| o   The same COBOL word, however, can be used as both a user-defined word
;|     and as a system-name.  The classification of a specific occurrence of
;|     a COBOL word is determined by the context of the clause or phrase in
;|     which it occurs.

 If we abstract from the problem to reject reserved words as user-defined
 words, user-defined words are COBOL words.
*/

user-defined-word = cobol-word

/*
 The class zero were introduced by us in the context of correcting the
 uses of the sort integer. The reference constrains integer to be a nonzero
 value, whereas some use sites allow zero. We relaxed those use sites from
 integer to (integer|zero). Now we have to define the trivial class zero.
*/

zero = [0]+

All sorts

[a] [b] [c] [d] [e] [f] [g] h [i] [j] k [l] [m] [n] [o] [p] [q] [r] [s] [t] [u] [v] [w] x y [z]