Unnamed Web page

Langauge and Syntax

Languages: Natural vs formal
- Natural (eg English, French): informally defined, ambiguous, highly context dependent (ie fruit flies like a banana)
- Formal (eg Java, Ada): precisely defined, less ambiguous, less context dependent
Formal languages: The term language can be used with 2 related meanings:
- Rules for describing valid sentences (ie statements, programs, etc) [sentences are also called strings]
- A set of strings (eg procedure short is begin null; end short;, etc)
Syntax of a language: rules describing the form of valid strings (eg statements and programs) in the language
Semantics of a language: rules describing the meaning of strings (ie what computation is specified by statements and programs)
Uses of Syntax Rules:
- Is a program legal
- What is the (hierarchical) structure of the program
  - How do its pieces fit together
  - What role does each piece play
Two Kinds of Syntax Rules:
- Lexical rules: define legal characters and how they can be combined to form symbols (called "lexemes").
- Syntactic rules: define how categories of lexemes (called "tokens") can be combined to form legal programs.
- Figure 1.3 from the text
- In 380, we are most interested in syntactic rules
- The term syntax usually refers to syntactic rules rather than lexical

Ways to Describe the Syntax of a Language?

English description - lengthy, tedious, ambiguous
Formal description - more concise, less ambiguous
Formal descriptions come in two kinds
- Recognizer: Rules allow us to tell if a given string (eg program), is in the language
- Generator: Rules for language L allow us to produce, on request, a valid string in L
Compilers first recognize validity then produce equivalent machine code
Generation is useful because it helps us understand recognition

BNF and Grammars

Backus-Naur Form (BNF): a metalanguage for creating generators that describe the syntax of a programming language
Metalanguage - Language for describing another language!
Developed by John Backus and Peter Naur
First used to describe ALGOL60
A language description in BNF is called a grammar

Grammars

Grammars are used to define languages by specifying what strings can be generated
To define a grammar you must specify 4 things:
1. Terminals: the words of language.
  (eg see, hit, I, the, a, ball, jackpot)
2. Non-terminals: the parts of speech in the language
  (eg <sentence>, <verb>, <subject>, <object> )
3. Start Symbol: a designated nonterminal that represents the most basic part of speech and that serves as the beginning of derivations,
  (eg <sentence>)
4. Productions, or rules : describe how one part of the language is made up of (ie generates) other parts. For example:
```
<sentence> -->  <subject><verb><object>           

<subject>  -->  I           
<verb>     -->  see | hit           
<object>   -->  <article> <noun>

<article>  -->  the | a
<noun>     -->  ball | jackpot
```
  The symbol -> means "is defined as"
  The symbol | means "OR"
  In BNF, each rule has a single nonterminal on its left hand side.
Derivation
Grammars can be used to derive (ie generate) strings in the language by starting with the Start Symbol and repeatedly replacing a single nonterminal with the RHS of a corresponding rule until no nonterminals remain.

Example: Derivation of I hit the jackpot

<sentence> ==>  <subject><verb><object>           

           ==>  I <verb><object>           

           ==>  I hit <article> <noun>           

           ==>  I hit the <noun>           

           ==>  I hit the jackpot

A sequence of replacements from the Start Symbol to string S is called a derivation of S.
The symbol ==> is used to show how one sentential form is changed into another by replacing a single nonterminal with its corresponding RHS. Each replacement is called a step in the derivation.
A string (eg program) is in a language if the grammar for the language can be used to generate the string from the Start Symbol.
We used the grammar to generate the sentence I hit the jackpot. Thus this sentence is in the language, that is, it follows the rules of the language and is a valid sentence.

Order of Replacement

In the above example, on second step, we could replace either <subject>, <verb>, or <object>. Does it make a difference which is replaced? (Try it).
In most derivations, there is a choice of which NT to replace next, but, for grammars specified using BNF, the order of replacement does not affect whether a string can be generated (or, equivalently, the set of strings that can be generated) by that grammar.
To make it easier to compare and think about derivations, we sometimes choose ahead of time which nonterminal to replace, for example, we might choose to always replace the leftmost (see above).
Choosing at each step to replace the left-most NT produces what is called a left-most derivation

Choosing at each step to replace the right-most NT produces what is called a right-most derivation. For example:

<sentence> ==>  <subject><verb><object>           
           ==>  <subject> <verb> <article> <noun>           
           ==>  <subject> <verb> <article> jackpot
           ==>  <subject> <verb> the jackpot
           ==>  <subject> hit the jackpot
           ==>  I hit the jackpot

Reminder: For grammars specified using BNF, the type of derivation does not affect whether a string can be generated. Any string that can be derived with a leftmost derivation can also be derived with a rightmost derivation, or even a random derivation.

Recursive Productions

How do we use a finite set of rules to generate strings of indefinite length? RECURSION!
Example: Generate strings made up of one or more 1's. (ie 1, 11, 111, 1111, ... )
```
<ones> --> 1 
         | 1<ones>
```
Note: As a shorthand description of these strings, we use the notation 1ⁿ, n>0 . Using this notation, 1⁵, for example, represents the string 11111.

Another example:

<ablist> --> ab 
           | a<ablist>b

What does this generate?

One replacement:
```
<ablist>     ==> ab     
```

Two replacements:

<ablist>     ==> a<ablist>b   
             ==> aabb

Three replacements:

<ablist>     ==> a<ablist>b   
             ==> aa<ablist>bb
             ==> aaabbb

We call this language aⁿ bⁿ, n>0, ie strings of n a's followed by n b's

Recursive Productions: More Examples

What does this generate:
```
<L> --> ab
    |   ab<L>
```

Can we generate aⁿbⁿcⁿ, n>0? Try this:

<L> --> a<L>b<L>c
    |   ab
    |   bc

The language aⁿbⁿcⁿ, n>0 is impossible with BNF.

Expression Grammar

Generates arithmetic expressions, eg A + B * (C + A)

<exp> --> <id> 
        | <exp> + <exp> 
        | <exp> - <exp> 
        | <exp> * <exp> 
        | <exp> / <exp> 
        | (<exp>) 

<id> --> A 
       | B 
       | C

This grammar can generate, for example, A * B + C

<exp> ==> <exp>         + <exp>
      ==> <exp> * <exp> + <exp> 

      ==> <id>  * <exp> + <exp> 
      ==>  A    * <exp> + <exp> 
           
      ==>  A    * <id>  + <exp> 
      ==>  A    *  B    + <exp> 
           
      ==>  A    *  B    + <id> 
      ==>  A    *  B    +  C

Program Grammar

(Part of) an (ambiguous) grammar to generate programs:

<program>    --> program <ident> is <stmts> end;

<stmts>      --> <stmt> ; | <stmt> ; <stmts>

<stmt>       --> <ident> := <expr>
               | if <boolExp> then <stmts> end if

<ident>      --> <letter> | <letter> <characters>

<characters> --> <character> | <character> <characters>

<character>  --> <letter> | <digit> | _

<letter>     --> a | b ... | z | A ... | Z
<digit>      --> 0 | 1 | 2 | ... | 9

<expr>       --> <expr> + <expr>
               |  ...
               | <ident>
               | <number>
               | ( <expr> )

<number>     --> <digit>
               | <digit> <number>

<boolExp>    --> ...

[LaTeX -> HTML by ltoh]

Edward G. Okie
Last modified: Sep 13 2002