Chapter 3

Describing Syntax and Semantics

Sections 1-3

1–2

Introduction

• Syntax: the form or structure of the expressions, statements, and program units

• Semantics: the meaning of the expressions, statements, and program units

• Syntax and semantics combined provide a language’s definition– Users of a language definition

• Other language designers• Implementers• Programmers (the users of the language)

1–3

Language Theory

• Chomsky identified four classes of language

– Types 2 and 3 useful for programming language specification

• Backus (on ALGOL58 committee) developed notation for specifying programming languages

Regular3Context-free2Context-sensitive1Unrestricted0CharacteristicsType

1–4

Terminology

• A metalanguage is a language used to describe another language

• A sentence is a string of characters over some alphabet• A language is a set of sentences

– a language is specified by a set of rules

• A lexeme is the lowest level syntactic unit of a language (e.g., *, sum, begin)

• A token is a category of lexemes (e.g., identifier)

1–5

Two approaches to Language Definition

• Recognizers– Read a string and decide whether it follows the rules for

the language – Example: syntax analysis part of a compiler (Chapter 4)

• Generators– A device that generates sentences of a language (BNF)– More useful for specifying the language than for checking

a string

1–6

Formal Methods of Describing Syntax

• Backus-Naur Form and Context-Free Grammars– Most widely known method for describing

programming language syntax

– Developed as part of the process for specifying ALGOL

– Define a class of languages called context-free languages

• Extended BNF– Improves readability and writability of BNF

1–7

BNF Fundamentals

• Non-terminals: BNF abstractions used to represent classes of syntactic structures

• Terminals: lexemes and tokens• Grammar: a collection of rules

– Examples of BNF rules:<ident_list> → identifier

| identifier, <ident_list>

<if_stmt> → if <logic_expr> then <stmt>

1–8

BNF Rules

• A rule has a left-hand side (LHS) and a right-hand side (RHS), and consists of terminal and nonterminal symbols

• In a context-free grammar, there can only be one symbol on the LHS

• A grammar is a finite nonempty set of rules• An abstraction (or nonterminal symbol) can have more

than one RHS <stmt> <single_stmt> | begin <stmt_list> end

1–9

Describing Lists

• Syntactic lists are described using recursion <ident_list>-> <ident> | <ident>, <ident_list> <arg_list> -> <expr>

| <expr>, <arg_list> <param_list> -> <param>

| <param>, <param_list> <stmt_list> -> <statement> | <statement> <stmt_list>

1–11

Derivations

• BNF is a generative device– Use a grammar to generate sentences that belong to the

language the grammar describes

• A derivation is a repeated application of rules, starting with the start symbol and ending with a sentence (all terminal symbols)

1–12

Derivation

• Every string of symbols in the derivation is a sentential form

• A sentence is a sentential form that has only terminal symbols

• A leftmost derivation is one in which the leftmost nonterminal in each sentential form is the one that is expanded

• A derivation may be neither leftmost nor rightmost

1–13

An Example Grammar

<program> -> <stmts>

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

<stmt> -> <var> = <expr>

<var> -> a | b | c | d

<expr> -> <term> + <term>

| <term> - <term>

<term> -> <var> | const

1–14

An Example Derivation

<program> => <stmts> => <stmt>

=> <var> = <expr>

=> a = <expr>

=> a = <term> + <term>

=> a = <var> + <term>

=> a = b + <term>

=> a = b + const

1–15

Parse Tree

• A hierarchical representation of a derivation

<program>

<stmts>

<stmt>

const

a

<var> = <expr>

<var>

b

<term> + <term>

1–18

Ambiguity in Grammars

• A grammar is ambiguous if and only if it generates a sentential form that has two or more distinct parse trees

<if_stmt> -> if <logic_expr> then <stmt>

| if <logic_expr> then <stmt> else <stmt>

<stmt> -> <if_stmt> | <assign_stmt> | …

1–20

An Ambiguous Expression Grammar

<expr> <expr> <op> <expr> | const<op> / | -

<expr>

<expr> <expr>

<expr> <expr>

<expr>

<expr> <expr>

<expr> <expr>

<op>

<op>

<op>

<op>

const const const const const const- -/ /

<op>

1–21

An Unambiguous Expression Grammar

• If we build precedence of the operators into the grammar, we cannot have ambiguity

<expr> <expr> - <term> | <term><term> <term> / const | const

<expr>

<expr> <term>

<term> <term>

const const

const/

-

1–22

Associativity of Operators

• Operator associativity can also be indicated by a grammar<expr> -> <expr> + <expr> | const (ambiguous)<expr> -> <expr> + const | const (unambiguous)

<expr><expr>

<expr>

<expr> const

const

const

+

+

1–23

Extended BNF

• Optional parts are placed in brackets [ ]<proc_call> -> ident ([<expr_list>])

• Alternative parts of RHSs are placed inside parentheses and separated via vertical bars <term> → <term> (+|-) const

• Repetitions (0 or more) are placed inside braces { }<ident> → letter {letter|digit}

1–24

BNF and EBNF

• BNF <expr> <expr> + <term> | <expr> - <term> | <term> <term> <term> * <factor> | <term> / <factor> | <factor>

• EBNF <expr> <term> {(+ | -) <term>} <term> <factor> {(* | /) <factor>}

1-25

Recent Variations in EBNF

• Alternative RHSs are put on separate lines

• Use of a colon instead of =>

• Use of opt for optional parts

• Use of oneof for choices

Static Semantics

• Context-free grammars (CFGs) cannot describe all of the syntax of programming languages

• For example– the requirement that a variable be declared before it can

be used is impossible to express in a grammar– information about variable and expression types could

be included in a grammar but only at the cost of great complexity

Dynamic Semantics

• Describe the meaning of programs– English language descriptions neither precise nor

complete

– "Holy Grail" to be able to prove a program correct

• No universal notation for semantics– Operational semantics

– Axiomatic semantics

– Denotational semantics

Axiomatic Semantics

• Based on mathematical logic• Assertions are attached to program statements

describing constraints on variable at that point in program

• Postcondition assertions describe result of the statement

• Precondition assertions describe state before statement is executed

• Can derive the weakest precondition that guarantees a particular postcondition

Monkey Language<stop> -> b | d

<plosive> -> <stop>a

<syllable> -> <plosive> | <plosive><stop>

| a<plosive> | a<stop>

<word> -> <syllable> | <syllable><word><syllable>

<sentence> -> <word>|<sentence>#<word>

Which are valid?

• ba#ababadada#bad#dabbada

• abdabaadab#ada

• dad#ad#abaadad#badadbaad