Incomputer science, aVan Wijngaarden grammar (alsovW-grammar orW-grammar[1]) is a formalism for definingformal languages. The name derives from the formalism invented byAdriaan van Wijngaarden[2]for the purpose of defining theALGOL 68programming language.The resulting specification[3] remains its most notable application.
Van Wijngaarden grammars address the problem thatcontext-free grammars cannot express agreement or reference, where two different parts of the sentence must agree with each other in some way. For example, the sentence "The birds was eating" is notStandard English because it fails toagree on number. A context-free grammar would parse "The birds was eating" and "The birds were eating" and "The bird was eating" in the same way. However, context-free grammars have the benefit of simplicity whereas van Wijngaarden grammars are considered highly complex.[4]
W-grammars aretwo-level grammars: they are defined by a pair of grammars, that operate on different levels:
The set of strings generated by a W-grammar is defined by a two-stage process:
Theconsistent substitution used in the first step is the same assubstitution in predicate logic, and actually supportslogic programming; it corresponds tounification inProlog, as noted byAlain Colmerauer[where?].
W-grammars areTuring complete;[5]hence, all decision problems regarding the languages they generate, such as
areundecidable.
Curtailed variants, known asaffix grammars, were developed, and applied incompiler construction and to the description of natural languages.
Definitelogic programs, that is, logic programs that make no use of negation, can be viewed as a subclass of W-grammars.[6]
In the 1950s, attempts started to apply computers to the recognition, interpretation and translation of natural languages, such as English and Russian. This requires a machine-readable description of the phrase structure of sentences, that can be used to parse and interpret them, and to generate them. Context-free grammars, a concept fromstructural linguistics, were adopted for this purpose; their rules can express how sentences are recursively built out ofparts of speech, such asnoun phrases andverb phrases, and ultimately, words, such asnouns,verbs, andpronouns.
This work influenced the design and implementation ofprogramming languages, most notably, ofALGOL 60, which introduced a syntax description inBackus–Naur form.
However, context-free rules cannot expressagreement or reference (anaphora), where two different parts of the sentence must agree with each other in some way.
These can be readily expressed in W-grammars. (See example below.)
Programming languages have the analogous notions oftyping andscoping.A compiler or interpreter for the language must recognize which uses of a variable belong together (refer to the same variable). This is typically subject to constraints such as:
W-grammars are based on the idea of providing the nonterminal symbols of context-free grammars withattributes (oraffixes) that pass information between the nodes of theparse tree, used to constrain the syntax and to specify the semantics.
This idea was well known at the time; e.g.Donald Knuth visited the ALGOL 68 design committee while developing his own version of it,attribute grammars.[7]
By augmenting the syntax description with attributes, constraints like the above can be checked, ruling many invalid programs out at compile time.As Van Wijngaarden wrote in his preface:[2]
My main objections were certain to me unnecessary restrictions and the definition of the syntax and semantics. Actually the syntax viewed in MR 75 produces a large number of programs, whereas I should prefer to have the subset of meaningful programs as large as possible, which requires a stricter syntax. [...] it soon became clear that some better tools than the Backus notation might be advantageous [...]. I developed a scheme [...] which enables the design of a language to carry much more information in the syntax than is normally carried.
Quite peculiar to W-grammars was their strict treatment of attributes as strings, defined by a context-free grammar, on which concatenation is the only possible operation; complex data structures and operations can be defined bypattern matching. (See example below.)
After their introduction in the 1968ALGOL 68 "Final Report", W-grammars were widely considered as too powerful and unconstrained to be practical.[citation needed]
This was partly a consequence of the way in which they had been applied; the 1973 ALGOL 68 "Revised Report" contains a much more readable grammar, without modifying the W-grammar formalism itself.
Meanwhile, it became clear that W-grammars, when used in their full generality, are indeed too powerful for such practical purposes as serving as the input for aparser generator.They describe precisely allrecursively enumerable languages,[8] which makes parsing impossible in general: it is anundecidable problem to decide whether a given string can be generated by a given W-grammar.
Hence, their use must be seriously constrained when used for automatic parsing or translation. Restricted and modified variants of W-grammars were developed to address this, e.g.
After the 1970s, interest in the approach waned; occasionally, new studies are published.[9]
In English, nouns, pronouns and verbs have attributes such asgrammatical number,gender, andperson, which must agree betweensubject, main verb, and pronouns referring to the subject:
are valid sentences; invalid are, for instance:
Here, agreement serves to stress that both pronouns (e.g.I andmyself) refer to the same person.
A context-free grammar to generate all such sentences:
<sentence>::=<subject><verb><object><subject>::= I | You | He | She | We | They<verb>::= wash | washes<object>::= myself | yourself | himself | herself | ourselves | yourselves | themselves
From<sentence>, we can generate all combinations:
I wash myselfI wash yourselfI wash himself[...]They wash yourselvesThey wash themselves
A W-grammar to generate only the valid sentences:
<sentence<NUMBER><GENDER><PERSON>>::= <subject<NUMBER><GENDER><PERSON>> <verb<NUMBER><PERSON>> <object<NUMBER><GENDER><PERSON>> <subject singular<GENDER> 1st>::= I <subject<NUMBER><GENDER> 2nd>::= You<subject singular male 3rd>::= He<subject singular female 3rd>::= She <subject plural<GENDER> 1st>::= We <subject singular<GENDER> 3rd>::= They<verb singular 1st>::= wash<verb singular 2nd>::= wash<verb singular 3rd>::= washes <verb plural<PERSON>>::= wash <object singular<GENDER> 1st>::= myself <object singular<GENDER> 2nd>::= yourself<object singular male 3rd>::= himself<object singular female 3rd>::= herself <object plural<GENDER> 1st>::= ourselves <object plural<GENDER> 2nd>::= yourselves <object plural<GENDER> 3rd>::= themselves<NUMBER>::== singular | plural<GENDER>::== male | female<PERSON>::== 1st | 2nd | 3rd
A well-known non-context-free language is
A two-level grammar for this language is the metagrammar
together with grammar schema
The Revised Report on the Algorithmic Language Algol 60[10]defines a full context-free syntax for the language.
Assignments are defined as follows (section 4.2.1):
<left part>::=<variable> := |<procedure identifier> :=<left part list>::=<left part> |<left part list><left part><assignment statement>::=<left part list><arithmetic expression> |<left part list><Boolean expression>
A<variable> can be (amongst other things) an<identifier>, which in turn is defined as:
<identifier> ::= <letter> | <identifier> <letter> | <identifier> <digit>
Examples (section 4.2.2):
s:=p[0]:=n:=n+1+sn:=n+1A:=B/C-v-q×SS[v,k+2]:=3-arctan(sTIMESzeta)V:=Q>Y^Z
Expressions and assignments must betype checked: for instance,
n:=n+1, n must be a number (integer or real);A:=B/C-v-q×S, all variables must be numbers;V:=Q>Y^Z, all variables must be of type Boolean.The rules above distinguish between<arithmetic expression> and<Boolean expression>, but they cannot verify that the same variable always has the same type.
This (non-context-free) requirement can be expressed in a W-grammar by annotating the rules with attributes that record, for each variable used or assigned to, its name and type.
This record can then be carried along to all places in the grammar where types need to be matched, and implement type checking.
Similarly, it can be used to checking initialization of variables before use, etcetera.
One may wonder how to create and manipulate such a data structure without explicit support in the formalism for data structures and operations on them. It can be done by using the metagrammar to define a string representation for the data structure and usingpattern matching to define operations:
<left part with<TYPED><NAME>>::= <variable with<TYPED><NAME>> := | <procedure identifier with<TYPED><NAME>> := <left part list<TYPEMAP1>>::= <left part with<TYPED><NAME>> <where<TYPEMAP1> is<TYPED><NAME> added to sorted<EMPTY>> | <left part list<TYPEMAP2>> <left part with<TYPED><NAME>> <where<TYPEMAP1> is<TYPED><NAME> added to sorted<TYPEMAP2>> <assignment statement<ASSIGNED TO><USED>>::= <left part list<ASSIGNED TO>> <arithmetic expression<USED>> | <left part list<ASSIGNED TO>> <Boolean expression<USED>> <where<TYPED><NAME> is<TYPED><NAME> added to sorted<EMPTY>>::= <where<TYPEMAP1> is<TYPED1><NAME1> added to sorted<TYPEMAP2>>::= <where<TYPEMAP2> is<TYPED2><NAME2> added to sorted<TYPEMAP3>> <where<NAME1> is lexicographically before<NAME2>> <where<TYPEMAP1> is<TYPED1><NAME1> added to sorted<TYPEMAP2>>::= <where<TYPEMAP2> is<TYPED2><NAME2> added to sorted<TYPEMAP3>> <where<NAME2> is lexicographically before<NAME1>> <where<TYPEMAP3> is<TYPED1><NAME1> added to sorted<TYPEMAP4>> <where<EMPTY> is lexicographically before<NAME1>>::= <where<NAME1> is<LETTER OR DIGIT> followed by<NAME2>> <where<NAME1> is lexicographically before<NAME2>>::= <where<NAME1> is<LETTER OR DIGIT> followed by<NAME3>> <where<NAME2> is<LETTER OR DIGIT> followed by<NAME4>> <where<NAME3> is lexicographically before<NAME4>> <where<NAME1> is lexicographically before<NAME2>>::= <where<NAME1> is<LETTER OR DIGIT 1> followed by<NAME3>> <where<NAME2> is<LETTER OR DIGIT 2> followed by<NAME4>> <where<LETTER OR DIGIT 1> precedes+<LETTER OR DIGIT 2> <where<LETTER OR DIGIT 1> precedes+<LETTER OR DIGIT 2>::= <where<LETTER OR DIGIT 1> precedes<LETTER OR DIGIT 2> <where<LETTER OR DIGIT 1> precedes+<LETTER OR DIGIT 2>::= <where<LETTER OR DIGIT 1> precedes+<LETTER OR DIGIT 3> <where<LETTER OR DIGIT 3> precedes+<LETTER OR DIGIT 2><where a precedes b> :==<where b precedes c> :== [...]<TYPED>::== real | integer | Boolean<NAME>::==<LETTER> |<NAME><LETTER> |<NAME><DIGIT><LETTER OR DIGIT>::==<LETTER> |<DIGIT><LETTER OR DIGIT 1>::=<LETTER OR DIGIT><LETTER OR DIGIT 2>::=<LETTER OR DIGIT><LETTER OR DIGIT 3>::=<LETTER OR DIGIT><LETTER>::== a | b | c | [...]<DIGIT>::== 0 | 1 | 2 | [...]<NAMES1>::==<NAMES><NAMES2>::==<NAMES><ASSIGNED TO>::==<NAMES><USED>::==<NAMES><NAMES>::==<NAME> |<NAME><NAMES><EMPTY>::==<TYPEMAP>::== (<TYPED><NAME>)<TYPEMAP><TYPEMAP1>::==<TYPEMAP><TYPEMAP2>::==<TYPEMAP><TYPEMAP3>::==<TYPEMAP>
When compared to the original grammar, three new elements have been added:
The new hyperrules areε-rules: they only generate the empty string.
The ALGOL 68 reports use a slightly different notation without <angled brackets>.
a) program : open symbol, standard prelude, library prelude option, particular program, exit, library postlude option, standard postlude, close symbol. b) standard prelude : declaration prelude sequence. c) library prelude : declaration prelude sequence. d) particular program : label sequence option, strong CLOSED void clause. e) exit : go on symbol, letter e letter x letter i letter t, label symbol. f) library postlude : statement interlude. g) standard postlude : strong void clause train
program : strong void new closed clause A) EXTERNAL :: standard ; library ; system ; particular. B) STOP :: label letter s letter t letter o letter p. a) program text : STYLE begin token, new LAYER1 preludes, parallel token, new LAYER1 tasks PACK, STYLE end token. b) NEST1 preludes : NEST1 standard prelude with DECS1, NEST1 library prelude with DECSETY2, NEST1 system prelude with DECSETY3, where (NEST1) is (new EMPTY new DECS1 DECSETY2 DECSETY3). c) NEST1 EXTERNAL prelude with DECSETY1 : strong void NEST1 series with DECSETY1, go on token ; where (DECSETY1) is (EMPTY), EMPTY. d) NEST1 tasks : NEST1 system task list, and also token, NEST1 user task PACK list. e) NEST1 system task : strong void NEST1 unit. f) NEST1 user task : NEST2 particular prelude with DECS, NEST2 particular program PACK, go on token, NEST2 particular postlude, where (NEST2) is (NEST1 new DECS STOP). g) NEST2 particular program : NEST2 new LABSETY3 joined label definition of LABSETY3, strong void NEST2 new LABSETY3 ENCLOSED clause. h) NEST joined label definition of LABSETY : where (LABSETY) is (EMPTY), EMPTY ; where (LABSETY) is (LAB1 LABSETY1), NEST label definition of LAB1, NEST joined label definition of$ LABSETY1. i) NEST2 particular postlude : strong void NEST2 series with STOP.
A simple example of the power of W-grammars is clause
a) program text : STYLE begin token, new LAYER1 preludes, parallel token, new LAYER1 tasks PACK, STYLE end token.
This allows BEGIN ... END and { } as block delimiters, while ruling out BEGIN ... } and { ... END.
One may wish to compare the grammar in the report with theYacc parser for a subset of ALGOL 68 by Marc van Leeuwen.[11]
Anthony Fisher wroteyo-yo,[12]a parser for a large class of W-grammars, with example grammars forexpressions,eva,sal andPascal (the actualISO 7185 standard for Pascal usesextended Backus–Naur form).
Dick Grune created aC program that would generate all possible productions of a W-grammar.[13]
The applications ofExtended Affix Grammars (EAG)s mentioned above can effectively be regarded as applications of W-grammars, since EAGs are so close to W-grammars.[14]
W-grammars have also been proposed for the description of complex human actions inergonomics.[citation needed]
A W-Grammar Description has also been supplied forAda.[15]