BNF Grammar: Difference between revisions

From Rosetta Code
Content added Content deleted
Line 4,284: Line 4,284:
=={{header|Lisaac}}==
=={{header|Lisaac}}==
=={{header|Lisp}}==
=={{header|Lisp}}==
<pre>
! -----------------------------------------------------------------------
! LISP
!
! LISt Programming
!
! "One can even conjecture that Lisp owes its survival specifically to the
! fact that its programs are lists, which everyone, including me, has
! regarded as a disadvantage."
!
! - John McCarthy, "Early History of Lisp"
!
!
! "Lisp is worth learning for the profound enlightenment experience you will
! have when you finally get it; that experience will make you a better programmer
! for the rest of your days, even if you never actually use Lisp itself a lot."
!
! - Eric Raymond, "How to Become a Hacker"
!
!
! "Lisp was far more powerful and flexible than any other language of its day; in
! fact, it is still a better design than most languages of today, twenty-five
! years later. Lisp freed ITS's hackers to think in unusual and creative ways. It
! was a major factor in their successes, and remains one of hackerdom's favorite
! languages."
!
! - Eric Raymond, in Open Sources on MIT's first OS, ITS
!
! The LISP programming language is one of the oldest still use today; second only to
! FORTRAN. It was invented by mathematician John McCarthy and organizes information into
! abstract "lists". This metaphor is used universially for both data and functions;
! in fact, the LISP runtime engine makes no differentiation between the two. This allows
! the programmer to perform actions that would be impossible in most programming languages
! such as, but not limited to, passing code as a parameter to a function, executing data,
! and modifying the program at runtime.
!
! For more information on LISP, please visit www.lisp.org.
!
! Updates:
! 3/5/2003: Added dotted pairs and backslash overrides to the language.
!
! Note: This is an ad hoc version of the language. If there are any flaws,
! please visit www.DevinCook.com/GOLDParser and I will update the grammar.
!
!
! -----------------------------------------------------------------------


"Name" = 'LISP'
"Author" = 'John McCarthy'
"Version" = 'Standard'
"About" = 'LISP is an abstract language that organizes ALL data around "lists".'

"Start Symbol" = <s-Expression>

