Rosetta Code

BNF Grammar: Difference between revisions

Page Discussion

BNF Grammar (view source)

Revision as of 10:13, 17 August 2012

113,300 bytes removed ,  11 years ago
m
→‎Pascal: move to pacsal page
m (→‎Pascal: move to pacsal page)
 
(46 intermediate revisions by 17 users not shown)
Line 1:
{{taskDeprecatedTask}}
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|Ada}}==
A BNF description of the language syntax is a part of its standard, [http://www.adaic.org/standards/1zrm/html/RM-P.html see Ada Reference Manual, Annex P].
=={{header|ALGOL 60}}==
A BNF description of the language syntax is a part of following,
[http://eli-project.sourceforge.net/a60_html/a60.html#s2 ALGOL 60 ][http://www.masswerk.at/algol60/syntax.txt -Syntax of ALGOL 60]
 
=={{header[[:Category:BASIC|BASIC}}]]==
<div style="height:30ex;overflow:scroll"><pre>
! -----------------------------------------------------------------------
Line 179 ⟶ 174:
| Real
</pre></div>
==[[:Category:BASIC Commodore PET|BASIC Commodore PET]]==
<div style="height:30ex;overflow:scroll"><pre>
! -----------------------------------------------------------------------
Line 384 ⟶ 380:
 
</pre></div>
=={{header|Brainf***}}==
<div style="height:30ex;overflow:scroll"><pre>
! ---------------------------------------------------------------------------
!
! Brainf***
!
!
! As legend states, the Brainf*** Programming Language (also called BF by
! those not wanting to curse) was created by Urban Mueller in 1993.
! The language was designed, in part, so Mueller could create the smallest
! compiler ever. The first BF compiler was written for the Commodore Amiga
! OS 2.0 and was only 240 bytes in size.
!
! BF is a Turing-complete language. This means that any BF program can be
! proved to be equivalent to a Turing Machine.
!
! The system consists of an continuous array of 30,000 bytes (more can be
! added of course, but this is the standard size). Each cell is accessed
! through a single, global, pointer that can either move forward or backward
! on the array. The content of each cell can be modified by either reading a
! new byte from standard input or by incrementing or decrementing the
! current value. The array is initialized with zeroes.
!
!
! The BF Programming Language only consists of 8 different instructions:
!
! > Increment the pointer
! < Decrement the pointer
!
! + Add 1 to the current cell
! - Substract 1 from current cell
!
! . Print the current cell to the screen using its ASCII value.
! , Read a character and store its ASCII value in the current cell
!
! [ Jump forward past the corresponding ] if the current byte is zero
! ] Jump back to the statement after the corresponding [ if the
! current cell is not zero.
!
! In reality, the BF Programming Language is not that different from ANSI C.
! Each of the 8 instructions can be substituted for C statements and
! language constructs.
!
! > becomes p++;
! < becomes p--;
! + becomes *p++;
! - becomes *p--;
! . becomes putchar(*p);
! , becomes *p = getchar();
!
! [ becomes while (*p) { ...
! ] becomes }
!
!
! BF also treats all characters that are not the 8 basic commands as
! comments. In the grammar below, Whitespace is defined to include all the
! printable characters - with the exception of the statements.
!
! Please see http://en.wikipedia.org/wiki/Brainfuck for more information
!
! PLEASE NOTE: This grammar was created for fun. If you want to create a BF
! parser, it is far easier (and much more efficient) to write
! one manually.
!
! ---------------------------------------------------------------------------
 
==[[:Category:Brainf***|Brainf***]]==
 
Code ::= Command Code | <NONE>
"Name" = 'Brainf***'
Command ::= "+" | "-" | "<" | ">" | "," | "." | "[" Code "]" | <ANY>
"Author" = 'Urban Mueller'
"Version" = '1993'
 
==[[:Category:PARI/GP|PARI/GP]]==
"About" = 'Brainf*** was created by Urban Mueller with the goal to build'
[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].
| 'the smallest compiler ever.'
 
==[[:Category:PowerShell|PowerShell]]==
"Start Symbol" = <Instructions>
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.
 
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
! ============================================== Comments
<lang powershell>for () {}</lang>
 
but the grammar would require
{WS} = {Printable} - [<>+-.,'['']']
<lang powershell>for (;;) {}</lang>
 
Whitespace = {WS}+
 
 
! ============================================== Statements
 
<Instructions> ::= <Instructions> <Instruction>
|
 
 
<Instruction> ::= '>' ! Increment p
| '<' ! Decrement p
| '+' ! Increment a[p]
| '-' ! Decrement a[p]
| '.' ! Output a[p]
| ',' ! Input a[p]
| '[' <Instructions> ']'</pre></div>
 
=={{header|C sharp}}==
See the following, [http://csharp.comsci.us/syntax/expression/ebnf.html C-sharp syntax]
 
=={{header|Cobol}}==
<div style="height:30ex;overflow:scroll"><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></div>
 
=={{header|Delphi}}==
<div style="height:30ex;overflow:scroll"><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
 
<SetConstructor> ::= '[' <SetElementList> ']'
| '[' ']'
 
<SetElementList> ::= <SetElement>
| <SetElementList> ',' <SetElement>
 
<SetElement> ::= <Expr>
| <Expr> '..' <Expr>
 
<ExprList> ::= <Expr>
| <ExprList> ',' <Expr>
<FmtExpr> ::= <Expr>
| <Expr> ':' <Expr>
| <Expr> ':' <Expr> ':' <Expr>
 
<FmtExprList> ::= <FmtExpr>
| <FmtExprList> ',' <FmtExpr>
 
 
<ConstExprList> ::= <ConstExpr>
| <ConstExprList> ',' <ConstExpr>
 
!------------------------------------------------------------------------------
! S T A T E M E N T S
!------------------------------------------------------------------------------
 
 
<StmtList> ::= <Statement>
| <StmtList> ';' <Statement>
 
<Statement> ::= <Label> <Statement>
| <AssignmentStmt>
| <CallStmt>
| <GotoStatement>
| <CompoundStmt>
| <IfStatement>
| <CaseStatement>
| <ForStatement>
| <WhileStatement>
| <RepeatStatement>
| <WithStatement>
| <TryFinallyStmt>
| <TryExceptStmt>
| <RaiseStmt>
| <AssemblerStmt>
| SynError
|
<Label> ::= <LCONST> ':'
| <LabelId> ':'
 
<AssignmentStmt> ::= <Designator> <AsnOp> <Expr>
| '@' <RefId> ':=' <Factor>
 
!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');
 
<CallStmt> ::= <Designator> !procedure, function, method, typecast
| WRITE '(' <FmtExprList> ')'
| WRITELN '(' <FmtExprList> ')'
! | INHERITED <CallStmt>
| INHERITED
 
 
<GotoStatement> ::= GOTO <LCONST>
| GOTO <RefId>
 
<CompoundStmt> ::= BEGIN <StmtList> END
 
 
<IfStatement> ::= IF <Expr> THEN <Statement> ELSE <Statement>
| IF <Expr> THEN <Statement>
| IF SynError THEN <Statement>
 
<CaseStatement> ::= CASE <Expr> OF <CaseList> <OtherWise> END
 
<ForStatement> ::= FOR <RefId> ':=' <Expr> <Dir> <Expr> DO <Statement>
 
<Dir> ::= TO | DOWNTO
 
<WhileStatement> ::= WHILE <Expr> DO <Statement>
 
<WithStatement> ::= WITH <DesignatorList> DO <Statement>
 
<DesignatorList> ::= <Designator>
| <DesignatorList> ',' <Designator>
 
<RepeatStatement> ::= REPEAT <StmtList> UNTIL <Expr>
 
 
<AssemblerStmt> ::= ASM <AsmLanguage> END
 
<OtherWise> ::= OTHERWISE <StmtList>
| ELSE <StmtList>
|
 
<CaseList> ::= <CaseSelector>
| <CaseList> ';' <CaseSelector>
| <CaseList> ';'
 
 
<CaseSelector> ::= <CaseLabels> ':' <Statement>
 
<CaseLabels> ::= <CaseLabel>
| <CaseLabels> ',' <CaseLabel>
<CaseLabel> ::= <ConstExpr>
| <ConstExpr> '..' <ConstExpr>
 
<RaiseStmt> ::= RAISE SynError ![object] [AT address]
| RAISE <OptExceptInstance>
| RAISE <OptExceptInstance> AT <Address>
 
<TryFinallyStmt> ::= TRY <StmtList> FINALLY <StmtList> END
 
<TryExceptStmt> ::= TRY <StmtList> EXCEPT <ExceptionBlock> <OptExceptionElse> END
 
<ExceptionBlock> ::= <ExceptionStmt>
| <ExceptionBlock> ';' <ExceptionStmt>
 
<ExceptionStmt> ::= ON <Selector> DO <Statement>
! | ELSE <Statement>
| <Statement>
 
<OptExceptionElse> ::= ELSE <StmtList>
|
 
<OptExceptInstance> ::= <Designator> !usually a method call (??)
|
 
<Address> ::= <Designator> !usually a functiion call, returning an adress
 
 
 
 
 
 
<OptSemi> ::= ';'
|
 
!------------------------------------------------------------------------------
! R O U T I N E S
!------------------------------------------------------------------------------
 
<ProcedureDeclSection> ::= <ProcedureDecl>
| <FunctionDecl>
| <MethodDecl>
<ProcedureDecl> ::= <ProcHeading> <CallBody> <OptSemi>
 
<FunctionDecl> ::= <FuncHeading> <CallBody> <OptSemi>
<MethodDecl> ::= <MethHeading> <CallBody> <OptSemi>
 
<ProcHeading> ::= PROCEDURE <RefId> <OptFormalParms> <OptCallSpecifiers> ';'
| <ProcHeading> <CallDirectives> <OptSemi>
 
 
<FuncHeading> ::= FUNCTION <RefId> <OptFormalParms> ':' <ResultType> <OptCallSpecifiers> ';'
| 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></div>
 
=={{header|Java}}==
The BNF description follows, [http://www.cui.unige.ch/db-research/Enseignement/analyseinfo/JAVA/BNFindex.html BNF index of Java Language Grammar]
 
=={{header|JavaScript}}==
The BNF description follows, [http://javascript.comsci.us/syntax/statement/bnf.html JavaScript Syntax]
 
=={{header|Lisp}}==
 
Outside of particularly restricted variants, no static grammar can exactly describe Lisp due to macros and reader-macros.
 
<div style="height:30ex;overflow:scroll"><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></div>
 
=={{header|Pascal}}==
The [[wp:ISO 7185|ISO 7185]] standard for Pascal uses [[wp:Extended Backus–Naur Form|Extended Backus–Naur Form]].
Also [[wp:Van Wijngaarden grammar|Van Wijngaarden's grammar]] can be used to define
[[Pascal]]'s grammar[http://www-users.cs.york.ac.uk/~fisher/software/yoyovwg/exs/pascal.vwg].
 
=={{header|Perl}}==
The BNF description follows, [http://perl.comsci.us/syntax/statement/index.html Perl Syntax]
 
=={{header|Python}}==
The best EBNF syntax so far is at, [http://www.martinrinehart.com/articles/python-grammar.html Python EBNF Syntax]
 
=={{header|SQL}}==
Syntax for SQL follows, [http://savage.net.au/SQL/sql-2003-2.bnf.html BNF Sytax for SQL Database Language]
 
=={{header|Smalltalk}}==
<div style="height:30ex;overflow:scroll"><pre>
! -----------------------------------------------------------------------
! SmallTalk IV
!
! The first object-oriented programming language.
!
! "Smalltalk was developed in the Learning Research Group at Xerox's Palo
! Alto Research Center in the early 70s. The major ideas in Smalltalk
! are generally credited to Alan Kay with many roots in Simula, LISP
! and SketchPad. Dan Engalls wrote the first overlapping windows, opaque
! pop-up menus and BitBlt. Guess where Apple's OS and Microsoft Windows
! "found" their roots? Right, Smalltalk! Adele Goldberg and Dave Robson
! wrote the reference manuals for Smalltalk and were key development team
! members."
!
! - Randy Best, STIC Director
!
!
! "Why Smalltalk? Smalltalk uses a simplified version of English. Nouns
! and verbs. Object are the nouns. Verbs are messages sent from one
! object to the next. Easy as 1, 2, 3. It is no longer necessary to
! write cryptic programs. This means that almost anyone can learn to
! write Smalltalk programs."
!
! - Peter William Lount
!
!
! "I invented the term Object-Oriented, and I can tell you I did not have
! C++ in mind."
!
! - Alan Kay (Inventor of Smalltalk)
!
! The Smalltalk programming language was the first language to incorporate the
! concept of object-oriented programming. Developed in the Xerox labs at Palo
! Alto, Smalltalk was one of a series of ground-breaking ideas that defined
! modern computer science.
!
! In the language's metaphor, everything is an object and every interaction
! between objects are known as messages. Due to a strict adherence to this
! concept, Smalltalk is recognized as a pure object-oriented language.
!
! For more information, please visit: http://www.smalltalk.org
!
! The SmallTalk grammar is amazingly simple with only three levels of
! operator precedence. In addition, the grammar contains no reserved words,
! and only a minimum of symbols. As a result, Smalltalk programs are mainly
! (if not entirely) defined by programmar-defined objects and method names.
!
! This is version IV of the grammar, which allows methods to be defined, but
! not yet the objects themselves.
!
! It should also be noted that comments in SmallTalk are defined as a series
! of characters delimited by Double-Quotes ("). The 'Comment Start' and
! 'Comment End' terminals in the normal GOLD Parser Builder Grammar cannot
! be used since the start and end terminals are identical. However, since
! they are identical, Smalltalk comments cannot be nested and the normal
! 'Whitespace' terminal can be used.
!
! Note: This is an ad hoc version of the grammar. If there are any flaws,
! please e-mail GOLDParser@DevinCook.com and I will update the grammar.
! -----------------------------------------------------------------------
 
 
"Name" = 'Smalltalk IV'
"Author" = 'Alan Kay'
"Version" = 'IV'
"About" = 'Smalltalk is considered one of the "purest" object-oriented'
| 'languages ever created.'
 
 
"Case Sensitive" = True
 
"Start Symbol" = <Program>
 
 
{Id Tail} = {Alphanumeric} + [_]
{Integer Tail} = [ABCDEFGHIJKLMNOPQRSTUVWXYZ] + {Digit}
{String Chars} = {Printable} - ['']
{Selector Char} = [!%&*+/<=>?@\~,]
{Comment Char} = {Printable} + {Whitespace} - ["]
 
! The whitespace character has been modified to accept all double-quoted strings
Whitespace = {Whitespace}+ | '"'{Comment Char}*'"'
 
! The Keyword token is used in SmallTalk to represent a binary message. Essentially,
! this is an object defined operator
KeyWord = {Letter}{Id Tail}*':'
 
Identifier = {Letter}{Id Tail}*
BinarySelector = {Selector Char}+
IntegerLiteral = {Digit}+ | {Digit}+ 'r' {Integer Tail}+
FloatLiteral = {Digit}+ '.'{Digit}+ ( [edq] '-'? {Digit}+ )?
ScaledLiteral = {Digit}+ ( '.' {Digit}+ )? 's' ( {Digit}+ )?
QuotedString = '' ( {String Chars} | '' '' )* ''
 
 
! ---------------------------------------------------- Grammar rules
<Program> ::= <Temporaries> <Sentences>
 
<Temporaries> ::= '|' '|'
| '|' <Identifier List> '|'
|
 
<Identifier List> ::= <Identifier List> Identifier
| Identifier
<Sentences> ::= <Sentence List>
|
 
<Sentence List> ::= <Sentence List> <Expresion> '.'
| <Expresion> '.'
! ---------------------------------------------------- Expressions
<Expresion> ::= Identifier ':=' <Message Exp>
| Identifier ':=' <Primary>
| <Message Exp>
| <Primary>
<Primary> ::= Identifier
| <Literal>
| <Block>
| '(' <Message Exp> ')'
| '(' <Primary> ')'
 
<Message Exp> ::= <Unary Exp>
| <Binary Exp>
| <KeyWord Exp>
<Unary Exp> ::= <Primary> <Unary Exp List>
 
<Unary Exp List> ::= <Unary Exp List> <Unary Message>
| <Unary Message>
<Binary Exp> ::= <Unary Exp> <Binary Exp List>
| <Primary> <Binary Exp List>
 
<Binary Exp List> ::= <Binary Exp List> <Binary Message>
| <Binary Message>
<KeyWord Exp> ::= <Binary Exp> <KeyWord Message>
| <Primary> <KeyWord Message>
| <Unary Exp> <KeyWord Message>
! ---------------------------------------------------- Messages
<Unary Message> ::= <Unary Selector>
<Binary Message> ::= <Binary Selector> <Unary Exp>
| <Binary Selector> <Primary>
<KeyWord Message> ::= KeyWord <Binary Exp> <KeyWord Message>
| KeyWord <Primary> <KeyWord Message>
| KeyWord <Primary>
| KeyWord <Binary Exp>
| KeyWord <Unary Exp> <KeyWord Message>
| KeyWord <Unary Exp>
<Block> ::= '[' ':' Identifier '|' <Sentences> ']'
| '[' <Sentences> ']'
 
 
<Binary Selector> ::= BinarySelector
 
<Unary Selector> ::= Identifier
 
! ---------------------------------------------------- Literals
<Literal> ::= <Literal Item>
| '#' '(' ')'
| '#' '(' <Literal List> ')'
 
<Literal List> ::= <Literal List> <Literal Item>
 
 
<Literal Item> ::= IntegerLiteral
| QuotedString
| FloatLiteral
| ScaledLiteral
</pre></div>
 
=={{header[[:Category:VBScript|VBScript}}]]==
<div style="height:30ex;overflow:scroll"><pre>
!===============================
Line 5,063 ⟶ 1,140:
| 'Empty'
</pre></div>
 
=={{header|Visual Basic .NET}}==
==[[:Category:Visual Basic .NET|Visual Basic .NET]]==
The following link (Appedix B) has a simple BNF Syntax [http://laser.physics.sunysb.edu/~amol/papers/mollypaper.pdf VB Syntax]
<div style="height:30ex;overflow:scroll"><pre>
! -----------------------------------------------------------------------
Line 5,733 ⟶ 1,812:
<Identifier> ::= ID | QualifiedID !Any type of identifier
</pre></div>
 
{{omit from|Tcl}}<!-- no meaningful grammar at a level that anyone cares about; see talk page -->
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/117436...117483"