Rosetta Code

BNF Grammar: Difference between revisions

Page Discussion

BNF Grammar (view source)

Revision as of 10:13, 17 August 2012

170,275 bytes removed ,  11 years ago
m
→‎Pascal: move to pacsal page
m (→‎Pascal: move to pacsal page)
 
(79 intermediate revisions by 25 users not shown)
Line 1:
{{DeprecatedTask}}
{{task|BNF GRAMMAR}}
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.
 
Line 6:
There are many extensions and variants of BNF, including Extended and Augmented Backus–Naur Forms (EBNF and ABNF).
 
'''This is a deprecated task. Please move these grammars to the language's category page, or somewhere else.'''
The task here is establish a BNF grammar for as many languages as possible to facilitate language categorization and translation.
=={{header|4D}}==
=={{header|ALGOL 60}}==
<pre>
! ----------------------------------------------------------------------------
! 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>
 
==[[:Category:BASIC|BASIC]]==
</pre>
<div style="height:30ex;overflow:scroll"><pre>
=={{header|ALGOL 68}}==
=={{header|APL}}==
=={{header|AWK}}==
=={{header|ActionScript}}==
=={{header|Ada}}==
=={{header|Agda2}}==
=={{header|AmigaE}}==
=={{header|AppleScript}}==
=={{header|Assembly}}==
=={{header|AutoHotkey}}==
=={{header|BASIC}}==
<pre>
! -----------------------------------------------------------------------
! BASIC '64
Line 688 ⟶ 173:
| String
| Real
</pre></div>
==[[:Category:BASIC Commodore PET|BASIC Commodore PET]]==
<pre>
<div style="height:30ex;overflow:scroll"><pre>
! -----------------------------------------------------------------------
! Commodore PET BASIC
Line 893 ⟶ 379:
| Real
 
</pre></div>
 
==[[:Category:Brainf***|Brainf***]]==
=={{header|Bc}}==
=={{header|Befunge}}==
=={{header|Brainf***}}==
=={{header|C}}==
<pre>
! -----------------------------------------------------------------------
! 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}*
 
Code ::= Command Code | <NONE>
Command ::= "+" | "-" | "<" | ">" | "," | "." | "[" Code "]" | <ANY>
 
