Rosetta Code

BNF Grammar: Difference between revisions

Page Discussion

BNF Grammar (view source)

Revision as of 10:13, 17 August 2012

39,798 bytes added ,  11 years ago
m
→‎Pascal: move to pacsal page
No edit summary
m (→‎Pascal: move to pacsal page)
 
(89 intermediate revisions by 25 users not shown)
Line 1:
{{DeprecatedTask}}
{{task|BNF GRAMMAR}}
In computer science, Backus–Naur Form (BNF) is a metasyntax used to express context-free grammars: that is, a formal way to describe formal languages. John Backus and Peter Naur developed a context free grammar to define the syntax of a programming language by using two sets of rules: i.e., lexical rules and syntactic rules.
 
Line 6:
There are many extensions and variants of BNF, including Extended and Augmented Backus–Naur Forms (EBNF and ABNF).
 
'''This is a deprecated task. Please move these grammars to the language's category page, or somewhere else.'''
The task here is establish a BNF grammar for as many languages as possible to facilitate language categorization and translation.
 
=={{header|4D}}==
==[[:Category:BASIC|BASIC]]==
=={{header|ALGOL 60}}==
<div style="height:30ex;overflow:scroll"><pre>
<pre>
! ----------------------------------------------------------------------------
! ALGOLBASIC '64 60
!
! Beginner's All-purpose Symbolic Instruction Code
! (ALGO)rithmic (L)anguage
!
! ALGOL "It is, bypractically far,impossible theto mostteach influentialgood programming language developedstyle to students
! that have had prior exposure to BASIC; as potential programmers they are
! date. Although is did not achieve mass use, a large number of syntactic
! mentally mutilated beyond hope of regeneration."
! and semantic principles and concepts were developed and incorporated into
! the language. As a result, ALGOL is considered the main reference language
! in computer science.
!
! In the late 1950's, many in the study of computer science believed that a
! new universal programming language was needed. This new language would be
! used through the study of computer science and would eventually replace
! other popular languages such as FORTRAN.
!
! The ACM (Association for Computing Machinery) and GAMM (a European
! organization of mathematics and mechanics) created an international
! committee to define and document the new language. This committee
! included computer scientists from both North America and Europe.
!
! The process of developing ALGOL included a number of challenges:
!
! First, the computers of the era varied greatly in the number of characters
! that could be represented. This made it difficult to define the exact
! lexics of the language. For instance, one mainframe could contain an
! ampersand character (&) while another may not.
!
! Another challenge involved an issue that nowadays seems trival - the
! representation of decimal points. In the 50 United States and Canada, real
! numbers are represented using a period. For instance, the value 4 1/2 can
! be written as "4.5". Europe, on the other hand, uses a comma. The same
! value is represented with "4,5". Both sides were steadfast that their
! format was superior. Although the "period" format would eventually
! dominate, this was a major issue at the time.
!
! To describe the syntax of the first version of ALGOL, Peter Naur modified
! Backus Normal Form to create Backus-Naur Form. This format is now used
! universially to describe the syntax of programming languages.
!
! To spite these challenges, ALGOL created a number of language features
! that would be incorporated into its numerious successors. These include:
!
! * Block structure
! * Free-form structure (elements are not required to be in a specific column)
! * Pass by Name (while powerful, it is not used in modern languages)
! * The For-Loop
! * The 'Else' clause on if-statements (LISP's 'cond' predates this though)
! * Reserved words
!
! The grammar below was, for the most part, cut and pasted from "Revised
! Report on the Algorithmic Language: Algol 60" by Peter Naur. The numbered
! sections refer directly to the chapters in the Report.
!
! - Edsger W. Dijkstra
! The grammar was modified to remove ambigities and define terminals using
! regular expressions.
!
! BASIC is one of the oldest programming language and one of the most popular.
! ----------------------------------------------------------------------------
! It was developed in 1964 by John G. Kemeny and Thomas E. Kurtz to teach
! students the basics of programming concepts. At the advent of the microcomputer,
! BASIC was implemented on numerous platforms such as the Commodore, Atari,
! Apple II, Altair, IBM PC computers. Over time, BASIC evolved into GW-BASIC,
! QBasic, Visual Basic, and recently Visual Basic .NET.
!
! In practically all programming languages, the reserved word/symbol that denotes
! a comment is treated as a form of whitespace - having no effect in the manner in
! which the program runs. Once such type of comment is used to indicate the remainder
! of the line is to be ignored. These can be added to the end of any line without
! changing the meaning of the program. In C++, it is the '//' symbol;
! in BASIC '64 it is 'REM'.
!
! However, in the BASIC programming language, the line comment is treated like a
! statement. For instance, if 'REM' was a normal line comment:
!
! 10 PRINT "Hello World" REM Common first program
!
! would be a valid statement. However, in BASIC, this is illegal. In the example
! above, the comment must be added as an additional statement.
!
! 10 PRINT "Hello World" : REM Common first program
!
! As a result, the Line Comment terminal that is used in the GOLD Parser cannot be
! used here. In the grammar below, a 'Remark' terminal was created that accepts all
! series of printable characters starting with the characters "REM ". In some
! implementations of BASIC, any string starting with "REM" is a comment statement.
! Examples include "REMARK", "REMARKABLE" and "REMODEL". This grammar requires the space.
!
! This grammar does not include the editor statements such as NEW, SAVE, LOAD, etc...
!
! Note: This is an ad hoc version of the language. If there are any flaws, please
! e-mail GOLDParser@DevinCook.com and I will update the grammar. Most likely I have
! included features not available in BASIC '64.
! -----------------------------------------------------------------------
 
 
"Name" = 'ALGOLBASIC (Beginners All-purpose Symbolic Instruction 60Code)'
"Author" = 'John G. Kemeny and Thomas E. Kurtz'
"Version" = '1960'
"Version" = '1964 - Original - before Microsoft enhanced the language for the IBM PC.'
"About" = 'BASIC is one of most common and popular teaching languages ever created. '
 
"Case Sensitive" = False
"Author" = 'J.W. Backus, F.L. Bauer, J.Green, C. Katz, J. McCarthy, P. Naur,'
"Start Symbol" = <Lines>
| 'A.J. Perlis, H. Rutishauser, K. Samuelson, B. Vauquois,'
| 'J.H. Wegstein, A. van Wijngaarden, M. Woodger'
 
{String Chars} = {Printable} - ["]
"About" = 'ALGOL (ALGOrithmic Language) is the most influential'
{WS} = {Whitespace} - {CR} - {LF}
| 'programming language to date. Although it did not achieve'
| 'mass use, it established multiple syntactic and semantic'
| 'features used in languages today.'
 
NewLine = {CR}{LF}|{CR}
Whitespace = {WS}+
 
Remark = REM{Space}{Printable}*
"Start Symbol" = <program>
ID = {Letter}[$%]?
String = '"'{String Chars}*'"'
Integer = {digit}+
Real = {digit}+.{digit}+
 
<Lines> ::= Integer <Statements> NewLine <Lines>
| Integer <Statements> NewLine
 
<Statements> ::= <Statement> ':' <Statements>
! ========================================================== Terminals
| <Statement>
 
<Statement> ::= CLOSE '#' Integer
| DATA <Constant List>
| DIM ID '(' <Integer List> ')'
| END
| FOR ID '=' <Expression> TO <Expression>
| FOR ID '=' <Expression> TO <Expression> STEP Integer
| GOTO <Expression>
| GOSUB <Expression>
| IF <Expression> THEN <Statement>
| INPUT <ID List>
| INPUT '#' Integer ',' <ID List>
| LET Id '=' <Expression>
| NEXT <ID List>
| OPEN <Value> FOR <Access> AS '#' Integer
| POKE <Value List>
| PRINT <Print list>
| PRINT '#' Integer ',' <Print List>
| READ <ID List>
| RETURN
| RESTORE
| RUN
| STOP
| SYS <Value>
| WAIT <Value List>
| Remark
 
<Access> ::= INPUT
{String Ch} = {Printable} - [`] - ['']
| OUPUT
<ID List> ::= ID ',' <ID List>
| ID
 
<Value List> ::= <Value> ',' <Value List>
Identifier = {Letter}{Alphanumeric}*
| <Value>
 
<Constant List> ::= <Constant> ',' <Constant List>
String = '`' ( '`' {String Ch}* '' | {String Ch} )* ''
| <Constant>
 
<Integer List> ::= Integer ',' <Integer List>
IntegerLiteral = {Digit}+
| Integer
RealLiteral = {Digit}+ '.' {Digit}+ (e {Digit}+)?
<Expression List> ::= <Expression> ',' <Expression List>
| <Expression>
 
<Print List> ::= <Expression> ';' <Print List>
| <Expression>
|
 
<Expression> ::= <And Exp> OR <Expression>
! =========================================================== Rules
| <And Exp>
 
<And Exp> ::= <Not Exp> AND <And Exp>
<unsigned integer>
::= IntegerLiteral | <Not Exp>
<unsignedNot numberExp> ::= NOT <Compare Exp>
::= IntegerLiteral | <Compare Exp>
| RealLiteral
 
<Compare Exp> ::= <Add Exp> '=' <Compare Exp>
| <Add Exp> '<>' <Compare Exp>
| <Add Exp> '><' <Compare Exp>
| <Add Exp> '>' <Compare Exp>
| <Add Exp> '>=' <Compare Exp>
| <Add Exp> '<' <Compare Exp>
| <Add Exp> '<=' <Compare Exp>
| <Add Exp>
 
<Add Exp> ::= <Mult Exp> '+' <Add Exp>
! ====================================================================
| <Mult Exp> '-' <Add Exp>
! 2.2.2 Logical values.
| <Mult Exp>
! ====================================================================
 
<Mult Exp> ::= <Negate Exp> '*' <Mult Exp>
<logical value> ::= true | false
| <Negate Exp> '/' <Mult Exp>
| <Negate Exp>
 
<Negate Exp> ::= '-' <Power Exp>
| <Power Exp>
 
<Power Exp> ::= <Power Exp> '^' <Value>
| <Value>
 
<Value> ::= '(' <Expression> ')'
! ====================================================================
| ID
! 3. Expressions
| ID '(' <Expression List> ')'
! ====================================================================
| <Constant>
 
<Constant> ::= Integer
<expression>
::= <Boolean expression> | String
| Real
</pre></div>
==[[:Category:BASIC Commodore PET|BASIC Commodore PET]]==
<div style="height:30ex;overflow:scroll"><pre>
! -----------------------------------------------------------------------
! Commodore PET BASIC
!
! Beginner's All-purpose Symbolic Instruction Code
!
! "It is practically impossible to teach good programming style to students
! that have had prior exposure to BASIC; as potential programmers they are
! mentally mutilated beyond hope of regeneration."
!
! - Edsger W. Dijkstra
!
!
! BASIC is one of the oldest programming language and one of the most popular.
! It was developed in 1964 by John G. Kemeny and Thomas E. Kurtz to teach
! students the basics of programming concepts. At the advent of the microcomputer,
! BASIC was implemented on numerous platforms such as the Commodore, Atari,
! Apple II, Altair, IBM PC computers. Over time, BASIC evolved into GW-BASIC,
! QBasic, Visual Basic, and recently Visual Basic .NET.
!
! In practically all programming languages, the reserved word/symbol that denotes
! a comment is treated as a form of whitespace - having no effect in the manner in
! which the program runs. Once such type of comment is used to indicate the remainder
! of the line is to be ignored. These can be added to the end of any line without
! changing the meaning of the program. In C++, it is the '//' symbol.
!
! However, in the BASIC programming language, the line comment is treated like a
! statement. For instance, if 'REM' was a normal line comment:
!
! 10 PRINT "Hello World" REM Common first program
!
! would be a valid statement. However, in BASIC, this is illegal. In the example
! above, the comment must be added as an additional statement.
!
! 10 PRINT "Hello World" : REM Common first program
!
! As a result, the Line Comment terminal that is used in the GOLD Parser cannot be
! used here. In the grammar below, a 'Remark' terminal was created that accepts all
! series of printable characters starting with the characters "REM ". In some
! implementations of BASIC, any string starting with "REM" is a comment statement.
! Examples include "REMARK", "REMARKABLE" and "REMODEL". This grammar requires the space.
!
! -----------------------------------------------------------------------
 
! ====================================================================
! 3.1. Variables
! ====================================================================
 
"Name" = 'Commodore PET BASIC'
<subscript expression>
"Author" = 'Commodore Business Machines'
::= <arithmetic expression>
"Version" = '2.0'
"About" = 'This is the version of BASIC that was used on the Commodore 64.'
 
"Case Sensitive" = False
<subscript list>
"Start Symbol" = <Lines>
::= <subscript expression>
| <subscript list> ',' <subscript expression>
 
{String Chars} = {Printable} - ["]
{WS} = {Whitespace} - {CR} - {LF}
 
NewLine = {CR}{LF}|{CR}
<variable>
Whitespace ::= Identifier{WS}+
| Identifier '[' <subscript list> ']' ! subscripted value
 
Remark = REM{Space}{Printable}*
! ====================================================================
ID = {Letter}{Alphanumeric}?[$%]? !IDs are can only have a maximum of 2 characters
! 3.2. Function designators
FunctionID = FN {Letter}{Letter}?
! ====================================================================
 
String = '"'{String Chars}*'"'
<actual parameter>
Integer ::= String{Digit}+
Real | <expression>= {Digit}+'.'{Digit}+
 
<Lines> ::= <Lines> <Line>
<parameter delimiter>
::= ',' | <Line>
| ')' Identifier ':' '('
 
<Line> ::= Integer <Statements> NewLine
<Statements> ::= <Statements> ':' <Statement>
| <Statement>
 
<Statement> ::= CLOSE Integer
<actual parameter list>
::= <actual parameter> | CLR
| <actual parameter list> <parameter delimiter> <actual| parameterCMD <Expression>
| CONT !Continue
| DATA <Constant List>
| DEF FunctionID '(' <ID List> ')' '=' <Expression> !The ID must start with FN
| DIM ID '(' <Expression List> ')'
| END
| FOR ID '=' <Expression> TO <Expression> <Step Opt>
| GET ID
| GET '#' Integer ',' ID
| GOSUB <Expression>
| GOTO <Expression>
| IF <Expression> THEN <Then Clause>
| INPUT <ID List>
| INPUT '#' Integer ',' <ID List>
| LET ID '=' <Expression>
| LIST <Line Range>
| LOAD <Value List>
| ID '=' <Expression>
| NEW
| NEXT <ID List>
| ON ID GOTO <Expression List>
| OPEN <Expression List>
| POKE <Expression> ',' <Expression>
| PRINT <Print list>
| PRINT '#' Integer ',' <Print List>
| READ <ID List>
| RETURN
| RESTORE
| RUN
| RUN <Expression>
| STOP
| SYS <Expression>
| WAIT <Expression List>
| VERIFY <Expression List>
| Remark
 
<Step Opt> ::= STEP <Expression>
|
<ID List> ::= ID ',' <ID List>
| ID
 
<Value List> ::= <Value> ',' <Value List>
! ====================================================================
| <Value>
! 3.3. Arithmetic expressions
! ====================================================================
 
<Constant List> ::= <Constant> ',' <Constant List>
<adding operator> ::= '+' | '-'
| <Constant>
<Expression List> ::= <Expression> ',' <Expression List>
| <Expression>
 
<Print List> ::= <Expression> ';' <Print List>
<multiplying operator> ::= '*' | '/' | 'div'
| <Expression>
|
 
<Line Range> ::= Integer
<primary>
::= <unsigned number> | Integer '-'
| Integer '-' Integer <variable>
| Identifier '(' <actual parameter list> ')'
| '(' <arithmetic expression> ')'
 
<Then Clause> ::= Integer
<factor>
::= | <primaryStatement>
| <factor> '^' <primary> !Originally an up-arrow
<term>
::= <factor>
| <term> <multiplying operator> <factor>
 
! ----------------------------------------------- Expressions
 
<Expression> ::= <And Exp> OR <Expression>
<simple arithmetic expression>
::= | <termAnd Exp>
| <adding operator> <term>
| <simple arithmetic expression> <adding operator> <term>
 
<ifAnd clauseExp> ::= if<Not Exp> AND <BooleanAnd expressionExp> then
| <Not Exp>
<Not Exp> ::= NOT <Compare Exp>
| <Compare Exp>
 
<Compare Exp> ::= <Add Exp> '=' <Compare Exp>
<arithmetic expression>
::= | <simpleAdd arithmeticExp> expression'<>' <Compare Exp>
| <if clause> | <simpleAdd arithmeticExp> expression'>' else <arithmeticCompare expressionExp>
| <Add Exp> '>=' <Compare Exp>
| <Add Exp> '<' <Compare Exp>
| <Add Exp> '<=' <Compare Exp>
| <Add Exp>
 
<Add Exp> ::= <Mult Exp> '+' <Add Exp>
| <Mult Exp> '-' <Add Exp>
| <Mult Exp>
 
<Mult Exp> ::= <Negate Exp> '*' <Mult Exp>
| <Negate Exp> '/' <Mult Exp>
| <Negate Exp>
 
<Negate Exp> ::= '-' <Power Exp>
! ====================================================================
| <Power Exp>
! 3.4. Boolean expressions
! ====================================================================
 
<Power Exp> ::= <Power Exp> '^' <Sub Exp> !On the Commodore, the symbol was an up-arrow
<relational operator> ::= '<' | '<=' | '=' | '>=' | '>' | '~='
| <Sub Exp>
 
<Sub Exp> ::= '(' <Expression> ')'
| <Value>
 
<Value> ::= ID
<relation>
| ABS '(' <Expression> ')'
::= <relation> <relational operator> <simple arithmetic expression>
| ASC <simple arithmetic expression> '(' <Expression> ')'
| ATN '(' <Expression> ')'
| 'CHR$' '(' <Expression> ')'
| COS '(' <Expression> ')'
| EXP '(' <Expression> ')'
| FunctionID '(' <Expression List> ')'
| FRE '(' <Value> ')' !The <Value> is irrelevant
| INT '(' <Expression> ')'
| 'LEFT$' '(' <Expression> ',' <Expression> ')'
| LEN '(' <Expression> ')'
| PEEK '(' <Expression> ')'
| POS '(' <Value> ')' !The <Value> is irrelevant
| 'RIGHT$' '(' <Expression> ',' <Expression> ')'
| RND '(' <Expression> ')'
| SGN '(' <Expression> ')'
| SPC '(' <Expression> ')'
| SQR '(' <Expression> ')'
| TAB '(' <Expression> ')'
| TAN '(' <Expression> ')'
| VAL '(' <Expression> ')'
| <Constant>
 
<Constant> ::= Integer
<Boolean primary>
::= <logical value> | String
| <relation> | Real
 
</pre></div>
<Boolean secondary>
::= <Boolean primary>
| not <Boolean primary>
 
==[[:Category:Brainf***|Brainf***]]==
 
Code ::= Command Code | <NONE>
<Boolean factor>
Command ::= "+" | "-" | "<" | ">" | "," | "." | "[" Code "]" | <ANY>
::= <Boolean secondary>
| <Boolean factor> and <Boolean secondary>
 
==[[:Category:PARI/GP|PARI/GP]]==
<Boolean term>
[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].
::= <Boolean factor>
| <Boolean term> or <Boolean factor>
 
==[[:Category:PowerShell|PowerShell]]==
<implication>
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.
::= <Boolean term>
| <implication> implies <Boolean term>
 
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
<simple Boolean>
<lang powershell>for () {}</lang>
::= <implication>
but the grammar would require
| <simple Boolean> eqv <implication>
<lang powershell>for (;;) {}</lang>
 
==[[:Category:VBScript|VBScript]]==
<div style="height:30ex;overflow:scroll"><pre>
!===============================
! VB Script grammar.
!
! To create the grammar I was using Microsoft's VB Script documentation
! available from http://msdn.microsoft.com/scripting,
! VB Script parser from ArrowHead project http://www.tripi.com/arrowhead/,
! and Visual Basic .Net grammar file written by Devin Cook.
!
! This grammar cannot cover all aspects of VBScript and may have some errors.
! Feel free to contact me if you find any flaws in the grammar.
!
! Vladimir Morozov vmoroz@hotmail.com
!
! Special thanks to Nathan Baulch for the grammar updates.
!
! USE GOLD PARSER BUILDER VERSION 2.1 AND LATER TO COMPILE THIS GRAMMAR.
!===============================
 
"Name" = 'VB Script'
<Boolean expression>
"Author" = 'John G. Kemeny and Thomas E. Kurtz'
::= <simple Boolean>
"Version" = '5.0'
| <if clause> <simple Boolean> else <Boolean expression>
"About" = 'VB Script grammar.'
"Case Sensitive" = False
"Start Symbol" = <Program>
 
!===============================
! Character sets
!===============================
 
{String Char} = {All Valid} - ["]
! ====================================================================
{Date Char} = {Printable} - [#]
! 3.5. Designational expressions
{ID Name Char} = {Printable} - ['['']']
! ====================================================================
{Hex Digit} = {Digit} + [abcdef]
{Oct Digit} = [01234567]
{WS} = {Whitespace} - {CR} - {LF}
{ID Tail} = {Alphanumeric} + [_]
 
!===============================
<label>
! Terminals
::= Identifier
!===============================
| <Unsigned Integer>
 
NewLine = {CR} {LF}
<switch designator>
::= Identifier '[' <subscript expression> ']' | {CR}
| {LF}
| ':'
 
! Special white space definition. Whitespace is either space or tab, which
<simple designational expression>
! can be followed by continuation symbol '_' followed by new line character
::= <label>
Whitespace = {WS}+
| <switch designator>
| '(_' <designational{WS}* expression>{CR}? ')'{LF}?
 
! Special comment definition
<designational expression>
Comment Line = ''
::= <simple designational expression>
| 'Rem'
| <if clause> <simple designational expression> else <designational expression>
 
! Literals
StringLiteral = '"' ( {String Char} | '""' )* '"'
IntLiteral = {Digit}+
HexLiteral = '&H' {Hex Digit}+ '&'?
OctLiteral = '&' {Oct Digit}+ '&'?
FloatLiteral = {Digit}* '.' {Digit}+ ( 'E' [+-]? {Digit}+ )?
| {Digit}+ 'E' [+-]? {Digit}+
DateLiteral = '#' {Date Char}+ '#'
 
! Identifier is either starts with letter and followed by letter,
! ====================================================================
! number or underscore, or it can be escaped sequence of any printable
! 4.1. Compound statements and blocks
! characters ([] and [_$% :-) @] are valid identifiers)
! ====================================================================
ID = {Letter} {ID Tail}*
| '[' {ID Name Char}* ']'
 
! White space is not allowed to be before dot, but allowed to be after it.
<unlabelled basic statement>
IDDot ::= <assignment{Letter} {ID statement>Tail}* '.'
| '[' {ID Name <goChar}* to']' statement>'.'
| !EMPTY | !dummy statement 'And.'
| <procedure statement> | 'ByRef.'
| 'ByVal.'
| 'Call.'
| 'Case.'
| 'Class.'
| 'Const.'
| 'Default.'
| 'Dim.'
| 'Do.'
| 'Each.'
| 'Else.'
| 'ElseIf.'
| 'Empty.'
| 'End.'
| 'Eqv.'
| 'Erase.'
| 'Error.'
| 'Exit.'
| 'Explicit.'
| 'False.'
| 'For.'
| 'Function.'
| 'Get.'
| 'GoTo.'
| 'If.'
| 'Imp.'
| 'In.'
| 'Is.'
| 'Let.'
| 'Loop.'
| 'Mod.'
| 'New.'
| 'Next.'
| 'Not.'
| 'Nothing.'
| 'Null.'
| 'On.'
| 'Option.'
| 'Or.'
| 'Preserve.'
| 'Private.'
| 'Property.'
| 'Public.'
| 'Redim.'
| 'Rem.'
| 'Resume.'
| 'Select.'
| 'Set.'
| 'Step.'
| 'Sub.'
| 'Then.'
| 'To.'
| 'True.'
| 'Until.'
| 'WEnd.'
| 'While.'
| 'With.'
| 'Xor.'
 
! The following identifiers should only be used in With statement.
! This rule must be checked by contextual analyzer.
DotID = '.' {Letter} {ID Tail}*
| '.' '[' {ID Name Char}* ']'
| '.And'
| '.ByRef'
| '.ByVal'
| '.Call'
| '.Case'
| '.Class'
| '.Const'
| '.Default'
| '.Dim'
| '.Do'
| '.Each'
| '.Else'
| '.ElseIf'
| '.Empty'
| '.End'
| '.Eqv'
| '.Erase'
| '.Error'
| '.Exit'
| '.Explicit'
| '.False'
| '.For'
| '.Function'
| '.Get'
| '.GoTo'
| '.If'
| '.Imp'
| '.In'
| '.Is'
| '.Let'
| '.Loop'
| '.Mod'
| '.New'
| '.Next'
| '.Not'
| '.Nothing'
| '.Null'
| '.On'
| '.Option'
| '.Or'
| '.Preserve'
| '.Private'
| '.Property'
| '.Public'
| '.Redim'
| '.Rem'
| '.Resume'
| '.Select'
| '.Set'
| '.Step'
| '.Sub'
| '.Then'
| '.To'
| '.True'
| '.Until'
| '.WEnd'
| '.While'
| '.With'
| '.Xor'
 
DotIDDot = '.' {Letter}{ID Tail}* '.'
<basic statement>
| '.' '[' {ID Name Char}* ']' '.'
::= <unlabelled basic statement>
| <label> ':' <basic statement> | '.And.'
| '.ByRef.'
| '.ByVal.'
| '.Call.'
| '.Case.'
| '.Class.'
| '.Const.'
| '.Default.'
| '.Dim.'
| '.Do.'
| '.Each.'
| '.Else.'
| '.ElseIf.'
| '.Empty.'
| '.End.'
| '.Eqv.'
| '.Erase.'
| '.Error.'
| '.Exit.'
| '.Explicit.'
| '.False.'
| '.For.'
| '.Function.'
| '.Get.'
| '.GoTo.'
| '.If.'
| '.Imp.'
| '.In.'
| '.Is.'
| '.Let.'
| '.Loop.'
| '.Mod.'
| '.New.'
| '.Next.'
| '.Not.'
| '.Nothing.'
| '.Null.'
| '.On.'
| '.Option.'
| '.Or.'
| '.Preserve.'
| '.Private.'
| '.Property.'
| '.Public.'
| '.Redim.'
| '.Rem.'
| '.Resume.'
| '.Select.'
| '.Set.'
| '.Step.'
| '.Sub.'
| '.Then.'
| '.To.'
| '.True.'
| '.Until.'
| '.WEnd.'
| '.While.'
| '.With.'
| '.Xor.'
 
!===============================
<unconditional statement>
! Rules
::= <basic statement>
!===============================
| <compound statement>
| <block>
 
<NL> ::= NewLine <NL>
<statement>
| NewLine
::= <unconditional statement>
| <conditional statement>
| <for statement>
 
<Program> ::= <NLOpt> <GlobalStmtList>
<compound tail>
::= <statement> end
| <statement> ';' <compound tail>
 
!===============================
<block head>
! Rules : Declarations
::= begin <declaration>
!===============================
| <block head> ';' <declaration>
 
<ClassDecl> ::= 'Class' <ExtendedID> <NL> <MemberDeclList> 'End' 'Class' <NL>
<unlabelled block>
::= <block head> ';' <compound tail>
 
<MemberDeclList> ::= <MemberDecl> <MemberDeclList>
<unlabelled compound>
::= begin <compound tail> |
 
<MemberDecl> ::= <FieldDecl>
<compound statement>
| <VarDecl>
::= <unlabelled compound>
| <label> ':' <compound statement | <ConstDecl>
| <SubDecl>
| <FunctionDecl>
| <PropertyDecl>
 
<FieldDecl> ::= 'Private' <FieldName> <OtherVarsOpt> <NL>
<block>
| 'Public' <FieldName> <OtherVarsOpt> <NL>
::= <unlabelled block>
| <label> ':' <block>
 
<FieldName> ::= <FieldID> '(' <ArrayRankList> ')'
<program>
::= | <blockFieldID>
| <compound statement>
 
<FieldID> ::= ID
| 'Default'
| 'Erase'
| 'Error'
| 'Explicit'
| 'Step'
 
<VarDecl> ::= 'Dim' <VarName> <OtherVarsOpt> <NL>
! ====================================================================
! 4.2. Assignment statements
! ====================================================================
 
<VarName> ::= <ExtendedID> '(' <ArrayRankList> ')'
<left part>
| <ExtendedID>
::= <variable> ':='
 
<OtherVarsOpt> ::= ',' <VarName> <OtherVarsOpt>
|
 
<ArrayRankList> ::= <IntLiteral> ',' <ArrayRankList>
<left part list>
::= <left part> | <IntLiteral>
| <left part list> <left part> |
 
<ConstDecl> ::= <AccessModifierOpt> 'Const' <ConstList> <NL>
<assignment statement>
::= <left part list> <Boolean expression>
 
<ConstList> ::= <ExtendedID> '=' <ConstExprDef> ',' <ConstList>
| <ExtendedID> '=' <ConstExprDef>
 
<ConstExprDef> ::= '(' <ConstExprDef> ')'
| '-' <ConstExprDef>
! ====================================================================
| '+' <ConstExprDef>
! 4.3. Go to statements
| <ConstExpr>
! ====================================================================
 
<SubDecl> ::= <MethodAccessOpt> 'Sub' <ExtendedID> <MethodArgList> <NL> <MethodStmtList> 'End' 'Sub' <NL>
<go to statement> ::= goto <designational expression>
| <MethodAccessOpt> 'Sub' <ExtendedID> <MethodArgList> <InlineStmt> 'End' 'Sub' <NL>
 
<FunctionDecl> ::= <MethodAccessOpt> 'Function' <ExtendedID> <MethodArgList> <NL> <MethodStmtList> 'End' 'Function' <NL>
| <MethodAccessOpt> 'Function' <ExtendedID> <MethodArgList> <InlineStmt> 'End' 'Function' <NL>
 
<MethodAccessOpt> ::= 'Public' 'Default'
! ====================================================================
| <AccessModifierOpt>
! 4.4. Dummy statements
! ====================================================================
 
<AccessModifierOpt> ::= 'Public'
!<dummy statement> ::= <empty>
| 'Private'
|
 
<MethodArgList> ::= '(' <ArgList> ')'
| '(' ')'
|
 
<ArgList> ::= <Arg> ',' <ArgList>
! ====================================================================
| <Arg>
! 4.5. Conditional statements
! ====================================================================
 
<Arg> ::= <ArgModifierOpt> <ExtendedID> '(' ')'
<if statement> ::= <if clause> <unconditional statement>
| <ArgModifierOpt> <ExtendedID>
 
<ArgModifierOpt> ::= 'ByVal'
<conditional statement>
| 'ByRef'
::= <if statement>
| <if statement> else <statement> |
| <if clause> <for statement>
| <label> ':' <conditional statement>
 
<PropertyDecl> ::= <MethodAccessOpt> 'Property' <PropertyAccessType> <ExtendedID> <MethodArgList> <NL> <MethodStmtList> 'End' 'Property' <NL>
 
<PropertyAccessType> ::= 'Get'
! ====================================================================
| 'Let'
! 4.6. For statements
| 'Set'
! ====================================================================
 
!===============================
<for list element>
! Rules : Statements
::= <arithmetic expression>
!===============================
| <arithmetic expression> step <arithmetic expression> until <arithmetic expression>
| <arithmetic expression> while <Boolean expression>
 
<GlobalStmt> ::= <OptionExplicit>
<for list>
| <ClassDecl>
::= <for list element>
| <for list> ',' <for list element | <FieldDecl>
| <ConstDecl>
| <SubDecl>
| <FunctionDecl>
| <BlockStmt>
 
<MethodStmt> ::= <ConstDecl>
<for clause> ::= for <variable> ':=' <for list> do
| <BlockStmt>
 
<BlockStmt> ::= <VarDecl>
<for statement>
::= <for clause> | <statementRedimStmt>
| <label> ':' <for statement | <IfStmt>
| <WithStmt>
| <SelectStmt>
| <LoopStmt>
| <ForStmt>
| <InlineStmt> <NL>
 
<InlineStmt> ::= <AssignStmt>
| <CallStmt>
| <SubCallStmt>
| <ErrorStmt>
| <ExitStmt>
| 'Erase' <ExtendedID>
 
<GlobalStmtList> ::= <GlobalStmt> <GlobalStmtList>
! ====================================================================
|
! 4.7. Procedure statements
! ====================================================================
 
<MethodStmtList> ::= <MethodStmt> <MethodStmtList>
|
<BlockStmtList> ::= <BlockStmt> <BlockStmtList>
|
<OptionExplicit> ::= 'Option' 'Explicit' <NL>
 
<ErrorStmt> ::= 'On' 'Error' 'Resume' 'Next'
<procedure statement>
| 'On' 'Error' 'GoTo' IntLiteral ! must be 0
::= Identifier '(' <actual parameter list> ')'
| Identifier
 
<ExitStmt> ::= 'Exit' 'Do'
| 'Exit' 'For'
| 'Exit' 'Function'
| 'Exit' 'Property'
| 'Exit' 'Sub'
 
<AssignStmt> ::= <LeftExpr> '=' <Expr>
! ====================================================================
| 'Set' <LeftExpr> '=' <Expr>
! 5. Declarations
| 'Set' <LeftExpr> '=' 'New' <LeftExpr>
! ====================================================================
 
! Hack: VB Script allows to have construct a = b = c, which means a = (b = c)
<declaration>
! In this grammar we do not allow it in order to prevent complications with
::= <type declaration>
! interpretation of a(1) = 2, which may be considered as array element assignment
| <array declaration>
! or a subroutine call: a ((1) = 2).
| <switch declaration>
! Note: VBScript allows to have missed parameters: a ,,2,3,
| <procedure declaration>
! VM: If somebody knows a better way to do it, please let me know
<SubCallStmt> ::= <QualifiedID> <SubSafeExprOpt> <CommaExprList>
| <QualifiedID> <SubSafeExprOpt>
| <QualifiedID> '(' <Expr> ')' <CommaExprList>
| <QualifiedID> '(' <Expr> ')'
| <QualifiedID> '(' ')'
| <QualifiedID> <IndexOrParamsList> '.' <LeftExprTail> <SubSafeExprOpt> <CommaExprList>
| <QualifiedID> <IndexOrParamsListDot> <LeftExprTail> <SubSafeExprOpt> <CommaExprList>
| <QualifiedID> <IndexOrParamsList> '.' <LeftExprTail> <SubSafeExprOpt>
| <QualifiedID> <IndexOrParamsListDot> <LeftExprTail> <SubSafeExprOpt>
 
! This very simplified case - the problem is that we cannot use parenthesis in aaa(bbb).ccc (ddd)
<SubSafeExprOpt> ::= <SubSafeExpr>
|
 
<CallStmt> ::= 'Call' <LeftExpr>
! ====================================================================
! 5.1. Type declarations
! ====================================================================
 
<LeftExpr> ::= <QualifiedID> <IndexOrParamsList> '.' <LeftExprTail>
<type list>
| <QualifiedID> <IndexOrParamsListDot> <LeftExprTail>
::= Identifier
| Identifier ',' | <typeQualifiedID> list<IndexOrParamsList>
| <QualifiedID>
| <SafeKeywordID>
 
<LeftExprTail> ::= <QualifiedIDTail> <IndexOrParamsList> '.' <LeftExprTail>
<type>
| <QualifiedIDTail> <IndexOrParamsListDot> <LeftExprTail>
::= real
| <QualifiedIDTail> <IndexOrParamsList>
| integer
| Boolean | <QualifiedIDTail>
 
! VB Script does not allow to have space between Identifier and dot:
<local or own type>
! a . b - Error ; ::=a. <type>b or a.b - OK
<QualifiedID> | ::= ownIDDot <typeQualifiedIDTail>
| DotIDDot <QualifiedIDTail>
| ID
| DotID
 
<QualifiedIDTail> ::= IDDot <QualifiedIDTail>
<type declaration>
::= <local or own type> <type list> | ID
| <KeywordID>
 
<KeywordID> ::= <SafeKeywordID>
| 'And'
| 'ByRef'
| 'ByVal'
| 'Call'
| 'Case'
| 'Class'
| 'Const'
| 'Dim'
| 'Do'
| 'Each'
| 'Else'
| 'ElseIf'
| 'Empty'
| 'End'
| 'Eqv'
| 'Exit'
| 'False'
| 'For'
| 'Function'
| 'Get'
| 'GoTo'
| 'If'
| 'Imp'
| 'In'
| 'Is'
| 'Let'
| 'Loop'
| 'Mod'
| 'New'
| 'Next'
| 'Not'
| 'Nothing'
| 'Null'
| 'On'
| 'Option'
| 'Or'
| 'Preserve'
| 'Private'
| 'Public'
| 'Redim'
| 'Resume'
| 'Select'
| 'Set'
| 'Sub'
| 'Then'
| 'To'
| 'True'
| 'Until'
| 'WEnd'
| 'While'
| 'With'
| 'Xor'
 
<SafeKeywordID> ::= 'Default'
! ====================================================================
| 'Erase'
! 5.2. Array declarations
| 'Error'
! ====================================================================
| 'Explicit'
| 'Property'
<lower bound> ::= <arithmetic expression>
| 'Step'
<upper bound> ::= <arithmetic expression>
<bound pair> ::= <lower bound> ':' <upper bound>
<bound pair list>
::= <bound pair>
| <bound pair list> ',' <bound pair>
<array segment>
::= Identifier '[' <bound pair list> ']'
| Identifier ',' <array segment>
<array list>
::= <array segment>
| <array list> ',' <array segment>
<array declaration>
::= array <array list>
| <local or own type> array <array list>
 
<ExtendedID> ::= <SafeKeywordID>
! ====================================================================
| ID
! 5.3. Switch declarations
! ====================================================================
 
<IndexOrParamsList> ::= <IndexOrParams> <IndexOrParamsList>
<switch list>
| <IndexOrParams>
::= <designational expression>
| <switch list> ',' <designational expression>
 
<IndexOrParams> ::= '(' <Expr> <CommaExprList> ')'
<switch declaration>
::= switch Identifier | ':=(' <switch listCommaExprList> ')'
| '(' <Expr> ')'
| '(' ')'
 
<IndexOrParamsListDot> ::= <IndexOrParams> <IndexOrParamsListDot>
| <IndexOrParamsDot>
 
<IndexOrParamsDot> ::= '(' <Expr> <CommaExprList> ').'
! ====================================================================
| '(' <CommaExprList> ').'
! 5.4. Procedure declarations
| '(' <Expr> ').'
! ====================================================================
| '(' ').'
 
<CommaExprList> ::= ',' <Expr> <CommaExprList>
<formal parameter>
| ',' <CommaExprList>
::= Identifier
| ',' <Expr>
| ','
 
!========= Redim Statement
<formal parameter list>
::= <formal parameter>
| <formal parameter list> <parameter delimiter> <formal parameter>
 
<RedimStmt> ::= 'Redim' <RedimDeclList> <NL>
<formal parameter part>
| 'Redim' 'Preserve' <RedimDeclList> <NL>
::= !EMPTY
| '(' <formal parameter list> ')'
 
<RedimDeclList> ::= <RedimDecl> ',' <RedimDeclList>
<identifier list>
::= Identifier | <RedimDecl>
| <identifier list> ',' Identifier
 
<RedimDecl> ::= <ExtendedID> '(' <ExprList> ')'
<value part>
::= value <identifier list> ';'
| !EMPTY
 
!========= If Statement
<specifier>
::= string
| <type>
| array
| <type> array
| label
| switch
| procedure
| <type> procedure
 
<IfStmt> ::= 'If' <Expr> 'Then' <NL> <BlockStmtList> <ElseStmtList> 'End' 'If' <NL>
<specification part>
| 'If' <Expr> 'Then' <InlineStmt> <ElseOpt> <EndIfOpt> <NL>
::= !EMPTY
| <specification>
!=== The following rule was added
 
<ElseStmtList> ::= 'ElseIf' <Expr> 'Then' <NL> <BlockStmtList> <ElseStmtList>
<specification>
::= | 'ElseIf' <specifierExpr> 'Then' <identifierInlineStmt> list<NL> ';'<ElseStmtList>
| 'Else' <InlineStmt> <NL>
| <specification> <specifier> <identifier list> ';'
| 'Else' <NL> <BlockStmtList>
|
 
<ElseOpt> ::= 'Else' <InlineStmt>
|
 
<EndIfOpt> ::= 'End' 'If'
|
 
!========= With Statement
<procedure heading>
::= Identifier <formal parameter part> ';' <value part> <specification part>
 
<WithStmt> ::= 'With' <Expr> <NL> <BlockStmtList> 'End' 'With' <NL>
<procedure body>
::= <statement>
!!! | <code> !<code> refers to any embedded non-Algol code
 
!========= Loop Statement
<procedure declaration>
::= procedure <procedure heading> <procedure body>
| <type> procedure <procedure heading> <procedure body>
 
<LoopStmt> ::= 'Do' <LoopType> <Expr> <NL> <BlockStmtList> 'Loop' <NL>
</pre>
| 'Do' <NL> <BlockStmtList> 'Loop' <LoopType> <Expr> <NL>
=={{header|ALGOL 68}}==
| 'Do' <NL> <BlockStmtList> 'Loop' <NL>
=={{header|APL}}==
| 'While' <Expr> <NL> <BlockStmtList> 'WEnd' <NL>
=={{header|AWK}}==
 
=={{header|ActionScript}}==
<LoopType> ::= 'While'
=={{header|Ada}}==
| 'Until'
=={{header|Agda2}}==
 
=={{header|AmigaE}}==
!========= For Statement
=={{header|AppleScript}}==
 
=={{header|Assembly}}==
<ForStmt> ::= 'For' <ExtendedID> '=' <Expr> 'To' <Expr> <StepOpt> <NL> <BlockStmtList> 'Next' <NL>
=={{header|AutoHotkey}}==
| 'For' 'Each' <ExtendedID> 'In' <Expr> <NL> <BlockStmtList> 'Next' <NL>
=={{header|BASIC}}==
 
<pre>
<StepOpt> ::= 'Step' <Expr>
|
 
!========= Select Statement
 
<SelectStmt> ::= 'Select' 'Case' <Expr> <NL> <CaseStmtList> 'End' 'Select' <NL>
 
<CaseStmtList> ::= 'Case' <ExprList> <NLOpt> <BlockStmtList> <CaseStmtList>
| 'Case' 'Else' <NLOpt> <BlockStmtList>
|
 
<NLOpt> ::= <NL>
|
 
<ExprList> ::= <Expr> ',' <ExprList>
| <Expr>
 
!===============================
! Rules : Expressions
!===============================
 
<SubSafeExpr> ::= <SubSafeImpExpr>
 
<SubSafeImpExpr> ::= <SubSafeImpExpr> 'Imp' <EqvExpr>
| <SubSafeEqvExpr>
 
<SubSafeEqvExpr> ::= <SubSafeEqvExpr> 'Eqv' <XorExpr>
| <SubSafeXorExpr>
 
<SubSafeXorExpr> ::= <SubSafeXorExpr> 'Xor' <OrExpr>
| <SubSafeOrExpr>
 
<SubSafeOrExpr> ::= <SubSafeOrExpr> 'Or' <AndExpr>
| <SubSafeAndExpr>
 
<SubSafeAndExpr> ::= <SubSafeAndExpr> 'And' <NotExpr>
| <SubSafeNotExpr>
 
<SubSafeNotExpr> ::= 'Not' <NotExpr>
| <SubSafeCompareExpr>
 
<SubSafeCompareExpr> ::= <SubSafeCompareExpr> 'Is' <ConcatExpr>
| <SubSafeCompareExpr> 'Is' 'Not' <ConcatExpr>
| <SubSafeCompareExpr> '>=' <ConcatExpr>
| <SubSafeCompareExpr> '=>' <ConcatExpr>
| <SubSafeCompareExpr> '<=' <ConcatExpr>
| <SubSafeCompareExpr> '=<' <ConcatExpr>
| <SubSafeCompareExpr> '>' <ConcatExpr>
| <SubSafeCompareExpr> '<' <ConcatExpr>
| <SubSafeCompareExpr> '<>' <ConcatExpr>
| <SubSafeCompareExpr> '=' <ConcatExpr>
| <SubSafeConcatExpr>
 
<SubSafeConcatExpr> ::= <SubSafeConcatExpr> '&' <AddExpr>
| <SubSafeAddExpr>
 
<SubSafeAddExpr> ::= <SubSafeAddExpr> '+' <ModExpr>
| <SubSafeAddExpr> '-' <ModExpr>
| <SubSafeModExpr>
 
<SubSafeModExpr> ::= <SubSafeModExpr> 'Mod' <IntDivExpr>
| <SubSafeIntDivExpr>
 
<SubSafeIntDivExpr> ::= <SubSafeIntDivExpr> '\' <MultExpr>
| <SubSafeMultExpr>
 
<SubSafeMultExpr> ::= <SubSafeMultExpr> '*' <UnaryExpr>
| <SubSafeMultExpr> '/' <UnaryExpr>
| <SubSafeUnaryExpr>
 
<SubSafeUnaryExpr> ::= '-' <UnaryExpr>
| '+' <UnaryExpr>
| <SubSafeExpExpr>
 
<SubSafeExpExpr> ::= <SubSafeValue> '^' <ExpExpr>
| <SubSafeValue>
 
<SubSafeValue> ::= <ConstExpr>
| <LeftExpr>
! | '(' <Expr> ')'
 
<Expr> ::= <ImpExpr>
 
<ImpExpr> ::= <ImpExpr> 'Imp' <EqvExpr>
| <EqvExpr>
 
<EqvExpr> ::= <EqvExpr> 'Eqv' <XorExpr>
| <XorExpr>
 
<XorExpr> ::= <XorExpr> 'Xor' <OrExpr>
| <OrExpr>
 
<OrExpr> ::= <OrExpr> 'Or' <AndExpr>
| <AndExpr>
 
<AndExpr> ::= <AndExpr> 'And' <NotExpr>
| <NotExpr>
 
<NotExpr> ::= 'Not' <NotExpr>
| <CompareExpr>
 
<CompareExpr> ::= <CompareExpr> 'Is' <ConcatExpr>
| <CompareExpr> 'Is' 'Not' <ConcatExpr>
| <CompareExpr> '>=' <ConcatExpr>
| <CompareExpr> '=>' <ConcatExpr>
| <CompareExpr> '<=' <ConcatExpr>
| <CompareExpr> '=<' <ConcatExpr>
| <CompareExpr> '>' <ConcatExpr>
| <CompareExpr> '<' <ConcatExpr>
| <CompareExpr> '<>' <ConcatExpr>
| <CompareExpr> '=' <ConcatExpr>
| <ConcatExpr>
 
<ConcatExpr> ::= <ConcatExpr> '&' <AddExpr>
| <AddExpr>
 
<AddExpr> ::= <AddExpr> '+' <ModExpr>
| <AddExpr> '-' <ModExpr>
| <ModExpr>
 
<ModExpr> ::= <ModExpr> 'Mod' <IntDivExpr>
| <IntDivExpr>
 
<IntDivExpr> ::= <IntDivExpr> '\' <MultExpr>
| <MultExpr>
 
<MultExpr> ::= <MultExpr> '*' <UnaryExpr>
| <MultExpr> '/' <UnaryExpr>
| <UnaryExpr>
 
<UnaryExpr> ::= '-' <UnaryExpr>
| '+' <UnaryExpr>
| <ExpExpr>
 
<ExpExpr> ::= <Value> '^' <ExpExpr>
| <Value>
 
<Value> ::= <ConstExpr>
| <LeftExpr>
| '(' <Expr> ')'
 
<ConstExpr> ::= <BoolLiteral>
| <IntLiteral>
| FloatLiteral
| StringLiteral
| DateLiteral
| <Nothing>
 
<BoolLiteral> ::= 'True'
| 'False'
 
<IntLiteral> ::= IntLiteral
| HexLiteral
| OctLiteral
 
<Nothing> ::= 'Nothing'
| 'Null'
| 'Empty'
</pre></div>
 
==[[: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>
! -----------------------------------------------------------------------
! BASICVisual '64Basic .NET
!
! Visual Basic .NET is the latest version in the long evoluation of the
! BASIC programming language. The Visual Basic .NET programming language
! is far more "clean" and orthagonal than its predecessors. Although some
! of the old constructs exist, the language is far easier to read and write.
!
! Major syntax changes include, but are not limited to:
!
! 1. The primative file access of VB6 was replaced by a class library. As
! a result, special statements such as
!
! Open "test" For Input As #1
!
! no longer exist.
!
! 2. Class module files were replaced by 'Class ... End Class' declarations
!
! 3. Module files were replaced by 'Module ... End Module' declarations
!
! 4. Structured error handling was added with C++ style Try ... Catch
! Beginner's All-purpose Symbolic Instruction Code
! statements. The old nonstructured approach is still, unfortunately,
! available.
!
! Unfortnately, the designers of Visual Basic .NET did not remove the
! datatype postfix characters on identifiers. In the original BASIC,
! variables types were determined by $ for strings and % for integers.
! QuickBasic expanded the postix notation to include other symbols
! for long integers, singles, etc...
!
! Part of the ID terminal definition was commented out to prevent the
! "It is practically impossible to teach good programming style to students
! old format. You can allow the postfix characters if you like.
! that have had prior exposure to BASIC; as potential programmers they are
! mentally mutilated beyond hope of regeneration."
!
! This grammar also does not contain the compiler directives.
! - Edsger W. Dijkstra
!
! BASICNote: This is onean ad hoc version of the oldest programming language. andIf onethere ofare theany most popular.flaws,
! please visit www.DevinCook.com/GOLDParser
! It was developed in 1964 by John G. Kemeny and Thomas E. Kurtz to teach
! students the basics of programming concepts. At the advent of the microcomputer,
! BASIC was implemented on numerous platforms such as the Commodore, Atari,
! Apple II, Altair, IBM PC computers. Over time, BASIC evolved into GW-BASIC,
! QBasic, Visual Basic, and recently Visual Basic .NET.
!
! Updates:
! In practically all programming languages, the reserved word/symbol that denotes
! 04/082005
! a comment is treated as a form of whitespace - having no effect in the manner in
! Devin Cook
! which the program runs. Once such type of comment is used to indicate the remainder
! of the line is to be ignored 1. TheseRemoved canminus besign added tofrom the end ofIntLiteral anyand lineRealLiteral without
! definitions. These can cause some parse errors when expressions
! changing the meaning of the program. In C++, it is the '//' symbol;
! like "2-2" are read. In this case it would have been interpreted
! in BASIC '64 it is 'REM'.
! as "2" and "-2" rather than "2", "-" and "2".
! 2. Members of an enumeration can be defined with any expression.
! 3. Made some very minor comment changes - mainly for readability.
!
! 03/27/2005
! However, in the BASIC programming language, the line comment is treated like a
! Adrian Moore [adrianrob@hotmail.com]
! statement. For instance, if 'REM' was a normal line comment:
! 1. Add support for Implements in Class
! 2. Add support for AddressOf keyword
! 3. No longer fails if variable starts with _
!
! 02/24/2004
! 10 PRINT "Hello World" REM Common first program
! Vladimir Morozov [vmoroz@hotmail.com] fixed a few flaws in the
! grammar. 1. The definition for strings did not allow the double
! double-quote override. 2. A real literal does not need to have a
! fraction if followed by an exponent. 3. Escaped identifiers can
! contain a null string and 4. Rem works the same as the '
!
! would be a valid statement. However, in BASIC, this is illegal. In the example
! above, the comment must be added as an additional statement.
!
! 10 PRINT "Hello World" : REM Common first program
!
! As a result, the Line Comment terminal that is used in the GOLD Parser cannot be
! used here. In the grammar below, a 'Remark' terminal was created that accepts all
! series of printable characters starting with the characters "REM ". In some
! implementations of BASIC, any string starting with "REM" is a comment statement.
! Examples include "REMARK", "REMARKABLE" and "REMODEL". This grammar requires the space.
!
! This grammar does not include the editor statements such as NEW, SAVE, LOAD, etc...
!
! USE GOLD PARSER BUILDER VERSION 2.1 AND LATER TO COMPILE THIS GRAMMAR.
! Note: This is an ad hoc version of the language. If there are any flaws, please
! Earlier versions cannot handle the complexity.
! e-mail GOLDParser@DevinCook.com and I will update the grammar. Most likely I have
! included features not available in BASIC '64.
! -----------------------------------------------------------------------
 
"Name" = 'Visual Basic .NET'
 
"Author" = 'John G. Kemeny and Thomas E. Kurtz'
"Name" = 'BASIC (Beginners All-purpose Symbolic Instruction Code)'
"Version" = '.NET'
"Author" = 'John G. Kemeny and Thomas E. Kurtz'
"VersionAbout" = '1964 - Original= -'Visual beforeBasic Microsoft.NET enhancedis the languagelatest forversion in the IBMlong PC.evoluation of the'
| 'BASIC programming language.'
"About" = 'BASIC is one of most common and popular teaching languages ever created. '
 
"Case Sensitive" = False
"Start Symbol" = <LinesProgram>
 
! ----------------------------------------------------------------- Sets
{String Chars} = {Printable} - ["]
{WS} = {Whitespace} - {CR} - {LF}
 
{String Chars} = {Printable} - ["]
NewLine = {CR}{LF}|{CR}
Whitespace{Date Chars} = {WSPrintable}+ - [#]
{ID Name Chars} = {Printable} - ['['']']
{Hex Digit} = {Digit} + [abcdef]
{Oct Digit} = [01234567]
 
Remark{WS} = REM{SpaceWhitespace} - {CR} - {PrintableLF}*
ID {Id Tail} = {LetterAlphanumeric} + [$%_]?
String = '"'{String Chars}*'"'
Integer = {digit}+
Real = {digit}+.{digit}+
 
! ----------------------------------------------------------------- Terminals
<Lines> ::= Integer <Statements> NewLine <Lines>
| Integer <Statements> NewLine
 
NewLine = {CR}{LF} | {CR} | ':'
<Statements> ::= <Statement> ':' <Statements>
Whitespace = {WS}+ | '_' {WS}* {CR} | <Statement>{LF}?
 
Comment Line = '' | Rem !Fixed by Vladimir Morozov
<Statement> ::= CLOSE '#' Integer
| DATA <Constant List>
| DIM ID '(' <Integer List> ')'
| END
| FOR ID '=' <Expression> TO <Expression>
| FOR ID '=' <Expression> TO <Expression> STEP Integer
| GOTO <Expression>
| GOSUB <Expression>
| IF <Expression> THEN <Statement>
| INPUT <ID List>
| INPUT '#' Integer ',' <ID List>
| LET Id '=' <Expression>
| NEXT <ID List>
| OPEN <Value> FOR <Access> AS '#' Integer
| POKE <Value List>
| PRINT <Print list>
| PRINT '#' Integer ',' <Print List>
| READ <ID List>
| RETURN
| RESTORE
| RUN
| STOP
| SYS <Value>
| WAIT <Value List>
| Remark
 
LABEL = {Letter}{ID Tail}*':'
<Access> ::= INPUT
 
| OUPUT
!Fixed by Vladimir Morozov
 
ID = [_]?{Letter}{ID Tail}* ! [%&@!#$]? !Archaic postfix chars
| '[' {ID Name Chars}* ']'
QualifiedID = ({Letter}{ID Tail}* | '['{ID Name Chars}*']') ( '.'({Letter}{ID Tail}* | '['{ID Name Chars}*']') )+
 
MemberID = '.' {Letter}{ID Tail}*
| '.[' {ID Name Chars}* ']'
!Fixed by Vladimir Morozov
StringLiteral = '"' ( {String Chars} | '""' )* '"'
 
 
CharLiteral = '"' {String Chars}* '"C'
IntLiteral = {digit}+ [FRDSIL]?
 
RealLiteral = {digit}* '.' {digit}+ ( 'E' [+-]? {Digit}+ )? [FR]?
| {digit}+ 'E' [+-]? {Digit}+ [FR]?
 
 
DateLiteral = '#'{Date chars}'#'
 
HexLiteral = '&H'{Hex Digit}+ [SIL]?
OctLiteral = '&O'{Oct Digit}+ [SIL]?
 
! ----------------------------------------------------------------- Rules
 
<Program> ::= <NameSpace Item> <Program>
| <Imports> <Program>
| <Option Decl> <Program>
|
 
! -------------------------------------------------------------------
! (Shared attributes)
! -------------------------------------------------------------------
 
<NL> ::= NewLine <NL>
| NewLine
 
<Modifiers> ::= <Modifier> <Modifiers>
|
 
<Modifier> ::= Shadows
| Shared
| MustInherit
| NotInheritable
 
| Overridable
| NotOverridable
| MustOverride
| Overrides
| Overloads
| Default
| ReadOnly
| WriteOnly
| <Access>
 
<Access Opt> ::= <Access>
|
 
<Access> ::= Public
| Private
| Friend
| Protected
 
<Var Member> ::= <Attributes> <Access> <Var Decl> <NL> !Variables
| <Attributes> <Access Opt> Const <Var Decl> <NL> !Constants
| <Attributes> <Access Opt> Static <Var Decl> <NL>
<Implements> ::= Implements <ID List>
 
<ID List> ::= <Identifier> ',' <ID List>
| <Identifier>
<Option Decl> ::= Option <IDs> <NL>
 
<IDs> ::= ID <IDs>
| ID
<Type> ::= As <Attributes> <Identifier>
|
 
<Compare Op> ::= '=' | '<>' | '<' | '>' | '>=' | '<='
 
! -------------------------------------------------------------------
! NameSpace
! -------------------------------------------------------------------
 
<NameSpace> ::= NameSpace ID <NL> <NameSpace Items> End NameSpace <NL>
 
<NameSpace Items> ::= <NameSpace Item> <NameSpace Items>
|
 
<NameSpace Item> ::= <Class>
| <Declare>
| <Delegate>
| <Enumeration>
| <Interface>
| <Structure>
| <Module>
| <Namespace>
 
! -------------------------------------------------------------------
! Attributes
! -------------------------------------------------------------------
 
<Attributes> ::= '<' <Attribute List> '>'
|
 
<Attribute List> ::= <Attribute> ',' <Attribute List>
| <Attribute>
<ID ListAttribute> ::= ID<Attribute ','Mod> <ID <Argument List Opt>
| ID
<Attribute Mod> ::= Assembly
| Module
|
! -------------------------------------------------------------------
! Delegates
! -------------------------------------------------------------------
<Delegate> ::= <Attributes> <Modifiers> Delegate <Method>
| <Attributes> <Modifiers> Delegate <Declare>
 
! -------------------------------------------------------------------
<Value List> ::= <Value> ',' <Value List>
! Imports
| <Value>
! -------------------------------------------------------------------
 
<Constant ListImports> ::= Imports <ConstantIdentifier> ',' <Constant ListNL>
| Imports ID '=' |<Identifier> <ConstantNL>
 
! -------------------------------------------------------------------
<Integer List> ::= Integer ',' <Integer List>
! Events
| Integer
! -------------------------------------------------------------------
 
<Event Member> ::= <Attributes> <Modifiers> Event ID <Parameters Or Type> <Implements Opt> <NL>
 
<Parameters Or Type> ::= <Param List>
| As <Identifier>
 
<Implements Opt> ::= <Implements>
|
! -------------------------------------------------------------------
! Class
! -------------------------------------------------------------------
 
<Class> ::= <Attributes> <Modifiers> Class ID <NL> <Class Items> End Class <NL>
 
 
<Class Items> ::= <Class Item> <Class Items>
|
 
<Class Item> ::= <Declare>
| <Method>
| <Property>
| <Var Member>
| <Enumeration>
| <Inherits>
| <Class Implements>
<Inherits> ::= Inherits <Identifier> <NL>
<Class Implements> ::= Implements <ID List> <NL>
 
! -------------------------------------------------------------------
! Structures
! -------------------------------------------------------------------
 
<Structure> ::= <Attributes> <Modifiers> Structure ID <NL> <Structure List> End Structure <NL>
 
<Structure List> ::= <Structure Item> <Structure List>
|
 
<Structure Item> ::= <Implements>
| <Enumeration>
| <Structure>
| <Class>
| <Delegate>
| <Var Member>
| <Event Member>
| <Declare>
| <Method>
| <Property>
 
! -------------------------------------------------------------------
! Module
! -------------------------------------------------------------------
 
<Module> ::= <Attributes> <Modifiers> Module ID <NL> <Module Items> End Module <NL>
 
<Module Items> ::= <Module Item> <Module Items>
|
<Module Item> ::= <Declare>
<Expression List> ::= <Expression> ',' <Expression List>
| <ExpressionMethod>
| <Property>
| <Var Member>
| <Enumeration>
| <Option Decl>
 
! -------------------------------------------------------------------
<Print List> ::= <Expression> ';' <Print List>
! Interface
| <Expression>
! -------------------------------------------------------------------
|
 
<Interface> ::= <Attributes> <Modifiers> Interface ID <NL> <Interface Items> End Interface <NL>
<Expression> ::= <And Exp> OR <Expression>
 
 
<Interface Items> ::= <Interface Item> <Interface Items>
|
<Interface Item> ::= <Implements>
| <Event Member>
| <Enum Member>
| <Method Member>
| <Property Member>
 
<Enum Member> ::= <Attributes> <Modifiers> Enum ID <NL>
 
<Method Member> ::= <Attributes> <Modifiers> Sub <Sub ID> <Param List> <Handles Or Implements> <NL>
| <Attributes> <Modifiers> Function ID <Param List> <Type> <Handles Or Implements> <NL>
 
<Property Member> ::= <Attributes> <Modifiers> Property ID <Param List> <Type> <Handles Or Implements> <NL>
! -------------------------------------------------------------------
! Parameters
! -------------------------------------------------------------------
 
<Param List Opt> ::= <Param List>
|
 
<Param List> ::= '(' <Param Items> ')'
| '(' ')'
<Param Items> ::= <Param Item> ',' <Param Items>
| <Param Item>
 
<Param Item> ::= <Param Passing> ID <Type>
 
 
<Param Passing> ::= ByVal
| ByRef
| Optional
| ParamArray
|
 
! -------------------------------------------------------------------
! Arguments
! -------------------------------------------------------------------
 
<Argument List Opt> ::= <Argument List>
|
<Argument List> ::= '(' <Argument Items> ')'
<Argument Items> ::= <Argument> ',' <Argument Items>
| <Argument>
 
<Argument> ::= <Expression>
| Id ':=' <Expression>
| !NULL
! -------------------------------------------------------------------
! Declares (External Procedures)
! -------------------------------------------------------------------
 
<Declare> ::= <Attributes> <Modifiers> Declare <Charset> Sub ID Lib StringLiteral <Alias> <Param List Opt> <NL>
| <Attributes> <Modifiers> Declare <Charset> Function ID Lib StringLiteral <Alias> <Param List Opt> <Type> <NL>
 
<Charset> ::= Ansi | Unicode | Auto | !Null
 
<Alias> ::= Alias StringLiteral
|
 
 
! -------------------------------------------------------------------
! Methods
! -------------------------------------------------------------------
 
<Method> ::= <Attributes> <Modifiers> Sub <Sub ID> <Param List> <Handles Or Implements> <NL> <Statements> End Sub <NL>
| <Attributes> <Modifiers> Function ID <Param List> <Type> <Handles Or Implements> <NL> <Statements> End Function <NL>
<Sub ID> ::= ID
| New !Class creation
 
<Handles Or Implements> ::= <Implements>
| <Handles>
|
 
<Handles> ::= Handles <ID List>
 
! -------------------------------------------------------------------
! Properties
! -------------------------------------------------------------------
<Property> ::= <Attributes> <Modifiers> Property ID <Param List> <Type> <NL> <Property Items> End Property <NL>
 
<Property Items> ::= <Property Item> <Property Items>
|
 
<Property Item> ::= Get <NL> <Statements> End Get <NL>
| Set <Param List> <NL> <Statements> End Set <NL>
 
 
! -------------------------------------------------------------------
! Enumerations
! -------------------------------------------------------------------
 
<Enumeration> ::= <Attributes> <Modifiers> Enum ID <NL> <Enum List> End Enum <NL>
 
<Enum List> ::= <Enum Item> <Enum List>
|
 
<Enum Item> ::= Id '=' <Expression> <NL>
| Id <NL>
 
! -------------------------------------------------------------------
! Variable Declaration
! -------------------------------------------------------------------
 
<Var Decl> ::= <Var Decl Item> ',' <Var Decl>
| <Var Decl Item>
<Var Decl Item> ::= <Var Decl ID> As <Identifier> <Argument List Opt>
| <Var Decl ID> As <Identifier> '=' <Expression> !Initialize
| <Var Decl ID> As New <Identifier> <Argument List Opt>
| <Var Decl ID>
| <Var Decl ID> '=' <Expression> !Initialize
 
<Var Decl ID> ::= ID <Argument List Opt>
! -------------------------------------------------------------------
! Normal Statements
! -------------------------------------------------------------------
 
<Statements> ::= <Statement> <Statements>
|
 
<Statement> ::= <Loop Stm>
| <For Stm>
| <If Stm>
| <Select Stm>
| <SyncLock Stm>
| <Try Stm>
| <With Stm>
| <Option Decl>
| <Local Decl>
| <Non-Block Stm> <NL> !Note the <NL>. A non-block statement can be a full statement
| LABEL <NL>
<Non-Block Stm> ::= Call <Variable>
| ReDim <Var Decl>
| ReDim Preserve <Var Decl>
| Erase ID
| Throw <Value>
| RaiseEvent <Identifier> <Argument List Opt>
| AddHandler <Expression> ',' <Expression>
| RemoveHandler <Expression> ',' <Expression>
| Exit Do
| Exit For
| Exit Function
| Exit Property
| Exit Select
| Exit Sub
| Exit Try
| Exit While
| GoTo ID !Argh - they still have this
| Return <Value>
 
| Error <Value> !Raise an error by number
| On Error GoTo IntLiteral ! 0 This is obsolete.
| On Error GoTo '-' IntLiteral !-1 This is obsolete.
| On Error GoTo Id
| On Error Resume Next
| Resume ID
| Resume Next
| <Variable> <Assign Op> <Expression>
| <Variable>
| <Method Call>
 
<Assign Op> ::= '=' | '^=' | '*=' | '/=' | '\=' | '+=' | '-=' | '&=' | '<<=' | '>>='
 
 
! -------------------------------------------------------------------
! Local declarations
! -------------------------------------------------------------------
 
<Local Decl> ::= Dim <Var Decl> <NL>
| Const <Var Decl> <NL>
| Static <Var Decl> <NL>
 
! -------------------------------------------------------------------
! Do Statement
! -------------------------------------------------------------------
 
<Loop Stm> ::= Do <Test Type> <Expression> <NL> <Statements> Loop <NL>
| Do <NL> <Statements> Loop <Test Type> <Expression> <NL>
| While <Expression> <NL> <Statements> End While <NL>
 
<Test Type> ::= While
| Until
 
! -------------------------------------------------------------------
! For Statement
! -------------------------------------------------------------------
 
<For Stm> ::= For <Identifier> '=' <Expression> To <Expression> <Step Opt> <NL> <Statements> Next <NL>
| For Each <Variable> In <Variable> <NL> <Statements> Next <NL>
 
<Step Opt> ::= Step <Expression>
|
 
 
! -------------------------------------------------------------------
! If Statement
! -------------------------------------------------------------------
 
<If Stm> ::= If <Expression> <Then Opt> <NL> <Statements> <If Blocks> End If <NL>
| If <Expression> Then <Non-Block Stm> <NL>
| If <Expression> Then <Non-Block Stm> Else <Non-Block Stm> <NL>
 
<Then Opt> ::= Then !!The reserved word 'Then' is optional for Block-If statements
|
 
<If Blocks> ::= ElseIf <Expression> <Then Opt> <NL> <Statements> <If Blocks>
| Else <NL> <Statements>
|
 
! -------------------------------------------------------------------
! Select Statement
! -------------------------------------------------------------------
 
<Select Stm> ::= Select <Case Opt> <Expression> <NL> <Select Blocks> End Select <NL>
 
<Case Opt> ::= Case !!The "Case" after Select is optional in VB.NEt
|
 
 
<Select Blocks> ::= Case <Case Clauses> <NL> <Statements> <Select Blocks>
| Case Else <NL> <Statements>
|
 
<Case Clauses> ::= <Case Clause> ',' <Case Clauses>
| <Case Clause>
 
<Case Clause> ::= <Is Opt> <Compare Op> <Expression>
| <Expression>
| <Expression> To <Expression>
 
<Is Opt> ::= Is
| !Null
 
! -------------------------------------------------------------------
! SyncLock Statement
! -------------------------------------------------------------------
 
<SyncLock Stm> ::= SyncLock <NL> <Statements> End SyncLock <NL>
 
! -------------------------------------------------------------------
! Try Statement
! -------------------------------------------------------------------
 
<Try Stm> ::= Try <NL> <Statements> <Catch Blocks> End Try <NL>
 
<Catch Blocks> ::= <Catch Block> <Catch Blocks>
| <Catch Block>
 
<Catch Block> ::= Catch <Identifier> As ID <NL> <Statements>
| Catch <NL> <Statements>
 
! -------------------------------------------------------------------
! With Statement
! -------------------------------------------------------------------
 
<With Stm> ::= With <Value> <NL> <Statements> End With <NL>
! -------------------------------------------------------------------
! Expressions
! -------------------------------------------------------------------
 
<Expression> ::= <And Exp> Or <Expression>
| <And Exp> OrElse <Expression>
| <And Exp> XOr <Expression>
| <And Exp>
 
<And Exp> ::= <Not Exp> ANDAnd <And Exp>
| <Not Exp> AndAlso <And Exp>
| <Not Exp>
<Not Exp> ::= NOT <Compare Exp>
| <Compare Exp>
 
<Compare Exp> ::= <AddShift Exp> '='<Compare Op> <Compare Exp> !e.g. x < y
| TypeOf <Add Exp> '<>'Is <Compare ExpObject>
| <AddShift Exp> '><'Is <Compare ExpObject>
| <AddShift Exp> '>' Like <Compare ExpValue>
| <AddShift Exp> '>=' <Compare Exp>
| <Add Exp> '<' <Compare Exp>
| <Add Exp> '<=' <Compare Exp>
| <Add Exp>
 
<AddShift Exp> ::= <MultConcat Exp> '+<<' <AddShift Exp>
| <MultConcat Exp> '->>' <AddShift Exp>
| <MultConcat Exp>
 
<Concat Exp> ::= <Add Exp> '&' <Concat Exp>
| <Add Exp>
 
<Add Exp> ::= <Modulus Exp> '+' <Add Exp>
| <Modulus Exp> '-' <Add Exp>
| <Modulus Exp>
 
<Modulus Exp> ::= <Int Div Exp> Mod <Modulus Exp>
| <Int Div Exp>
 
<Int Div Exp> ::= <Mult Exp> '\' <Int Div Exp>
| <Mult Exp>
 
<Mult Exp> ::= <Negate Exp> '*' <Mult Exp>
Line 680 ⟶ 1,778:
| <Value>
 
<Value> ::= '(' <Expression> ')'
| IDNew <Identifier> <Argument List Opt>
| IDIntLiteral '(' <Expression List> ')'
| <Constant> HexLiteral
| OctLiteral
| StringLiteral
| CharLiteral
| RealLiteral
| DateLiteral
| True
| False
| Me
| MyClass
| MyBase
| Nothing
| <Variable>
| AddressOf <Identifier>
 
<Object> ::= <Identifier> !Object identifiers
<Constant> ::= Integer
| StringMe
| RealMyClass
| MyBase
</pre>
| Nothing
=={{header|Bc}}==
 
=={{header|Befunge}}==
<Variable> ::= <Identifier> <Argument List Opt> <Method Calls>
=={{header|Brainf***}}==
=={{header|C}}==
<Method Calls> ::= <Method Call> <Method Calls>
=={{header|C sharp}}==
|
=={{header|C++}}==
 
=={{header|Caml}}==
<Method Call> ::= MemberID <Argument List Opt>
=={{header|Clean}}==
 
=={{header|Clojure}}==
 
=={{header|Cobol}}==
<Identifier> ::= ID | QualifiedID !Any type of identifier
=={{header|ColdFusion}}==
</pre></div>
=={{header|Common Lisp}}==
=={{header|Component Pascal}}==
=={{header|Coq}}==
=={{header|D}}==
=={{header|DOS Batch File}}==
=={{header|Dc}}==
=={{header|Delphi}}==
=={{header|E}}==
=={{header|EC}}==
=={{header|ELLA}}==
=={{header|ESQL}}==
=={{header|Eiffel}}==
=={{header|Emacs Lisp}}==
=={{header|Erlang}}==
=={{header|F}}==
=={{header|F Sharp}}==
=={{header|FALSE}}==
=={{header|FP}}==
=={{header|Factor}}==
=={{header|Fan}}==
=={{header|Forth}}==
=={{header|Fortran}}==
=={{header|GAP}}==
=={{header|Gnuplot}}==
=={{header|Groovy}}==
=={{header|HaXe}}==
=={{header|Haskell}}==
=={{header|IDL}}==
=={{header|Icon}}==
=={{header|Io}}==
=={{header|J}}==
=={{header|JSON}}==
=={{header|JScript.NET}}==
=={{header|Java}}==
=={{header|JavaScript}}==
=={{header|JoCaml}}==
=={{header|Joy}}==
=={{header|JudoScript}}==
=={{header|Korn Shell}}==
=={{header|LSE64}}==
=={{header|LaTeX}}==
=={{header|LabVIEW}}==
=={{header|Lisaac}}==
=={{header|Lisp}}==
=={{header|Logo}}==
=={{header|Logtalk}}==
=={{header|LotusScript}}==
=={{header|Lua}}==
=={{header|Lucid}}==
=={{header|M4}}==
=={{header|MAXScript}}==
=={{header|MIRC Scripting Language}}==
=={{header|MS SQL}}==
=={{header|Make}}==
=={{header|Maple}}==
=={{header|Mathematica}}==
=={{header|Maxima}}==
=={{header|Metafont}}==
=={{header|Modula-3}}==
=={{header|NewLISP}}==
=={{header|Nial}}==
=={{header|OCaml}}==
=={{header|Oberon-2}}==
=={{header|Object Pascal}}==
=={{header|Objective-C}}==
=={{header|Octave}}==
=={{header|Omega}}==
=={{header|OpenEdge/Progress}}==
=={{header|Oz}}==
=={{header|PHP}}==
=={{header|PL/I}}==
=={{header|PL/SQL}}==
=={{header|Pascal}}==
=={{header|Perl}}==
=={{header|Pike}}==
=={{header|PlainTeX}}==
=={{header|Pop11}}==
=={{header|PostScript}}==
=={{header|PowerShell}}==
=={{header|Prolog}}==
=={{header|Python}}==
=={{header|Q}}==
=={{header|R}}==
=={{header|REXX}}==
=={{header|RapidQ}}==
=={{header|Raven}}==
=={{header|Rhope}}==
=={{header|Ruby}}==
=={{header|SAS}}==
=={{header|SETL}}==
=={{header|SMEQL}}==
=={{header|SNUSP}}==
=={{header|SQL}}==
=={{header|Scala}}==
=={{header|Scheme}}==
=={{header|Script3D}}==
=={{header|Seed7}}==
=={{header|Self}}==
=={{header|Slate}}==
=={{header|Smalltalk}}==
=={{header|Standard ML}}==
=={{header|TI-83 BASIC}}==
=={{header|TI-89 BASIC}}==
=={{header|Tcl}}==
=={{header|Toka}}==
=={{header|Tr}}==
=={{header|Transact-SQL}}==
=={{header|Twelf}}==
=={{header|UNIX Shell}}==
=={{header|UnixPipes}}==
=={{header|Unlambda}}==
=={{header|V}}==
=={{header|VBScript}}==
=={{header|Vedit macro language}}==
=={{header|Visual Basic}}==
=={{header|Visual Basic .NET}}==
=={{header|Visual Objects}}==
=={{header|Wrapl}}==
=={{header|XSLT}}==
=={{header|XTalk}}==
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/117393...117483"