Part 5 Program Analysis Principles and Techniques

Transcription

1 1 Part 5 Program Analysis Principles and Techniques Front end 2 source code scanner tokens parser il errors Responsibilities: Recognize legal programs Report errors Produce il Preliminary storage map Shape the code for the back end Much of front end construction can be automated

2 3 Scanner source code scanner tokens parser il Scanner errors Maps characters into tokens the basic unit of syntax x = x + y; Becomes <id,x> = <id,x> + <id,y> ; character string for token is a lexeme Typical tokens: number, id, +, -, *, /, do, end Eliminates white space ( tables, blanks, comments) A key issue is speed use specialized recognizer (lex) 4 Specifying patterns A scanner must recognize various parts of the language s syntax. Some parts are easy: White space some combination of <b> and tab Keywords and operators specified as literal patterns do, end Comments opening and closing delimiters - /* */

3 Specifying patterns 5 Other parts are much harder: Identifiers alphabetic followed by k alphanumerics Special symbols (-, $, &, ) Numbers interger 0 or digit from 1-9 followed by digitals from 0-9 decimals integer. digits from 0-9 reals (integer or decimal) E (+ or -) digits from 0-9 complex ( real, real ) We need a powerful notation to specify these patterns. Definitions 6 Operation Definition Union of L and M written L M Concatenation of L and M written LM Kleene closure of L written L* Positive closure of L written L+ L M = { s s L or s M } LM = {st s L and t M} L* = i=0 L i L+ = i=1 L i

4 Regular expressions 7 Patterns are often specified as regular languages. Notations used to describe a regular language (or a regular set) include both regular expressions and regular grammars. Regular expressions (over an alphabet Σ): 1. is a RE denoting the set { } 2. If a Є Σ, then a is RE denoting {a} Regular expressions 8 Regular expressions (over an alphabet Σ): 3. If r and s are REs, denoting L(r) and L(s), then: (r) is a RE denoting L(r) (r) (s) is a RE denoting L(r) L(s) (r) (s) is a RE denoting L(r) L(s) (r)* is a RE denoting L(r)* (r)+ is a RE denoting L(r)+ If we adopt a precedence for operators, the extra parentheses can go away. We assume closure, then concatenation, the alternation as the order of precedence.

5 9 RE examples identifier letter (a b c z A B C Z) digit ( ) id letter (letter digit)* numbers integer ( + - ) ( ) (digit)* decimal integer. (digit)* real (integer decimal) E (+ -) (digit)* Complex ( real. real ) 10 RE examples Most programming language tokens can be described with regular expressions. We can use regular expressions to automatically build scanners.

6 21 Regular expressions Regular expressions represent languages Languages are sets of strings. Operations include Kleene closure, concatenation, and union. Regular expression (a) (a) (b) (a)(b) (a)* (a)+ Language { a } { a, b } { ab } {, a, aa, } { a, aa, } 22 Regular expressions We assume that closure, concatenation, union as the order of precedence. ab cd* = (ab) (c(d*)) = { ab, c, cd, cdd, } a (bc)* = { a, abc, abcbc, }

7 Recognizers 23 From a regular expression, we can construct a deterministic finite automan (dfa). Recognizer for the identifier: letter digit S0 letter S1 other S2 digit other accept S3 error Recognizers 24 Identifier: letter (a b c z A B C Z) digit ( ) id letter (letter digit)*

8 So what is hard? 25 Language features that can cause problems: Reserved words PL/I had no reserved words if then then then = else; else else = then; Significant blanks FORTRAN and Algol68 ignore blanks do 10 I = 1,25 do 10 I = 1.25 So what is hard? 26 String constants special charaters in strings newline, tab, quote, comment, Finite closures some languages limit identifier lengths adds states to count length FORTRAN 66 6 characters These problems can be swept under the rug (avoided) by intelligent language design.

9 27 Methods and parameters What is a lexical error? 1234G6 Illegal character What should the scanner do? Report the error Try to connect it? Error connection techniques Minimum distance corrections Hard token recovery Skip until match 28 Scanners source code scanner tokens parser IL errors A scanner separates input into tokens based on lexical analysis. Legal tokens are usually specified by regular expressions (REs). Regular expressions specify regular languages.

10 Limits of regular languages 31 Not all languages are regular. You cannot construct dfa s to recognize these languages: L = { p k q k } L = { wcw τ w Σ* } Note: neither of these is a regular expression! (dfa s cannot count!) Limits of regular languages 32 But, this is a little subtle. You can construct dfa s for: Alternating 0 s and 1 s ( 1) (01)* ( 0) Sets of pairs of 0 s and 1 s (01 10)+

11 More regular languages 33 Let s look at another regular language the set of strings containing an even number of zeros and an even number of ones. The regular expression is: Start S2 1 1 S (00 11)* ((01 10)(00 11)*(01 10)(00 11)*)* 1 1 S3 Summary 34 Scanners Break up input into tokens Catch lexical errors Difficulty affected by language design Scanner generators Tokens specified by regular expressions Construct dfa to recognize language Highly efficient in practise

12 The role of the parser 35 source code scanner tokens parser il errors Parser: Perform context-free syntax anaylsis Guide the context-sensitive anaylsis Construct an intermediate representation Produce meaningful error messages Attempt error correction Syntax analysis Context-free syntax is specified with a grammar. 36 Formally, a context-free grammar G is a four-tuple (T, NT, S, P) T is the set of terminal symbols in the grammar. For our purposes, the set of terminals is equivalent to the set of tokens returned by the lexical analyzer.