==[[:Category:PARI/GP|PARI/GP]]==
! ===================================================================
[http://pari.math.u-bordeaux.fr/cgi-bin/viewcvs.cgi/trunk/src/language/parse.y?view=markup&revision=12950&root=pari parse.y] contains a grammar for GP. The grammar for PARI is that of [http://c.comsci.us/syntax/ C].
! Comments
! ===================================================================
 
==[[:Category:PowerShell|PowerShell]]==
Comment Start = '/*'
An annotated version of the PowerShell grammar can be found in Bruce Payette's book ''Windows PowerShell in Action''. The appendix containing the grammar is available in [http://www.manning.com/payette/AppCexcerpt.pdf PDF form] on the publisher's site.
Comment End = '*/'
Comment Line = '//'
 
This grammar does not accurately represent the PowerShell language, though, as for example the <code>for</code> loop mandates semicolons in the grammar but in practice does not require them when arguments are omitted. The infinite loop may be represented by
<lang powershell>for () {}</lang>
but the grammar would require
<lang powershell>for (;;) {}</lang>
 
==[[:Category:VBScript|VBScript]]==
! Typically, C comments cannot be nested. As a result, the
<div style="height:30ex;overflow:scroll"><pre>
! Comment Start and Comment End terminals cannot be used.
!===============================
! VB Script grammar.
!
! To create the grammar I was using Microsoft's VB Script documentation
! To implement non-nested comments, the whitespace terminal is
! available from http://msdn.microsoft.com/scripting,
! modified to accept them. In the definition below, Whitespace
! VB Script parser from ArrowHead project http://www.tripi.com/arrowhead/,
! is defined as one or more {Whitespace} characters OR a series
! and Visual Basic .Net grammar file written by Devin Cook.
! of characters delimited by /* and */. Note that the characters
! between the two delimiters cannot contain the */ sequence.
!
! This grammar cannot cover all aspects of VBScript and may have some errors.
! Uncomment the following to prevent block commments. Make sure
! Feel free to contact me if you find any flaws in the grammar.
! to comment the Comment Start and Comment End definitions.
!
! Vladimir Morozov vmoroz@hotmail.com
! {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> ')'
</pre>
 
=={{header|C sharp}}==
<pre>
! ----------------------------------------------------------------------------
! C#
!
! Special thanks to Nathan Baulch for the grammar updates.
! The C# Programming Language was created by the Microsoft Corporation to be
! used with the .NET platform. The goal of C# was to counter the flaws and
! difficulties found in Java and C++. In addition, the language was designed
! to work well with the Common Language Runtime which runs the .NET platform.
!
! USE GOLD PARSER BUILDER VERSION 2.1 AND LATER TO COMPILE THIS GRAMMAR.
! C# was primarily the work of computer scientist Anders Hejlsberg who has
!===============================
! worked on a wide range of programming languages. These include, but are
! not limited to, Visual J++, Borland Delphi and Turbo Pascal. His previous
! works and influences from Java and C++ can be seen in C#.
!
!
! GRAMMAR NOTES:
!
! The grammar was designed, in part, using the official language
! specification that can be found on the Microsoft website.
!
! Unfortunately, C# has a very complex grammar. As a result, considerable
! time was required to write a LALR(1) compliant version. In most cases,
! I preserved the section names used in the original specification, but many
! productions, especially those regarding local variable declarations and
! expressions, required modifications.
!
! Feel free to modify and port this grammar to other parsing systems, but
! please leave this information. Have a great day and happy programming!
!
! Note: If there are any flaws, please visit www.DevinCook.com/GOLDParser
!
! - Devin Cook
!
!
! Updates:
! 05/09/2006
! Devin Cook
! The first version of the grammar was released.
!
! 04/04/2007
! Devin Cook
! Fixed a flaw in the Primary Exp. Thanks to Patrick Kristiansen for
! the reporting the error.
!
! 09/21/2007
! Devin Cook
! Modified the grammar to include the new features in C# 2.0. These include
! delegate expressions and partial classes.
!
! 11/07/2007
! Devin Cook
! Made some additional changes to make the grammar compliant to the C# spec.
!
! ----------------------------------------------------------------------------
 
"Name" = 'C#VB Script'
"Author" = 'John G. Kemeny and Thomas E. Kurtz'
"Version" = '2.0'
"AuthorVersion" = 'Anders Hejlsberg' = '5.0'
"About" = 'VB Script grammar.'
"Case Sensitive" = False
"Start Symbol" = <Program>
 
!===============================
"About" = 'C# was created by Anders Hejlsberg for the Microsoft Corporation.'
! Character sets
| 'The language was designed primarily to both fix flaws found in'
!===============================
| 'other languages and to integrate with the the .NET platform.'
| 'This grammar was written by Devin Cook.'
 
{String Char} = {All Valid} - ["]
"Start Symbol" = <Compilation Unit>
{Date Char} = {Printable} - [#]
{ID Name Char} = {Printable} - ['['']']
{Hex Digit} = {Digit} + [abcdef]
{Oct Digit} = [01234567]
{WS} = {Whitespace} - {CR} - {LF}
{ID Tail} = {Alphanumeric} + [_]
 
!===============================
! ----------------------------------------------------------------- Sets
! Terminals
!===============================
 
{ID Head}NewLine = {LetterCR} + [_]{LF}
{ID Tail} = {AlphaNumeric} + [_] | {CR}
{String Ch} = {Printable} - ["] | {LF}
{Char Ch} = {Printable} - [ | ':']
{Hex Digit} = {Digit} + [abcdef] + [ABCDEF]
 
! Special white space definition. Whitespace is either space or tab, which
! ----------------------------------------------------------------- Terminals
! can be followed by continuation symbol '_' followed by new line character
Whitespace = {WS}+
| '_' {WS}* {CR}? {LF}?
 
! Special comment definition
Identifier = [@]? {ID Head} {ID Tail}* !The @ is an override char
Comment Line = ''
| 'Rem'
 
! Literals
MemberName = '.' {ID Head} {ID Tail}*
StringLiteral = '"' ( {String Char} | '""' )* '"'
IntLiteral = {Digit}+
HexLiteral = '&H' {Hex Digit}+ '&'?
OctLiteral = '&' {Oct Digit}+ '&'?
FloatLiteral = {Digit}* '.' {Digit}+ ( 'E' [+-]? {Digit}+ )?
| {Digit}+ 'E' [+-]? {Digit}+
DateLiteral = '#' {Date Char}+ '#'
 
! Identifier is either starts with letter and followed by letter,
DecLiteral = {Digit}+ ( [UuLl] | [Uu][Ll] | [Ll][Uu] )?
! number or underscore, or it can be escaped sequence of any printable
HexLiteral = '0'[xX]{Hex Digit}+ ( [UuLl] | [Uu][Ll] | [Ll][Uu] )?
! characters ([] and [_$% :-) @] are valid identifiers)
RealLiteral = {Digit}*'.'{Digit}+
ID = {Letter} {ID Tail}*
| '[' {ID Name Char}* ']'
 
! White space is not allowed to be before dot, but allowed to be after it.
StringLiteral = '"'( {String Ch} | '\'{Printable} )* '"'
CharLiteralIDDot = '' ( = {Char ChLetter} |{ID '\'{PrintableTail}* )'.'
| '[' {ID Name Char}* ']' '.'
| 'And.'
| 'ByRef.'
| 'ByVal.'
| 'Call.'
| 'Case.'
| 'Class.'
| 'Const.'
| 'Default.'
| 'Dim.'
| 'Do.'
| 'Each.'
| 'Else.'
| 'ElseIf.'
| 'Empty.'
| 'End.'
| 'Eqv.'
| 'Erase.'
| 'Error.'
| 'Exit.'
| 'Explicit.'
| 'False.'
| 'For.'
| 'Function.'
| 'Get.'
| 'GoTo.'
| 'If.'
| 'Imp.'
| 'In.'
| 'Is.'
| 'Let.'
| 'Loop.'
| 'Mod.'
| 'New.'
| 'Next.'
| 'Not.'
| 'Nothing.'
| 'Null.'
| 'On.'
| 'Option.'
| 'Or.'
| 'Preserve.'
| 'Private.'
| 'Property.'
| 'Public.'
| 'Redim.'
| 'Rem.'
| 'Resume.'
| 'Select.'
| 'Set.'
| 'Step.'
| 'Sub.'
| 'Then.'
| 'To.'
| 'True.'
| 'Until.'
| 'WEnd.'
| 'While.'
| 'With.'
| 'Xor.'
 
! The following identifiers should only be used in With statement.
! ----------------------------------------------------------------- Comments
! This rule must be checked by contextual analyzer.
DotID = '.' {Letter} {ID Tail}*
| '.' '[' {ID Name Char}* ']'
| '.And'
| '.ByRef'
| '.ByVal'
| '.Call'
| '.Case'
| '.Class'
| '.Const'
| '.Default'
| '.Dim'
| '.Do'
| '.Each'
| '.Else'
| '.ElseIf'
| '.Empty'
| '.End'
| '.Eqv'
| '.Erase'
| '.Error'
| '.Exit'
| '.Explicit'
| '.False'
| '.For'
| '.Function'
| '.Get'
| '.GoTo'
| '.If'
| '.Imp'
| '.In'
| '.Is'
| '.Let'
| '.Loop'
| '.Mod'
| '.New'
| '.Next'
| '.Not'
| '.Nothing'
| '.Null'
| '.On'
| '.Option'
| '.Or'
| '.Preserve'
| '.Private'
| '.Property'
| '.Public'
| '.Redim'
| '.Rem'
| '.Resume'
| '.Select'
| '.Set'
| '.Step'
| '.Sub'
| '.Then'
| '.To'
| '.True'
| '.Until'
| '.WEnd'
| '.While'
| '.With'
| '.Xor'
 
DotIDDot = '.' {Letter}{ID Tail}* '.'
Comment Line = '//'
| '.' '[' {ID Name Char}* ']' '.'
Comment Start = '/*'
| '.And.'
Comment End = '*/'
| '.ByRef.'
| '.ByVal.'
| '.Call.'
| '.Case.'
| '.Class.'
| '.Const.'
| '.Default.'
| '.Dim.'
| '.Do.'
| '.Each.'
| '.Else.'
| '.ElseIf.'
| '.Empty.'
| '.End.'
| '.Eqv.'
| '.Erase.'
| '.Error.'
| '.Exit.'
| '.Explicit.'
| '.False.'
| '.For.'
| '.Function.'
| '.Get.'
| '.GoTo.'
| '.If.'
| '.Imp.'
| '.In.'
| '.Is.'
| '.Let.'
| '.Loop.'
| '.Mod.'
| '.New.'
| '.Next.'
| '.Not.'
| '.Nothing.'
| '.Null.'
| '.On.'
| '.Option.'
| '.Or.'
| '.Preserve.'
| '.Private.'
| '.Property.'
| '.Public.'
| '.Redim.'
| '.Rem.'
| '.Resume.'
| '.Select.'
| '.Set.'
| '.Step.'
| '.Sub.'
| '.Then.'
| '.To.'
| '.True.'
| '.Until.'
| '.WEnd.'
| '.While.'
| '.With.'
| '.Xor.'
 
!===============================
! Rules
!===============================
 
<NL> ::= NewLine <NL>
! ===========================================================================
| NewLine
! Shared by multiple sections
! ===========================================================================
 
<Program> ::= <NLOpt> <GlobalStmtList>
<Block or Semi>
::= <Block>
| ';'
 
!===============================
<Valid ID>
! Rules : Declarations
::= Identifier
!===============================
| this
| base
| <Base Type>
 
<ClassDecl> ::= 'Class' <ExtendedID> <NL> <MemberDeclList> 'End' 'Class' <NL>
<Qualified ID>
::= <Valid ID> <Member List>
<Member List>
::= <Member List> MemberName
| !Zero or more
 
<MemberDeclList> ::= <MemberDecl> <MemberDeclList>
<Semicolon Opt>
::= ';' |
| !Nothing
 
<MemberDecl> ::= <FieldDecl>
! ===========================================================================
| <VarDecl>
! C.1.8 Literals
| <ConstDecl>
! ===========================================================================
| <SubDecl>
| <FunctionDecl>
| <PropertyDecl>
 
<FieldDecl> ::= 'Private' <FieldName> <OtherVarsOpt> <NL>
<Literal>
| 'Public' <FieldName> <OtherVarsOpt> <NL>
::= true
| false
| DecLiteral
| HexLiteral
| RealLiteral
| CharLiteral
| StringLiteral
| null
 
<FieldName> ::= <FieldID> '(' <ArrayRankList> ')'
! ===========================================================================
| <FieldID>
! C.2.2 Types
! ===========================================================================
 
<FieldID> ::= ID
! All date types in C# are objects. A distinction is made between different
| 'Default'
! subtypes of objects, though. Some language constructs are restricted to
| 'Erase'
! one type or another.
| 'Error'
| 'Explicit'
| 'Step'
 
<VarDecl> ::= 'Dim' <VarName> <OtherVarsOpt> <NL>
<Type>
::= <Non Array Type>
| <Non Array Type> '*'
| <Non Array Type> <Rank Specifiers>
| <Non Array Type> <Rank Specifiers> '*'
<Pointer Opt>
::= '*'
| !Nothing
<Non Array Type>
! ::= <Other Type>
! | <Integral Type>
! | <Qualified ID>
 
<VarName> ::= <Qualified IDExtendedID> '(' <ArrayRankList> ')'
| <ExtendedID>
 
<OtherVarsOpt> ::= ',' <VarName> <OtherVarsOpt>
|
 
<ArrayRankList> ::= <IntLiteral> ',' <ArrayRankList>
! The following defines built-in datatypes only. This is necessary for local
| <IntLiteral>
! variable declarations.
|
 
<ConstDecl> ::= <AccessModifierOpt> 'Const' <ConstList> <NL>
<Base Type>
::= <Other Type>
| <Integral Type>
 
<ConstList> ::= <ExtendedID> '=' <ConstExprDef> ',' <ConstList>
<Other Type>
| <ExtendedID> '=' <ConstExprDef>
::= float
| double
| decimal
| bool
| void
| object
| string
! Integral types are valid in enumeration declarations.
 
<ConstExprDef> ::= '(' <ConstExprDef> ')'
<Integral Type>
| '-' <ConstExprDef>
::= sbyte
| '+' byte<ConstExprDef>
| <ConstExpr> short
| ushort
| int
| uint
| long
| ulong
| char
 
<SubDecl> ::= <MethodAccessOpt> 'Sub' <ExtendedID> <MethodArgList> <NL> <MethodStmtList> 'End' 'Sub' <NL>
! Rank specifiers are used to define the dimensions of arrays. The notation is odd.
| <MethodAccessOpt> 'Sub' <ExtendedID> <MethodArgList> <InlineStmt> 'End' 'Sub' <NL>
 
<FunctionDecl> ::= <MethodAccessOpt> 'Function' <ExtendedID> <MethodArgList> <NL> <MethodStmtList> 'End' 'Function' <NL>
<Rank Specifiers Opt>
| <MethodAccessOpt> 'Function' <ExtendedID> <MethodArgList> <InlineStmt> 'End' 'Function' <NL>
::= <Rank Specifiers Opt> <Rank Specifier>
|
 
<MethodAccessOpt> ::= 'Public' 'Default'
<Rank Specifiers>
| <AccessModifierOpt>
::= <Rank Specifiers> <Rank Specifier>
| <Rank Specifier>
 
<AccessModifierOpt> ::= 'Public'
<Rank Specifier>
::= '[' <Dim Separators> | ']Private'
|
 
<MethodArgList> ::= '(' <ArgList> ')'
<Dim Separators>
::= <Dim Separators> | ',(' ')'
| !Nothing |
 
<ArgList> ::= <Arg> ',' <ArgList>
| <Arg>
 
<Arg> ::= <ArgModifierOpt> <ExtendedID> '(' ')'
! ===========================================================================
| <ArgModifierOpt> <ExtendedID>
! C.2.4 Expressions
! ===========================================================================
 
<ArgModifierOpt> ::= 'ByVal'
<Expression Opt>
::= <Expression> | 'ByRef'
| !Nothing |
 
<PropertyDecl> ::= <MethodAccessOpt> 'Property' <PropertyAccessType> <ExtendedID> <MethodArgList> <NL> <MethodStmtList> 'End' 'Property' <NL>
<Expression List>
::= <Expression>
| <Expression> ',' <Expression List>
 
<PropertyAccessType> ::= 'Get'
| 'Let'
| 'Set'
 
!===============================
<Expression>
! Rules : Statements
::= <Conditional Exp> '=' <Expression>
!===============================
| <Conditional Exp> '+=' <Expression>
| <Conditional Exp> '-=' <Expression>
| <Conditional Exp> '*=' <Expression>
| <Conditional Exp> '/=' <Expression>
| <Conditional Exp> '^=' <Expression>
| <Conditional Exp> '&=' <Expression>
| <Conditional Exp> '|=' <Expression>
| <Conditional Exp> '%=' <Expression>
| <Conditional Exp> '<<=' <Expression>
| <Conditional Exp> '>>=' <Expression>
| <Conditional Exp>
 
<GlobalStmt> ::= <OptionExplicit>
<Conditional Exp>
::= <Or Exp> '?' <Or Exp> ':' <Conditional Exp | <ClassDecl>
| <Or Exp | <FieldDecl>
| <ConstDecl>
| <SubDecl>
| <FunctionDecl>
| <BlockStmt>
 
<MethodStmt> ::= <ConstDecl>
<Or Exp>
::= <Or Exp> ' ||' <And ExpBlockStmt>
| <And Exp>
 
<BlockStmt> ::= <VarDecl>
<And Exp>
::= <And Exp> '&&' <Logical Or Exp | <RedimStmt>
| <Logical Or Exp | <IfStmt>
| <WithStmt>
| <SelectStmt>
| <LoopStmt>
| <ForStmt>
| <InlineStmt> <NL>
 
<InlineStmt> ::= <AssignStmt>
<Logical Or Exp>
::= <Logical Or Exp> '|' <Logical Xor Exp | <CallStmt>
| <Logical Xor Exp | <SubCallStmt>
| <ErrorStmt>
| <ExitStmt>
| 'Erase' <ExtendedID>
 
<GlobalStmtList> ::= <GlobalStmt> <GlobalStmtList>
<Logical Xor Exp>
::= <Logical Xor Exp> '^' <Logical And Exp> |
| <Logical And Exp>
 
<MethodStmtList> ::= <MethodStmt> <MethodStmtList>
<Logical And Exp>
::= <Logical And Exp> '&' <Equality Exp> |
| <Equality Exp>
<BlockStmtList> ::= <BlockStmt> <BlockStmtList>
 
|
<Equality Exp>
::= <Equality Exp> '==' <Compare Exp>
| <Equality Exp> '!=' <Compare Exp>
| <Compare Exp>
 
<Compare Exp>
::= <Compare Exp> '<' <Shift Exp>
| <Compare Exp> '>' <Shift Exp>
| <Compare Exp> '<=' <Shift Exp>
| <Compare Exp> '>=' <Shift Exp>
| <Compare Exp> is <Type>
| <Compare Exp> as <Type>
| <Shift Exp>
 
<Shift Exp>
::= <Shift Exp> '<<' <Add Exp>
| <Shift Exp> '>>' <Add Exp>
| <Add Exp>
 
<Add Exp>
::= <Add Exp> '+' <Mult Exp>
| <Add Exp> '-' <Mult Exp>
| <Mult Exp>
 
<Mult Exp>
::= <Mult Exp> '*' <Unary Exp>
| <Mult Exp> '/' <Unary Exp>
| <Mult Exp> '%' <Unary Exp>
| <Unary Exp>
 
<Unary Exp>
::= '!' <Unary Exp>
| '~' <Unary Exp>
| '-' <Unary Exp>
| '++' <Unary Exp>
| '--' <Unary Exp>
| '(' <Expression> ')' <Object Exp> !Cast "expression" is required to avoid a conflict
| <Object Exp>
 
! Primary: x.y f(x) a[x] x++ x-- new typeof checked unchecked ->
 
<Object Exp>
::= delegate '(' <Formal Param List Opt> ')' <Block> !New in 2.0
| <Primary Array Creation Exp>
| <Method Exp>
<Primary Array Creation Exp>
::= new <Non Array Type> '[' <Expression List> ']' <Rank Specifiers Opt> <Array Initializer Opt>
| new <Non Array Type> <Rank Specifiers> <Array Initializer>
 
<Method Exp>
::= <Method Exp> <Method>
| <Primary Exp>
 
<Primary Exp>
::= typeof '(' <Type> ')'
| sizeof '(' <Type> ')'
| checked '(' <Expression> ')'
| unchecked '(' <Expression> ')'
 
| new <Non Array Type> '(' <Arg List Opt> ')' !Non array creation
| <Primary>
| '(' <Expression> ')'
<Primary>
::= <Valid ID>
| <Valid ID> '(' <Arg List Opt> ')' !Current object method
| <Literal>
 
! ===========================================================================
! Arguments
! ===========================================================================
 
<Arg List Opt>
::= <Arg List>
| !Nothing
<Arg List>
::= <Arg List> ',' <Argument>
| <Argument>
 
<Argument>
::= <Expression>
| ref <Expression>
| out <Expression>
 
! ===========================================================================
! C.2.5 Statements
! ===========================================================================
 
<Stm List>
::= <Stm List> <Statement>
| <Statement>
 
 
! This repetative productions below resolve the hanging-else problem by
! restricting the "if-then" statement to remove ambiguity. Two levels of
! statements are declared with the second, "restricted", group only used in
! the "then" clause of a "if-then-else" statement.
!
! The "restricted" group is completely identical the the first with one
! exception: only the "if-then-else" variant of the if statement is allowed.
! In other words, no "if" statements without "else" clauses can appear inside
! the "then" part of an "if-then-else" statement. Using this solution, the
! "else" will bind to the last "If" statement, and still allows chaining.
 
<Statement>
::= Identifier ':' ! label
| <Local Var Decl> ';'
 
| if '(' <Expression> ')' <Statement>
| if '(' <Expression> ')' <Then Stm> else <Statement>
| for '(' <For Init Opt> ';' <For Condition Opt> ';' <For Iterator Opt> ')' <Statement>
| foreach '(' <Type> Identifier in <Expression> ')' <Statement>
| while '(' <Expression> ')' <Statement>
| lock '(' <Expression> ')' <Statement>
| using '(' <Resource> ')' <Statement>
| fixed '(' <Type> <Fixed Ptr Decs> ')' <Statement>
| delegate '(' <Formal Param List Opt> ')' <Statement>
| <Normal Stm>
 
 
<Then Stm>
::= if '(' <Expression> ')' <Then Stm> else <Then Stm>
| for '(' <For Init Opt> ';' <For Condition Opt> ';' <For Iterator Opt> ')' <Then Stm>
| foreach '(' <Type> Identifier in <Expression> ')' <Then Stm>
| while '(' <Expression> ')' <Then Stm>
| lock '(' <Expression> ')' <Then Stm>
| using '(' <Resource> ')' <Then Stm>
| fixed '(' <Type> <Fixed Ptr Decs> ')' <Then Stm>
| delegate '(' <Formal Param List Opt> ')' <Then Stm>
| <Normal Stm>
<Normal Stm>
::= switch '(' <Expression> ')' '{' <Switch Sections Opt> '}'
| do <Normal Stm> while '(' <Expression> ')' ';'
| try <Block> <Catch Clauses> <Finally Clause Opt>
| checked <Block>
| unchecked <Block>
| unsafe <Block>
| break ';'
| continue ';'
| goto Identifier ';'
| goto case <Expression> ';'
| goto default ';'
| return <Expression Opt> ';'
| throw <Expression Opt> ';'
| <Statement Exp> ';'
| ';'
| <Block>
 
<Block>
::= '{' <Stm List> '}'
| '{' '}'
<Variable Decs>
::= <Variable Declarator>
| <Variable Decs> ',' <Variable Declarator>
 
<Variable Declarator>
::= Identifier
| Identifier '=' <Variable Initializer>
 
<Variable Initializer>
::= <Expression>
| <Array Initializer>
| stackalloc <Non Array Type> '[' <Non Array Type> ']'
 
<Constant Declarators>
::= <Constant Declarator>
| <Constant Declarators> ',' <Constant Declarator>
 
<Constant Declarator>
::= Identifier '=' <Expression>
 
 
! ===========================================================================
! Switch Clauses
! ===========================================================================
 
<Switch Sections Opt>
::= <Switch Sections Opt> <Switch Section>
| !Nothing
 
<Switch Section>
::= <Switch Labels> <Stm List>
 
<Switch Labels>
::= <Switch Label>
| <Switch Labels> <Switch Label>
 
<Switch Label>
::= case <Expression> ':'
| default ':'
 
 
! ===========================================================================
! For Clauses
! ===========================================================================
 
<For Init Opt>
::= <Local Var Decl>
| <Statement Exp List>
| !Nothing
 
<For Iterator Opt>
::= <Statement Exp List>
| !Nothing
 
<For Condition Opt>
::= <Expression>
| !Nothing
 
<Statement Exp List>
::= <Statement Exp List> ',' <Statement Exp>
| <Statement Exp>
 
! ===========================================================================
! Catch Clauses
! ===========================================================================
 
<Catch Clauses>
::= <Catch Clause> <Catch Clauses>
| !Nothing
 
<Catch Clause>
::= catch '(' <Qualified ID> Identifier ')' <Block>
| catch '(' <Qualified ID> ')' <Block>
| catch <Block>
 
<Finally Clause Opt>
::= finally <Block>
| !Nothing
 
! ===========================================================================
! Using Clauses
! ===========================================================================
 
<Resource>
::= <Local Var Decl>
| <Statement Exp>
 
! ===========================================================================
! Fixed Clauses
! ===========================================================================
 
<Fixed Ptr Decs>
::= <Fixed Ptr Dec>
| <Fixed Ptr Decs> ',' <Fixed Ptr Dec>
 
<Fixed Ptr Dec>
::= Identifier '=' <Expression>
 
! ===========================================================================
! Statement Expressions & Local Variable Declaration
! ===========================================================================
 
! The complex productions below are able to avoid the shift-reduce error caused
! by declaring an array. The notation used by C# (and the rest of the C++
! family) prevents an array declaration to be distinguished from an array
! assignment statement until a number of characters are read.
!
! a.b.c[2] = "Test"
! a.b.c[] = new String[3]
!
! The system CANNOT make a decision between the two until it is reading the
! contents the [ ... ].
!
! As a result, the local variable declaration below contains the full notation
! for each of the C# methods at the same level as local variable declarations.
! Since the system does not have to reduce UNTIL it is within the [ ... ], no
! shift-reduce error will occur. Nasty, huh?
 
<Local Var Decl>
::= <Qualified ID> <Rank Specifiers> <Pointer Opt> <Variable Decs>
| <Qualified ID> <Pointer Opt> <Variable Decs>
! | <Base Type> <Rank Specifiers> <Pointer Opt> <Variable Decs>
! | <Base Type> <Pointer Opt> <Variable Decs>
 
<Statement Exp>
::= <Qualified ID> '(' <Arg List Opt> ')'
| <Qualified ID> '(' <Arg List Opt> ')' <Methods Opt> <Assign Tail>
| <Qualified ID> '[' <Expression List> ']' <Methods Opt> <Assign Tail>
| <Qualified ID> '->' Identifier <Methods Opt> <Assign Tail>
| <Qualified ID> '++' <Methods Opt> <Assign Tail>
| <Qualified ID> '--' <Methods Opt> <Assign Tail>
| <Qualified ID> <Assign Tail>
 
<Assign Tail>
::= '++'
| '--'
| '=' <Expression>
| '+=' <Expression>
| '-=' <Expression>
| '*=' <Expression>
| '/=' <Expression>
| '^=' <Expression>
| '&=' <Expression>
| '|=' <Expression>
| '%=' <Expression>
| '<<=' <Expression>
| '>>=' <Expression>
 
<Methods Opt>
::= <Methods Opt> <Method>
| !Null
 
<Method>
::= MemberName
| MemberName '(' <Arg List Opt> ')' !Invocation
| '[' <Expression List> ']'
| '->' Identifier
| '++'
| '--'
 
! ===========================================================================
! C.2.6 Namespaces
! ===========================================================================
 
<Compilation Unit>
::= <Using List> <Compilation Items>
 
<Using List>
::= <Using List> <Using Directive>
| !Nothing
 
<Using Directive>
::= using Identifier '=' <Qualified ID> ';'
| using <Qualified ID> ';'
 
<Compilation Items>
::= <Compilation Items> <Compilation Item>
| ! Zero or more
 
<Compilation Item>
::= <Namespace Dec>
| <Namespace Item> !Default namespace
 
! ===========================================================================
! Namespace
! ===========================================================================
 
<Namespace Dec>
::= <Attrib Opt> namespace <Qualified ID> '{' <Using List> <Namespace Items> '}' <Semicolon Opt>
 
<Namespace Items>
::= <Namespace Items> <Namespace Item>
| ! Zero or more
 
<Namespace Item>
::= <Constant Dec>
| <Field Dec>
| <Method Dec>
| <Property Dec>
| <Type Decl>
 
<Type Decl>
::= <Class Decl>
| <Struct Decl>
| <Interface Decl>
| <Enum Decl>
| <Delegate Decl>
! ================================= Modifiers
 
<Header>
::= <Attrib Opt> <Access Opt> <Modifier List Opt>
 
<Access Opt>
::= private
| protected
| public
| internal !Friend
| !Nothing
 
<Modifier List Opt>
::= <Modifier List Opt> <Modifier>
| !Nothing
 
<Modifier>
::= abstract
| extern
| new
| override
| partial
| readonly
| sealed
| static
| unsafe
| virtual
| volatile
 
! ===========================================================================
! C.2.7 Classes
! ===========================================================================
 
<Class Decl>
::= <Header> class Identifier <Class Base Opt> '{' <Class Item Decs Opt> '}' <Semicolon Opt>
 
<Class Base Opt>
::= ':' <Class Base List>
| !Nothing
 
<Class Base List>
::= <Class Base List> ',' <Non Array Type>
| <Non Array Type>
 
 
<Class Item Decs Opt>
::= <Class Item Decs Opt> <Class Item>
| !Nothing
 
<Class Item>
::= <Constant Dec>
| <Field Dec>
| <Method Dec>
| <Property Dec>
| <Event Dec>
| <Indexer Dec>
| <Operator Dec>
| <Constructor Dec>
| <Destructor Dec>
| <Type Decl>
 
<Constant Dec>
::= <Header> const <Type> <Constant Declarators> ';'
 
<Field Dec>
::= <Header> <Type> <Variable Decs> ';'
 
<Method Dec>
::= <Header> <Type> <Qualified ID> '(' <Formal Param List Opt> ')' <Block or Semi>
<Formal Param List Opt>
::= <Formal Param List>
| !Nothing
 
<Formal Param List>
::= <Formal Param>
| <Formal Param List> ',' <Formal Param>
 
<Formal Param>
::= <Attrib Opt> <Type> Identifier
| <Attrib Opt> ref <Type> Identifier
| <Attrib Opt> out <Type> Identifier
| <Attrib Opt> params <Type> Identifier !Parameter array
 
<Property Dec>
::= <Header> <Type> <Qualified ID> '{' <Accessor Dec> '}'
<Accessor Dec>
::= <Access Opt> get <Block or Semi>
| <Access Opt> get <Block or Semi> <Access Opt> set <Block or Semi>
| <Access Opt> set <Block or Semi>
| <Access Opt> set <Block or Semi> <Access Opt> get <Block or Semi>
 
<Event Dec>
::= <Header> event <Type> <Variable Decs> ';'
| <Header> event <Type> <Qualified ID> '{' <Event Accessor Decs> '}'
 
<Event Accessor Decs>
::= add <Block or Semi>
| add <Block or Semi> remove <Block or Semi>
| remove <Block or Semi>
| remove <Block or Semi> add <Block or Semi>
 
 
!<Indexer Dec>
! ::= <Header> <Type> <Indexer This> '[' <Formal Param List> ']' '{' <Accessor Dec>'}'
!
!<Indexer This>
! ::= this
! | <Qualified ID> !Ending in 'this' - This is a post-parse semantic check
 
<Indexer Dec>
::= <Header> <Type> <Qualified ID> '[' <Formal Param List> ']' '{' <Accessor Dec>'}'
!Ending in 'this' - This is a post-parse semantic check
 
! ===========================================================================
! Operator Declarations
! ===========================================================================
 
<Operator Dec>
::= <Header> <Overload Operator Decl> <Block or Semi>
| <Header> <Conversion Operator Decl> <Block or Semi>
 
<Overload Operator Decl>
::= <Type> operator <Overload Op> '(' <Type> Identifier ')'
| <Type> operator <Overload Op> '(' <Type> Identifier ',' <Type> Identifier ')'
<Conversion Operator Decl>
::= implicit operator <Type> '(' <Type> Identifier ')'
| explicit operator <Type> '(' <Type> Identifier ')'
 
 
<Overload Op>
::= '+'
| '-'
| '!'
| '~'
| '++'
| '--'
| true
| false
| '*'
| '/'
| '%'
| '&'
| '|'
| '^'
| '<<'
| '>>'
| '=='
| '!='
| '>'
| '<'
| '>='
| '<='
 
 
! ===========================================================================
! Constructor / Destructor Declarations
! ===========================================================================
 
<Constructor Dec>
::= <Header> <Constructor Declarator> <Block or Semi>
 
<Constructor Declarator>
::= Identifier '(' <Formal Param List Opt> ')' <Constructor Init Opt>
 
<Constructor Init Opt>
::= <Constructor Init>
| !Nothing
 
<Constructor Init>
::= ':' base '(' <Arg List Opt> ')'
| ':' this '(' <Arg List Opt> ')'
 
 
<Destructor Dec>
::= <Header> '~' Identifier '(' ')' <Block>
 
 
! ===========================================================================
! C.2.8 Structs
! ===========================================================================
 
! Note: Structures have the SAME members as normal classes. As a result, the
! <Class Item Decs Opt> rule is used
 
 
<Struct Decl>
::= <Header> struct Identifier <Class Base Opt> '{' <Class Item Decs Opt>'}' <Semicolon Opt>
 
 
! ===========================================================================
! C.2.9 Arrays
! ===========================================================================
 
<Array Initializer Opt>
::= <Array Initializer>
| ! NOTHING
 
<Array Initializer>
::= '{' <Variable Initializer List Opt> '}'
| '{' <Variable Initializer List> ',' '}'
 
<Variable Initializer List Opt>
::= <Variable Initializer List>
| ! Nothing
 
<Variable Initializer List>
::= <Variable Initializer>
| <Variable Initializer List> ',' <Variable Initializer>
 
 
! ===========================================================================
! C.2.10 Interfaces
! ===========================================================================
 
<Interface Decl>
::= <Header> interface Identifier <Interface Base Opt> '{' <Interface Item Decs Opt> '}' <Semicolon Opt>
 
<Interface Base Opt>
::= ':' <Class Base List>
| !Nothing
 
 
<Interface Item Decs Opt>
::= <Interface Item Decs Opt> <Interface Item Dec>
| !Nothing
 
<Interface Item Dec>
::= <Interface Method Dec>
| <Interface Property Dec>
| <Interface Event Dec>
| <Interface Indexer Dec>
 
<Interface Method Dec>
::= <Attrib Opt> <New Opt> <Type> Identifier '(' <Formal Param List Opt> ')' <Interface Empty Body>
<New Opt>
::= NEW
| !Nothing
 
<Interface Property Dec>
::= <Attrib Opt> <New Opt> <Type> Identifier '{' <Interface Accessors> '}'
 
<Interface Indexer Dec>
::= <Attrib Opt> <New Opt> <Type> this '[' <Formal Param List> ']' '{' <Interface Accessors> '}'
 
<Interface Accessors>
::= <Attrib Opt> <Access Opt> get <Interface Empty Body>
| <Attrib Opt> <Access Opt> set <Interface Empty Body>
| <Attrib Opt> <Access Opt> get <Interface Empty Body> <Attrib Opt> <Access Opt> set <Interface Empty Body>
| <Attrib Opt> <Access Opt> set <Interface Empty Body> <Attrib Opt> <Access Opt> get <Interface Empty Body>
 
<Interface Event Dec>
::= <Attrib Opt> <New Opt> event <Type> Identifier <Interface Empty Body>
 
<Interface Empty Body>
::= ';'
| '{' '}'
 
! ===========================================================================
! C.2.11 Enums
! ===========================================================================
 
<Enum Decl> ::= <Header> enum Identifier <Enum Base Opt> <Enum Body> <Semicolon Opt>
 
<Enum Base Opt>
::= ':' <Integral Type>
| !Nothing
 
<Enum Body>
::= '{' <Enum Item Decs Opt> '}'
| '{' <Enum Item Decs> ',' '}'
 
<Enum Item Decs Opt>
::= <Enum Item Decs>
| !Nothing
 
<Enum Item Decs>
::= <Enum Item Dec>
| <Enum Item Decs> ',' <Enum Item Dec>
 
<Enum Item Dec>
::= <Attrib Opt> Identifier
| <Attrib Opt> Identifier '=' <Expression>
 
 
! ===========================================================================
! C.2.12 Delegates
! ===========================================================================
 
 
<Delegate Decl> ::= <Header> delegate <Type> Identifier '(' <Formal Param List Opt> ')' ';'
 
 
! ===========================================================================
! C.2.13 Attributes
! ===========================================================================
 
<Attrib Opt>
::= <Attrib Opt> <Attrib Section>
| !Nothing
 
<Attrib Section>
::= '[' <Attrib Target Spec Opt> <Attrib List> ']'
| '[' <Attrib Target Spec Opt> <Attrib List> ',' ']'
 
<Attrib Target Spec Opt>
::= assembly ':'
| field ':'
| event ':'
| method ':'
| module ':'
| param ':'
| property ':'
| return ':'
| type ':'
| ! Nothing
 
<Attrib List>
::= <Attribute>
| <Attrib List> ',' <Attribute>
 
<Attribute>
::= <Qualified ID> '(' <Expression List> ')'
| <Qualified ID> '(' ')'
| <Qualified ID>
 
</pre>
 
=={{header|C++}}==
=={{header|Caml}}==
=={{header|Clean}}==
=={{header|Clojure}}==
=={{header|Cobol}}==
<pre>
! -----------------------------------------------------------------------------
! 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
</pre>
 
=={{header|ColdFusion}}==
=={{header|Common Lisp}}==
=={{header|Component Pascal}}==
=={{header|Coq}}==
=={{header|D}}==
=={{header|DOS Batch File}}==
=={{header|Dc}}==
=={{header|Delphi}}==
<pre>
! -----------------------------------------------------------------------
! Delphi 7.0 Object Pascal Grammar
! -----------------------------------------------------------------------
! (c) Rob F.M. van den Brink - the Netherlands, 2006 - R.F.M.vandenBrink@hccnet.nl
! Version V1.1, Aug 2006
!
! This grammar parses almost everything of the language, except for a few issues
! that are probably beyond the capabilities of Gold parser.
! Known limitations:
! (1) Cannot handle comment directives like {$ifdef Windows} ... {$endif}
! When parts of the source code is uncommented in this way, the grammer will
! still read it, and may fail.
! (2) The parser consumes all assembler statements, but is too tolerant in accepting
! input. Groups of several <AsmItem> does not belong to a single <AsmInstruction>
! because a 'newline' is regarded as whitespace while it should be a terminator here.
! (3) Lexemes like 'protected' , 'forward' can be both a keyword as well as an identifier
! in Delphi (even in the same object declaration), and when these lexemes should mean
! an identifier, the current grammar cannot handle it correctly.
! For several of them a workaround was created, but a better solution should be
! developped.
! (4) Strings with characters above #127 cannot be handled by the current Grammar.
! This should be very simple, but if the grammar defines string characters
! as the range {#32 .. #255}, Goldparser also adds {#376} and {#956}.
! This looks like a bug in Gold Parser.
! (5) The inclusion of an adequate number of error productions (SynError) is still
! to be done.
! (6) constructs that are considered (for the timebeing) as too weird, are not
! supported; see below.
! -----------------------------------------------------------------------
! This grammar supports also most of 'weird' constructs that Borland has added
! to Delphi. This refers to the inconsistent syntax for several directives
! like in <CallConvention> and <MethodDirective>. Sometimes these directives have
! to be separated by an ';' sometimes not and somtimes both is alowed.
! An example of a syntax that was considered as too weird to be covered by this
! grammar was found in library routine "IdSSLOpenSSLHeaders.pas" (comes with Delphi)
! VAR
! IdSslCtxSetVerifyDepth : procedure(ctx: PSSL_CTX; depth: Integer); cdecl = nil;
! IdSslCtxGetVerifyDepth : function (ctx: PSSL_CTX):Integer; cdecl = nil;
! In a consistent syntax, cdecl should refer to some variable that is set to "nil', but
! the ';' does not close the <TypeSpec> and the rest is still part of the syntax
!
! -----------------------------------------------------------------------
! Version history
! V1.0 - June 2006, derived from scratch, using Delphi 7.0 help and code files
! V1.1 - Aug 2006, lots of refinements to cover almost evberything of the language
! Consumes assembler code as well.
! -----------------------------------------------------------------------
 
"Name" = 'ObjectPascal'
"Version" = '1.1, Aug 2006'
"Author" = 'Rob F.M. van den Brink'
"About" = 'Derived from scratch, from Delphi 7.0 help and experiments with code files'
"Start Symbol" = <ObjectPascal>
 
!------------------------------------------------------------------------------
"Case Sensitive" = False
"Virtual Terminals" = SynError CommentStart2 CommentEnd2
 
 
Comment Line = '//'
Comment Start = '{'
Comment End = '}'
 
CommentStart1 = '(*'
CommentEnd1 = '*)'
 
 
{Hex Digit} = {Digit} + [abcdefABCDEF]
 
{Id Head} = {Letter} + [_]
 
{Id Tail} = {Id Head} + {Digit}
 
!{String Ch} = {#32 .. #255} - [''] + {HT} !WHY DOES GOLS ADD character #376 and #956 ??
 
{String Ch} = {printable} - [''] + {HT}
 
 
DecLiteral = {digit}+
 
HexLiteral = '$'{Hex Digit}+
 
FloatLiteral = {Digit}+.{Digit}+
 
RealLiteral = {Digit}+ ('.' {Digit}* | {Digit}*) ('E' '+' | 'E' '-' | 'E') {digit}+
 
 
StringLiteral = ( '' {String Ch}* '' | '#' {digit}+ | '#' '$' {hex digit}+ | '''' )+
 
!StringLiteral = ( ( '' {String Ch}* '' )
! | ( '#' {digit}+ )
! | ( '#' '$' {hex digit}+ )
! | ( '''' )
! )+
 
id = {Id Head}{Id Tail}*
 
 
 
 
<LCONST> ::= DecLiteral
 
<ICONST> ::= DecLiteral
| HexLiteral
 
<RCONST> ::= FloatLiteral
| RealLiteral
 
<SCONST> ::= StringLiteral
| '^' id ! handles characters like ^H and ^V
 
!------------------------------------------------------------------------------
 
!<UnitId> ::= id
 
<IdList> ::= <IdList> ',' <RefId>
| <RefId>
 
<LabelId> ::= id
 
<TypeId> ::= id
! | id '.' <RefId>
| NAME
<TypeName> ::= <TypeId>
| id '.' <RefId> !!accepts UnitId.Id as well
 
<TypeList> ::= <TypeName>
| <TypeList> ',' <TypeName>
 
<RefId> ::= id
| AT | ON | READ | WRITE | READLN | WRITELN | NAME | INDEX
| VIRTUAL | ABSOLUTE | MESSAGE | DEFAULT | OVERRIDE | ABSTRACT
| DISPID | REINTRODUCE
| REGISTER | PASCAL | CDECL | STDCALL | SAFECALL
| STRING | WIDESTRING | ANSISTRING
| VARIANT | OLEVARIANT
| READONLY | IMPLEMENTS | NODEFAULT | STORED
| OVERLOAD | LOCAL | VARARGS
| FORWARD
| CONTAINS | PACKAGE | REQUIRES | LIBRARY
| IMPORT | EXPORT
| PLATFORM | DEPRECATED
| EXTERNAL
! PROTECTED | PUBLISHED | PRIVATE | PUBLIC !THIS FAILS IN FIELDS
 
 
<FieldDesignator> ::= <RefId>
| <FieldDesignator> '.' <RefId>
 
 
 
!* predefined identifiers are no part of a syntax
<RealTypeId> ::= REAL48
| REAL
| SINGLE
| DOUBLE
| EXTENDED
| CURRENCY
| COMP
 
<OrdTypeId> ::= SHORTINT
| SMALLINT
| INTEGER
| BYTE
| LONGINT
| INT64
| WORD
| BOOLEAN
| CHAR
| WIDECHAR
| LONGWORD
| PCHAR
*!
 
!------------------------------------------------------------------------------
! M O D U L E S
!------------------------------------------------------------------------------
 
<ObjectPascal> ::= <Program> | <Unit> | <Package> | <Library>
 
<Program> ::= <ProgHeader> <OptUsesSection> <Block> '.'
 
<ProgHeader> ::= PROGRAM <RefId> <OptProgParamList> ';'
 
<OptProgParamList> ::= '(' <IdList> ')'
|
 
<Unit> ::= <UnitHeader> <InterfaceSection> <ImplementationSection> <InitSection> '.'
 
<UnitHeader> ::= UNIT <RefId> <OptPortDirectives> ';'
 
<Package> ::= <PackageHeader> <OptRequiresClause> <OptContainsClause> END '.'
 
 
<PackageHeader> ::= PACKAGE <RefId> ';'
 
<OptRequiresClause> ::= REQUIRES <IdList> ';'
|
 
<OptContainsClause> ::= CONTAINS <IdList> ';'
|
 
<LibraryHeader> ::= LIBRARY <RefId> ';'
 
<Library> ::= <LibraryHeader> <OptUsesSection> <Block> '.'
 
 
 
<InterfaceSection> ::= INTERFACE <OptUsesSection> <OptExportDeclList>
 
<OptUsesSection> ::= <UsesSection>
|
 
 
<UsesClause> ::= USES <IdList> ';'
| SynError
 
<UsesSection> ::= <UsesClause>
| <UsesSection> <UsesClause>
 
<OptExportDeclList> ::= <ExportDeclList>
|
 
<ExportDeclList> ::= <ExportDeclItem>
| <ExportDeclList> <ExportDeclItem>
 
<ExportDeclItem> ::= <ConstSection>
| <TypeSection>
| <VarSection>
| <CallSection>
| <CallSection> FORWARD ';'
! The forward directive has no effect in the interface section of a unit,
! but is not forbidden here.
 
<CallSection> ::= <ProcHeading>
| <FuncHeading>
 
 
 
<ImplementationSection> ::= IMPLEMENTATION <OptUsesSection> <OptDeclSection> <OptExportBlock>
<InitSection> ::= INITIALIZATION <StmtList> END
| INITIALIZATION <StmtList> FINALIZATION <StmtList> END
| <CompoundStmt>
| END
 
<Block> ::= <OptDeclSection> <OptExportBlock> <CompoundStmt> <OptExportBlock>
 
 
<OptExportBlock> ::= <ExportStmt>
| <OptExportBlock> <ExportStmt>
|
 
<ExportStmt> ::= EXPORTS <ExportList> ';'
 
 
<ExportList> ::= <ExportItem>
| <ExportList> ',' <ExportItem>
 
<ExportItem> ::= id
| id NAME '' <ConstExpr> ''
| Id INDEX '' <ConstExpr> ''
| NAME '' <ConstExpr> ''
| INDEX '' <ConstExpr> ''
 
!------------------------------------------------------------------------------
! D E C L A R A T I O N S
!------------------------------------------------------------------------------
 
<OptDeclSection> ::= <DeclSection>
|
 
<DeclSection> ::= <DeclItem>
| <DeclSection> <DeclItem>
 
<DeclItem> ::= <LabelSection>
| <ConstSection>
| <TypeSection>
| <VarSection>
| <ProcedureDeclSection>
| SynError
<LabelSection> ::= LABEL <LabelList> ';'
 
<LabelList> ::= <LabelId>
| <LabelList> ',' <LabelId>
 
!-----CONSTS-------------------------------------------------------------------
 
<ConstSection> ::= CONST <ConstantDeclList>
| RESOURCESTRING <ConstantDeclList> !all these constants should be string
 
<ConstantDeclList> ::= <ConstantDecl>
| <ConstantDeclList> <ConstantDecl>
 
<ConstantDecl> ::= <RefId> '=' <ConstExpr> <OptPortDirectives> ';'
| <RefId> ':' <Type> '=' <TypedConstant> <OptPortDirectives> ';'
| SynError ';'
 
<TypedConstant> ::= <ConstExpr>
| <ArrayConstant>
| <RecordConstant>
 
<ArrayConstant> ::= '(' <TypedConstList> ')'
 
<RecordConstant> ::= '(' <RecordFieldConstList> ')'
| '(' <RecordFieldConstList> ';' ')'
| '(' ')' !only to initialize globar vars"
 
<RecordFieldConstList> ::= <RecordFieldConstant>
| <RecordFieldConstList> ';' <RecordFieldConstant>
 
<RecordFieldConstant> ::= <RefId> ':' <TypedConstant>
 
<TypedConstList> ::= <TypedConstant>
| <TypedConstList> ',' <TypedConstant>
 
 
!-----TYPES--------------------------------------------------------------------
 
 
<TypeSection> ::= TYPE <TypeDeclList>
 
<TypeDeclList> ::= <TypeDecl>
| <TypeDeclList> <TypeDecl>
 
<TypeDecl> ::= <TypeId> '=' <TypeSpec>
| SynError ';'
 
 
<TypeSpec> ::= <GenericType> ';'
| <RestrictedType> <OptPortDirectives> ';'
| <CallType> ';'
| <CallType> ';' <CallConventions> ';'
| SynError ';'
 
<Type> ::= <GenericType>
| <CallType>
 
<TypeRef> ::= <TypeName>
| <StringType>
| <VariantType>
 
<GenericType> ::= <TypeName>
| <StringType>
| <VariantType>
| <SubrangeType>
| <EnumType>
| <StructType>
| <PointerType>
| <ClassRefType>
| <ClonedType>
 
 
<ClonedType> ::= TYPE <TypeRef>
 
 
<StringType> ::= STRING
| ANSISTRING
| WIDESTRING
| STRING '[' <ConstExpr> ']'
<VariantType> ::= VARIANT
| OLEVARIANT
<OrdinalType> ::= <SubrangeType> | <EnumType> | <TypeName>
 
<SubrangeType> ::= <ConstOrdExpr> '..' <ConstOrdExpr>
| <ConstOrdExpr> SynError
| '(' <RefId> ')' '..' <ConstOrdExpr>
 
 
 
 
<EnumType> ::= '(' <EnumList> ')'
| '(' <RefId> ')'
 
<EnumList> ::= <EnumId>
| <EnumList> ',' <EnumId>
<EnumId> ::= <RefId>
| <RefId> '=' <ConstExpr>
 
 
<OptPacked> ::= PACKED
|
<StructType> ::= <ArrayType>
| <SetType>
| <FileType>
| <RecType>
 
 
<ArrayType> ::= <OptPacked> ARRAY '[' <OrdinalTypeList> ']' OF <Type>
| <OptPacked> ARRAY OF CONST
| <OptPacked> ARRAY OF <Type> !dynamic array, starting from 0
! FCells: array of array of TIWGridCell;
 
 
<OrdinalTypeList> ::= <OrdinalType>
| <OrdinalTypeList> ',' <OrdinalType>
 
 
 
<RecType> ::= <OptPacked> RECORD <RecFieldList> END <OptPortDirectives>
 
<RecFieldList> ::=
| <RecField1>
| <RecField2>
| <RecField1> ';' <RecFieldList>
| <RecField2> ';' <RecFieldList>
| <RecField2> ';' <CallConvention>
| <RecField2> ';' <CallConvention> ';' <RecFieldList>
| CASE <Selector> OF <RecVariantList>
 
<RecVariantList> ::=
| <RecVariant>
| <RecVariant> ';' <RecVariantList>
 
<RecField1> ::= <IdList> ':' <GenericType> <OptPortDirectives>
 
<RecField2> ::= <IdList> ':' <CallType>
 
<RecVariant> ::= <ConstExprList> ':' '(' <RecFieldList> ')'
 
 
 
 
 
<Selector> ::= <RefId> ':' <TypeName>
| <TypeName>
 
 
<SetType> ::= <OptPacked> SET OF <OrdinalType>
 
<FileType> ::= <OptPacked> FILE OF <TypeRef>
| FILE
 
<PointerType> ::= '^' <TypeRef>
 
<CallType> ::= PROCEDURE <OptFormalParms> <OptCallConventions>
| PROCEDURE <OptFormalParms> OF OBJECT <OptCallConventions>
| FUNCTION <OptFormalParms> ':' <ResultType> <OptCallConventions>
| FUNCTION <OptFormalParms> ':' <ResultType> OF OBJECT <OptCallConventions>
 
 
 
 
!-----CLASSES AND OBJECTS------------------------------------------------------
 
<RestrictedType> ::= <ObjectType>
| <ClassType>
| <InterfaceType>
<ObjectType> ::= <OptPacked> OBJECT <OptObjectHeritage> <ObjectMemberList> END
 
<ClassType> ::= CLASS <OptClassHeritage> <ClassMemberList> END
| CLASS <OptClassHeritage>
 
<ClassRefType> ::= CLASS OF <TypeName>
 
<InterfaceType> ::= INTERFACE <OptClassHeritage> <OptClassGUID> <OptClassMethodList> END
| DISPINTERFACE <OptClassHeritage> <OptClassGUID> <OptClassMethodList> END
| INTERFACE
| DISPINTERFACE
 
 
<OptObjectHeritage> ::= '(' <TypeName> ')'
|
 
 
<OptClassHeritage> ::='(' <TypeList> ')'
|
<OptClassGUID> ::= '[' <ConstStrExpr> ']' ! <SCONST> globally unique identifier
|
 
<ObjectMemberList> ::= <OptFieldList> <OptObjectMethodList>
| <ObjectMemberList> PUBLIC <OptFieldList> <OptObjectMethodList>
| <ObjectMemberList> PRIVATE <OptFieldList> <OptObjectMethodList>
| <ObjectMemberList> PROTECTED <OptFieldList> <OptObjectMethodList>
 
<ClassMemberList> ::= <OptFieldList> <OptClassMethodList>
| <ClassMemberList> PUBLIC <OptFieldList> <OptClassMethodList>
| <ClassMemberList> PRIVATE <OptFieldList> <OptClassMethodList>
| <ClassMemberList> PROTECTED <OptFieldList> <OptClassMethodList>
| <ClassMemberList> PUBLISHED <OptFieldList> <OptClassMethodList>
 
 
<OptFieldList> ::= <FieldList>
|
 
<OptObjectMethodList> ::= <ObjectMethodList>
|
 
<OptClassMethodList> ::= <ClassMethodList>
|
 
<FieldList> ::= <FieldSpec>
| <FieldList> <FieldSpec>
 
<ObjectMethodList> ::= <ObjectMethodSpec>
| <ObjectMethodList> <ObjectMethodSpec>
 
<ClassMethodList> ::= <ClassMethodSpec>
| <ClassMethodList> <ClassMethodSpec>
 
 
<FieldSpec> ::= <IdList> ':' <Type> <OptPortDirectives> ';'
| SynError ';'
 
 
<ObjectMethodSpec> ::= <MethodSpec> <OptMethodDirectives>
| <PropertySpec> <OptPropertyDirectives>
| SynError
 
<ClassMethodSpec> ::= <MethodSpec> <OptMethodDirectives>
| <ResolutionSpec> <OptMethodDirectives>
| CLASS <ProcSpec> <OptMethodDirectives>
| CLASS <FuncSpec> <OptMethodDirectives>
| <PropertySpec> <OptPropertyDirectives>
| SynError
<MethodSpec> ::= <ConstructorSpec>
| <DestructorSpec>
| <ProcSpec>
| <FuncSpec>
 
 
<ConstructorSpec> ::= CONSTRUCTOR <RefId> <OptFormalParms> ';'
 
<DestructorSpec> ::= DESTRUCTOR <RefId> <OptFormalParms> ';'
 
<ProcSpec> ::= PROCEDURE <RefId> <OptFormalParms> <OptCallConventions> ';'
 
<FuncSpec> ::= FUNCTION <RefId> <OptFormalParms> ':' <ResultType> <OptCallConventions> ';'
 
<ResolutionSpec> ::= PROCEDURE <RefId> '.' <RefId> '=' <RefId> ';'
| FUNCTION <RefId> '.' <RefId> '=' <RefId> ';'
 
<PropertySpec> ::= PROPERTY <PropertyDecl> <OptPropSpecifiers> ';'
 
<PropertyDecl> ::= <RefId> ':' <TypeRef>
| <RefId> '[' <IndexList> ']' ':' <TypeRef>
| <RefId>
 
<IndexList> ::= <IndexDecl>
| <IndexList> ';' <IndexDecl>
<IndexDecl> ::= <IdDecl>
| CONST <IdDecl>
 
<IdDecl> ::= <IdList> ':' <Type>
 
 
<OptPropSpecifiers> ::= <PropertySpecifiers>
|
 
<PropertySpecifiers> ::= <PropertySpecifier>
| <PropertySpecifiers> <PropertySpecifier>
 
 
<PropertySpecifier> ::= INDEX <ConstExpr> !StorageSpecifier
| READ <FieldDesignator>
| WRITE <FieldDesignator>
| STORED <FieldDesignator>
! | STORED <ConstExpr>
| DEFAULT <ConstExpr>
| NODEFAULT
| WRITEONLY
| READONLY
| DISPID <ConstExpr> !Only within InterfaceTypes
| <ImplementsSpecifier>
 
<ImplementsSpecifier> ::= IMPLEMENTS <TypeRef>
| <ImplementsSpecifier> ',' <TypeRef>
! The implements directive must be the last specifier in the property
! declaration and can list more than one interface, separated by commas
 
!-----VARS---------------------------------------------------------------------
 
<VarSection> ::= VAR <VarDeclList>
| THREADVAR <ThreadVarDeclList>
 
<VarDeclList> ::= <VarDecl>
| <VarDeclList> <VarDecl>
 
<VarDecl> ::= <IdList> ':' <Type> <OptAbsoluteClause> <OptPortDirectives> ';'
| <IdList> ':' <Type> '=' <TypedConstant> <OptPortDirectives> ';'
| <IdList> ':' <TypeSpec>
| SynError ';'
 
<ThreadVarDeclList> ::= <ThreadVarDecl>
| <ThreadVarDeclList> <ThreadVarDecl>
 
<ThreadVarDecl> ::= <IdList> ':' <TypeSpec>
| SynError ';'
 
 
 
<OptAbsoluteClause> ::= ABSOLUTE <RefId>
! | ABSOLUTE <ConstExpr> !on windows only, not on linux
|
 
 
 
 
!------------------------------------------------------------------------------
! E X P R E S S I O N S
!------------------------------------------------------------------------------
 
<ConstExpr> ::= <Expr>
 
<ConstOrdExpr> ::= <AddExpr>
 
<ConstStrExpr> ::= <AddExpr>
 
<Expr> ::= <AddExpr>
| <AddExpr> <RelOp> <AddExpr>
| SynError
 
<AddExpr> ::= <MulExpr>
| <AddExpr> <AddOp> <MulExpr>
 
<MulExpr> ::= <Factor>
| <MulExpr> <MulOp> <Factor>
 
 
<Factor> ::= NIL
| <ICONST>
| <RCONST>
| <SCONST>
| <Designator>
| <SetConstructor>
| '@' <Designator>
| '@' '@' <Designator> !returns memory address of a procedural variable
| '(' <Expr> ')'
| '(' <Expr> ')' '^'
| '+' <Factor>
| '-' <Factor>
| NOT <Factor>
!---PortArray
 
 
<Designator> ::= <FieldDesignator>
| <Designator> '.' <FieldDesignator>
| <Designator> '^'
| <Designator> '[' <ExprList> ']'
| <Designator> '(' <ExprList> ')' !FunctionCall or TypeCast
| <Designator> '(' ')' !FunctionCall
| <Designator> AS <TypeRef> !eg "with Source as TListItem do ..."
| '(' <Designator> ')'
| INHERITED <Designator>
 
 
<AsnOp> ::= ':='
| '+=' | '-=' | '*=' | '/='
 
 
<RelOp> ::= '=' | '>' | '<' | '<=' | '>=' | '<>'
| IN | IS | AS
<AddOp> ::= '+' |'-'
| OR | XOR
<MulOp> ::='*' | '/'
| DIV | MOD | AND | SHL | SHR
<OptionExplicit> ::= 'Option' 'Explicit' <NL>
 
<ErrorStmt> ::= 'On' 'Error' 'Resume' 'Next'
<SetConstructor> ::= '[' <SetElementList> ']'
| 'On' 'Error' 'GoTo' IntLiteral ! must be 0
| '[' ']'
 
<ExitStmt> ::= 'Exit' 'Do'
<SetElementList> ::= <SetElement>
| 'Exit' 'For'
| <SetElementList> ',' <SetElement>
| 'Exit' 'Function'
| 'Exit' 'Property'
| 'Exit' 'Sub'
 
<SetElementAssignStmt> ::= <LeftExpr> '=' <Expr>
| 'Set' <ExprLeftExpr> '..=' <Expr>
| 'Set' <LeftExpr> '=' 'New' <LeftExpr>
 
! Hack: VB Script allows to have construct a = b = c, which means a = (b = c)
<ExprList> ::= <Expr>
! In this grammar we do not allow it in order to prevent complications with
| <ExprList> ',' <Expr>
! interpretation of a(1) = 2, which may be considered as array element assignment
! or a subroutine call: a ((1) = 2).
<FmtExpr> ::= <Expr>
! Note: VBScript allows to have missed parameters: a ,,2,3,
| <Expr> ':' <Expr>
! VM: If somebody knows a better way to do it, please let me know
| <Expr> ':' <Expr> ':' <Expr>
<SubCallStmt> ::= <QualifiedID> <SubSafeExprOpt> <CommaExprList>
| <QualifiedID> <SubSafeExprOpt>
| <QualifiedID> '(' <Expr> ')' <CommaExprList>
| <QualifiedID> '(' <Expr> ')'
| <QualifiedID> '(' ')'
| <QualifiedID> <IndexOrParamsList> '.' <LeftExprTail> <SubSafeExprOpt> <CommaExprList>
| <QualifiedID> <IndexOrParamsListDot> <LeftExprTail> <SubSafeExprOpt> <CommaExprList>
| <QualifiedID> <IndexOrParamsList> '.' <LeftExprTail> <SubSafeExprOpt>
| <QualifiedID> <IndexOrParamsListDot> <LeftExprTail> <SubSafeExprOpt>
 
! This very simplified case - the problem is that we cannot use parenthesis in aaa(bbb).ccc (ddd)
<FmtExprList> ::= <FmtExpr>
<SubSafeExprOpt> ::= <SubSafeExpr>
| <FmtExprList> ',' <FmtExpr>
|
 
<CallStmt> ::= 'Call' <LeftExpr>
 
<LeftExpr> ::= <QualifiedID> <IndexOrParamsList> '.' <LeftExprTail>
<ConstExprList> ::= <ConstExpr>
| <QualifiedID> <IndexOrParamsListDot> <LeftExprTail>
| <ConstExprList> ',' <ConstExpr>
| <QualifiedID> <IndexOrParamsList>
| <QualifiedID>
| <SafeKeywordID>
 
<LeftExprTail> ::= <QualifiedIDTail> <IndexOrParamsList> '.' <LeftExprTail>
!------------------------------------------------------------------------------
| <QualifiedIDTail> <IndexOrParamsListDot> <LeftExprTail>
! S T A T E M E N T S
| <QualifiedIDTail> <IndexOrParamsList>
!------------------------------------------------------------------------------
| <QualifiedIDTail>
 
! VB Script does not allow to have space between Identifier and dot:
! a . b - Error ; a. b or a.b - OK
<QualifiedID> ::= IDDot <QualifiedIDTail>
| DotIDDot <QualifiedIDTail>
| ID
| DotID
 
<QualifiedIDTail> ::= IDDot <QualifiedIDTail>
<StmtList> ::= <Statement>
| ID
| <StmtList> ';' <Statement>
| <KeywordID>
 
<KeywordID> ::= <SafeKeywordID>
<Statement> ::= <Label> <Statement>
| 'And'
| <AssignmentStmt>
| 'ByRef'
| <CallStmt>
| 'ByVal'
| <GotoStatement>
| 'Call'
| <CompoundStmt>
| 'Case'
| <IfStatement>
| 'Class'
| <CaseStatement>
| 'Const'
| <ForStatement>
| 'Dim'
| <WhileStatement>
| 'Do'
| <RepeatStatement>
| 'Each'
| <WithStatement>
| 'Else'
| <TryFinallyStmt>
| 'ElseIf'
| <TryExceptStmt>
| 'Empty'
| <RaiseStmt>
| 'End'
| <AssemblerStmt>
| 'Eqv'
| SynError
| 'Exit'
|
| 'False'
| 'For'
<Label> ::= <LCONST> ':'
| 'Function'
| <LabelId> ':'
| 'Get'
| 'GoTo'
| 'If'
| 'Imp'
| 'In'
| 'Is'
| 'Let'
| 'Loop'
| 'Mod'
| 'New'
| 'Next'
| 'Not'
| 'Nothing'
| 'Null'
| 'On'
| 'Option'
| 'Or'
| 'Preserve'
| 'Private'
| 'Public'
| 'Redim'
| 'Resume'
| 'Select'
| 'Set'
| 'Sub'
| 'Then'
| 'To'
| 'True'
| 'Until'
| 'WEnd'
| 'While'
| 'With'
| 'Xor'
 
<SafeKeywordID> ::= 'Default'
<AssignmentStmt> ::= <Designator> <AsnOp> <Expr>
| 'Erase'
| '@' <RefId> ':=' <Factor>
| 'Error'
| 'Explicit'
| 'Property'
| 'Step'
 
<ExtendedID> ::= <SafeKeywordID>
| ID
!EXAMPLE of this '@' <RefId>, that calls the GetProcAddress
!function and points a var StrComp to the result.
! var StrComp: function(Str1, Str2: PChar): Integer;
! ...
! @StrComp := GetProcAddress(KernelHandle, 'lstrcmpi');
 
<IndexOrParamsList> ::= <IndexOrParams> <IndexOrParamsList>
| <IndexOrParams>
<CallStmt> ::= <Designator> !procedure, function, method, typecast
| WRITE '(' <FmtExprList> ')'
| WRITELN '(' <FmtExprList> ')'
! | INHERITED <CallStmt>
| INHERITED
 
<IndexOrParams> ::= '(' <Expr> <CommaExprList> ')'
| '(' <CommaExprList> ')'
| '(' <Expr> ')'
| '(' ')'
 
<IndexOrParamsListDot> ::= <IndexOrParams> <IndexOrParamsListDot>
<GotoStatement> ::= GOTO <LCONST>
| <IndexOrParamsDot>
| GOTO <RefId>
 
<IndexOrParamsDot> ::= '(' <Expr> <CommaExprList> ').'
<CompoundStmt> ::= BEGIN <StmtList> END
| '(' <CommaExprList> ').'
| '(' <Expr> ').'
| '(' ').'
 
<CommaExprList> ::= ',' <Expr> <CommaExprList>
| ',' <CommaExprList>
| ',' <Expr>
| ','
 
!========= Redim Statement
<IfStatement> ::= IF <Expr> THEN <Statement> ELSE <Statement>
| IF <Expr> THEN <Statement>
| IF SynError THEN <Statement>
 
<RedimStmt> ::= 'Redim' <RedimDeclList> <NL>
| 'Redim' 'Preserve' <RedimDeclList> <NL>
<CaseStatement> ::= CASE <Expr> OF <CaseList> <OtherWise> END
 
<RedimDeclList> ::= <RedimDecl> ',' <RedimDeclList>
<ForStatement> ::= FOR <RefId> ':=' <Expr> <Dir> <Expr> DO <Statement>
| <RedimDecl>
 
<RedimDecl> ::= <ExtendedID> '(' <ExprList> ')'
<Dir> ::= TO | DOWNTO
 
<WhileStatement> ::!========= WHILE <Expr> DOIf <Statement>
 
<IfStmt> ::= 'If' <Expr> 'Then' <NL> <BlockStmtList> <ElseStmtList> 'End' 'If' <NL>
<WithStatement> ::= WITH <DesignatorList> DO <Statement>
| 'If' <Expr> 'Then' <InlineStmt> <ElseOpt> <EndIfOpt> <NL>
 
<ElseStmtList> ::= 'ElseIf' <Expr> 'Then' <NL> <BlockStmtList> <ElseStmtList>
<DesignatorList> ::= <Designator>
| 'ElseIf' <Expr> 'Then' <InlineStmt> <NL> <ElseStmtList>
| <DesignatorList> ',' <Designator>
| 'Else' <InlineStmt> <NL>
| 'Else' <NL> <BlockStmtList>
|
 
<ElseOpt> ::= 'Else' <InlineStmt>
<RepeatStatement> ::= REPEAT <StmtList> UNTIL <Expr>
|
 
<EndIfOpt> ::= 'End' 'If'
|
 
!========= With Statement
<AssemblerStmt> ::= ASM <AsmLanguage> END
 
<WithStmt> ::= 'With' <Expr> <NL> <BlockStmtList> 'End' 'With' <NL>
<OtherWise> ::= OTHERWISE <StmtList>
| ELSE <StmtList>
|
 
!========= Loop Statement
<CaseList> ::= <CaseSelector>
| <CaseList> ';' <CaseSelector>
| <CaseList> ';'
 
<LoopStmt> ::= 'Do' <LoopType> <Expr> <NL> <BlockStmtList> 'Loop' <NL>
| 'Do' <NL> <BlockStmtList> 'Loop' <LoopType> <Expr> <NL>
| 'Do' <NL> <BlockStmtList> 'Loop' <NL>
| 'While' <Expr> <NL> <BlockStmtList> 'WEnd' <NL>
 
<LoopType> ::= 'While'
<CaseSelector> ::= <CaseLabels> ':' <Statement>
| 'Until'
 
!========= For Statement
<CaseLabels> ::= <CaseLabel>
| <CaseLabels> ',' <CaseLabel>
<CaseLabel> ::= <ConstExpr>
| <ConstExpr> '..' <ConstExpr>
 
<ForStmt> ::= 'For' <ExtendedID> '=' <Expr> 'To' <Expr> <StepOpt> <NL> <BlockStmtList> 'Next' <NL>
<RaiseStmt> ::= RAISE SynError ![object] [AT address]
| 'For' 'Each' <ExtendedID> 'In' <Expr> <NL> <BlockStmtList> 'Next' <NL>
| RAISE <OptExceptInstance>
| RAISE <OptExceptInstance> AT <Address>
 
<StepOpt> ::= 'Step' <Expr>
<TryFinallyStmt> ::= TRY <StmtList> FINALLY <StmtList> END
|
 
!========= Select Statement
<TryExceptStmt> ::= TRY <StmtList> EXCEPT <ExceptionBlock> <OptExceptionElse> END
 
<SelectStmt> ::= 'Select' 'Case' <Expr> <NL> <CaseStmtList> 'End' 'Select' <NL>
<ExceptionBlock> ::= <ExceptionStmt>
| <ExceptionBlock> ';' <ExceptionStmt>
 
<CaseStmtList> ::= 'Case' <ExprList> <NLOpt> <BlockStmtList> <CaseStmtList>
<ExceptionStmt> ::= ON <Selector> DO <Statement>
| 'Case' 'Else' <NLOpt> <BlockStmtList>
! | ELSE <Statement>
|
| <Statement>
 
<NLOpt> ::= <NL>
<OptExceptionElse> ::= ELSE <StmtList>
|
|
 
<ExprList> ::= <Expr> ',' <ExprList>
<OptExceptInstance> ::= <Designator> !usually a method call (??)
| <Expr>
|
 
!===============================
<Address> ::= <Designator> !usually a functiion call, returning an adress
! Rules : Expressions
!===============================
 
<SubSafeExpr> ::= <SubSafeImpExpr>
 
<SubSafeImpExpr> ::= <SubSafeImpExpr> 'Imp' <EqvExpr>
| <SubSafeEqvExpr>
 
<SubSafeEqvExpr> ::= <SubSafeEqvExpr> 'Eqv' <XorExpr>
| <SubSafeXorExpr>
 
<SubSafeXorExpr> ::= <SubSafeXorExpr> 'Xor' <OrExpr>
| <SubSafeOrExpr>
 
<SubSafeOrExpr> ::= <SubSafeOrExpr> 'Or' <AndExpr>
| <SubSafeAndExpr>
 
<SubSafeAndExpr> ::= <SubSafeAndExpr> 'And' <NotExpr>
<OptSemi> ::= ';'
| <SubSafeNotExpr>
|
 
<SubSafeNotExpr> ::= 'Not' <NotExpr>
!------------------------------------------------------------------------------
| <SubSafeCompareExpr>
! R O U T I N E S
!------------------------------------------------------------------------------
 
<SubSafeCompareExpr> ::= <SubSafeCompareExpr> 'Is' <ConcatExpr>
<ProcedureDeclSection> ::= <ProcedureDecl>
| <SubSafeCompareExpr> 'Is' 'Not' <ConcatExpr>
| <FunctionDecl>
| <SubSafeCompareExpr> '>=' <ConcatExpr>
| <MethodDecl>
| <SubSafeCompareExpr> '=>' <ConcatExpr>
| <SubSafeCompareExpr> '<=' <ConcatExpr>
| <SubSafeCompareExpr> '=<' <ConcatExpr>
<ProcedureDecl> ::= <ProcHeading> <CallBody> <OptSemi>
| <SubSafeCompareExpr> '>' <ConcatExpr>
| <SubSafeCompareExpr> '<' <ConcatExpr>
| <SubSafeCompareExpr> '<>' <ConcatExpr>
| <SubSafeCompareExpr> '=' <ConcatExpr>
| <SubSafeConcatExpr>
 
<SubSafeConcatExpr> ::= <SubSafeConcatExpr> '&' <AddExpr>
<FunctionDecl> ::= <FuncHeading> <CallBody> <OptSemi>
| <SubSafeAddExpr>
<MethodDecl> ::= <MethHeading> <CallBody> <OptSemi>
 
<SubSafeAddExpr> ::= <SubSafeAddExpr> '+' <ModExpr>
<ProcHeading> ::= PROCEDURE <RefId> <OptFormalParms> <OptCallSpecifiers> ';'
| <SubSafeAddExpr> '-' <ModExpr>
| <ProcHeading> <CallDirectives> <OptSemi>
| <SubSafeModExpr>
 
<SubSafeModExpr> ::= <SubSafeModExpr> 'Mod' <IntDivExpr>
| <SubSafeIntDivExpr>
 
<SubSafeIntDivExpr> ::= <SubSafeIntDivExpr> '\' <MultExpr>
<FuncHeading> ::= FUNCTION <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';'
| <SubSafeMultExpr>
| FUNCTION <RefId> ';'
| <FuncHeading> <CallDirectives> <OptSemi>
!
! if the heading is 'incomplete' it was declared before
! and must be followed by a <CallBody> TO BE IMPROVED
 
<MethHeading> ::= PROCEDURE <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';'
| FUNCTION <RefId> '.' <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';'
| FUNCTION <RefId> '.' <RefId> ';'
| CONSTRUCTOR <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';'
| DESTRUCTOR <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';'
| CLASS PROCEDURE <RefId> '.' <RefId> <OptFormalParms> <OptCallSpecifiers> ';'
| CLASS FUNCTION <RefId> '.' <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';'
| <MethHeading> <CallDirectives> ';'
!
! the class methods operates on classes instead of objects
 
<ResultType> ::= <TypeRef>
 
 
<OptFormalParms> ::= '(' <FormalParmList> ')'
| '(' ')'
|
 
<FormalParmList> ::= <FormalParm>
| <FormalParmList> ';' <FormalParm>
 
<FormalParm> ::= <Parameter>
| CONST <Parameter>
| VAR <Parameter>
| OUT <Parameter>
 
<Parameter> ::= <IdList>
| <IdList> ':' <ParmType>
| <IdList> ':' <TypeRef> '=' <ConstExpr>
 
<ParmType> ::= <TypeRef>
| ARRAY OF <TypeRef>
| ARRAY OF CONST
| FILE
<CallBody> ::= <OptDeclSection> <CompoundStmt>
| <OptDeclSection> <AssemblerStmt>
| <ExternalDeclaration>
| FORWARD
 
!-----DIRECTIVES---------------------------------------------------------------
! <PortDirectives> are to produce warnings at compile time when source code is compiled
! in the {$HINTS ON} {$WARNINGS ON} state. It can be applied to declarations
!
! <PortDirectives are accepted:
! WITHIN const and var declarations (not after),
! WITHIN unit headers (not after)
! AFTER function/procedure headings (not within) (ONE terminating ';' is optional)
! <PortDirectives are NOT accepted:
! in/after type declarations
!------------------------------------------------------------------------------
 
 
<OptPortDirectives> ::= <PortDirectives>
|
<PortDirectives> ::= <PortDirective>
| <PortDirectives> <PortDirective>
 
<PortDirective> ::= PLATFORM ! to warn that it is specific to a particular operating environment (such as Windows or Linux)
| PLATFORM '=' <ConstExpr>
| DEPRECATED ! to warn it is obsolete or supported only for backward compatibility
| LIBRARY ! to warn dependencies on a particular library or component framework (such as CLX).
 
 
 
!------------------------
<OptMethodDirectives> ::= <MethodDirectives>
| <OptMethodDirectives> <PortDirective> ';'
|
 
<MethodDirectives> ::= <MethodDirective> ';'
| <MethodDirectives> <MethodDirective> ';'
 
<MethodDirective> ::= VIRTUAL
| VIRTUAL <ConstExpr>
| DYNAMIC !for classes only
| OVERRIDE
| ABSTRACT
| MESSAGE <ConstExpr>
| OVERLOAD
| REINTRODUCE
| DISPID <ConstExpr> !only within an <InterfaceType>
| <CallConvention>
!TODO NOT ALL THESE METHOD DIRECTIVES CAN BE COMBINED WITH EACH OTHER
 
!------------------------
 
<OptPropertyDirectives> ::= <PropertyDirective> ';'
| <OptPropertyDirectives> <PortDirective> ';'
|
 
<PropertyDirective> ::= DEFAULT
 
 
 
!------------------------
<ExternalDeclaration> ::= EXTERNAL
| EXTERNAL <ConstStrExpr>
| EXTERNAL <ConstStrExpr> NAME <ConstStrExpr>
! | EXTERNAL <SCONST>
! | EXTERNAL <SCONST> NAME <SCONST>
 
 
!------------------------
 
<CallDirectives> ::= <CallDirective>
| <CallDirectives> <CallDirective>
 
<CallDirective> ::= <CallConvention>
| <CallObsolete>
| <PortDirective>
| VARARGS !works only with external routines and cdecl calling convention.
| LOCAL !prevents exporting in a library
| <SCONST> !for PasPro only
| OVERLOAD
 
<OptCallSpecifiers> ::= <CallSpecifier>
| <OptCallSpecifiers> <CallSpecifier>
|
<CallSpecifier> ::= <CallConvention>
| <CallObsolete>
<CallConventions> ::= <CallConvention>
| <CallConventions> <CallConvention>
 
<OptCallConventions> ::= <CallConvention>
| <OptCallConventions> <CallConvention>
|
![ParmOrder] [CleanUp] [RegParms]
<CallConvention> ::= REGISTER !Left-to-right Routine Yes
| PASCAL !Left-to-right Routine No
| CDECL !Right-to-left Caller No
| STDCALL !Right-to-left Routine No
| SAFECALL !Right-to-left Routine No
 
<CallObsolete> ::= INLINE !for backward compatibility only; has no effect on the compiler.
| ASSEMBLER !for backward compatibility only; has no effect on the compiler.
| NEAR !for 16-bits programming only, has no effect in 32 bit applications
| FAR !for 16-bits programming only, has no effect in 32 bit applications
| EXPORT !for 16-bits programming only, has no effect in 32 bit applications
 
 
!------------------------------------------------------------------------------
! A S S E M B L E R I N S T R U C T I O N S
!------------------------------------------------------------------------------
! The asm 'grammar' below is rather tolerant in accepting assembler code and needs
! further elaboration. The main problem is that end of lines are not detected, so
! the separators between the instructions cannot be found, so an <AsmItem> cannot
! be grouped in a meaningfull way with another <AsmItem> into a true <AsmInstruction>
! A fundamental solution could be to start a new lexical "context" in this grammar, with
! that forces the lexical scanner to recognize an assembler specific list of keywords
! Unfortunately, this is not supported by the Gold parser
 
<AsmLanguage> ::= <AsmInstruction>
| <AsmLanguage> <AsmInstruction>
 
<AsmInstruction> ::= <AsmItem>
| <AsmInstruction> <AsmItem>
| <AsmInstruction> ',' <AsmItem>
| <AsmInstruction> ';'
 
<AsmItem> ::= <AsmLabel>
| <AsmExpr>
 
<AsmLabel> ::= <AsmLocal> ':'
| <AsmId> ':'
 
<AsmExpr> ::= <AsmFactor>
| '-' <AsmFactor>
| <AsmExpr> '+' <AsmFactor>
| <AsmExpr> '*' <AsmFactor>
| <AsmExpr> '-' <AsmFactor>
| <AsmExpr> '.' <AsmFactor>
| '[' <AsmExpr> ']'
| '(' <AsmExpr> ')'
! <AsmId> '(' <AsmExpr> ')'
| SynError
 
<AsmFactor> ::= <AsmId>
| <AsmLocal>
| <ICONST>
| <RCONST>
| <SCONST>
 
<AsmId> ::= <RefId>
| '&' <RefId>
| REPEAT | WHILE | IF
| AND | OR | XOR | SHR | SHL | DIV | NOT
! plus many other keywords as well that may serve as an identifier
 
<AsmLocal> ::= '@' <LCONST>
| '@' <AsmId>
| '@' <AsmLocal>
| '@' END
</pre>
 
=={{header|E}}==
=={{header|EC}}==
=={{header|ELLA}}==
=={{header|ESQL}}==
=={{header|Eiffel}}==
=={{header|Emacs Lisp}}==
=={{header|Erlang}}==
=={{header|F}}==
=={{header|F Sharp}}==
=={{header|FALSE}}==
=={{header|FP}}==
=={{header|Factor}}==
=={{header|Fan}}==
=={{header|Forth}}==
=={{header|Fortran}}==
=={{header|GAP}}==
=={{header|Gnuplot}}==
=={{header|Groovy}}==
=={{header|HaXe}}==
=={{header|Haskell}}==
=={{header|IDL}}==
=={{header|Icon}}==
=={{header|Io}}==
=={{header|J}}==
=={{header|JSON}}==
=={{header|JScript.NET}}==
=={{header|Java}}==
<pre>
"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>
</pre>
 
=={{header|JavaScript}}==
<pre>
"Name" = 'JavaScript Grammar'
"Author" = 'M.Schnoor-Matriciani'
"Version" = '0.9'
"About" = 'JavaScript Grammar, Subset of ECMA Edition 3'
 
"Start Symbol" = <Program>
"Case Sensitive" = 'True'
! ------------------------------------------------- Sets
 
{ID Head} = {Letter} + [_] + [$]
{ID Tail} = {Alphanumeric} + [_] + [$]
{String Chars1} = {Printable} + {HT} - ["\]
{String Chars2} = {Printable} + {HT} - [\'']
{Hex Digit} = {Digit} + [ABCDEF] + [abcdef]
{RegExp Chars} = {Letter}+{Digit}+['^']+['$']+['*']+['+']+['?']+['{']+['}']+['|']+['-']+['.']+[',']+['#']+['[']+[']']+['_']+['<']+['>']
{Non Terminator} = {String Chars1} - {CR} - {LF}
{Non Zero Digits}={Digit}-[0]
 
! ------------------------------------------------- Terminals
 
Identifier = {ID Head}{ID Tail}*
StringLiteral = '"' ( {String Chars1} | '\' {Printable} )* '"' | '' ( {String Chars2} | '\' {Printable} )* ''
 
HexIntegerLiteral = '0x' {Hex Digit}+
 
RegExp = '/' ({RegExp Chars} | '\' {Non Terminator})+ '/' ( 'g' | 'i' | 'm' )*
DecimalLiteral= {Non Zero Digits}+ '.' {Digit}* ('e' | 'E' ) {Non Zero Digits}+ {Digit}* | {Non Zero Digits}+ '.' {Digit}* | '0' '.' {Digit}+ ('e' | 'E' ) {Non Zero Digits}+ {Digit}* | {Non Zero Digits}+ {Digit}* | '0' | '0' '.' {Digit}+
 
Comment Start = '/*'
Comment End = '*/'
Comment Line = '//'
 
! ------------------------------------------------- Rules
 
<Literal> ::= <Null Literal>
| <Boolean Literal>
| <Numeric Literal>
| StringLiteral
 
<Null Literal> ::= null
<Boolean Literal> ::= 'true'
| 'false'
 
<Numeric Literal> ::= DecimalLiteral
| HexIntegerLiteral
 
<Regular Expression Literal> ::= RegExp
 
<Primary Expression> ::= 'this'
| Identifier
| <Literal>
| <Array Literal>
| <Object Literal>
| '(' <Expression> ')'
| <Regular Expression Literal>
 
<Array Literal> ::= '[' ']'
| '[' <Elision> ']'
| '[' <Element List> ']'
| '[' <Element List> ',' <Elision> ']'
 
<Elision> ::= ','
| <Elision> ','
 
<Element List> ::= <Elision> <Assignment Expression>
| <Element List> ',' <Elision> <Assignment Expression>
| <Element List> ',' <Assignment Expression>
| <Assignment Expression>
 
<Object Literal> ::= '{' <Property Name and Value List> '}'
 
<Property Name and Value List> ::= <Property Name> ':' <Assignment Expression>
| <Property Name and Value List> ',' <Property Name> ':' <Assignment Expression>
 
<Property Name> ::= Identifier
| StringLiteral
| <Numeric Literal>
 
<Member Expression > ::= <Primary Expression>
| <Function Expression>
| <Member Expression> '[' <Expression> ']'
| <Member Expression> '.' Identifier
| 'new' <Member Expression> <Arguments>
 
<New Expression> ::= <Member Expression>
| new <New Expression>
 
<Call Expression> ::= <Member Expression> <Arguments>
| <Call Expression> <Arguments>
| <Call Expression> '[' <Expression> ']'
| <Call Expression> '.' Identifier
 
<Arguments> ::= '(' ')'
| '(' <Argument List> ')'
 
<Argument List> ::= <Assignment Expression>
| <Argument List> ',' <Assignment Expression>
 
 
<Left Hand Side Expression> ::= <New Expression>
| <Call Expression>
 
<Postfix Expression> ::= <Left Hand Side Expression>
| <Postfix Expression> '++'
| <Postfix Expression> '--'
 
<Unary Expression> ::= <Postfix Expression>
| 'delete' <Unary Expression>
| 'void' <Unary Expression>
| 'typeof' <Unary Expression>
| '++' <Unary Expression>
| '--' <Unary Expression>
| '+' <Unary Expression>
| '-' <Unary Expression>
| '~' <Unary Expression>
| '!' <Unary Expression>
 
<Multiplicative Expression> ::= <Unary Expression>
| <Unary Expression> '*' <Multiplicative Expression>
| <Unary Expression> '/' <Multiplicative Expression>
| <Unary Expression> '%' <Multiplicative Expression>
 
<Additive Expression> ::= <Additive Expression>'+'<Multiplicative Expression>
| <Additive Expression>'-'<Multiplicative Expression>
| <Multiplicative Expression>
 
 
 
<Shift Expression> ::= <Shift Expression> '<<' <Additive Expression>
| <Shift Expression> '>>' <Additive Expression>
| <Shift Expression> '>>>' <Additive Expression>
| <Additive Expression>
 
<Relational Expression>::= <Shift Expression>
| <Relational Expression> '<' <Shift Expression>
| <Relational Expression> '>' <Shift Expression>
| <Relational Expression> '<=' <Shift Expression>
| <Relational Expression> '>=' <Shift Expression>
| <Relational Expression> 'instanceof' <Shift Expression>
 
<Equality Expression> ::= <Relational Expression>
| <Equality Expression> '==' <Relational Expression>
| <Equality Expression> '!=' <Relational Expression>
| <Equality Expression> '===' <Relational Expression>
| <Equality Expression> '!==' <Relational Expression>
 
<Bitwise And Expression> ::= <Equality Expression>
| <Bitwise And Expression> '&' <Equality Expression>
 
<Bitwise XOr Expression> ::= <Bitwise And Expression>
| <Bitwise XOr Expression> '^' <Bitwise And Expression>
 
<Bitwise Or Expression> ::= <Bitwise XOr Expression>
| <Bitwise Or Expression> '|' <Bitwise XOr Expression>
 
<Logical And Expression> ::= <Bitwise Or Expression>
| <Logical And Expression> '&&' <Bitwise Or Expression>
 
<Logical Or Expression> ::= <Logical And Expression>
| <Logical Or Expression> '||' <Logical And Expression>
 
<Conditional Expression> ::= <Logical Or Expression>
| <Logical Or Expression> '?' <Assignment Expression> ':' <Assignment Expression>
 
<Assignment Expression> ::= <Conditional Expression>
| <Left Hand Side Expression> <Assignment Operator> <Assignment Expression>
<Assignment Operator> ::= '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|='
 
<Expression> ::= <Assignment Expression>
| <Expression> ',' <Assignment Expression>
 
<Statement> ::= <Block>
| <Variable Statement>
| <Empty Statement>
| <If Statement>
| <If Else Statement>
| <Iteration Statement>
| <Continue Statement>
| <Break Statement>
| <Return Statement>
| <With Statement>
| <Labelled Statement>
| <Switch Statement>
| <Throw Statement>
| <Try Statement>
| <Expression>
 
<Block > ::= '{' '}'
| '{' <Statement List> '}'
 
<Statement List> ::= <Statement>
| <Statement List> <Statement>
 
<Variable Statement> ::= var <Variable Declaration List> ';'
<Variable Declaration List> ::= <Variable Declaration>
| <Variable Declaration List> ',' <Variable Declaration>
 
<Variable Declaration> ::= Identifier
| Identifier <Initializer>
 
<Initializer> ::= '=' <Assignment Expression>
 
<Empty Statement> ::= ';'
 
<If Statement> ::= 'if' '(' <Expression> ')' <Statement>
<If Else Statement> ::= 'if' '(' <Expression> ')' <Statement> 'else' <Statement>
 
<Iteration Statement> ::= 'do' <Statement> 'while' '(' <Expression> ')' ';'
| 'while' '(' <Expression> ')' <Statement>
| 'for' '(' <Expression> ';' <Expression> ';' <Expression> ')' <Statement>
| 'for' '(' 'var' <Variable Declaration List> ';' <Expression> ';' <Expression> ')' <Statement>
| 'for' '(' <Left Hand Side Expression> in <Expression> ')' <Statement>
| 'for' '(' 'var' <Variable Declaration> in <Expression> ')' <Statement>
 
<Continue Statement> ::= 'continue' ';'
| 'continue' Identifier ';'
 
<Break Statement> ::= 'break' ';'
| 'break' Identifier ';'
 
<Return Statement> ::= 'return' ';'
| 'return' <Expression> ';'
 
<With Statement> ::= 'with' '(' <Expression> ')' <Statement> ';'
 
<Switch Statement> ::= 'switch' '(' <Expression> ')' <Case Block>
 
<Case Block> ::= '{' '}'
| '{' <Case Clauses> '}'
| '{' <Case Clauses> <Default Clause> '}'
| '{' <Case Clauses> <Default Clause> <Case Clauses> '}'
| '{' <Default Clause> <Case Clauses> '}'
| '{' <Default Clause> '}'
 
<Case Clauses> ::= <Case Clause>
| <Case Clauses> <Case Clause>
 
<Case Clause> ::= 'case' <Expression> ':' <Statement List>
| 'case' <Expression> ':'
 
<Default Clause> ::= 'default' ':'
| 'default' ':' <Statement List>
 
<Labelled Statement> ::= Identifier ':' <Statement>
 
<Throw Statement> ::= 'throw' <Expression>
 
<Try Statement> ::= 'try' <Block> <Catch>
| 'try' <Block> <Finally>
| 'try' <Block> <Catch> <Finally>
 
<Catch> ::= 'catch' '(' Identifier ')' <Block>
 
<Finally> ::= 'finally' <Block>
 
<Function Declaration> ::= 'function' Identifier '(' <Formal Parameter List> ')' '{' <Function Body> '}'
| 'function' Identifier '(' ')' '{' <Function Body> '}'
 
<Function Expression> ::= 'function' '(' ')' '{' <Function Body> '}'
| 'function' '(' <Formal Parameter List> ')' '{' <Function Body> '}'
 
 
<Formal Parameter List> ::= Identifier
| <Formal Parameter List> ',' Identifier
 
<Function Body> ::= <Source Elements>
|
 
<Program> ::= <Source Elements>
 
<Source Elements> ::= <Source Element>
| <Source Elements> <Source Element>
 
<Source Element> ::= <Statement>
| <Function Declaration>
 
</pre>
 
=={{header|JoCaml}}==
=={{header|Joy}}==
=={{header|JudoScript}}==
=={{header|Korn Shell}}==
=={{header|LSE64}}==
=={{header|LaTeX}}==
=={{header|LabVIEW}}==
=={{header|Lisaac}}==
=={{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|Logtalk}}==
=={{header|LotusScript}}==
=={{header|Lua}}==
=={{header|Lucid}}==
=={{header|M4}}==
=={{header|MAXScript}}==
=={{header|MIRC Scripting Language}}==
=={{header|MS SQL}}==
=={{header|Make}}==
=={{header|Maple}}==
=={{header|Mathematica}}==
=={{header|Maxima}}==
=={{header|Metafont}}==
=={{header|Modula-3}}==
=={{header|NewLISP}}==
=={{header|Nial}}==
=={{header|OCaml}}==
=={{header|Oberon-2}}==
=={{header|Object Pascal}}==
=={{header|Objective-C}}==
=={{header|Octave}}==
=={{header|Omega}}==
=={{header|OpenEdge/Progress}}==
=={{header|Oz}}==
=={{header|PHP}}==
=={{header|PL/I}}==
=={{header|PL/SQL}}==
=={{header|Pascal}}==
<pre>
! -----------------------------------------------------------------------
! 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>
 
<SubSafeMultExpr> ::= <SubSafeMultExpr> '*' <UnaryExpr>
<ProcedureCall> ::= id <Actuals>
| <SubSafeMultExpr> '/' <UnaryExpr>
| <SubSafeUnaryExpr>
 
<SubSafeUnaryExpr> ::= '-' <UnaryExpr>
<ForStatement> ::= FOR id ':=' <Expression> TO <Expression> DO <Statement>
| FOR id ':=' <Expression> DOWNTO <Expression> DO | '+' <StatementUnaryExpr>
| <SubSafeExpExpr>
 
<WhileStatementSubSafeExpExpr> ::= WHILE <ExpressionSubSafeValue> DO'^' <StatementExpExpr>
| <SubSafeValue>
 
<SubSafeValue> ::= <ConstExpr>
<IfStatement> ::= IF <Expression> THEN <Statement> ELSE <Statement>
| <LeftExpr>
! | '(' <Expr> ')'
 
<Expr> ::= <ImpExpr>
<RepeatStatement> ::= REPEAT <StatementList> UNTIL <Expression>
 
<ImpExpr> ::= <ImpExpr> 'Imp' <EqvExpr>
<CaseStatement> ::= CASE <Expression> OF <CaseList> END
| <EqvExpr>
 
<EqvExpr> ::= <EqvExpr> 'Eqv' <XorExpr>
<CaseList> ::= <Case>
| <Case> ';' | <CaseListXorExpr>
 
<CaseXorExpr> ::= <ConstantListXorExpr> ':Xor' <StatementOrExpr>
| <OrExpr>
 
<OrExpr> ::= <OrExpr> 'Or' <AndExpr>
<ConstantList> ::= <constant>
| <constant> ',' | <ConstantListAndExpr>
 
<AndExpr> ::= <AndExpr> 'And' <NotExpr>
<Expression> ::= <SimpleExpression>
| <SimpleExpression> '=' | <SimpleExpressionNotExpr>
| <SimpleExpression> '<>' <SimpleExpression>
| <SimpleExpression> '<' <SimpleExpression>
| <SimpleExpression> '<=' <SimpleExpression>
| <SimpleExpression> '>' <SimpleExpression>
| <SimpleExpression> '>=' <SimpleExpression>
 
<NotExpr> ::= 'Not' <NotExpr>
<SimpleExpression> ::= <Term>
| <SimpleExpression> '+' | <TermCompareExpr>
| <SimpleExpression> '-' <Term>
| <SimpleExpression> OR <Term>
 
<CompareExpr> ::= <CompareExpr> 'Is' <ConcatExpr>
<Term> ::= <Factor>
| <TermCompareExpr> '*Is' 'Not' <FactorConcatExpr>
| <TermCompareExpr> '/>=' <FactorConcatExpr>
| <TermCompareExpr> 'DIV=>' <FactorConcatExpr>
| <TermCompareExpr> 'MOD<=' <FactorConcatExpr>
| <TermCompareExpr> 'AND=<' <FactorConcatExpr>
| <CompareExpr> '>' <ConcatExpr>
| <CompareExpr> '<' <ConcatExpr>
| <CompareExpr> '<>' <ConcatExpr>
| <CompareExpr> '=' <ConcatExpr>
| <ConcatExpr>
 
<FactorConcatExpr> ::= '(' <ExpressionConcatExpr> ')&' <AddExpr>
| '+' | <FactorAddExpr>
| '-' <Factor>
| NOT <Factor>
| <constant>
| <Variable>
 
<AddExpr> ::= <AddExpr> '+' <ModExpr>
<FunctionCall> ::= id <Actuals>
| <AddExpr> '-' <ModExpr>
| <ModExpr>
 
<ModExpr> ::= <ModExpr> 'Mod' <IntDivExpr>
<Actuals> ::= '(' <ExpressionList> ')'
| <IntDivExpr>
 
<IntDivExpr> ::= <IntDivExpr> '\' <MultExpr>
<ExpressionList> ::= <Expression>
| <Expression> ',' | <ExpressionListMultExpr>
 
<MultExpr> ::= <MultExpr> '*' <UnaryExpr>
<Variable> ::= id
| <VariableMultExpr> './' id<UnaryExpr>
| <VariableUnaryExpr> '^'
| <Variable> '[' <ExpressionList> ']'
 
<UnaryExpr> ::= '-' <UnaryExpr>
<TypeSpecifier> ::= id
| '^+' <TypeSpecifierUnaryExpr>
| '(' | <IdListExpExpr> ')'
| <constant> '..' <constant>
| ARRAY '[' <DimensionList> ']' OF <TypeSpecifier>
| RECORD <FieldList> END
| FILE OF <TypeSpecifier>
 
<ExpExpr> ::= <Value> '^' <ExpExpr>
<DimensionList> ::= <Dimension>
| <Dimension> ',' | <DimensionListValue>
 
<Value> ::= <ConstExpr>
<Dimension> ::= <constant> '..' <constant>
| id<LeftExpr>
| '(' <Expr> ')'
 
<FieldListConstExpr> ::= <FieldBoolLiteral>
| <Field> ';' | <FieldListIntLiteral>
| FloatLiteral
| StringLiteral
| DateLiteral
| <Nothing>
 
<BoolLiteral> ::= 'True'
<Field> ::= <IdList> ':' <TypeSpecifier>
| 'False'
 
<IntLiteral> ::= IntLiteral
<IdList> ::= id
| id ',' <IdList> | HexLiteral
| OctLiteral
 
<Nothing> ::= 'Nothing'
</pre>
| 'Null'
| 'Empty'
</pre></div>
 
==[[:Category:Visual Basic .NET|Visual Basic .NET]]==
=={{header|Perl}}==
The following link (Appedix B) has a simple BNF Syntax [http://laser.physics.sunysb.edu/~amol/papers/mollypaper.pdf VB Syntax]
=={{header|Pike}}==
<div style="height:30ex;overflow:scroll"><pre>
=={{header|PlainTeX}}==
=={{header|Pop11}}==
=={{header|PostScript}}==
=={{header|PowerShell}}==
=={{header|Prolog}}==
=={{header|Python}}==
=={{header|Q}}==
=={{header|R}}==
=={{header|REXX}}==
=={{header|RapidQ}}==
=={{header|Raven}}==
=={{header|Rhope}}==
=={{header|Ruby}}==
=={{header|SAS}}==
=={{header|SETL}}==
=={{header|SMEQL}}==
=={{header|SNUSP}}==
=={{header|SQL}}==
=={{header|Scala}}==
=={{header|Scheme}}==
=={{header|Script3D}}==
=={{header|Seed7}}==
=={{header|Self}}==
=={{header|Slate}}==
=={{header|Smalltalk}}==
=={{header|Standard ML}}==
=={{header|TI-83 BASIC}}==
=={{header|TI-89 BASIC}}==
=={{header|Tcl}}==
=={{header|Toka}}==
=={{header|Tr}}==
=={{header|Transact-SQL}}==
=={{header|Twelf}}==
=={{header|UNIX Shell}}==
=={{header|UnixPipes}}==
=={{header|Unlambda}}==
=={{header|V}}==
=={{header|VBScript}}==
=={{header|Vedit macro language}}==
=={{header|Visual Basic}}==
=={{header|Visual Basic .NET}}==
<pre>
! -----------------------------------------------------------------------
! Visual Basic .NET
Line 7,804 ⟶ 1,811:
 
<Identifier> ::= ID | QualifiedID !Any type of identifier
</pre></div>
 
=={{header|Visual Objects}}==
=={{header|Wrapl}}==
=={{header|XSLT}}==
=={{header|XTalk}}==
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/117403...117483"