{Atom Char} = {Printable} - {Whitespace} - [()"\'']
{String Char} = {Printable} - ["\]

Atom = ( {Atom Char} | '\'{Printable} )+

String = '"' ( {String Char} | '\'{Printable} )* '"'


<s-Expression> ::= <Quote> Atom
| <Quote> '(' <Series> ')'
| <Quote> '(' <s-Expression> '.' <s-Expression> ')' !Dotted Pair
| String !Strings are never evaluated

<Series> ::= <s-Expression> <Series>
|

<Quote> ::= ''  !Quote = do not evaluate
|
</pre>

=={{header|Logo}}==
=={{header|Logo}}==
=={{header|Logtalk}}==
=={{header|Logtalk}}==

Revision as of 04:53, 21 June 2009

Task
BNF Grammar
You are encouraged to solve this task according to the task description, using any language you may know.

In computer science, Backus–Naur Form (BNF) is a metasyntax used to express context-free grammars: that is, a formal way to describe formal languages. John Backus and Peter Naur developed a context free grammar to define the syntax of a programming language by using two sets of rules: i.e., lexical rules and syntactic rules.

BNF is widely used as a notation for the grammars of computer programming languages, instruction sets and communication protocols, as well as a notation for representing parts of natural language grammars. Many textbooks for programming language theory and/or semantics document the programming language in BNF.

There are many extensions and variants of BNF, including Extended and Augmented Backus–Naur Forms (EBNF and ABNF).

The task here is establish a BNF grammar for as many languages as possible to facilitate language categorization and translation.

4D

ALGOL 60

! ----------------------------------------------------------------------------
! ALGOL 60
!
! (ALGO)rithmic (L)anguage
!
! ALGOL is, by far, the most influential programming language developed to 
! date. Although is did not achieve mass use, a large number of syntactic 
! and semantic principles and concepts were developed and incorporated into 
! the language. As a result, ALGOL is considered the main reference language 
! in computer science. 
! 
! In the late 1950's, many in the study of computer science believed that a 
! new universal programming language was needed. This new language would be 
! used through the study of computer science and would eventually replace 
! other popular languages such as FORTRAN. 
! 
! The ACM (Association for Computing Machinery) and GAMM (a European 
! organization of mathematics and mechanics) created an international 
! committee to define and document the new language. This committee 
! included computer scientists from both North America and Europe. 
! 
! The process of developing ALGOL included a number of challenges: 
! 
! First, the computers of the era varied greatly in the number of characters 
! that could be represented. This made it difficult to define the exact 
! lexics of the language. For instance, one mainframe could contain an 
! ampersand character (&) while another may not. 
! 
! Another challenge involved an issue that nowadays seems trival - the 
! representation of decimal points. In the 50 United States and Canada, real 
! numbers are represented using a period. For instance, the value 4 1/2 can 
! be written as "4.5". Europe, on the other hand, uses a comma. The same 
! value is represented with "4,5". Both sides were steadfast that their 
! format was superior. Although the "period" format would eventually 
! dominate, this was a major issue at the time. 
! 
! To describe the syntax of the first version of ALGOL, Peter Naur modified 
! Backus Normal Form to create Backus-Naur Form. This format is now used 
! universially to describe the syntax of programming languages. 
! 
! To spite these challenges, ALGOL created a number of language features 
! that would be incorporated into its numerious successors. These include: 
! 
! * Block structure 
! * Free-form structure (elements are not required to be in a specific column) 
! * Pass by Name  (while powerful, it is not used in modern languages) 
! * The For-Loop 
! * The 'Else' clause on if-statements (LISP's 'cond' predates this though) 
! * Reserved words 
! 
! The grammar below was, for the most part, cut and pasted from "Revised 
! Report on the Algorithmic Language: Algol 60" by Peter Naur. The numbered
! sections refer directly to the chapters in the Report. 
!
! The grammar was modified to remove ambigities and define terminals using
! regular expressions.
!
! ----------------------------------------------------------------------------


"Name"      = 'ALGOL 60'
"Version"   = '1960'

"Author"    = 'J.W. Backus, F.L. Bauer, J.Green, C. Katz, J. McCarthy, P. Naur,'
            | 'A.J. Perlis, H. Rutishauser, K. Samuelson, B. Vauquois,'
            | 'J.H. Wegstein, A. van Wijngaarden, M. Woodger'

"About"     = 'ALGOL (ALGOrithmic Language) is the most influential'
            | 'programming language to date. Although it did not achieve'
            | 'mass use, it established multiple syntactic and semantic'
            | 'features used in languages today.'


"Start Symbol" = <program>


! ========================================================== Terminals


{String Ch}    = {Printable} - [`] - ['']

Identifier     = {Letter}{Alphanumeric}*

String         = '`' ( '`' {String Ch}* '' | {String Ch} )* ''

IntegerLiteral = {Digit}+ 
RealLiteral    = {Digit}+ '.' {Digit}+  (e {Digit}+)?


! =========================================================== Rules

<unsigned integer> 
        ::= IntegerLiteral
         
<unsigned number>          
        ::= IntegerLiteral
         |  RealLiteral


! ====================================================================
! 2.2.2 Logical values.
! ====================================================================

<logical value> ::= true | false



! ====================================================================
! 3. Expressions
! ====================================================================

<expression> 
       ::= <Boolean expression> 
          

! ====================================================================
! 3.1. Variables
! ====================================================================

<subscript expression> 
        ::= <arithmetic expression>

<subscript list> 
        ::= <subscript expression> 
         |  <subscript list> ',' <subscript expression>


<variable> 
        ::= Identifier
         |  Identifier '[' <subscript list> ']'      ! subscripted value

! ====================================================================
! 3.2. Function designators
! ====================================================================

<actual parameter> 
        ::= String
         |  <expression>

<parameter delimiter> 
        ::= ',' 
         |  ')' Identifier ':' '('


<actual parameter list> 
        ::= <actual parameter>  
         |  <actual parameter list> <parameter delimiter> <actual parameter>


! ====================================================================
! 3.3. Arithmetic expressions
! ====================================================================

<adding operator> ::= '+' | '-'

<multiplying operator> ::=  '*' | '/' | 'div'       

<primary> 
        ::= <unsigned number>
         |  <variable>
         |  Identifier '(' <actual parameter list> ')'
         |  '(' <arithmetic expression> ')'

<factor> 
       ::= <primary> 
         | <factor> '^' <primary>     !Originally an up-arrow                          
       
<term> 
        ::= <factor> 
         |  <term> <multiplying operator> <factor>


<simple arithmetic expression> 
        ::= <term> 
         |  <adding operator> <term>
         |  <simple arithmetic expression> <adding operator> <term>

<if clause> ::= if <Boolean expression> then

<arithmetic expression> 
        ::= <simple arithmetic expression>
         |  <if clause> <simple arithmetic expression> else <arithmetic expression>



! ====================================================================
! 3.4. Boolean expressions
! ====================================================================

<relational operator> ::= '<' | '<=' | '=' | '>=' | '>' | '~='


<relation> 
        ::= <relation> <relational operator> <simple arithmetic expression>
         |  <simple arithmetic expression>  

<Boolean primary> 
        ::= <logical value>
         |  <relation> 

<Boolean secondary> 
        ::= <Boolean primary> 
         |  not <Boolean primary>


<Boolean factor> 
        ::= <Boolean secondary>
         |  <Boolean factor> and <Boolean secondary>

<Boolean term> 
        ::= <Boolean factor> 
         |  <Boolean term> or <Boolean factor>

<implication> 
        ::= <Boolean term> 
         |  <implication> implies <Boolean term>

<simple Boolean> 
        ::= <implication>
         |  <simple Boolean> eqv <implication>


<Boolean expression> 
        ::= <simple Boolean> 
         |  <if clause> <simple Boolean> else <Boolean expression>


! ====================================================================
! 3.5. Designational expressions
! ====================================================================

<label> 
       ::= Identifier
        |  <Unsigned Integer>

<switch designator>
       ::= Identifier '[' <subscript expression> ']'

<simple designational expression> 
       ::= <label> 
        |  <switch designator> 
        | '(' <designational expression> ')'

<designational expression> 
       ::= <simple designational expression> 
        |  <if clause> <simple designational expression> else <designational expression>


! ====================================================================
! 4.1. Compound statements and blocks
! ====================================================================

<unlabelled basic statement> 
        ::= <assignment statement> 
         |  <go to statement>
         |  !EMPTY                 !dummy statement 
         |  <procedure statement>


<basic statement> 
        ::= <unlabelled basic statement>
         |  <label> ':' <basic statement>

<unconditional statement> 
        ::= <basic statement> 
         |  <compound statement> 
         |  <block>

<statement> 
        ::= <unconditional statement>
         |  <conditional statement>
         |  <for statement>

<compound tail> 
        ::= <statement> end 
         |  <statement> ';' <compound tail>

<block head> 
        ::= begin <declaration> 
         |  <block head> ';' <declaration>

<unlabelled block> 
        ::= <block head> ';' <compound tail>

<unlabelled compound> 
        ::= begin <compound tail>

<compound statement> 
        ::= <unlabelled compound> 
         |  <label> ':' <compound statement>

<block> 
        ::= <unlabelled block>
         |  <label> ':' <block>

<program> 
        ::= <block> 
         |  <compound statement>


! ====================================================================
! 4.2. Assignment statements
! ====================================================================

<left part> 
        ::= <variable> ':=' 


<left part list> 
        ::= <left part> 
         |  <left part list> <left part>

<assignment statement> 
        ::= <left part list> <Boolean expression>


 
! ====================================================================
! 4.3. Go to statements
! ====================================================================

<go to statement> ::= goto <designational expression>


! ====================================================================
! 4.4. Dummy statements
! ====================================================================

!<dummy statement> ::= <empty>


! ====================================================================
! 4.5. Conditional statements
! ====================================================================

<if statement> ::= <if clause> <unconditional statement>

<conditional statement> 
       ::= <if statement> 
        |  <if statement> else <statement> 
        |  <if clause> <for statement> 
        |  <label> ':' <conditional statement>


! ====================================================================
! 4.6. For statements
! ====================================================================

<for list element> 
       ::= <arithmetic expression> 
        |  <arithmetic expression> step <arithmetic expression> until <arithmetic expression>
        |  <arithmetic expression> while <Boolean expression>

<for list> 
       ::= <for list element> 
        |  <for list> ',' <for list element>

<for clause> ::= for <variable> ':=' <for list> do

<for statement> 
       ::= <for clause> <statement> 
        |  <label> ':' <for statement>


! ====================================================================
! 4.7. Procedure statements
! ====================================================================


<procedure statement> 
        ::= Identifier '(' <actual parameter list> ')'
         |  Identifier 


! ====================================================================
! 5. Declarations
! ====================================================================

<declaration> 
       ::= <type declaration>
        |  <array declaration>
        |  <switch declaration>
        |  <procedure declaration>


! ====================================================================
! 5.1. Type declarations
! ====================================================================

<type list> 
       ::= Identifier 
        |  Identifier ',' <type list>

<type> 
       ::= real 
        |  integer 
        |  Boolean

<local or own type> 
       ::= <type> 
        |  own <type>

<type declaration> 
       ::= <local or own type> <type list>


! ====================================================================
! 5.2. Array declarations
! ==================================================================== 
 
<lower bound> ::= <arithmetic expression>
 
<upper bound> ::= <arithmetic expression>
 
<bound pair>  ::= <lower bound> ':' <upper bound>
 
<bound pair list> 
       ::= <bound pair> 
        |  <bound pair list> ',' <bound pair>
 
<array segment> 
       ::= Identifier '[' <bound pair list> ']' 
        |  Identifier ',' <array segment>
 
<array list> 
       ::= <array segment> 
        |  <array list> ',' <array segment>
 
<array declaration> 
       ::= array <array list> 
        |  <local or own type> array <array list>
 

! ====================================================================
! 5.3. Switch declarations
! ====================================================================

<switch list> 
       ::= <designational expression> 
        |  <switch list> ',' <designational expression>

<switch declaration> 
       ::= switch Identifier ':=' <switch list>


! ====================================================================
! 5.4. Procedure declarations
! ====================================================================

<formal parameter> 
        ::= Identifier

<formal parameter list> 
        ::= <formal parameter>
         |  <formal parameter list> <parameter delimiter> <formal parameter>

<formal parameter part> 
        ::= !EMPTY 
         | '(' <formal parameter list> ')'

<identifier list> 
        ::= Identifier
         |  <identifier list> ',' Identifier

<value part> 
        ::= value <identifier list> ';' 
         |  !EMPTY

<specifier> 
        ::= string 
         |  <type>
         |  array
         |  <type> array
         |  label
         |  switch
         |  procedure
         |  <type> procedure

<specification part> 
        ::= !EMPTY
         | <specification>
  
!=== The following rule was added

<specification>
        ::=                 <specifier> <identifier list> ';'
         |  <specification> <specifier> <identifier list> ';'



<procedure heading> 
        ::= Identifier <formal parameter part> ';' <value part> <specification part>

<procedure body> 
        ::= <statement>         
!!!      |  <code>             !<code> refers to any embedded non-Algol code         
         

<procedure declaration> 
        ::=        procedure <procedure heading> <procedure body> 
         |  <type> procedure <procedure heading> <procedure body>

ALGOL 68

APL

AWK

ActionScript

Ada

Agda2

AmigaE

AppleScript

Assembly

AutoHotkey

BASIC

! -----------------------------------------------------------------------
! BASIC '64 
!
! Beginner's All-purpose Symbolic Instruction Code 
!
!    "It is practically impossible to teach good programming style to students 
!     that have had prior exposure to BASIC; as potential programmers they are 
!     mentally mutilated beyond hope of regeneration." 
!
!     - Edsger W. Dijkstra 
!
! BASIC is one of the oldest programming language and one of the most popular. 
! It was developed in 1964 by John G. Kemeny and Thomas E. Kurtz to teach 
! students the basics of programming concepts. At the advent of the microcomputer,
! BASIC was implemented on numerous platforms such as the Commodore, Atari, 
! Apple II, Altair, IBM PC computers. Over time, BASIC evolved into GW-BASIC, 
! QBasic, Visual Basic, and recently Visual Basic .NET.
!
! In practically all programming languages, the reserved word/symbol that denotes
! a comment is treated as a form of whitespace - having no effect in the manner in
! which the program runs. Once such type of comment is used to indicate the remainder
! of the line is to be ignored. These can be added to the end of any line without
! changing the meaning of the program. In C++, it is the '//' symbol;
! in BASIC '64 it is 'REM'.
!
! However, in the BASIC programming language, the line comment is treated like a 
! statement. For instance, if 'REM' was a normal line comment:
!
!    10  PRINT "Hello World" REM Common first program
!
! would be a valid statement. However, in BASIC, this is illegal. In the example 
! above, the comment must be added as an additional statement.
!
!    10  PRINT "Hello World" : REM Common first program
!
! As a result, the Line Comment terminal that is used in the GOLD Parser cannot be
! used here. In the grammar below, a 'Remark' terminal was created that accepts all 
! series of printable characters starting with the characters "REM ". In some 
! implementations of BASIC, any string starting with "REM" is a comment statement.
! Examples include "REMARK", "REMARKABLE" and "REMODEL". This grammar requires the space.
!
! This grammar does not include the editor statements such as NEW, SAVE, LOAD, etc...
!
! Note: This is an ad hoc version of the language. If there are any flaws, please 
! e-mail GOLDParser@DevinCook.com and I will update the grammar. Most likely I have
! included features not available in BASIC '64.
! -----------------------------------------------------------------------


"Name"    = 'BASIC (Beginners All-purpose Symbolic Instruction Code)'
"Author"  = 'John G. Kemeny and Thomas E. Kurtz' 
"Version" = '1964 - Original - before Microsoft enhanced the language for the IBM PC.'
"About"   = 'BASIC is one of most common and popular teaching languages ever created. '

"Case Sensitive" = False 
"Start Symbol"   = <Lines>

{String Chars} = {Printable} - ["]
{WS}           = {Whitespace} - {CR} - {LF}

NewLine        = {CR}{LF}|{CR}
Whitespace     = {WS}+

Remark         = REM{Space}{Printable}*
ID             = {Letter}[$%]? 
String         = '"'{String Chars}*'"' 
Integer        = {digit}+ 
Real           = {digit}+.{digit}+ 

<Lines>       ::= Integer <Statements> NewLine <Lines> 
                | Integer <Statements> NewLine

<Statements>  ::= <Statement> ':' <Statements>
                | <Statement>

<Statement>   ::= CLOSE '#' Integer
                | DATA <Constant List> 
                | DIM ID '(' <Integer List> ')'
                | END          
                | FOR ID '=' <Expression> TO <Expression>     
                | FOR ID '=' <Expression> TO <Expression> STEP Integer      
                | GOTO <Expression> 
                | GOSUB <Expression> 
                | IF <Expression> THEN <Statement>         
                | INPUT <ID List>       
                | INPUT '#' Integer ',' <ID List>       
                | LET Id '=' <Expression> 
                | NEXT <ID List>               
                | OPEN <Value> FOR <Access> AS '#' Integer
                | POKE <Value List>
                | PRINT <Print list>
                | PRINT '#' Integer ',' <Print List>
                | READ <ID List>           
                | RETURN
                | RESTORE
                | RUN
                | STOP
                | SYS <Value>
                | WAIT <Value List>
                | Remark

<Access>   ::= INPUT
             | OUPUT
                   
<ID List>  ::= ID ',' <ID List> 
             | ID 

<Value List>      ::= <Value> ',' <Value List> 
                    | <Value> 

<Constant List>   ::= <Constant> ',' <Constant List> 
                    | <Constant> 

<Integer List>    ::= Integer ',' <Integer List>
                    | Integer
                 
<Expression List> ::= <Expression> ',' <Expression List> 
                    | <Expression> 

<Print List>      ::= <Expression> ';' <Print List>
                    | <Expression> 
                    |  

<Expression>  ::= <And Exp> OR <Expression> 
                | <And Exp> 

<And Exp>     ::= <Not Exp> AND <And Exp> 
                | <Not Exp> 
 
<Not Exp>     ::= NOT <Compare Exp> 
                | <Compare Exp> 

<Compare Exp> ::= <Add Exp> '='  <Compare Exp> 
                | <Add Exp> '<>' <Compare Exp> 
                | <Add Exp> '><' <Compare Exp> 
                | <Add Exp> '>'  <Compare Exp> 
                | <Add Exp> '>=' <Compare Exp> 
                | <Add Exp> '<'  <Compare Exp> 
                | <Add Exp> '<=' <Compare Exp> 
                | <Add Exp> 

<Add Exp>     ::= <Mult Exp> '+' <Add Exp> 
                | <Mult Exp> '-' <Add Exp> 
                | <Mult Exp> 

<Mult Exp>    ::= <Negate Exp> '*' <Mult Exp> 
                | <Negate Exp> '/' <Mult Exp> 
                | <Negate Exp> 

<Negate Exp>  ::= '-' <Power Exp> 
                | <Power Exp> 

<Power Exp>   ::= <Power Exp> '^' <Value> 
                | <Value> 

<Value>       ::= '(' <Expression> ')'
                | ID 
                | ID '(' <Expression List> ')'
                | <Constant> 

<Constant> ::= Integer 
             | String 
             | Real

Bc

Befunge

Brainf***

C

! -----------------------------------------------------------------------
! ANSI C
!
! The C programming language evolved at Bell Labs from a series of 
! programming languages: 'CPL', 'BCPL', and then 'B'. As a result, C's
! development was a combined effort between Dennis Ritchie, Ken Thompson,
! and Martin Richards.  
!
! C was designed for the creation and implementation of low-level systems
! such as operating systems, device drivers, firmware, etc... To realize 
! this goal, the language contains the ability to perform operations 
! directly on memory and has direct access to system pointers. While this 
! gives an enormous amount of control and flexibility, it also makes C a 
! professional programming language - not to be used by an inexperienced
! programmer.
!
! C (and later C++) quickly became the de facto standard for developing
! operating systems, applications and most other large projects. UNIX as 
! well as Windows, Linux, and Mac-OS X were developed using this 
! language (and its successors).
!
! More information is available at Dennis Ritchie's website:
!     http://cm.bell-labs.com/cm/cs/who/dmr/
!
! The C grammar is inherently ambigious and requires a large number of
! LALR(1) states to parse. As a result, the time required by the GOLD 
! Parser Builder to compile this grammar is extensive.
! 
! C is not a line-based grammar with the notable exception of compiler
! directives (which are preceeded by a '#' character). These are usually not
! handled directly by the actual parser, but, rather, the pre-processor. 
! Before the program is analyzed by the parser, C compilers scan the code and
! act on these commands. The final C program is then passed to the parser.
! -----------------------------------------------------------------------

! -----------------------------------------------------------------------
! This grammar does not contain the compiler directives.
!
! Note: This is an ad hoc version of the language. If there are any flaws, 
! please visit the contact page and tell me.
!
! SPECIAL THANKS TO:
!     BOB MEAGHER
!     MIKE WISDOM
!     VLADIMIR MOROZOV
!     TOM VAN DIJCK
!
! Modified 06/14/2002
!   * The correct definition for "return" was added. Thanks to Bob Meagher.
!   * Added the missing rules for labels, storage specifications, etc...
!     which were left out. Thanks to Mike Wisdom for calling this to
!     my attention.
!
! Modified 06/21/2002
!   * I fixed an error in the grammar for declaring functions. 
!
! Modified 06/15/2003
!   * Vladimir Morozov fixed an error for calling functions with no parameters
!
! Modified 01/31/2004
!   * Tom van Dijck found a bug in the grammar concerning variable 
!     initialization.
!
! Modified 04/26/2004
!   * Some errors in the grammar were fixed.
!
! Modified 01/19/2005
!   * The definition for comments was modified. In ANSI C, block comments
!     cannot be nested. As a result, they are defined using the whitespace
!     terminal.
!
! Modified 03/28/2007
!   * The commented-out definition for non-nested comments was updated. The
!     previous version did not work in all cases.
! -----------------------------------------------------------------------


"Name"    = 'ANSI C' 
"Version" = '1973'
"Author"  = 'Dennis Ritchie, Ken Thompson, Martin Richards' 
"About"   = 'C is one of the most common, and complex, programming languages in use today.'

"Case Sensitive" = True
"Start Symbol"   = <Decls>

{Hex Digit}      = {Digit} + [abcdefABCDEF]
{Oct Digit}      = [01234567]

{Id Head}        = {Letter} + [_]
{Id Tail}        = {Id Head} + {Digit}

{String Ch}      = {Printable} - ["]
{Char Ch}        = {Printable} - ['']

DecLiteral       = [123456789]{digit}*
OctLiteral       = 0{Oct Digit}*
HexLiteral       = 0x{Hex Digit}+
FloatLiteral     = {Digit}*'.'{Digit}+

StringLiteral    = '"'( {String Ch} | '\'{Printable} )* '"'
CharLiteral      = '' ( {Char Ch} | '\'{Printable} )''

Id               = {Id Head}{Id Tail}*


! ===================================================================
! Comments
! ===================================================================

Comment Start = '/*'
Comment End   = '*/'
Comment Line  = '//'


! Typically, C comments cannot be nested. As a result, the 
! Comment Start and Comment End terminals cannot be used.
!
! To implement non-nested comments, the whitespace terminal is
! modified to accept them. In the definition below, Whitespace 
! is defined as one or more {Whitespace} characters OR a series
! of characters delimited by /* and */. Note that the characters
! between the two delimiters cannot contain the */ sequence. 
!
! Uncomment the following to prevent block commments. Make sure 
! to comment the Comment Start and Comment End definitions.
!
! {Non Slash}     = {Printable} - [/]  
! {Non Asterisk}  = {Printable} - [*]
! 
! Whitespace     = {Whitespace}+   
!                | '/*' (  {Non Asterisk} | '*' {Non Slash}? )*  '*/'

!=======================================================

<Decls> ::= <Decl> <Decls>
          |

<Decl>  ::= <Func Decl>
          | <Func Proto>
          | <Struct Decl>
          | <Union Decl>
          | <Enum Decl>
          | <Var Decl>    
          | <Typedef Decl>
              
! ===================================================================
! Function  Declaration
! ===================================================================

<Func Proto> ::= <Func ID> '(' <Types>  ')' ';'
               | <Func ID> '(' <Params> ')' ';'
               | <Func ID> '(' ')' ';'

<Func Decl>  ::= <Func ID> '(' <Params>  ')' <Block>
               | <Func ID> '(' <Id List> ')' <Struct Def> <Block>
               | <Func ID> '(' ')' <Block>


<Params>     ::= <Param> ',' <Params>
               | <Param>
               
<Param>      ::= const <Type> ID
               |       <Type> ID
               
<Types>      ::= <Type>  ',' <Types>
               | <Type> 
   
<Id List>    ::= Id ',' <Id List>
               | Id

<Func ID>    ::= <Type> ID
               | ID

! ===================================================================
! Type Declaration
! ===================================================================

<Typedef Decl> ::= typedef <Type> ID ';'

<Struct Decl>  ::= struct Id '{' <Struct Def> '}'  ';' 

<Union Decl>   ::= union Id '{' <Struct Def> '}'  ';' 


<Struct Def>   ::= <Var Decl> <Struct Def>
                 | <Var Decl>

! ===================================================================
! Variable Declaration
! ===================================================================

<Var Decl>     ::= <Mod> <Type> <Var> <Var List>  ';'
                 |       <Type> <Var> <Var List>  ';'
                 | <Mod>        <Var> <Var List>  ';'
             
<Var>      ::= ID <Array>
             | ID <Array> '=' <Op If> 

<Array>    ::= '[' <Expr> ']'
             | '[' ']'
             |
             
<Var List> ::=  ',' <Var Item> <Var List>
             | 

<Var Item> ::= <Pointers> <Var>

             
<Mod>      ::= extern 
             | static
             | register
             | auto
             | volatile
             | const   

! ===================================================================
! Enumerations
! ===================================================================

<Enum Decl>    ::= enum Id '{' <Enum Def> '}'  ';'
 
<Enum Def>     ::= <Enum Val> ',' <Enum Def>
                 | <Enum Val>

<Enum Val>     ::= Id
                 | Id '=' OctLiteral
                 | Id '=' HexLiteral
                 | Id '=' DecLiteral  


! ===================================================================
! Types
! ===================================================================

<Type>     ::= <Base> <Pointers> 

<Base>     ::= <Sign> <Scalar>
             | struct Id 
             | struct '{' <Struct Def> '}' 
             | union Id
             | union '{' <Struct Def> '}' 
             | enum Id  


<Sign>     ::= signed 
             | unsigned
             |

<Scalar>   ::= char
             | int
             | short
             | long
             | short int
             | long int
             | float
             | double
             | void           

<Pointers> ::= '*' <Pointers>
             |

! ===================================================================
! Statements
! ===================================================================

<Stm>        ::= <Var Decl>
               | Id ':'                            !Label
               | if '(' <Expr> ')' <Stm>          
               | if '(' <Expr> ')' <Then Stm> else <Stm>         
               | while '(' <Expr> ')' <Stm> 
               | for '(' <Arg> ';' <Arg> ';' <Arg> ')' <Stm>
               | <Normal Stm>

<Then Stm>   ::= if '(' <Expr> ')' <Then Stm> else <Then Stm> 
               | while '(' <Expr> ')' <Then Stm> 
               | for '(' <Arg> ';' <Arg> ';' <Arg> ')' <Then Stm>
               | <Normal Stm>

<Normal Stm> ::= do <Stm> while '(' <Expr> ')'
               | switch '(' <Expr> ')' '{' <Case Stms> '}'
               | <Block>
               | <Expr> ';'               
               | goto Id ';'
               | break ';'
               | continue ';'
               | return <Expr> ';'
               | ';'              !Null statement


<Arg>       ::= <Expr> 
              | 

<Case Stms> ::= case <Value> ':' <Stm List> <Case Stms>
              | default ':' <Stm List>                  
              |

<Block>     ::= '{' <Stm List> '}' 

<Stm List>  ::=  <Stm> <Stm List> 
              | 


! ===================================================================
! Here begins the C's 15 levels of operator precedence.
! ===================================================================

<Expr>       ::= <Expr> ',' <Op Assign>   
               | <Op Assign>

<Op Assign>  ::= <Op If> '='   <Op Assign>
               | <Op If> '+='  <Op Assign>
               | <Op If> '-='  <Op Assign>
               | <Op If> '*='  <Op Assign>
               | <Op If> '/='  <Op Assign>
               | <Op If> '^='  <Op Assign>
               | <Op If> '&='  <Op Assign>
               | <Op If> '|='  <Op Assign>
               | <Op If> '>>=' <Op Assign>
               | <Op If> '<<=' <Op Assign>
               | <Op If>

<Op If>      ::= <Op Or> '?' <Op If> ':' <Op If>
               | <Op Or>

<Op Or>      ::= <Op Or> '||' <Op And>
               | <Op And>

<Op And>     ::= <Op And> '&&' <Op BinOR>
               | <Op BinOR>

<Op BinOR>   ::= <Op BinOr> '|' <Op BinXOR>
               | <Op BinXOR>

<Op BinXOR>  ::= <Op BinXOR> '^' <Op BinAND>
               | <Op BinAND>

<Op BinAND>  ::= <Op BinAND> '&' <Op Equate>
               | <Op Equate>

<Op Equate>  ::= <Op Equate> '==' <Op Compare>
               | <Op Equate> '!=' <Op Compare>
               | <Op Compare>

<Op Compare> ::= <Op Compare> '<'  <Op Shift>
               | <Op Compare> '>'  <Op Shift>
               | <Op Compare> '<=' <Op Shift>
               | <Op Compare> '>=' <Op Shift>
               | <Op Shift>

<Op Shift>   ::= <Op Shift> '<<' <Op Add>
               | <Op Shift> '>>' <Op Add>
               | <Op Add>

<Op Add>     ::= <Op Add> '+' <Op Mult>
               | <Op Add> '-' <Op Mult>
               | <Op Mult>

<Op Mult>    ::= <Op Mult> '*' <Op Unary>
               | <Op Mult> '/' <Op Unary>
               | <Op Mult> '%' <Op Unary>
               | <Op Unary>

<Op Unary>   ::= '!'    <Op Unary>
               | '~'    <Op Unary>   
               | '-'    <Op Unary>
               | '*'    <Op Unary>
               | '&'    <Op Unary>               
               | '++'   <Op Unary>
               | '--'   <Op Unary>
               | <Op Pointer> '++'
               | <Op Pointer> '--'
               | '(' <Type> ')' <Op Unary>   !CAST
               | sizeof '(' <Type> ')'
               | sizeof '(' ID <Pointers> ')'
               | <Op Pointer>

<Op Pointer> ::= <Op Pointer> '.' <Value>
               | <Op Pointer> '->' <Value>
               | <Op Pointer> '[' <Expr> ']'
               | <Value>

<Value>      ::= OctLiteral
               | HexLiteral
               | DecLiteral  
               | StringLiteral
               | CharLiteral
               | FloatLiteral
               | Id '(' <Expr> ')'
               | Id '(' ')'          

               | Id
               | '(' <Expr> ')'

C#

C++

Caml

Clean

Clojure

Cobol

! -----------------------------------------------------------------------------
! COBOL 85
!
! COmmon Business Oriented Language 
!
!
! The COBOL programmming language is one of the oldest still in use today. It
! was originally designed by the United States Department of defense under the 
! supervision of the COnference on DAta SYstems Languages (CODASYL) Committee.
! Most of the groundwork and design of COBOL was done by General Grace Hopper 
! of the United States Navy.
!
! The COBOL language was designed to be a self-documenting language where 
! programs would read as close to English as possible. All interaction
! between the user, the terminal and files are performed through language
! statements rather than third-party libraries. The metaphor used for data 
! types is abstract and completely platform independant. As a result of these
! factors, COBOL is a very portable. 
!
! The COBOL 85 grammar is complex - containing, over 350 reserved words, 
! 950 rules which results in iver 1,600 LALR states.
!
!
! Side Note: General Grace Hopper was the engineer who coined the term "bug" 
! when she found an "ill-positioned" insect in an early mainframe.
!
! Revisions:
!    09-13-06: Devin Cook  
!       * Fixed a flaw in the Communications Section where a period was added 
!         to the end of a terminal rather than as a separate terminal. Thanks
!         to Jose Ventura for finding this flaw.
!
!       * Fixed a flaw in the PicString terminal. The definition required two or
!         more spaces between PIC and the picture characters. Thanks to Jose 
!         Ventura for finding this flaw.
!
!    07-21-06: Devin Cook  
!       * The grammar was modified to better handle embeded statements and 
!         message handling clauses.
!
!    06-12-06: Devin Cook  
!       * Grammar was completed
! -----------------------------------------------------------------------------

"Name"    = 'COBOL 85'
"Version" = '1.1'

"Author"  = 'General Grace Hopper (United States Navy) and the CODASYL Committee'

"About"   = 'Originally created in 1960, COBOL (COmmon Business Oriented Language)'
          | 'is one of the top 5 most popular languages in use today. COBOL was designed'
          | 'to be self-documenting by using a structure simular to basic English.'
          | 'This is the full 85 grammar. However, However, differ vendors have'
          | 'created specialized dialects. As result, this grammar may not parse'
          | 'them. This grammar was written by Devin Cook.'

"Case Sensitive" = False
"Start Symbol" = <Program>


{String Chars 1} = {Printable} - ['']
{String Chars 2} = {Printable} - ["]
{Id Tail Chars}  = {Alphanumeric} + [-]

StringLiteral = ''{String Chars 1}*'' | '"'{String Chars 2}*'"'
IntLiteral    = {Digit}+
FloatLiteral  = {Digit}+'.'{Digit}+
Identifier    = {Letter}{Id Tail Chars}*

! -----------------------------------------------------------------------------   
! Picture Clause
! -----------------------------------------------------------------------------

! TYPE SYMBOLS
!   X
!   9
!
! EDITED SYMBOLS
!   , B 0 /          Simple Insertion
!   .                Special Insertion
!   - CR DB $        Fixed Insertion
!   + - $            Floating Insertion
!   Z *              Suppression and Replacement


{Pic Ch} = [xa9] + [bpz0*+-,]
{WS}     = {Space} + {HT} + {NBSP}

PicString = PIC(TURE)? {WS}+ (IS {WS}+)?  (CR|DB|[$s])? {Pic Ch}+ ( '('{Number}+')' )? ( [v.] {Pic Ch}+ ( '('{Number}+')' )? )? (CR|DB|[$s])?
          | PIC(TURE)? {WS}+ (IS {WS}+)?  ''  {String Chars 1}* ''
          | PIC(TURE)? {WS}+ (IS {WS}+)?  '"' {String Chars 2}* '"'

! -----------------------------------------------------------------------------  
! Main program structure
! ----------------------------------------------------------------------------- 

<Program>
        ::= <Identification Division> <Environment Division> <Data Division> <Procedure Division>

! -----------------------------------------------------------------------------  
! Optional Keywords - Often used only for readbility
! -----------------------------------------------------------------------------        

<ADVANCING Opt>  ::= ADVANCING    |  !Optional
<ALL Opt>        ::= ALL          |  !Optional
<ARE Opt>        ::= ARE          |  !Optional                  
<AREA Opt>       ::= AREA | AREAS |  !Optional
<AT Opt>         ::= AT           |  !Optional        
<BY Opt>         ::= BY           |  !Optional
<CHARACTERS Opt> ::= CHARACTERS   |  !Optional
<COLLATING Opt>  ::= COLLATING    |  !Optional
<CONTAINS Opt>   ::= CONTAINS     |  !Optional
<DATA Opt>       ::= DATA         |  !Optional
<EVERY Opt>      ::= EVERY        |  !Optional      
<FILE Opt>       ::= FILE         |  !Optional      
<FINAL Opt>      ::= FINAL        |  !Optional
<FOR Opt>        ::= FOR          |  !Optional
<GLOBAL Opt>     ::= GLOBAL       |  !Optional
<IN Opt>         ::= IN           |  !Optional
<INDICATE Opt>   ::= INDICATE     |  !Optional 
<INITIAL Opt>    ::= INITIAL      |  !Optional 
<IS Opt>         ::= IS           |  !Optional
<KEY Opt>        ::= KEY          |  !Optional
<LINE Opt>       ::= LINE         |  !Optional
<LINES Opt>      ::= LINE | LINES |  !Optional
<MESSAGE opt>    ::= MESSAGE      |  !Optional
<MODE Opt>       ::= MODE         |  !Optional
<NEXT Opt>       ::= NEXT         |  !Optional
<NUMBER Opt>     ::= NUMBER       |  !Optional 
<OF Opt>         ::= OF           |  !Optional
<ON Opt>         ::= ON           |  !Optional
<ORDER opt>      ::= ORDER        |  !Optional
<PRINTING Opt>   ::= PRINTING     |  !Optional
<RECORD Opt>     ::= RECORD       |  !Optional
<REFERENCES Opt> ::= REFERENCES   |  !Optional
<RIGHT Opt>      ::= RIGHT        |  !Optional 
<ROUNDED Opt>    ::= ROUNDED      |  !Optional
<STANDARD Opt>   ::= STANDARD     |  !Optional
<SIGN Opt>       ::= SIGN         |  !Optional
<SIZE Opt>       ::= SIZE         |  !Optional
<STATUS Opt>     ::= STATUS       |  !Optional
<SYMBOLIC Opt>   ::= SYMBOLIC     |  !Optional
<TAPE Opt>       ::= TAPE         |  !Optional
<THEN Opt>       ::= THEN         |  !Optional
<THAN Opt>       ::= THAN         |  !Optional
<TO Opt>         ::= TO           |  !Optional
<WHEN Opt>       ::= WHEN         |  !Optional
<WITH Opt>       ::= WITH         |  !Optional

! -----------------------------------------------------------------------------  
! Equivelent Keywords
! -----------------------------------------------------------------------------                        

<THRU>
        ::= THRU
         |  THROUGH

<IS ARE Opt>
        ::= IS
         |  ARE
         |  !Optional  

<CORRESPONDING>
        ::= CORRESPONDING
         |  CORR

! -----------------------------------------------------------------------------  
! Clauses Shared By Multiple Rules
! -----------------------------------------------------------------------------                        

<Giving Clause Opt> 
        ::= GIVING Identifier
         |  !Optional
               
<Pointer Clause>   
        ::= <WITH Opt> POINTER <Variable>
         |  !Optional
               
<File Name>
        ::= Identifier
         |  StringLiteral

<File Name List>
        ::= <File Name List> <File Name>
         |  <File Name>

<Int Constant>
        ::= Identifier
         |  <Integer>

<Index Clause>
        ::= INDEXED <BY Opt> Identifier
         |  !Optional

<BEFORE AFTER>
        ::= BEFORE
         |  AFTER

! -----------------------------------------------------------------------------  
! Values, Literals, etc...
! -----------------------------------------------------------------------------

<Symbolic Value>
        ::= <Literal>
         |  <Variable>
         |  <Figurative>

<Values>       
       ::= <Values> <Value>
        |  <Value>   
                
<Value>      
        ::= <Literal>
         |  <Variable>
                     
<Numeric>    
        ::= <Integer>
         |  Identifier
                                  
<Literal>
        ::= <Integer>
         |  FloatLiteral
         |  StringLiteral
         |  QUOTE
         |  QUOTES

<Integer>
        ::= IntLiteral
         |  '66'
         |  '77'         
         |  '88'
         
<Figurative> 
        ::= ZERO
         |  ZEROS
         |  ZEROES
         |  SPACE
         |  SPACES
         |  HIGH-VALUE
         |  HIGH-VALUES
         |  LOW-VALUE
         |  LOW-VALUES
         |  ALL StringLiteral
         |  NULL
         |  NULLS

<Identifiers> 
        ::= <Identifiers> Identifier
         |  Identifier

<Variables> 
        ::= <Variables> Identifier 
         |  Identifier

<Variable>
        ::= Identifier
         |  Identifier '(' <Subsets> ')'

<Subsets>
        ::= <Subsets> ':' <Numeric> 
         |  <Numeric>

! -----------------------------------------------------------------------------
! ------------------------- IDENTIFICATION DIVISION ---------------------------
! -----------------------------------------------------------------------------
       
<Identification Division> 
        ::= IDENTIFICATION DIVISION '.' <Prog ID> <Program Info Items>
        
<Prog ID>
        ::= PROGRAM-ID '.' <Word List> <Prog Name Opt> '.'

<Program Info Items> 
        ::= <Program Info Items> <Program Info Item>
         |  !Zero or more
        
<Program Info Item>
        ::= AUTHOR        '.' <Word List> '.'
         |  INSTALLATION  '.' <Word List> '.'
         |  DATE-WRITTEN  '.' <Word List> '.'
         |  DATE-COMPILED '.' <Word List> '.'
         |  SECURITY      '.' <Word List> '.'
         
<Word List> 
        ::= <Word List> <Word Item>                         
         |  <Word Item>

<Word Item>
        ::= Identifier 
         |  <Integer> 
         |  FloatLiteral 
         |  StringLiteral 
         |  '/' 
         |  ','
                                         
<Prog Name Opt>
        ::= <IS Opt> <Common Initial> <Program Opt>
         |  !Optional
    
<Common Initial> 
        ::= COMMON
         |  INITIAL
        
<Program Opt>
         ::= PROGRAM
          |  !Optional
 
! -----------------------------------------------------------------------------
! -------------------------- ENVIRONMENT DIVISION -----------------------------
! -----------------------------------------------------------------------------  

<Environment Division>
       ::= ENVIRONMENT DIVISION '.' <Config Section> <Input-Output Section>
        |  !Optional
        
! -----------------------------------------------------------------------------   
! CONFIGURATION SECTION
! -----------------------------------------------------------------------------

<Config Section>   
        ::= CONFIGURATION SECTION '.' <Config Section Items>
         |  !Optional

<Config Section Items>
        ::= <Config Section Items> <Config Section Item>
         |  !Zero or more

<Config Section Item>
        ::= <Source Computer>
         |  <Object Computer>
         |  <Special Names>
                           
! -----------------------------------------------------------------------------  
! SOURCE-COMPUTER
! ----------------------------------------------------------------------------- 

<Source Computer>  
        ::= SOURCE-COMPUTER '.' <Source Computer Clause Opt>

<Source Computer Clause Opt>
        ::= Identifier <Source Debug Opt> '.'
         |  !Optional 
                  
<Source Debug Opt> 
        ::= <WITH Opt> DEBUGGING MODE
        
! -----------------------------------------------------------------------------  
! OBJECT-COMPUTER
! ----------------------------------------------------------------------------- 
                     
<Object Computer>  
        ::= OBJECT-COMPUTER '.' <Object Computer Clause Opt>

<Object Computer Clause Opt>
        ::= Identifier <Object Clauses> '.'
         |  !Optional
        
<Object Clauses>
        ::= <Object Clause> <Object Clauses>
         |  !Optional

<Object Clause>
        ::= <Program Opt> <COLLATING Opt> SEQUENCE <IS Opt> Identifier
         |  SEGMENT-LIMIT <IS Opt> <Integer>
        
! -----------------------------------------------------------------------------  
! SPECIAL-NAMES
! ----------------------------------------------------------------------------- 
      
<Special Names> 
        ::= SPECIAL-NAMES '.' <Special Name List>
        
<Special Name List>
        ::= <Special Name List> <Special Names Item>
         |  !Zero or more
  
<Special Names Item> 
        ::= Identifier <IS Opt> Identifier <Name Status Items> '.' 
         |  Identifier                     <Name Status Items> '.'
         |  SYMBOLIC <CHARACTERS Opt> <Symbolic Char List>  '.'
         |  ALPHABET Identifier <IS Opt> <Alphabet Item>    '.'
         |  CLASS Identifier    <IS Opt> <Special Ranges>   '.'
         |  CURRENCY <SIGN Opt> <IS Opt> <Literal>          '.'
         |  DECIMAL-POINT       <IS Opt> COMMA              '.'
         
<Name Status Items> 
        ::= <Name Status Items> <Name Status Item>
         |  !Zero or more

<Name Status Item>
        ::= ON  <STATUS Opt> <IS Opt> Identifier
         |  OFF <STATUS Opt> <IS Opt> Identifier

! -----------------------------------------------

<Alphabet Item>
        ::= STANDARD-1
         |  STANDARD-2 
         |  NATIVE
         |  Identifier
         |  <Special Ranges>

<Special Ranges>
         ::= <Special Ranges> ALSO <Special Range>
          |  <Special Range>

<Special Range>
         ::= <Literal> <THRU> <Literal>

! -----------------------------------------------

<Symbolic Char List>
         ::= <Symbolic Characters>
          |  <Symbolic Characters> IN Identifier

<Symbolic Characters>
         ::= <Symbolic Character> <Symbolic Value>
          |  <Symbolic Character>

<Symbolic Character>
         ::= Identifier <IS ARE Opt> <Literal>

! -----------------------------------------------------------------------------   
! INPUT-OUTPUT SECTION
! -----------------------------------------------------------------------------        
        
<Input-Output Section> 
        ::= INPUT-OUTPUT SECTION '.' <File-Control> <I-O-Control>
         |  !Optional
                
! -----------------------------------------------------------------------------  
! FILE-CONTROL
! ----------------------------------------------------------------------------- 
   
<File-Control> 
        ::= FILE-CONTROL '.' <Select Block>
         |  !Optional
        
<Select Block>
        ::= <Select Block> <Select Paragraph>
         |  !Optional
        
<Select Paragraph> 
        ::= SELECT <Optional Opt> Identifier ASSIGN <TO Opt> Identifier <Select Opt List> '.'

<Optional Opt> 
        ::= OPTIONAL
         |  !Null
                    
<Select Opt List>
        ::= <Select Option> <Select Opt List>
         |  !Zero or more
                
<Select Option> 
        ::= RESERVE <Integer> <AREA Opt>
         |  ORGANIZATION <IS Opt> <Organization Kind>
         |                        <Organization Kind>
         |  PADDING <Character Opt> <IS Opt> <Padding Kind>  
         |  RECORD DELIMITER  <IS Opt> <Record Delimiter Kind>
         |  RECORD <KEY Opt>  <IS Opt> Identifier
         |  ALTERNATIVE RECORD <KEY Opt> <IS Opt> Identifier <Duplicates Clause Opt>

         |  ACCESS <MODE Opt> <IS Opt> <Access Mode>
         |  <FILE Opt> STATUS <IS Opt> Identifier
                                         
<Access Mode> 
        ::= SEQUENTIAL
         |  RANDOM
         |  DYNAMIC
                    
<Organization Kind> 
        ::= SEQUENTIAL
         |  LINE SEQUENTIAL
         |  RELATIVE <Relative Key Opt>
         |  INDEXED 
                
<Relative Key Opt>  
        ::= <KEY Opt> <IS Opt> Identifier
         |  !Optional
                  
<Record Delimiter Kind>
        ::= STANDARD-1
         |  Identifier

<Padding Kind>
        ::= Identifier
         |  <Literal>

<Duplicates Clause Opt>
        ::= <WITH Opt> DUPLICATES
         |  !Optional   

! -----------------------------------------------------------------------------  
! I-O CONTROL
! ----------------------------------------------------------------------------- 

<I-O-Control>
        ::= I-O-CONTROL '.' <Rerun List> <Same List> <Multiple List> '.'
        
<Rerun List>
        ::= <Rerun List> <Rerun Item>
         |  !Zero or more

<Rerun Item>
        ::= RERUN <Rerun Clause Opt> <EVERY Opt> <Every Clause>
        
<Rerun Clause Opt>
        ::= ON <File Name>
         |  !Optional 

<Every Clause>
        ::= <End Of Opt> <Every End Target> <OF Opt> <File Name>
         |  <Integer> RECORDS
         |  <Integer> CLOCK-UNITS
         |  Identifier 

<End Of Opt>
        ::= END <OF Opt>
         |  !Optional

<Every End Target>
        ::= REEL
         |  UNIT

! -----------------------------------------------

<Same List>
        ::= <Same List> <Same Item>
         |  !Zero or more

<Same Item>
        ::= SAME <Same Source> <AREA Opt> <File Name> <File Name List>

<Same Source>
        ::= RECORD
         |  SORT
         |  SORT-MERGE 

<Multiple List> 
        ::= <Multiple List> <Multiple Item>
         |  !Zero or more

<Multiple Item>
        ::= MULTIPLE FILE <TAPE Opt> <CONTAINS Opt> <Contain List>

<Contain List>
        ::= <Contain List> <Contain Item>
         |  <Contain Item>

<Contain Item>
        ::= <File Name> POSITION <IS Opt> <Integer>
         |  <File Name>

! -----------------------------------------------------------------------------
! ------------------------------ DATA DIVISION --------------------------------
! -----------------------------------------------------------------------------        
        
<Data Division>  
        ::= DATA DIVISION '.' <Data Section List>
        
        
<Data Section List> 
        ::= <Data Section Entry> <Data Section List>
         |  !Zero or more
        
<Data Section Entry> 
        ::= <File Section>
         |  <Working-Storage Section>
         |  <Linkage Section>
         |  <Screen Section>
         |  <Communication Section> 
         |  <Report Section>
                       
! -----------------------------------------------------------------------------
! Record Definition
! -----------------------------------------------------------------------------
        
<Record Entry Block>
        ::= <Record Entry Block> <Record Entry>
         |  !Zero or more   

<Record Entry>
        ::= IntLiteral <Level Name> <Record Option List>         '.'   !Normal Record
         |  '66'       <Level Name> RENAMES <Identifier Range>   '.'
         |  '77'       <Level Name> <Record Option List>         '.'   !Constant
         |  '88'       <Level Name> VALUES <IS ARE Opt> <Values> '.'
               
<Level Name>    
        ::= Identifier
         |  FILLER
          
<Times Opt>     
        ::= TIMES
         |  !Optional       

<Record Option List>
        ::= <Record Option List> <Record Option>
         |  !Zero or more  


<Record Option>
        ::= REDEFINES Identifier
         |  <IS Opt> EXTERNAL
         |  <IS Opt> INTERNAL
         |  <Picture>             
       
         |  USAGE <IS Opt> <Usage Args>
         |                 <Usage Args>  

         |  SIGN <IS Opt> <Sign Args> <Sep Char Option>
         |  OCCURS <Numeric>              <Times Opt>                               <Key Clause> <Index Clause>
         |  OCCURS <Numeric> TO <Numeric> <Times Opt> DEPENDING <ON Opt> Identifier <Key Clause> <Index Clause>
         |  SYNCHRONIZED <Left Right Opt>  
         |  SYNC         <Left Right Opt>  
         |  JUSTIFIED <RIGHT Opt>  
         |  JUST      <RIGHT Opt>  
         |  BLANK <WHEN Opt> ZERO
         |  VALUE <IS Opt> <Symbolic Value> 

<Picture>
        ::= PicString

<Key Clause>
        ::= ASCENDING <KEY Opt> <IS Opt> <Identifiers>
         |  DESCENDING <KEY Opt> <IS Opt> <Identifiers>
         |  !Optional

<Usage Args> 
        ::= BINARY
         |  COMPUTATIONAL
         |  COMP
         |  DISPLAY
         |  INDEX
         |  PACKED-DECIMAL
           
<Sign Args>
        ::= LEADING
         |  TRAILING
            
<Sep Char Option>  
        ::= SEPARATE <Character Opt>
         |  !Optional
        
<Character Opt>    
        ::= CHARACTER
         |  !Optional

<Left Right Opt>   
        ::= LEFT
         |  RIGHT
         |  !Optional 
           
        
! -----------------------------------------------------------------------------  
! FILE SECTION
! -----------------------------------------------------------------------------

<File Section> 
        ::= FILE SECTION '.' <File Desc Block>
                
<File Desc Block> 
        ::= <File Desc Entry> <File Desc Block>
         |  !Zero ore more
        
<File Desc Entry> 
        ::= FD Identifier <File Option List> '.' <Record Entry Block>
         |  SD Identifier <File Option List> '.' <Record Entry Block>
                                              
<File Option List>
        ::= <File Option List> <File Option>
         |  !Zero or more

<File Option>
        ::= <File Is Option>
         |  <File Block Option>
         |  <File Record Option>
         |  <File Label Option> 
         |  <File Value Option>
         |  <File Data Option>
         |  <File Linage Option>
         |  <File Code-Set Option>

! -----------------------------------------------------------------------------  
! Description Clauses
! -----------------------------------------------------------------------------

<File Is Option>
        ::= <IS Opt> EXTERNAL
         |  <IS Opt> INTERNAL

! -----------------------------------------------

<File Block Option>
        ::= BLOCK <CONTAINS Opt> <Numeric>              <File Block Units>
         |  BLOCK <CONTAINS Opt> <Numeric> TO <Numeric> <File Block Units>

<File Block Units>
        ::= RECORDS
         |  CHARACTERS
         |  !Optional - defaults to characters.          

! -----------------------------------------------
 
<File Record Option>
        ::= RECORD <CONTAINS Opt> <Numeric> <CHARACTERS Opt>
         |  RECORD <CONTAINS Opt> <Numeric> TO <Numeric> <CHARACTERS Opt>
         |  RECORD <IS Opt> VARYING <IN Opt> <SIZE Opt> <File Record Size Clause> <File Record Depending Clause>

<File Record Size Clause>
        ::= FROM <Numeric> <CHARACTERS Opt>
         |  TO   <Numeric> <CHARACTERS Opt>
         |  FROM <Numeric> TO <Numeric> <CHARACTERS Opt>
         |  !Optional 

<File Record Depending Clause>
        ::= DEPENDING <ON Opt> Identifier
         |  !Optional 

! -----------------------------------------------

<File Label Option> 
        ::= LABEL RECORD  <IS Opt> <File Label Type>
         |  LABEL RECORDS <IS Opt> <File Label Type>

<File Label Type> 
        ::= STANDARD
         |  OMITTED

! -----------------------------------------------

<File Value Option>
        ::= VALUE OF <File Value List>

<File Value List>
        ::= <File Value List> <File Value Item>
         |  <File Value Item>

<File Value Item>
        ::= Identifier <IS Opt> Identifier
         |  Identifier <IS Opt> <Literal>

! -----------------------------------------------

<File Data Option>
        ::= DATA RECORD  <IS Opt>  <Identifiers>
         |  DATA RECORDS <ARE Opt> <Identifiers>

! -----------------------------------------------

<File Linage Option>
        ::= LINAGE <IS Opt> <Int Constant> <LINES Opt> <File Linage Footing> <File Linage Top> <File Linage Bottom>
 
<File Linage Footing> 
        ::= <WITH Opt> FOOTING <AT Opt> <Int Constant>
         !  Optional

<File Linage Top>
        ::= <LINES Opt> <AT Opt> TOP <Int Constant>
         !  Optional

<File Linage Bottom>
        ::= <LINES Opt> <AT Opt> BOTTOM <Int Constant>
         !  Optional

! -----------------------------------------------

<File Code-Set Option>
        ::= CODE-SET <IS Opt> Identifier

! -----------------------------------------------------------------------------  
! WORKING-STORAGE SECTION
! -----------------------------------------------------------------------------

<Working-Storage Section> 
        ::= WORKING-STORAGE SECTION '.' <Record Entry Block>
        
        
! -----------------------------------------------------------------------------  
! LINKAGE SECTION
! -----------------------------------------------------------------------------

<Linkage Section>  
        ::= LINKAGE SECTION '.' <Record Entry Block>
            

! -----------------------------------------------------------------------------  
! SCREEN SECTION
! -----------------------------------------------------------------------------

<Screen Section> 
        ::= SCREEN SECTION '.'  <Screen Field List>      
        
<Screen Field List> 
        ::= <Screen Field> <Screen Field List>
         |  <Screen Field>
                
<Screen Field>
        ::= <Integer> <Field Name opt> <Field Def List> '.'
                
<Field Name opt> 
        ::= Identifier
         |  !Optional
                
<Field Def List> 
        ::= <Field Def List>  <Field Def Item>
         |  !Optional
        
<Field Def Item> 
        ::= LINE   <Numeric>
         |  COLUMN <Numeric>
         |  FOREGROUND-COLOR <Numeric>
         |  BACKGROUND-COLOR <Numeric>
         |  VALUE <IS Opt> <Symbolic Value>
         |  <Picture>
         |  FROM Identifier
         |  USING Identifier
         |  HIGHLIGHT
         |  REVERSE-VIDEO
         |  BLINK
         |  UNDERLINE
         |  BLANK SCREEN
                       
! -----------------------------------------------------------------------------  
! COMMUNICATION SECTION
! -----------------------------------------------------------------------------

<Communication Section>
        ::= COMMUNICATION SECTION '.' <Comm Desc List> 

<Comm Desc List>
        ::= <Comm Desc List> <Comm Desc>
         |   !Zero or more

<Comm Desc>
        ::= CD Identifier <FOR Opt> <INITIAL Opt> INPUT  <Comm Input Body>     '.' <Record Entry Block>
         |  CD Identifier <FOR Opt>               OUTPUT <Comm Output Options> '.' <Record Entry Block>
         |  CD Identifier <FOR Opt> <INITIAL Opt> I-O    <Comm I-O Body>       '.' <Record Entry Block>

<Comm Input Body>
        ::= <Identifiers>
         |  <Comm Input Options>

<Comm Input Options>
        ::= <Comm Input Options> <Comm Input Option>
         |  !Zero ore more

<Comm Input Option>
        ::= <SYMBOLIC Opt> QUEUE       <IS Opt> Identifier
         |  <SYMBOLIC Opt> SUB-QUEUE-1 <IS Opt> Identifier
         |  <SYMBOLIC Opt> SUB-QUEUE-2 <IS Opt> Identifier
         |  <SYMBOLIC Opt> SUB-QUEUE-3 <IS Opt> Identifier
         |  MESSAGE DATE <IS Opt> Identifier   
         |  MESSAGE TIME <IS Opt> Identifier
         |  <SYMBOLIC Opt> SOURCE <IS Opt> Identifier
         |  TEXT LENGTH <IS Opt> <Numeric>
         |  END KEY <IS Opt> Identifier
         |  STATUS KEY  <IS Opt> Identifier
         |  MESSAGE COUNT <IS Opt> Identifier           
           
<Comm Output Options>
        ::= <Comm Output Options>  <Comm Output Option>
         |  !Zero or more

<Comm Output Option>
        ::= DESTINATION TABLES OCCURS <Numeric> <TIMES Opt> <Index Clause>
         |  DESTINATION COUNT    <IS Opt> Identifier           
         |  TEXT LENGTH          <IS Opt> Identifier           
         |  STATUS KEY           <IS Opt> Identifier
         |  ERROR KEY            <IS Opt> Identifier
         |  SYMBOLIC DESTINATION <IS Opt> Identifier
         |  DESTINATION          <IS Opt> Identifier

<Comm I-O Body>
        ::= <Identifiers>
         |  <Comm I-O Options>

<Comm I-O Options>
        ::= <Comm I-O Options> <Comm I-O Option>
         |  !Zero or more 

<Comm I-O Option>
        ::= MESSAGE DATE <IS Opt> Identifier   
         |  MESSAGE TIME <IS Opt> Identifier
         |  <SYMBOLIC Opt> TERMINAL <IS Opt> Identifier
         |  TEXT LENGTH  <IS Opt> <Numeric>
         |  END KEY      <IS Opt> Identifier
         |  STATUS KEY   <IS Opt> Identifier

! -----------------------------------------------------------------------------  
! REPORT SECTION
! -----------------------------------------------------------------------------

<Report Section>
        ::= REPORT SECTION '.' <Report Desc List> 

<Report Desc List>
        ::= <Report Desc List> <Report Desc> 
         |  !Zero or more

<Report Desc>
        ::= RD Identifier <Report Options> <Report Entry Block> 
  
<Report Options>
        ::= <Report Options> <Report Option>
         |  !Zero or more

<Report Option>
        ::= <IS Opt> GLOBAL
         |  CODE <Literal>
         |  <CONTROL IS> <FINAL Opt> <Identifiers>
         |  PAGE <LIMITS IS Opt> <Numeric> <LINES Opt> <Report Heading Opt>

<CONTROL IS>
        ::= CONTROL  IS 
         |  CONTROLS ARE

<LIMITS IS Opt>
        ::= LIMIT IS
         |  LIMITS ARE
         |  !Optional

<Report Heading Opt>
        ::= HEADING <Integer>
         |  !Optional

<Report Entry Block>
        ::= <Report Entry Block> <Report Entry>
         |  !Zero or more   

<Report Entry>
        ::= <Integer> Identifier <Report Entry Options>  '.'

<Report Entry Options>
        ::= <Report Entry Option> <Report Entry Options>
         |  !Zero or more

<Report Entry Option>
        ::= LINE <NUMBER Opt> <IS Opt> <Numeric>           
         |  LINE <NUMBER Opt> <IS Opt> <Numeric> ON NEXT PAGE      !Same as above
         |  LINE <NUMBER Opt> <IS Opt> PLUS <Numeric>
         |  NEXT GROUP        <IS Opt> <Report Entry Next Group>
         |  TYPE              <IS Opt> <Report Entry Type>
         |  USAGE             <IS Opt> DISPLAY
         |  DISPLAY

         |  <Picture>                    
         |  SIGN <IS Opt> <Sign Args> <Sep Char Option>
         |  JUSTIFIED <RIGHT Opt>  
         |  JUST      <RIGHT Opt>  
         |  BLANK <WHEN Opt> ZERO
         |  COLUMN <Number Opt> <IS Opt> <Numeric>
         |  SOURCE  <IS Opt> <Numeric>
         |  VALUE   <IS Opt> <Symbolic Value> 
         |  SUM <Identifiers> 
         |  SUM <Identifiers> UPON <Identifiers> <Report Entry Result Clause>
         |  GROUP <INDICATE Opt>

<Report Entry Next Group>
        ::= <Numeric>
         |  PLUS <Numeric>
         |  NEXT PAGE     

<Report Entry Type>
        ::= REPORT HEADING
         |  RH                !Report Heading
         |  PAGE HEADING
         |  PH                !Page Heading
         |  CONTROL HEADING
         |  CH                !Control Heading
         |  DETAIL          
         |  DE                !Detail
         |  CONTROL FOOTING
         |  CF                !Control Footing      
         |  PAGE FOOTING   
         |  PF                !Page Footing
         |  REPORT FOOTING
         |  RF                !Report Footing


<Report Entry Result Clause>
        ::= RESET <ON Opt> Identifier 
         |  RESET <ON Opt> FINAL
         |  !Optional

! ------------------------------------------------------------------------------
! --------------------------- PROCEDURE DIVISION ------------------------------- 
! ------------------------------------------------------------------------------
  
<Procedure Division>
        ::= PROCEDURE DIVISION <Using Clause Opt> <Declarative Block> '.' <Paragraphs>  

<Using Clause Opt> 
        ::= USING <Identifiers>
         |  !Optional
        
<Paragraphs>  
        ::= <Paragraphs> <Paragraph>
         |  !Zero or more

<Paragraph>
        ::= Identifier SECTION '.' Identifier '.' <Sentences>
         |                         Identifier '.' <Sentences>

! -----------------------------------------------------------------------------  
! Declaratives
! -----------------------------------------------------------------------------
    
<Declarative Block>
        ::= DECLARATIVES '.' <Declarative Sections> END DECLARATIVES '.'    !No dash - inconsistent
         |  !Optional

<Declarative Sections>
        ::= <Declarative Sections> <Declarative Section> 
         |  !Zero or more

<Declarative Section>
        ::= Identifier SECTION '.' USE <BEFORE AFTER> <STANDARD Opt> ERROR PROCEDURE ON <Error Cause>  '.' <Sentences>
         |  Identifier '.' <Sentences>

<Error Cause>
        ::= Identifier 
         |  INPUT 
         |  OUTPUT
         |  I-O
         |  EXTEND 

! -----------------------------------------------------------------------------  
! Shared by sentences
! -----------------------------------------------------------------------------

<Sort Keys>
        ::= <Sort Keys> <Sort Key>
         |  <Sort Key>
         
<Sort Key>         
        ::= <ON Opt> ASCENDING  <KEY Opt> Identifier
         |  <ON Opt> DESCENDING <KEY Opt> Identifier

<Collating Clause>
        ::= <COLLATING Opt> SEQUENCE <IS Opt> Identifier
         |  !Optional        

<Sort Source>
        ::= INPUT PROCEDURE <IS Opt> <Identifier Range>
         |  USING <Values>                
     
<Sort Target>
        ::= OUTPUT PROCEDURE <IS Opt> <Identifier Range>
         |  GIVING <Values>                
    
<Identifier Range>
        ::= Identifier
         |  Identifier THRU Identifier
         |  Identifier THROUGH Identifier          
                               
<Enabled Disable Mode>        
        ::= INPUT 
         |  INPUT TERMINAL
         |  I-O TERMINAL
         |  OUTPUT

<Enable Disable Key>
        ::= <WITH Opt> KEY <Value>
         |  !Optional

! -----------------------------------------------------------------------------  
! Boolean Expressions
! -----------------------------------------------------------------------------

! Note: <Not Opt> is very significant in the operators below

<Boolean Exp>   
        ::= <Boolean Exp> OR <And Exp>
         |  <And Exp>

<And Exp>
        ::= <Negation Exp> And <And Exp>
         |  <Negation Exp>
              
<Negation Exp>  
        ::= <Compare Exp>
         |  NOT <Compare Exp>
 
!<And Exp>
!        ::= <And Exp> AND <Compare Exp>
!         |  <Compare Exp>
              
<Compare Exp> 
        ::= <Symbolic Value> <Compare Op> <Symbolic Value>
         |  <Symbolic Value> IS ALPHABETIC
         |  <Symbolic Value> IS ALPHABETIC-UPPER
         |  <Symbolic Value> IS ALPHABETIC-LOWER
         |  '(' <Boolean Exp> ')'
         |  <Symbolic Value>
    
<Compare Op>
        ::= <IS ARE Opt>     <Greater Op>
         |  <IS ARE Opt> NOT <Greater Op>

         |  <IS ARE Opt>     <Greater Eq Op>
         |  <IS ARE Opt> NOT <Greater Eq Op>

         |  <IS ARE Opt>     <Less Op>
         |  <IS ARE Opt> NOT <Less Op>

         |  <IS ARE Opt>     <Less Eq Op>
         |  <IS ARE Opt> NOT <Less Eq Op>

         |  <IS ARE Opt>     <Equal Op>
         |  <IS ARE Opt> NOT <Equal Op>
  
<Greater Op>    
        ::= GREATER <THAN Opt>
         |  '>'
                    
<Greater Eq Op> 
        ::= GREATER <THAN Opt> OR EQUAL <TO Opt>
         |  '>='
                    
<Less Op>       
        ::= LESS <THAN Opt>
         |  '<'
                    
<Less Eq Op>    
        ::= LESS <THAN Opt> OR EQUAL <TO Opt>
         |  '<='

<Equal Op>
        ::= EQUAL <TO Opt>
         |  '='


! -----------------------------------------------------------------------------  
! Sentences
! -----------------------------------------------------------------------------

! If you add statements to the grammar, make sure to update the corresponding 
! <Statement> rules below
             
<Sentences> 
        ::= <Sentence> <Sentences>
         |  !Zero or more

<Sentence> 
        ::= <Sent Stm>  '.'   

<Sent Stm>
        ::= <Accept Sent>
         |  <Add Sent>     
         |  <Alter Sent>         
         |  <Call Sent>
         |  <Cancel Sent>
         |  <Close Sent>
         |  <Compute Sent>
         |  <Continue Sent>
         |  <Delete Sent>
         |  <Disable Sent> 
         |  <Display Sent>
         |  <Divide Sent>
         |  <Enable Sent>
         |  <Evaluate Sent>
         |  <Exit Sent>
         |  <Generate Sent>     
         |  <Go To Sent>
         |  <If Sent>
         |  <Initialize Sent>                      
         |  <Initiate Sent>      
         |  <Inspect Sent>     
         |  <Merge Sent>
         |  <Move Sent>         
         |  <Multiply Sent>
         |  <Open Sent>
         |  <Perform Sent>
         |  <Read Sent>
         |  <Release Sent>
         |  <Return Sent>                         
         |  <Rewrite Sent>  
         |  <Search Sent>
         |  <Send Sent>                      
         |  <Set Sent>
         |  <Sort Sent>
         |  <Start Sent>
         |  <Stop Sent>         
         |  <String Sent>      
         |  <Subtract Sent>             
         |  <Suppress Sent>
         |  <Terminate Sent>
         |  <Unstring Sent>
         |  <Use Sent> 
         |  <Write Sent>

<Embed Stms> 
        ::= <Embed Stms> <Embed Stm>
         |  <Embed Stm>
                
<Embed Stm>
        ::= <Accept Embed>
         |  <Add Embed>     
         |  <Alter Embed>         
         |  <Call Embed>
         |  <Cancel Embed>
         |  <Close Embed>
         |  <Compute Embed>
         |  <Continue Embed>
         |  <Delete Embed>
         |  <Disable Embed> 
         |  <Display Embed>
         |  <Divide Embed>
         |  <Enable Embed>
         |  <Evaluate Embed>
         |  <Exit Embed>
         |  <Generate Embed>     
         |  <Go To Embed>
         |  <If Embed>
         |  <Initialize Embed>                      
         |  <Initiate Embed>      
         |  <Inspect Embed>     
         |  <Merge Embed>
         |  <Move Embed>         
         |  <Multiply Embed>
         |  <Open Embed>
         |  <Perform Embed>
         |  <Read Embed>
         |  <Release Embed>
         |  <Return Embed>                         
         |  <Rewrite Embed>  
         |  <Search Embed>
         |  <Send Embed>                      
         |  <Set Embed>
         |  <Sort Embed>
         |  <Start Embed>
         |  <Stop Embed>         
         |  <String Embed>      
         |  <Subtract Embed>             
         |  <Suppress Embed>
         |  <Terminate Embed>
         |  <Unstring Embed>
         |  <Use Embed> 
         |  <Write Embed>

<Imperative Stms> 
        ::= <Imperative Stms> <Imperative Stm>
         |  <Imperative Stm>
                              
<Imperative Stm>
        ::= <Accept Imp>
         |  <Add Imp>     
         |  <Alter Imp>         
         |  <Call Imp>
         |  <Cancel Imp>
         |  <Close Imp>
         |  <Compute Imp>
         |  <Continue Imp>
         |  <Delete Imp>
         |  <Disable Imp> 
         |  <Display Imp>
         |  <Divide Imp>
         |  <Enable Imp>
         |  <Evaluate Imp>
         |  <Exit Imp>
         |  <Generate Imp>     
         |  <Go To Imp>
         |  <If Imp>
         |  <Initialize Imp>                      
         |  <Initiate Imp>      
         |  <Inspect Imp>     
         |  <Merge Imp>
         |  <Move Imp>         
         |  <Multiply Imp>
         |  <Open Imp>
         |  <Perform Imp>
         |  <Read Imp>
         |  <Release Imp>
         |  <Return Imp>                         
         |  <Rewrite Imp> 
         |  <Search Imp> 
         |  <Send Imp>                      
         |  <Set Imp>
         |  <Sort Imp>
         |  <Start Imp>
         |  <Stop Imp>         
         |  <String Imp>      
         |  <Subtract Imp>             
         |  <Suppress Imp>
         |  <Terminate Imp>
         |  <Unstring Imp>
         |  <Use Imp> 
         |  <Write Imp>
    
! -----------------------------------------------------------------------------  
! Exception Handling
! -----------------------------------------------------------------------------

<Size Clauses>
        ::= <Size Clauses> <Size Clause>
         |  <Size Clause>

<Size Clause>
        ::=     <ON Opt> SIZE ERROR <Imperative Stms>
         |  NOT <ON Opt> SIZE ERROR <Imperative Stms>
 
!-----------------------------------------

<Invalid Key Clauses>
        ::= <Invalid Key Clauses> <Invalid Key Clause>
         |  <Invalid Key Clause>

<Invalid Key Clause>
        ::=     INVALID <KEY Opt> <Imperative Stms>
         |  NOT INVALID <KEY Opt> <Imperative Stms>
   
!-----------------------------------------

<Exception Clauses>
        ::= <Exception Clauses> <Exception Clause>
         |  <Exception Clause>

<Exception Clause>
        ::=     <ON Opt> EXCEPTION <Imperative Stms>
         |  NOT <ON Opt> EXCEPTION <Imperative Stms>
    
!-----------------------------------------     

<Overflow Clauses>
        ::= <Overflow Clauses> <Overflow Clause>
         |  <Overflow Clause>

<Overflow Clause>  
        ::=     <ON Opt> OVERFLOW <Imperative Stms>
         |  NOT <ON Opt> OVERFLOW <Imperative Stms>
   
!-----------------------------------------

<At End Clauses>
        ::= <At End Clauses> <At End Clause>
         |  <At End Clause>

<At End Clause>
        ::=     AT END <Imperative Stms>
         |  NOT AT END <Imperative Stms>    

!-----------------------------------------

<AT EOP Clauses>           
        ::= <AT EOP Clauses> <AT EOP Clause>
         |  <AT EOP Clause>

<AT EOP Clause>           
        ::= AT <End of Page> <Imperative Stms>    
         |  NOT AT <End of Page> <Imperative Stms>
          
<End of Page>
        ::= END-OF-PAGE
         |  EOP

! -----------------------------------------------------------------------------  
! ACCEPT Statement
! -----------------------------------------------------------------------------

<Accept Sent>
       ::= <Accept Stm> 

<Accept Embed>
       ::= <Accept Stm>

<Accept Imp>
       ::= <Accept Stm>

<Accept Stm> 
       ::= ACCEPT Identifier 
        |  ACCEPT Identifier FROM <Accept From Arg> 
        |  ACCEPT Identifier <MESSAGE opt> COUNT        !CD
    
<Accept From Arg> 
       ::= FROM DATE
        |  FROM DAY 
        |  FROM DAY-OF-WEEK 
        |  FROM TIME 
        |  FROM CONSOLE 
        |  FROM Identifier
        |  !Optional 

! -----------------------------------------------------------------------------  
! ADD Statement
! -----------------------------------------------------------------------------       

<Add Sent>
        ::= <Add Stm> <Size Clauses> <END-ADD Opt>
         |  <Add Stm>

<Add Embed>
        ::= <Add Stm> <Size Clauses> 'END-ADD'
         |  <Add Stm>

<Add Imp>
        ::= <Add Stm> 
   
<Add Stm>
        ::= ADD <Values> TO <Add Items> <Giving Clause>
         |  ADD <CORRESPONDING> Identifier TO Identifier <ROUNDED Opt>
        
<Giving Clause>
        ::= GIVING <Add Item>
         |  !Optional

<Add Items>
        ::= <Add Items> <Add Item>
         |  <Add Item>
         
<Add Item>
        ::= <Variable> <ROUNDED Opt>


<END-ADD Opt>
        ::= END-ADD
         |  !Optional 

! -----------------------------------------------------------------------------  
! ALTER Statement
! -----------------------------------------------------------------------------       

<Alter Sent>
       ::= <Alter Stm>

<Alter Embed>
       ::= <Alter Stm>

<Alter Imp>
       ::= <Alter Stm>

<Alter Stm>
       ::= ALTER Identifier TO Identifier
        |  ALTER Identifier TO PROCEED TO Identifier
 
! -----------------------------------------------------------------------------  
! CALL Statement
! -----------------------------------------------------------------------------

!Call can call just about anything, it depends on the system.

<Call Sent> 
        ::= <Call Stm> <Exception Clauses> <END-CALL Opt>
         |  <Call Stm> <Overflow Clauses>  <END-CALL Opt>
         |  <Call Stm>

<Call Embed> 
        ::= <Call Stm> <Exception Clauses> END-CALL
         |  <Call Stm> <Overflow Clauses>  END-CALL
         |  <Call Stm>

<Call Imp>
        ::= <Call Stm>  

<Call Stm> 
        ::= CALL <Value>                        
         |  CALL <Value> USING <Call Items>

<Call Items>
        ::= <Call Items> <Call Item>
         |  <Call Item>

<Call Item>
        ::= <Variable>        
         |  <BY Opt> REFERENCE <Variable>   !default
         |  <BY Opt> CONTENT   <Variable>

<END-CALL Opt>
        ::= END-CALL
         |  !Optional

! -----------------------------------------------------------------------------  
! CANCEL Statement
! -----------------------------------------------------------------------------                     

<Cancel Sent>  
        ::= <Cancel Stm>

<Cancel Embed>  
        ::= <Cancel Stm>

<Cancel Imp>  
        ::= <Cancel Stm>

<Cancel Stm>  
        ::= CANCEL <Values>

! -----------------------------------------------------------------------------  
! CLOSE Statement
! -----------------------------------------------------------------------------                     

<Close Sent>
        ::= <Close Stm>    

<Close Embed>
        ::= <Close Stm>    

<Close Imp>
        ::= <Close Stm>    

<Close Stm>    
        ::= CLOSE <Close Items>

<Close Items>
        ::= <Close Items> <Close Item>
         |  <Close Item>

<Close Item>
        ::= Identifier <Close Options> 

<Close Options> 
        ::= UNIT <Close Method>
         |  REEL <Close Method>
         |  <WITH Opt> LOCK
         |  <WITH Opt> NO REWIND
         |  !Empty
       
<Close Method>  
        ::= <FOR Opt> REMOVAL
         |  !Optional
        
! -----------------------------------------------------------------------------  
! COMPUTE Statement
! -----------------------------------------------------------------------------              

<Compute Sent> 
        ::= <Compute Stm> <Size Clauses> <END-COMPUTE Opt>
         |  <Compute Stm>

<Compute Embed> 
        ::= <Compute Stm> <Size Clauses> END-COMPUTE
         |  <Compute Stm>

<Compute Imp> 
        ::= <Compute Stm>

<Compute Stm> 
        ::= COMPUTE Identifier <ROUNDED Opt> <Equal Op> <Math Exp>
       
<Math Exp>
        ::= <Math Exp> '+' <Mult Exp>
         |  <Math Exp> '-' <Mult Exp>
         |  <Mult Exp> 

<Mult Exp>
        ::= <Mult Exp> '*' <Negate Exp>
         |  <Mult Exp> '/' <Negate Exp>
         |  <Negate Exp>

<Negate Exp>   
        ::= '-' <Value>
         |  <Value>
         |  '(' <Math Exp> ')'

<END-COMPUTE Opt>
        ::= END-COMPUTE
         |  !Optional

! -----------------------------------------------------------------------------  
! CONTINUE
! -----------------------------------------------------------------------------              

<Continue Sent> 
        ::= <Continue Stm> 

<Continue Embed> 
        ::= <Continue Stm> 

<Continue Imp> 
        ::= <Continue Stm> 

<Continue Stm> 
        ::= CONTINUE

! -----------------------------------------------------------------------------  
! DELETE Statement
! -----------------------------------------------------------------------------
           
<Delete Sent>
        ::= <Delete Stm> <Invalid Key Clauses> <END-DELETE Opt>
         |  <Delete Stm> 

<Delete Embed>
        ::= <Delete Stm> <Invalid Key Clauses> END-DELETE
         |  <Delete Stm>

<Delete Imp>
        ::= <Delete Stm>

<Delete Stm>
        ::= DELETE Identifier <RECORD Opt>

<END-DELETE Opt>
        ::= END-DELETE
         |  !Optional

! -----------------------------------------------------------------------------  
! DISABLE Statement
! -----------------------------------------------------------------------------

<Disable Sent>    
        ::= <Disable Stm> 

<Disable Embed>    
        ::= <Disable Stm> 

<Disable Imp>    
        ::= <Disable Stm> 

<Disable Stm> 
        ::= DISABLE <Enabled Disable Mode> Identifier <Enable Disable Key>
         
! -----------------------------------------------------------------------------  
! DISPLAY Statement
! -----------------------------------------------------------------------------

<Display Sent>    
        ::= <Display Stm> 

<Display Embed>    
        ::= <Display Stm> 

<Display Imp>    
        ::= <Display Stm> 
    
<Display Stm> 
        ::= DISPLAY <Values> <Display Target> <Advancing Clause>

<Display Target>
        ::= UPON Identifier
         |  !Optional

<Advancing Clause>
        ::= <WITH Opt> NO ADVANCING
         |  !Optional

! -----------------------------------------------------------------------------  
! DIVIDE Statement
! -----------------------------------------------------------------------------       

<Divide Sent> 
        ::= <Divide Stm> <Size Clauses> <END-DIVIDE Opt> 
         |  <Divide Stm>

<Divide Embed> 
        ::= <Divide Stm> <Size Clauses> 'END-DIVIDE' 
         |  <Divide Stm>

<Divide Imp>
        ::= <Divide Stm> 

<Divide Stm> 
        ::= DIVIDE <Values> BY   <Values>
         |  DIVIDE <Values> BY   <Values> GIVING <Variable> <ROUNDED Opt> 
         |  DIVIDE <Values> INTO <Values>
         |  DIVIDE <Values> INTO <Values> GIVING <Variable> <ROUNDED Opt> <Remainder Opt>

<Remainder Opt>
        ::= REMAINDER <Variable>
         |  !Optional
 
<END-DIVIDE Opt>
        ::= END-DIVIDE
         |  !Optional

! -----------------------------------------------------------------------------  
! ENABLE Statement
! -----------------------------------------------------------------------------       

<Enable Sent>
        ::= <Enable Stm>  

<Enable Embed>
        ::= <Enable Stm>  

<Enable Imp>
        ::= <Enable Stm>  

<Enable Stm> 
        ::= ENABLE <Enabled Disable Mode> Identifier <Enable Disable Key>
         
! -----------------------------------------------------------------------------  
! EVALUATE Statement
! -----------------------------------------------------------------------------

<Evaluate Sent> 
        ::= <Evaluate Stm> <END-EVALUATE Opt> 

<Evaluate Embed> 
        ::= <Evaluate Stm> END-EVALUATE

<Evaluate Imp> 
        ::= <Evaluate Stm> END-EVALUATE
 
<Evaluate Stm> 
        ::= EVALUATE <Subjects> <When Clauses> 
              
<Subjects>
        ::= <Subjects> ALSO <Subject>
         |  <Subject>

<Subject>
        ::= TRUE
         |  <Boolean Exp>

<When Clauses>
        ::= <When Clauses> <When Clause>
         |  <When Clause>

<When Clause>  
        ::= WHEN <Phrases> <THEN Opt> <Embed Stms>
         |  WHEN OTHER <THEN Opt> <Embed Stms>

<Phrases> 
        ::= <Phrases> ALSO <Phrase>
         |  <Phrase>

<Phrase>  
        ::= ANY
         |  <Symbolic Value> THROUGH <Symbolic Value>
         |  <Symbolic Value> THRU <Symbolic Value>
         |  <Symbolic Value>

<END-EVALUATE Opt>
        ::= END-EVALUATE
         |  !Optional

! -----------------------------------------------------------------------------  
! EXIT Statement
! -----------------------------------------------------------------------------       

<Exit Sent>
       ::= <Exit Stm>

<Exit Embed>
       ::= <Exit Stm>

<Exit Imp>
       ::= <Exit Stm>

<Exit Stm> 
        ::= EXIT
         |  EXIT PROGRAM
         
! -----------------------------------------------------------------------------  
! GENERATE Statement
! -----------------------------------------------------------------------------       

<Generate Sent>
        ::= <Generate Stm>

<Generate Embed>
        ::= <Generate Stm>

<Generate Imp>
        ::= <Generate Stm>

<Generate Stm>     
        ::= GENERATE Identifier
        
! -----------------------------------------------------------------------------  
! GO TO Statement
! -----------------------------------------------------------------------------       

<Go To Sent> 
        ::= <Go To Stm>

<Go To Embed> 
        ::= <Go To Stm>

<Go To Imp> 
        ::= <Go To Stm>

<Go To Stm>          
        ::= GO TO Identifier
         |  GO TO <Identifiers> DEPENDING ON <Variable>
                
! -----------------------------------------------------------------------------  
! IF Statement
! -----------------------------------------------------------------------------

<If Sent> 
        ::= <If Stm> <END-IF Opt>          

<If Embed> 
        ::= <If Stm> END-IF

<If Imp> 
        ::= <If Stm> END-IF

<If Stm> 
        ::= IF <Boolean Exp> <THEN Opt> <Embed Stms>
         |  IF <Boolean Exp> <THEN Opt> <Embed Stms> ELSE <THEN Opt> <Embed Stms>
         |  IF <Boolean Exp> <THEN Opt> <Embed Stms> ELSE NEXT SENTENCE

<END-IF Opt>
        ::= END-IF
         |  !Optional

! -----------------------------------------------------------------------------  
! INITIALIZE Statement
! -----------------------------------------------------------------------------

<Initialize Sent> 
        ::= <Initialize Stm>  

<Initialize Embed> 
        ::= <Initialize Stm> 

<Initialize Imp> 
        ::= <Initialize Stm> 

<Initialize Stm> 
        ::= INITIALIZE <Variables> <Replacing Opt>
        
<Replacing Opt>
        ::= REPLACING <Replacing Items>
        
<Replacing Items>
        ::= <Replacing Items> <Replacing Item>
         |  <Replacing Item>
        
<Replacing Item>        
        ::= <Replacing Type> <DATA Opt> <Value>

<Replacing Type> 
        ::= ALPHABETIC       
         |  ALPHANUMERIC     
         |  NUMERIC          
         |  ALPHANUMERIC-EDITED 
         |  NUMERIC-EDITED 

! -----------------------------------------------------------------------------  
! INITIATE Statement
! -----------------------------------------------------------------------------

<Initiate Sent> 
        ::= <Initiate Stm>

<Initiate Embed> 
        ::= <Initiate Stm>

<Initiate Imp> 
        ::= <Initiate Stm>

<Initiate Stm> 
        ::= INITIATE <Identifiers> 
         
! -----------------------------------------------------------------------------  
! INSPECT Statement
! -----------------------------------------------------------------------------

<Inspect Sent> 
        ::= <Inspect Stm> 

<Inspect Embed> 
        ::= <Inspect Stm> 

<Inspect Imp> 
        ::= <Inspect Stm> 

<Inspect Stm>        
        ::= INSPECT <Variable> TALLYING <Tally Variables>
         |  INSPECT <Variable> TALLYING <Tally Variables> REPLACING <Replace Chars>
         |  INSPECT <Variable> REPLACING <Replace Chars>
         |  INSPECT <Variable> CONVERTING <Value> TO <Value> <Inspect Specs>       

! ----------------------------------- Tally group

<Tally Variables>
        ::= <Tally Variables> <Tally Variable>
         |  <Tally Variable>
         
<Tally Variable>           
        ::= <Variable> FOR <Tally Items>

<Tally Items>
        ::= <Tally Items> <Tally Item>
         |  <Tally Item>
        
<Tally Item>
        ::= CHARACTERS <Inspect Specs>
         |  ALL      <Value> <Inspect Specs>
         |  LEADING  <Value> <Inspect Specs>

! ----------------------------------- Replacing group
 
<Replace Chars>
        ::= <Replace Chars> <Replace Char>
         |  <Replace Char>
         
<Replace Char>
        ::= CHARACTERS BY <Value> <Inspect Specs>
         |  ALL     <Replace Items>
         |  LEADING <Replace Items>
         |  FIRST   <Replace Items>
        
<Replace Items>
        ::= <Replace Items> <Replace Item>
         |  <Replace Item>
                
<Replace Item>
        ::= <Value> BY <Value> <Inspect Specs>

! ----------------------------------- Substring Specifiers
        
<Inspect Specs>
        ::= <Inspect Specs> <Inspect Spec>
         |  !Zero or more

<Inspect Spec>
        ::= <BEFORE AFTER> INITIAL <Value>
        
! -----------------------------------------------------------------------------  
! MERGE Statement
! -----------------------------------------------------------------------------     

<Merge Sent>
        ::= <Merge Stm>

<Merge Embed>
        ::= <Merge Stm>

<Merge Imp>
        ::= <Merge Stm>

<Merge Stm>
        ::= MERGE Identifier <Sort Keys> <Collating Clause> USING <Identifiers> <Sort Target>
        
! -----------------------------------------------------------------------------  
! MOVE Statement
! -----------------------------------------------------------------------------       

<Move Sent> 
        ::= <Move Stm> <Size Clauses> <END-MOVE Opt>
         |  <Move Stm> 

<Move Embed> 
        ::= <Move Stm> <Size Clauses> END-MOVE
         |  <Move Stm> 

<Move Imp> 
        ::= <Move Stm>

<Move Stm> 
        ::= MOVE <Symbolic Value> TO <Variables>               
         |  MOVE <CORRESPONDING> Identifier TO Identifier 
 
<END-MOVE Opt>
        ::= END-MOVE
         |  !Optional

! -----------------------------------------------------------------------------  
! MULTIPLY Statement
! -----------------------------------------------------------------------------       

<Multiply Sent> 
        ::= <Multiply Stm> <Size Clauses> <END-MULTIPLY Opt>
         |  <Multiply Stm>

<Multiply Embed> 
        ::= <Multiply Stm> <Size Clauses> END-MULTIPLY
         |  <Multiply Stm>

<Multiply Imp> 
        ::= <Multiply Stm>

<Multiply Stm> 
        ::= MULTIPLY <Variables> BY <Multiply Items> <Giving Clause Opt>

<Multiply Items>
        ::= <Multiply Items> <Multiply Item>
         |  <Multiply Item>

<Multiply Item>
        ::= <Value> <ROUNDED Opt>

<END-MULTIPLY Opt>
        ::= END-MULTIPLY
         |  !Optional

! -----------------------------------------------------------------------------  
! OPEN Statement
! ----------------------------------------------------------------------------- 

<Open Sent>
        ::= <Open Stm>

<Open Embed>
        ::= <Open Stm>

<Open Imp>
        ::= <Open Stm>

<Open Stm> 
        ::= OPEN <Open List>
        
<Open List> 
        ::= <Open List> <Open Entry> 
         |  <Open Entry>
              
<Open Entry>
        ::= INPUT  <Variables> <Open No Rewind>
         |  OUTPUT <Variables> <Open No Rewind>
         |  EXTEND <Variables> <Open No Rewind>
         |  I-O    <Variables> <Open No Rewind>
        
<Open No Rewind>
        ::= <WITH Opt> NO REWIND
         |  !Optional
         
! -----------------------------------------------------------------------------  
! PERFORM Statement
! -----------------------------------------------------------------------------              

<Perform Sent>
        ::= <Perform Block> <END-PERFORM Opt>
         |  <Perform Stm>
         |  <Perform Loop>

<Perform Embed>
        ::= <Perform Block> END-PERFORM
         |  <Perform Stm>
         |  <Perform Loop>
           
<Perform Imp>
        ::= <Perform Block> END-PERFORM
         |  <Perform Stm>


<Perform Stm>
        ::= PERFORM <Identifier Range>
         |  PERFORM <Identifier Range> <Numeric> TIMES 

<Perform Loop>
        ::= PERFORM <Identifier Range> <With Test> UNTIL <Boolean Exp> 
         |  PERFORM <Identifier Range> <With Test> VARYING <Perform For List>  

<Perform Block>
        ::= PERFORM <With Test> UNTIL <Boolean Exp>         <Embed Stms>
         |  PERFORM <With Test> VARYING <Perform For List>  <Embed Stms>
         |  PERFORM <Numeric> TIMES                         <Embed Stms>

<With Test> 
        ::= <WITH Opt> TEST <BEFORE AFTER>
         |  !Optional
                      
<Perform For List>
        ::= <Perform For List> AFTER <Perform For Range>
         |  <Perform For Range>

<Perform For Range>
        ::=  <Variable> FROM <Numeric> BY <Numeric> UNTIL <Boolean Exp>

<END-PERFORM Opt>
        ::= END-PERFORM
         |  !Optional

! -----------------------------------------------------------------------------  
! READ Statement
! -----------------------------------------------------------------------------

<Read Sent> 
        ::= <Read Stm> <Read Msg Clauses> <END-READ Opt> 
         |  <Read Stm>

<Read Embed> 
        ::= <Read Stm> <Read Msg Clauses> END-READ 
         |  <Read Stm>

<Read Imp> 
        ::= <Read Stm>

<Read Stm> 
        ::= READ Identifier <Next Opt> <RECORD Opt>                                 
         |  READ Identifier <Next Opt> <RECORD Opt> INTO <Variable> <Read Key Opt>  
             
<Read Msg Clauses>
        ::= <At End Clauses>
         |  <Invalid Key Clauses>

<Read Key Opt>
        ::= KEY <IS Opt> Identifier
         |  !Optional

<END-READ Opt>
        ::= END-READ
         |  !Optional

! -----------------------------------------------------------------------------  
! RELEASE Statement
! -----------------------------------------------------------------------------

<Release Sent>
        ::= <Release Stm>

<Release Embed>
        ::= <Release Stm>

<Release Imp>
        ::= <Release Stm>

<Release Stm>
        ::= RELEASE Identifier 
         |  RELEASE Identifier FROM Identifier
       
! -----------------------------------------------------------------------------  
! RETURN Statement
! -----------------------------------------------------------------------------

<Return Sent> 
        ::= <Return Stm> 

<Return Embed> 
        ::= <Return Stm> 

<Return Imp> 
        ::= <Return Stm> 

<Return Stm> 
        ::= RETURN Identifier <RECORD Opt>
         |  RETURN Identifier <RECORD Opt> INTO Identifier
        
! -----------------------------------------------------------------------------  
! REWRITE Statement
! -----------------------------------------------------------------------------

<Rewrite Sent>
        ::= <Rewrite Stm> <Invalid Key Clauses> <END-REWRITE Opt>
         |  <Rewrite Stm>

<Rewrite Embed>
        ::= <Rewrite Stm> <Invalid Key Clauses> END-REWRITE
         |  <Rewrite Stm>

<Rewrite Imp>
        ::= <Rewrite Stm>

<Rewrite Stm>
        ::= REWRITE Identifier                     
         |  REWRITE Identifier FROM Identifier 

<END-REWRITE Opt>   
        ::= END-REWRITE
         |  !Optional

! -----------------------------------------------------------------------------  
! SEARCH Statement
! -----------------------------------------------------------------------------

<Search Sent> 
        ::= <Search Stm> <END-SEARCH Opt>

<Search Embed> 
        ::= <Search Stm> END-SEARCH

<Search Imp> 
        ::= <Search Stm> END-SEARCH
         
<Search Stm> 
        ::= SEARCH Identifier <Varying Opt> <At End Clauses> <When Clauses>
         |  SEARCH ALL Identifier           <At End Clauses> <When Clauses>

<Varying Opt>
        ::= VARYING <Value>
         |  !Optional 

<END-SEARCH Opt> 
        ::= END-SEARCH
         |  !Optional

! -----------------------------------------------------------------------------  
! SEND Statement
! -----------------------------------------------------------------------------

<Send Sent>
        ::= <Send Stm> 

<Send Embed>
        ::= <Send Stm> 

<Send Imp>
        ::= <Send Stm> 

<Send Stm> 
        ::= SEND Identifier FROM <Variable>
         |  SEND Identifier FROM <Variable> <Send With> <Send Spec> <Send Replacing Opt>
         |  SEND Identifier                 <Send With> <Send Spec> <Send Replacing Opt>

<Send With> 
        ::= <WITH Opt> Identifier
         |  <WITH Opt> ESI
         |  <WITH Opt> EMI
         |  <WITH Opt> EGI
        
<Send Spec>
        ::= <BEFORE AFTER> <ADVANCING Opt> <Send Advance>

<Send Advance>
        ::= <Value> <LINES Opt>
         |  PAGE
               
<Send Replacing Opt>
        ::= REPLACING <LINE Opt>

! -----------------------------------------------------------------------------  
! SET Statement
! -----------------------------------------------------------------------------

<Set Sent>
        ::= <Set Stm> 

<Set Embed>
        ::= <Set Stm> 

<Set Imp>
        ::= <Set Stm> 

<Set Stm> 
        ::= SET <Variables> UP BY <Value>         
         |  SET <Variables> DOWN BY <Value>
         |  SET <Variables> TO <Set Value> 
         
<Set Value> 
        ::= ON
         |  OFF
         |  TRUE

! -----------------------------------------------------------------------------  
! SORT Statement
! -----------------------------------------------------------------------------

<Sort Sent>
        ::= <Sort Stm>

<Sort Embed>
        ::= <Sort Stm>

<Sort Imp>
        ::= <Sort Stm>

<Sort Stm>
        ::= SORT <Value> <Sort Keys> <Sort Duplicates Opt> <Collating Opt> <Sort Source> <Sort Target>
        
<Sort Duplicates Opt>
        ::= <WITH Opt> DUPLICATES <IN Opt> <ORDER opt>
         |  !Optional
              
! -----------------------------------------------------------------------------  
! START Statement
! -----------------------------------------------------------------------------

<Start Sent> 
        ::= <Start Stm> <Invalid Key Clauses> <END-START Opt>
         |  <Start Stm>

<Start Embed> 
        ::= <Start Stm> <Invalid Key Clauses> END-START
         |  <Start Stm>

<Start Imp> 
        ::= <Start Stm>

<Start Stm>   
        ::= START Identifier <Start Key Opt>

<Start Key Opt>
        ::= KEY <Compare Op> Identifier
         |  !Optional

<END-START Opt>
        ::= END-START
         |  !Optional

! -----------------------------------------------------------------------------  
! STOP Statement
! -----------------------------------------------------------------------------

<Stop Sent>
        ::= <Stop Stm> 

<Stop Embed>
        ::= <Stop Stm> 

<Stop Imp>
        ::= <Stop Stm> 

<Stop Stm>
        ::= STOP RUN
         |  STOP <Literal>
                 
! -----------------------------------------------------------------------------  
! STRING Statement
! -----------------------------------------------------------------------------

<String Sent>
        ::= <String Stm> <Overflow Clauses> <END-STRING Opt>
         |  <String Stm> 

<String Embed>
        ::= <String Stm> <Overflow Clauses> END-STRING
         |  <String Stm> 

<String Imp>
        ::= <String Stm>

<String Stm>    
        ::= STRING <String Items> INTO <Variable> <Pointer Clause>

<String Items>
        ::= <String Item> <String Items>
         |  <String Item>

<String Item>
        ::= <Values> DELIMITED <BY Opt> <Value>
           
<END-STRING Opt>    
        ::= END-STRING
         |  !Optional

! -----------------------------------------------------------------------------  
! SUBTRACT Statement
! -----------------------------------------------------------------------------       

<Subtract Sent>
        ::= <Subtract Stm> <Size Clauses> <END-SUBTRACT Opt>
         |  <Subtract Stm> 

<Subtract Embed>
        ::= <Subtract Stm> <Size Clauses> END-SUBTRACT
         |  <Subtract Stm> 

<Subtract Imp>
        ::= <Subtract Stm> 

<Subtract Stm> 
        ::= SUBTRACT <Values> FROM <Variables> <Giving Clause Opt>
          | SUBTRACT <CORRESPONDING> <Value> FROM Identifier
        
<END-SUBTRACT Opt> 
        ::= END-SUBTRACT
         |  !Optional

! -----------------------------------------------------------------------------  
! SUPPRESS Statement
! -----------------------------------------------------------------------------

<Suppress Sent> 
        ::= <Suppress Stm>  

<Suppress Embed> 
        ::= <Suppress Stm>  

<Suppress Imp> 
        ::= <Suppress Stm>  

<Suppress Stm> 
        ::= SUPPRESS <PRINTING Opt>
                          
! -----------------------------------------------------------------------------  
! TERMMINATE Statement
! -----------------------------------------------------------------------------

<Terminate Sent> 
        ::= <Terminate Stm> 

<Terminate Embed> 
        ::= <Terminate Stm> 

<Terminate Imp> 
        ::= <Terminate Stm> 

<Terminate Stm> 
        ::= TERMINATE <Identifiers>                                                 
                         
! -----------------------------------------------------------------------------  
! UNSTRING Statement
! -----------------------------------------------------------------------------

<Unstring Sent>
        ::= <Unstring Stm> <Overflow Clauses> <END-UNSTRING Opt>
         |  <Unstring Stm> 

<Unstring Embed>
        ::= <Unstring Stm> <Overflow Clauses> END-UNSTRING
         |  <Unstring Stm> 

<Unstring Imp>
        ::= <Unstring Stm> 

<Unstring Stm>
        ::= UNSTRING identifier <Delimiter Clause> INTO Identifier <Unstring Options>

<Delimiter Clause>
        ::= DELIMITED <BY Opt> <Unstring Delimiter List>
         |  !Optional

<Unstring Delimiter List>
        ::= <Unstring Delimiter List> OR <Unstring Delimiter>
         |  <Unstring Delimiter> 

<Unstring Delimiter>
        ::= <ALL Opt> <Value>

<Unstring Options>
        ::= <Unstring Options> <Unstring Option> 
         |  !Empty

<Unstring Option> 
        ::= <WITH Opt> POINTER <Variable>
         |  TALLYING <IN Opt> Identifier 
 
<END-UNSTRING Opt>  
        ::= END-UNSTRING
         |  !Optional

! -----------------------------------------------------------------------------  
! USE Statement
! -----------------------------------------------------------------------------

<Use Sent> 
        ::= <Use Stm> 

<Use Embed> 
        ::= <Use Stm> 

<Use Imp> 
        ::= <Use Stm> 

<Use Stm> 
        ::= USE <GLOBAL Opt> AFTER STANDARD <Use Proc Type> PROCEDURE ON <Use Access>
         |  USE <GLOBAL Opt> BEFORE REPORTING Identifier
         |  USE <FOR Opt> DEBUGGING <ON Opt> <Use Debug>

<Use Proc Type>
        ::= EXCEPTION
         |  ERROR

<Use Access>
        ::= INPUT
         |  OUTPUT
         |  I-O
         |  EXTEND
         |  <Value>
         
<Use Debug>
        ::= ALL <REFERENCES Opt> <OF Opt> Identifier
         |  ALL PROCEDURES
         |  <Value>

! -----------------------------------------------------------------------------  
! WRITE Statement
! -----------------------------------------------------------------------------

<Write Sent> 
        ::= <Write Stm> <Invalid Key Clauses> <END-WRITE Opt>
         |  <Write Stm> <AT EOP Clauses>      <END-WRITE Opt>  
         |  <Write Stm> 

<Write Embed> 
        ::= <Write Stm> <Invalid Key Clauses> END-WRITE
         |  <Write Stm> <AT EOP Clauses>      END-WRITE  
         |  <Write Stm> 

<Write Imp> 
        ::= <Write Stm> 

<Write Stm> 
        ::= WRITE Identifier                 <Write Options>
         |  WRITE Identifier FROM Identifier <Write Options>
           
<Write Options> 
        ::= <BEFORE AFTER> <ADVANCING Opt> <Write Advance>

<Write Advance>
        ::= <Value> <LINES Opt>
         |  PAGE 
               
<END-WRITE Opt>
        ::= END-WRITE
         |  !Optional

ColdFusion

Common Lisp

Component Pascal

Coq

D

DOS Batch File

Dc

Delphi

E

EC

ELLA

ESQL

Eiffel

Emacs Lisp

Erlang

F

F#

FALSE

FP

Factor

Fan

Forth

Fortran

GAP

Gnuplot

Groovy

HaXe

Haskell

IDL

Icon

Io

J

JSON

JScript.NET

Java

"Name"    = 'LALR(1) Java nonunicode grammar'
"Version" = '1.0 alpha 110'
"Author"  = 'Dmitry Gazko'
"About"   = 'Based on partial conversion of Sun Java 1.0-2.0 specification'

{String Char} = {Printable} - ["]
{Quote} = ['']
{IdLetter} = {Letter} + [_$]
{IdAlphaNumeric} = {Alphanumeric} + [_$]
{HexDigit} = {Digit} + [abcdefABCDEF]
{OctalCharSet} = [01234567]
{NoZeroDigit} = [123456789]
{LongTypeSuffix} =[lL]
{FloatTypeSuffix} =[dfDF]
{ExponentPartIndicator} = [eE]
{Sign} = [-+]
{CharSign} = [abtnfr"\] + {Quote}
{CharSign1} = {String Char} - [\]
{HexEscapeSign} =[uUxX]

Identifier     = {IdLetter}{IdAlphaNumeric}*
StringLiteral  = '"'{String Char}*'"'
FloatingPointLiteral   = {Digit}+'.'{Digit}+{FloatTypeSuffix}? | {Digit}+{FloatTypeSuffix} | '.'{Digit}+{FloatTypeSuffix}?
FloatingPointLiteralExponent = {Digit}+'.'{Digit}+{ExponentPartIndicator}{Sign}?{Digit}+{FloatTypeSuffix}? | {Digit}+{ExponentPartIndicator}{Sign}?{Digit}+{FloatTypeSuffix}? | '.'{Digit}+{ExponentPartIndicator}{Sign}?{Digit}+{FloatTypeSuffix}?
BooleanLiteral = 'true' | 'false'
IndirectCharLiteral = {Quote}{CharSign1}{Quote}
StandardEscapeCharLiteral = {Quote}'\'{CharSign}{Quote}
OctalEscapeCharLiteral ={Quote}'\'{OctalCharSet}+{Quote}
HexEscapeCharLiteral ={Quote}'\'{HexEscapeSign}{HexDigit}+{Quote}
NullLiteral = 'null'
StartWithNoZeroDecimalIntegerLiteral = {NoZeroDigit}{Digit}*{LongTypeSuffix}?
StartWithZeroDecimalIntegerLiteral = '0'{LongTypeSuffix}?
HexIntegerLiteral = '0'('x'|'X'){HexDigit}+{LongTypeSuffix}?
OctalIntegerLiteral = '0'{OctalCharSet}+{LongTypeSuffix}?


"Case Sensitive" = 'True'
"Start Symbol"   = <CompilationUnit>

Comment Start = '/*'
Comment End = '*/'
Comment Line = '//'

<CharacterLiteral> 
        ::= IndirectCharLiteral
         |  StandardEscapeCharLiteral
         |  OctalEscapeCharLiteral
         |  HexEscapeCharLiteral

<DecimalIntegerLiteral> 
        ::= StartWithZeroDecimalIntegerLiteral
         |  StartWithNoZeroDecimalIntegerLiteral

<FloatPointLiteral> 
        ::= FloatingPointLiteral
         |  FloatingPointLiteralExponent

<IntegerLiteral> 
        ::= <DecimalIntegerLiteral>
         |  HexIntegerLiteral  
         |  OctalIntegerLiteral


<Literal> 
        ::= <IntegerLiteral>
         |  <FloatPointLiteral>
         |  BooleanLiteral
         |  <CharacterLiteral>
         |  StringLiteral
         |  NullLiteral

<Type>  ::= <PrimitiveType>
         |  <ReferenceType>

<PrimitiveType> ::= <NumericType>
                  | 'boolean'

<NumericType> 
        ::= <IntegralType>
         |  <FloatingPointType>

<IntegralType>
        ::= 'byte'
         |  'short'
         |  'int'
         |  'long'
         |  'char'

<FloatingPointType> 
        ::= 'float'
         |  'double'

<ReferenceType> 
        ::= <ClassOrInterfaceType>
         |  <ArrayType>

<ClassOrInterfaceType> ::= <Name>

<ClassType> ::= <ClassOrInterfaceType>

<InterfaceType> ::= <ClassOrInterfaceType>

<ArrayType>
        ::= <PrimitiveType> '[' ']'
         |  <Name> '[' ']'
         |  <ArrayType> '[' ']'

<Name>
        ::= <SimpleName>
         |  <QualifiedName>

<SimpleName> ::= Identifier

<QualifiedName> ::= <Name> '.' Identifier

<CompilationUnit> 
        ::= <PackageDeclaration> <ImportDeclarations> <TypeDeclarations>
         |  <PackageDeclaration> <ImportDeclarations>
         |  <PackageDeclaration> <TypeDeclarations>
         |  <PackageDeclaration>
         |  <ImportDeclarations> <TypeDeclarations>
         |  <ImportDeclarations>
         |  <TypeDeclarations>
         |  

<ImportDeclarations> 
        ::= <ImportDeclaration>
         |  <ImportDeclarations> <ImportDeclaration>

<TypeDeclarations> 
        ::= <TypeDeclaration>
         |  <TypeDeclarations> <TypeDeclaration>

<PackageDeclaration> 
        ::= 'package' <Name> ';'

<ImportDeclaration>
        ::= <SingleTypeImportDeclaration>
         |  <TypeImportOnDemandDeclaration>

<SingleTypeImportDeclaration> 
        ::= 'import' <Name> ';'

<TypeImportOnDemandDeclaration> 
        ::= 'import' <Name> '.' '*' ';'

<TypeDeclaration> 
        ::= <ClassDeclaration>
         |  <InterfaceDeclaration>
         |  ';'

<Modifiers> 
        ::= <Modifier>
         |  <Modifiers> <Modifier>

<Modifier> 
        ::= 'public'
         |  'protected'
         |  'private'
         |  'static'
         |  'abstract'
         |  'final'
         |  'native'
         |  'synchronized'
         |  'transient'
         |  'volatile'

<ClassDeclaration> 
        ::= <Modifiers> 'class' Identifier <Super> <Interfaces> <ClassBody>
         |  <Modifiers> 'class' Identifier <Super>  <ClassBody>
         |  <Modifiers> 'class' Identifier <Interfaces> <ClassBody>
         |  <Modifiers> 'class' Identifier <ClassBody>
         |  'class' Identifier <Super> <Interfaces> <ClassBody>
         |  'class' Identifier <Super> <ClassBody>
         |  'class' Identifier <Interfaces> <ClassBody>
         |  'class' Identifier <ClassBody>

<Super> ::= 'extends' <ClassType>

<Interfaces> ::= 'implements' <InterfaceTypeList>

<InterfaceTypeList> ::= <InterfaceType>
                        | <InterfaceTypeList> ',' <InterfaceType>

<ClassBody> 
        ::= '{' <ClassBodyDeclarations> '}'
         |  '{' '}'
               

<ClassBodyDeclarations> 
        ::= <ClassBodyDeclaration>
         |  <ClassBodyDeclarations> <ClassBodyDeclaration>

<ClassBodyDeclaration> 
        ::= <ClassMemberDeclaration>
         |  <StaticInitializer>
         |  <ConstructorDeclaration>

<ClassMemberDeclaration>
        ::= <FieldDeclaration>
         |  <MethodDeclaration>

<FieldDeclaration> 
        ::= <Modifiers> <Type> <VariableDeclarators> ';'
         |  <Type> <VariableDeclarators> ';'

<VariableDeclarators>
        ::= <VariableDeclarator>
         |  <VariableDeclarators> ',' <VariableDeclarator>

<VariableDeclarator> 
        ::= <VariableDeclaratorId>
         |  <VariableDeclaratorId> '=' <VariableInitializer>

<VariableDeclaratorId> 
        ::= Identifier
         |  <VariableDeclaratorId> '[' ']'

<VariableInitializer> 
        ::= <Expression>
         |  <ArrayInitializer>

<MethodDeclaration> ::= <MethodHeader> <MethodBody>

<MethodHeader>
        ::= <Modifiers> <Type> <MethodDeclarator> <Throws>
         |  <Modifiers> <Type> <MethodDeclarator>
         |  <Type> <MethodDeclarator> <Throws>
         |  <Type> <MethodDeclarator>
         |  <Modifiers> 'void' <MethodDeclarator> <Throws>
         |  <Modifiers> 'void' <MethodDeclarator>
         |  'void' <MethodDeclarator> <Throws>
         |  'void' <MethodDeclarator>

<MethodDeclarator>
        ::= Identifier '(' <FormalParameterList> ')'
         |  Identifier '(' ')'
         |  <MethodDeclarator> '[' ']'

<FormalParameterList> 
        ::= <FormalParameter>
         |  <FormalParameterList> ',' <FormalParameter>

<FormalParameter> 
        ::= <Type> <VariableDeclaratorId>

<Throws> 
        ::= 'throws' <ClassTypeList>

<ClassTypeList>
        ::= <ClassType>
         |  <ClassTypeList> ',' <ClassType>

<MethodBody> 
        ::= <Block>
         |  ';'

<StaticInitializer> 
        ::= 'static' <Block>

<ConstructorDeclaration>
        ::= <Modifiers> <ConstructorDeclarator> <Throws> <ConstructorBody>
         |  <Modifiers> <ConstructorDeclarator> <ConstructorBody>
         |  <ConstructorDeclarator> <Throws> <ConstructorBody>
         |  <ConstructorDeclarator> <ConstructorBody>

<ConstructorDeclarator>
        ::= <SimpleName> '(' <FormalParameterList> ')'
         |  <SimpleName> '(' ')'

<ConstructorBody> 
        ::= '{' <ExplicitConstructorInvocation> <BlockStatements> '}'
         |  '{' <ExplicitConstructorInvocation> '}'
         |  '{' <BlockStatements> '}'
         |  '{' '}'

<ExplicitConstructorInvocation>
        ::= 'this' '(' <ArgumentList> ')' ';'
         |  'this' '(' ')' ';'
         |  'super' '(' <ArgumentList> ')' ';'
         |  'super' '(' ')' ';'
                                   
<InterfaceDeclaration> 
        ::= <Modifiers> 'interface' Identifier <ExtendsInterfaces> <InterfaceBody>
         |  <Modifiers> 'interface' Identifier <InterfaceBody>
         |  'interface' Identifier <ExtendsInterfaces> <InterfaceBody>
         |  'interface' Identifier <InterfaceBody>

<ExtendsInterfaces> 
        ::= 'extends' <InterfaceType>
         |  <ExtendsInterfaces> ',' <InterfaceType>

<InterfaceBody> 
        ::= '{' <InterfaceMemberDeclarations> '}'
         |  '{' '}'

<InterfaceMemberDeclarations> 
        ::= <InterfaceMemberDeclaration>
         |  <InterfaceMemberDeclarations> <InterfaceMemberDeclaration>

<InterfaceMemberDeclaration> 
        ::= <ConstantDeclaration>
         |  <AbstractMethodDeclaration>

<ConstantDeclaration> ::= <FieldDeclaration>

<AbstractMethodDeclaration> ::= <MethodHeader> ';'

<ArrayInitializer>
        ::= '{' <VariableInitializers> ',' '}'
         |  '{' <VariableInitializers> '}'
         |  '{' ',' '}'
         |  '{' '}'

<VariableInitializers> ::= <VariableInitializer>
                        | <VariableInitializers> ',' <VariableInitializer>

<Block> ::= '{' <BlockStatements> '}'
         |  '{' '}'

<BlockStatements> 
        ::= <BlockStatement>
         |  <BlockStatements> <BlockStatement>

<BlockStatement>
        ::= <LocalVariableDeclarationStatement>
         |  <Statement>

<LocalVariableDeclarationStatement> 
        ::= <LocalVariableDeclaration> ';'

<LocalVariableDeclaration> 
        ::= <Type> <VariableDeclarators>

<Statement>
        ::= <StatementWithoutTrailingSubstatement>
         |  <LabeledStatement>
         |  <IfThenStatement>
         |  <IfThenElseStatement>
         |  <WhileStatement>
         |  <ForStatement>

<StatementNoShortIf> 
        ::= <StatementWithoutTrailingSubstatement>
         |  <LabeledStatementNoShortIf>
         |  <IfThenElseStatementNoShortIf>
         |  <WhileStatementNoShortIf>
         |  <ForStatementNoShortIf>

<StatementWithoutTrailingSubstatement> 
        ::= <Block>
         |  <EmptyStatement>
         |  <ExpressionStatement>
         |  <SwitchStatement>
         |  <DoStatement>
         |  <BreakStatement>
         |  <ContinueStatement>
         |  <ReturnStatement>
         |  <SynchronizedStatement>
         |  <ThrowStatement>
         |  <TryStatement>

<EmptyStatement> 
        ::= ';'

<LabeledStatement> 
        ::= Identifier ':' <Statement>

<LabeledStatementNoShortIf> 
        ::= Identifier ':' <StatementNoShortIf>

<ExpressionStatement> 
        ::= <StatementExpression> ';'

<StatementExpression>
        ::= <Assignment>
         |  <PreIncrementExpression>
         |  <PreDecrementExpression>
         |  <PostIncrementExpression>
         |  <PostDecrementExpression>
         |  <MethodInvocation>
         |  <ClassInstanceCreationExpression>

<IfThenStatement> 
        ::= 'if' '(' <Expression> ')' <Statement>

<IfThenElseStatement> 
        ::= 'if' '(' <Expression> ')' <StatementNoShortIf> 'else' <Statement>

<IfThenElseStatementNoShortIf> 
        ::= 'if' '(' <Expression> ')' <StatementNoShortIf> 'else' <StatementNoShortIf>

<SwitchStatement> 
        ::= 'switch' '(' <Expression> ')' <SwitchBlock>

<SwitchBlock> 
        ::= '{' <SwitchBlockStatementGroups> <SwitchLabels> '}'
         |  '{' <SwitchBlockStatementGroups> '}'
         |  '{' <SwitchLabels> '}'
         |  '{' '}'

<SwitchBlockStatementGroups>
        ::= <SwitchBlockStatementGroup>
         |  <SwitchBlockStatementGroups> <SwitchBlockStatementGroup>

<SwitchBlockStatementGroup> 
        ::= <SwitchLabels> <BlockStatements>

<SwitchLabels>
        ::= <SwitchLabel>
         |  <SwitchLabels> <SwitchLabel>

<SwitchLabel> 
        ::= 'case' <ConstantExpression> ':'
         |  'default' ':'

<WhileStatement> 
        ::= 'while' '(' <Expression> ')' <Statement>

<WhileStatementNoShortIf>
        ::= 'while' '(' <Expression> ')' <StatementNoShortIf>

<DoStatement> 
        ::= 'do' <Statement> 'while' '(' <Expression> ')' ';'

<ForStatement> 
        ::= 'for' '(' <ForInit> ';' <Expression> ';' <ForUpdate> ')' <Statement>
         |  'for' '(' <ForInit> ';' <Expression> ';' ')' <Statement>
         |  'for' '(' <ForInit> ';' ';' <ForUpdate> ')' <Statement>
         |  'for' '(' <ForInit> ';' ';' ')' <Statement>
         |  'for' '(' ';' <Expression> ';' <ForUpdate> ')' <Statement>
         |  'for' '(' ';' <Expression> ';' ')' <Statement>
         |  'for' '(' ';' ';' <ForUpdate> ')' <Statement>
         |  'for' '(' ';' ';'  ')' <Statement>

<ForStatementNoShortIf> 
        ::= 'for' '(' <ForInit> ';' <Expression> ';' <ForUpdate> ')' <StatementNoShortIf>
         |  'for' '(' <ForInit> ';' <Expression> ';' ')' <StatementNoShortIf>
         |  'for' '(' <ForInit> ';' ';' <ForUpdate> ')' <StatementNoShortIf>
         |  'for' '(' <ForInit> ';' ';' ')' <StatementNoShortIf>
         |  'for' '(' ';' <Expression> ';' <ForUpdate> ')' <StatementNoShortIf>
         |  'for' '(' ';' <Expression> ';' ')' <StatementNoShortIf>
         |  'for' '(' ';' ';' <ForUpdate> ')' <StatementNoShortIf>
         |  'for' '(' ';' ';' ')' <StatementNoShortIf>

<ForInit> ::= <StatementExpressionList>
            | <LocalVariableDeclaration>

<ForUpdate> ::= <StatementExpressionList>

<StatementExpressionList> 
        ::= <StatementExpression>
         |  <StatementExpressionList> ',' <StatementExpression>

<BreakStatement> 
        ::= 'break' Identifier ';'
         |  'break' ';'

<ContinueStatement>
        ::= 'continue' Identifier ';'
         |  'continue' ';'

<ReturnStatement> 
        ::= 'return' <Expression> ';'
         |  'return' ';'

<ThrowStatement> 
        ::= 'throw' <Expression> ';'

<SynchronizedStatement> 
        ::= 'synchronized' '(' <Expression> ')' <Block>

<TryStatement>
        ::= 'try' <Block> <Catches>
         |  'try' <Block> <Catches> <Finally>
         |  'try' <Block> <Finally>

<Catches>
        ::= <CatchClause>
         |  <Catches> <CatchClause>

<CatchClause>
        ::= 'catch' '(' <FormalParameter> ')' <Block>

<Finally> 
        ::= 'finally' <Block>

<Primary> 
        ::= <PrimaryNoNewArray>
         |  <ArrayCreationExpression>

<PrimaryNoNewArray> 
        ::= <Literal>
         |  'this'
         |  '(' <Expression> ')'
         |  <ClassInstanceCreationExpression>
         |  <FieldAccess>
         |  <MethodInvocation>
         |  <ArrayAccess>

<ClassInstanceCreationExpression> 
        ::= 'new' <ClassType> '(' <ArgumentList> ')'
         |  'new' <ClassType> '(' ')'

<ArgumentList> 
        ::= <Expression>
         |  <ArgumentList> ',' <Expression>

<ArrayCreationExpression> 
        ::= 'new' <PrimitiveType> <DimExprs> <Dims>
         |  'new' <PrimitiveType> <DimExprs>
         |  'new' <ClassOrInterfaceType> <DimExprs> <Dims>
         |  'new' <ClassOrInterfaceType> <DimExprs>

<DimExprs> 
        ::= <DimExpr>
         |  <DimExprs> <DimExpr>

<DimExpr> ::= '[' <Expression> ']'

<Dims> ::= '[' ']'
         | <Dims> '[' ']'

<FieldAccess> 
        ::= <Primary> '.' Identifier
         |  'super' '.' Identifier

<MethodInvocation>
        ::= <Name> '(' <ArgumentList> ')'
         |  <Name> '(' ')'
         |  <Primary> '.' Identifier '(' <ArgumentList> ')'
         |  <Primary> '.' Identifier '(' ')'
         |  'super' '.' Identifier '(' <ArgumentList> ')'
         |  'super' '.' Identifier '(' ')'

<ArrayAccess> 
        ::= <Name> '[' <Expression> ']'
         |  <PrimaryNoNewArray> '[' <Expression> ']'

<PostfixExpression>
        ::= <Primary>
         |  <Name>
         |  <PostIncrementExpression>
         |  <PostDecrementExpression>

<PostIncrementExpression>
        ::= <PostfixExpression> '++'

<PostDecrementExpression>
        ::= <PostfixExpression> '--'

<UnaryExpression>
        ::= <PreIncrementExpression>
         |  <PreDecrementExpression>
         |  '+' <UnaryExpression>
         |  '-' <UnaryExpression>
         |  <UnaryExpressionNotPlusMinus>

<PreIncrementExpression> 
        ::= '++' <UnaryExpression>

<PreDecrementExpression>
        ::= '--' <UnaryExpression>

<UnaryExpressionNotPlusMinus> 
        ::= <PostfixExpression>
         |  '~' <UnaryExpression>
         |  '!' <UnaryExpression>
         |  <CastExpression>

<CastExpression>
        ::= '(' <PrimitiveType> <Dims> ')' <UnaryExpression>
         |  '(' <PrimitiveType> ')' <UnaryExpression>
         |  '(' <Expression> ')' <UnaryExpressionNotPlusMinus>
         |  '(' <Name> <Dims> ')' <UnaryExpressionNotPlusMinus>

<MultiplicativeExpression>
        ::= <UnaryExpression>
         |  <MultiplicativeExpression> '*' <UnaryExpression>
         |  <MultiplicativeExpression> '/' <UnaryExpression>
         |  <MultiplicativeExpression> '%' <UnaryExpression>

<AdditiveExpression>
        ::= <MultiplicativeExpression>
         |  <AdditiveExpression> '+' <MultiplicativeExpression>
         |  <AdditiveExpression> '-' <MultiplicativeExpression>

<ShiftExpression>
        ::= <AdditiveExpression>
         |  <ShiftExpression> '<<' <AdditiveExpression>
         |  <ShiftExpression> '>>' <AdditiveExpression>
         |  <ShiftExpression> '>>>' <AdditiveExpression>

<RelationalExpression>
        ::= <ShiftExpression>
         |  <RelationalExpression> '<' <ShiftExpression>
         |  <RelationalExpression> '>' <ShiftExpression>
         |  <RelationalExpression> '<=' <ShiftExpression>
         |  <RelationalExpression> '>=' <ShiftExpression>
         |  <RelationalExpression> 'instanceof' <ReferenceType>

<EqualityExpression>
        ::= <RelationalExpression>
         |  <EqualityExpression> '==' <RelationalExpression>
         |  <EqualityExpression> '!=' <RelationalExpression>

<AndExpression>
        ::= <EqualityExpression>
         |  <AndExpression> '&' <EqualityExpression>

<ExclusiveOrExpression>
        ::= <AndExpression>
         |  <ExclusiveOrExpression> '^' <AndExpression>

<InclusiveOrExpression> 
        ::= <ExclusiveOrExpression>
         |  <InclusiveOrExpression> '|' <ExclusiveOrExpression>

<ConditionalAndExpression>
        ::= <InclusiveOrExpression>
         |  <ConditionalAndExpression> '&&' <InclusiveOrExpression>

<ConditionalOrExpression>
        ::= <ConditionalAndExpression>
         |  <ConditionalOrExpression> '||' <ConditionalAndExpression>

<ConditionalExpression> 
        ::= <ConditionalOrExpression>
         |  <ConditionalOrExpression> '?' <Expression> ':' <ConditionalExpression>

<AssignmentExpression> 
        ::= <ConditionalExpression>
         |  <Assignment>

<Assignment>
        ::= <LeftHandSide> <AssignmentOperator> <AssignmentExpression>

<LeftHandSide> 
        ::= <Name>
         |  <FieldAccess>
         |  <ArrayAccess>

<AssignmentOperator> 
        ::= '='
         |  '*='
         |  '/='
         |  '%='
         |  '+='
         |  '-='
         |  '<<='
         |  '>>='
         |  '>>>='
         |  '&='
         |  '^='
         |  '|='

<Expression> ::= <AssignmentExpression>

<ConstantExpression> ::= <Expression>

JavaScript

JoCaml

Joy

JudoScript

Korn Shell

LSE64

LaTeX

LabVIEW

Lisaac

Lisp

! -----------------------------------------------------------------------
! LISP
!
! LISt Programming
!
!    "One can even conjecture that Lisp owes its survival specifically to the 
!     fact that its programs are lists, which everyone, including me, has 
!     regarded as a disadvantage."
!
!     - John McCarthy, "Early History of Lisp"
!
!
!    "Lisp is worth learning for the profound enlightenment experience you will 
!     have when you finally get it; that experience will make you a better programmer
!     for the rest of your days, even if you never actually use Lisp itself a lot."
!  
!     - Eric Raymond, "How to Become a Hacker"
!
!
!    "Lisp was far more powerful and flexible than any other language of its day; in 
!     fact, it is still a better design than most languages of today, twenty-five 
!     years later. Lisp freed ITS's hackers to think in unusual and creative ways. It 
!     was a major factor in their successes, and remains one of hackerdom's favorite 
!     languages."
!
!     - Eric Raymond, in Open Sources on MIT's first OS, ITS 
!
! The LISP programming language is one of the oldest still use today; second only to 
! FORTRAN. It was invented by mathematician John McCarthy and organizes information into
! abstract "lists". This metaphor is used universially for both data and functions; 
! in fact, the LISP runtime engine makes no differentiation between the two. This allows 
! the programmer to perform actions that would be impossible in most programming languages 
! such as, but not limited to, passing code as a parameter to a function, executing data, 
! and modifying the program at runtime.
!
! For more information on LISP, please visit www.lisp.org.
!
! Updates:
!    3/5/2003: Added dotted pairs and backslash overrides to the language.
!
! Note: This is an ad hoc version of the language. If there are any flaws, 
! please visit www.DevinCook.com/GOLDParser and I will update the grammar. 
!
!
! -----------------------------------------------------------------------


"Name"    = 'LISP'
"Author"  = 'John McCarthy'
"Version" = 'Standard'
"About"   = 'LISP is an abstract language that organizes ALL data around "lists".'

"Start Symbol" = <s-Expression>

{Atom Char}   = {Printable} - {Whitespace} - [()"\'']
{String Char} = {Printable} - ["\]

Atom   = ( {Atom Char} | '\'{Printable} )+

String = '"' ( {String Char} | '\'{Printable} )* '"'


<s-Expression> ::= <Quote> Atom
                 | <Quote> '(' <Series> ')'
                 | <Quote> '(' <s-Expression> '.' <s-Expression> ')'   !Dotted Pair
                 | String                                              !Strings are never evaluated

<Series> ::= <s-Expression> <Series>
           |

<Quote>  ::= ''           !Quote = do not evaluate
           |

Logtalk

LotusScript

Lua

Lucid

M4

MAXScript

MIRC Scripting Language

MS SQL

Make

Maple

Mathematica

Maxima

Metafont

Modula-3

NewLISP

Nial

OCaml

Oberon-2

Object Pascal

Objective-C

Octave

Omega

OpenEdge/Progress

Oz

PHP

PL/I

PL/SQL

Pascal

! -----------------------------------------------------------------------
! Standard Pascal Grammar
! -----------------------------------------------------------------------
"Name"    = 'Pascal' 
"Version" = '1973'
"Author"  = 'Niklaus Wirth' 
"About"   = 'PASCAL was developed by NIKLAUS WIRTH of the ETH Technical Institute of Zuerich in 1970-1971.(published in 1973)'

"Case Sensitive" = False
"Start Symbol"   = <Program>

{Hex Digit}      = {Digit} + [abcdefABCDEF]

{Id Head}        = {Letter} + [_]
{Id Tail}        = {Id Head} + {Digit}

{String Ch}      = {Printable} - ['']
{Char Ch}        = {Printable} - ['']

DecLiteral       = [123456789]{digit}*
HexLiteral       = '$'{Hex Digit}+
FloatLiteral     = {Digit}*.{Digit}+

StringLiteral    = ''( {String Ch} | '\'{Printable} )* ''
CharLiteral      = '' ( {Char Ch} | '\'{Printable} )''

id               = {Id Head}{Id Tail}*

<constant>         ::= DecLiteral
                     | StringLiteral
                     | FloatLiteral
                     | HexLiteral
                     | CharLiteral


!=========================================== Program

<Program> ::= <ProgramHeader> <Declarations> <CompoundStatement> '.'

<ProgramHeader> ::= PROGRAM id ';'
                  | PROGRAM id '(' <IdList> ')' ';'

<Declarations> ::= <ConstantDefinitions> <TypeDefinitions> <VariableDeclarations> <ProcedureDeclarations>

<ConstantDefinitions> ::= CONST <ConstantDefinitionList>
                        |  

<ConstantDefinitionList> ::= <ConstantDef>
                           | <ConstantDef> <ConstantDefinitionList>

<ConstantDef> ::= id '=' <constant> ';'

<TypeDefinitions> ::= TYPE <TypeDefinitionList>
                     |

<TypeDefinitionList> ::= <TypeDef>
                       | <TypeDef> <TypeDefinitionList>

<TypeDef> ::= id '=' <TypeSpecifier> ';'

<VariableDeclarations> ::= VAR <VariableDeclarationList>
                        | 

<VariableDeclarationList> ::= <VariableDec>
                            | <VariableDec> <VariableDeclarationList>

<VariableDec> ::= <IdList> ':' <TypeSpecifier> ';'

<ProcedureDeclarations> ::= <ProcedureDec> <ProcedureDeclarations>
                          | 

<ProcedureDec> ::= <ProcedureHeader> FORWARD ';'
                 | <ProcedureHeader> <Declarations> <CompoundStatement> ';'
                 | <FunctionHeader> FORWARD ';'
                 | <FunctionHeader> <Declarations> <CompoundStatement> ';'

<ProcedureHeader> ::= PROCEDURE id <Arguments> ';'

<FunctionHeader> ::= FUNCTION id <Arguments> ':' <TypeSpecifier> ';'

<Arguments> ::= '(' <ArgumentList> ')'
              | 

<ArgumentList> ::= <Arg>
                 | <Arg> ';' <ArgumentList>

<Arg> ::= <IdList> ':' <TypeSpecifier>
        | VAR <IdList> ':' <TypeSpecifier>

<CompoundStatement> ::= BEGIN <StatementList> END

<StatementList> ::= <Statement>
                  | <Statement> ';' <StatementList>

<Statement> ::= <CompoundStatement>
              | <AssignmentStatement>
              | <ProcedureCall>
              | <ForStatement>
              | <WhileStatement>
              | <IfStatement>
              | <CaseStatement>
              | <RepeatStatement>
              | 

<AssignmentStatement> ::= <Variable> ':=' <Expression>

<ProcedureCall> ::= id <Actuals>

<ForStatement> ::= FOR id ':=' <Expression> TO <Expression> DO <Statement>
                 | FOR id ':=' <Expression> DOWNTO <Expression> DO <Statement>

<WhileStatement> ::= WHILE <Expression> DO <Statement>

<IfStatement> ::= IF <Expression> THEN <Statement> ELSE <Statement>

<RepeatStatement> ::= REPEAT <StatementList> UNTIL <Expression>

<CaseStatement> ::= CASE <Expression> OF <CaseList> END

<CaseList> ::= <Case>
             | <Case> ';' <CaseList>

<Case> ::= <ConstantList> ':' <Statement>

<ConstantList> ::= <constant>
                 | <constant> ',' <ConstantList>

<Expression> ::= <SimpleExpression>
               | <SimpleExpression> '=' <SimpleExpression>
               | <SimpleExpression> '<>' <SimpleExpression>
               | <SimpleExpression> '<' <SimpleExpression>
               | <SimpleExpression> '<=' <SimpleExpression>
               | <SimpleExpression> '>' <SimpleExpression>
               | <SimpleExpression> '>=' <SimpleExpression>

<SimpleExpression> ::= <Term>
                    | <SimpleExpression> '+' <Term>
                    | <SimpleExpression> '-' <Term>
                    | <SimpleExpression> OR <Term>

<Term> ::= <Factor>
         | <Term> '*' <Factor>
         | <Term> '/' <Factor>
         | <Term> 'DIV' <Factor>
         | <Term> 'MOD' <Factor>
         | <Term> 'AND' <Factor>

<Factor> ::= '(' <Expression> ')'
           | '+' <Factor>
           | '-' <Factor>
           | NOT <Factor>
           | <constant>
           | <Variable>

<FunctionCall> ::= id <Actuals>

<Actuals> ::= '(' <ExpressionList> ')'
            | 

<ExpressionList> ::= <Expression>
                   | <Expression> ',' <ExpressionList>

<Variable> ::= id
             | <Variable> '.' id
             | <Variable> '^'
             | <Variable> '[' <ExpressionList> ']'

<TypeSpecifier> ::= id
                  | '^' <TypeSpecifier>
                  | '(' <IdList> ')'
                  | <constant> '..' <constant>
                  | ARRAY '[' <DimensionList> ']' OF <TypeSpecifier>
                  | RECORD <FieldList> END
                  | FILE OF <TypeSpecifier>

<DimensionList> ::= <Dimension>
                  | <Dimension> ',' <DimensionList>

<Dimension> ::= <constant> '..' <constant>
              | id

<FieldList> ::= <Field>
              | <Field> ';' <FieldList>

<Field> ::= <IdList> ':' <TypeSpecifier>

<IdList> ::= id
           | id ',' <IdList>

Perl

Pike

Plain TeX

Pop11

PostScript

PowerShell

Prolog

Python

Q

R

REXX

RapidQ

Raven

Rhope

Ruby

SAS

SETL

SMEQL

SNUSP

SQL

Scala

Scheme

Script3D

Seed7

Self

Slate

Smalltalk

Standard ML

TI-83 BASIC

TI-89 BASIC

Tcl

Toka

Tr

Transact-SQL

Twelf

UNIX Shell

UnixPipes

Unlambda

V

VBScript

Vedit macro language

Visual Basic

Visual Basic .NET

Visual Objects

Wrapl

XSLT

XTalk

Retrieved from "https://rosettacode.org/wiki/BNF_Grammar?oldid=117398"