13 37 Syntax analysis NT is a set of syntactic variables that denote sets of (sub)strings occurring in the language. These are used to impose a structure on the grammar. S is a distinguished nonterminal (S NT) that denotes the entire set of strings in L(G). This is sometimes called a goal symbol. S cannot appear on the right hand side of some production. P is a set of productions that specify the way that terminals and non-terminals can be combined to from strings in the language. Each production must have a single non-terminal on its left hand side. 38 Syntax analysis Grammars are often written in BNF, or Backus-Naur Form 1. <goal> ::= <expr> 2. <expr> ::= <expr> <op> <expr> 3. number 4. id 5. <op> ::= * 8. /

14 Syntax analysis 39 This grammar gives simple expressions over numbers and identifiers. In a BNF for a grammar, we represent Non-terminal with brackets or capital letters, Terminals with typewriter font or underline, Productions as in example Why use context-free grammars? 40 Many advantages: Precise syntactic specification of a programming language Easy to understand, avoids ad hoc definition Easier to maintain, add new language features Can automatically construct efficient parser Parser construction reveals ambiguity, other difficulties Imparts structure to language Supports syntax-directed translation

15 Grammars for regular languages 41 Can we place a restriction on the form of grammar to ensure that it describes a regular language? Provable fact: For any RE r, there is a grammar g such, that L(r) = L(g) The grammar that generate regular sets are called regular grammar Grammars for regular languages 42 Defintion: In a regular grammar, all productions have one of two forms: 1. A aa 2. A a Where A is a non-terminal and a is a terminal symbol. These are also called type 3 grammars (Chlomsky).

16 Scanning vs. parsing 43 Where do we draw the line? term [a-za-z] ( [ a-za-z ] [0-9 ] )* 0 [1-9 ] [0-9 ] * op + - * / expr (term op)* term Regular expressions are use to classify. identifiers, numbers, keywords Scanning vs. parsing 44 Context-free grammars are used to count. Brackets ( ), begin end, if then else, imposing structure - expressions Grammar for cc has 188 productions.

17 47 Derivations We can view the productions of a cfg as rewriting rules. Using a example: <goal> <expr> <expr> <op> <expr> <expr> <op> <expr> <op> <expr> <id,x> <op> <expr> <op> <expr> <id,x> + <expr> <op> <expr> <id,x> + <num,2> <op> <expr> <id,x> + <num,2> * <expr> <id,x> + <num,2> * <id,y> 48 Derivations We have derived the sentence x + 2 * y We denote this <goal> id + num * id. Such a sequence of rewrites is a derivation or a parse. The process of discovering a derivation is called parsing.

18 49 Derivations At each step, we chose a non-terminal to replace. This choice can lead to different derivations. Two are of particular interest Leftmost derivation the leftmost non-terminal is replaced at each step Rightmost derivation the rightmost non-terminal is replaced at each step. The example was a leftmost derivation. 50 For the string x y: Rightmost Derivation <goal> <expr> <expr> <op> <expr> <expr> <op> <id,y> <expr> * <id,y> <expr> <op> <expr> * <id,y> <expr> <op> <num,2> * <id,y> <expr> + <num,2> * <id,y> <term> + <num,2> * <id,y> <id,x> + <num,2> * <id,y> Again, <goal>... id + num * id.

19 Parse tree 51 Let s look at the parse tree goal Treewalk evaluation would give the wrong answer. (x + 2) * y instead of x + (2 * y) expr <id,x> expr op term + <num,2> expr op * expr <id,y> Precedence 52 These two derivations point out a problem with the grammar. The grammar has no notion of precedence, or implied order of evaluation.

20 53 Precedence To add precedence takes additional machinery 1. <goal> ::= <expr> 2. <expr> ::= <expr> + <term> 3. <expr> - <term> 4. <term> 5. <term> ::= <term> * <factor> 6. <term> / < factor> 7. <factor> 8. <factor> ::= number 9. id 54 Precedence This grammar enforces a precedence on the derivation termsmust be derived from expressions forces the "correct" tree

21 Precedence 55 Now, for the string x + 2 * y: <goal> <expr> <expr> + <term> <expr> + <term> * <factor> <expr> + <term> * <id,y> <expr> + <factor> * <id,y> <expr> + <num,2> * <id,y> <term> + <num,2> * <id,y> <factor> + <num,2> * <id,y> <id,x> + <num,2> * <id,y> Again, <goal>... id + num * id, but this time, we build the desired tree. Precedence 56 This time, we get the desired parse tree. Treewalk evaluation computes x + (2 * y). <id,x> <num,2>

22 57 Ambiguity If a grammar has multiple leftmost derivations for a single (terminal) word of the language, the grammar is ambiguous. Similarly, a grammar with multiple rightmost derivations for a single (terminal) word of the language is ambiguous. Example <stmt> ::= if <expr> then <stmt> if <expr> then <stmt> else <stmt> other stmts 58 Ambiguity Consider deriving the sentential form: ife 1 then if E 2 then S 1 else S 2 It has two derivations. This ambiguity is purely grammatical. It is a context-free ambiguity.

23 Ambiguity 59 We may be able to eliminate ambiguities by rearranging the grammar. <stmt> ::= <ms> <us> <ms> ::= if <expr> then <ms> else <ms> other stmts <us> ::= if <expr> then <stmt> if <expr> then <ms> else <us> Ambiguity 60 This grammar generates the same language as the ambiguous grammar, but applies the common sense rule match each else with the closest unmatched then This is pretty clearly the language designer's intent.

24 Ambiguity 61 Ambiguity generally refers to a confusion in the context-free specification. Context-sensitive confusions can arise from overloading. a = f(17) In many Algol-like languages, f could be either a function or a subscripted variable. Ambiguity 62 Disambiguating this Statement requires context. need values of declarations not context free really an issue of type Rather than complicate parsing, we will handle this separately.

25 66 Summary: Parser Parser performs context-free syntax analysis Recognizes structure over set of tokens Deals with ambiguity and precedences