Fragments of Course Notes...

High-level, assembly, and machine languages
Scanners (lexical analyzers), parsers (syntax analyzers), code generators, optimizers
Parser-driven compilation

Scanner

Regular grammars
Finite state automata
Deterministic finite state automata
Brute force / table driven programs
Coding: accepting states, lexical and semantical info, symbols table, constants table

Example: IF, END, LET, ids, integers, +, -, *, /, (, ), /*...*/

Top-Down Parser

Top-down with backtracking

	S		ASA
			ASB
			A
	A		a
	B		b

Input: aab

Any cotext-free grammar
Exponential time
Undo semantic actions
Little info on source of failures

Brute-force coding with recursive functions

Recursive-descent parsing

	S		aA
			bB
	A		Sa
			Ca
	B		bS
			c
	C		cB

Input: acca

LL(1) grammars and parse-tables (FIRST and FOLLOW functions)
LL(1) table-driven pushdown automata

LL(1) parsers

	E		TE'
	E'		+TE'

	T		FT'
	T'		*FT'

	F		(E)
			I

LL(k) grammars

	S		CSAc
			BAD
	A		a

	B		bS

	C		c
	D		d

Syntaxt-Directed Code Generator

Assumptions:

The semantic actions are driven by left-to-right bottom-up parsing.
each terminal and nonterminal has semantic information
INFO stack
- When a new token is consumed its semantics is pushed into INFO
- When a reduction for A happens, the top || entities in INFO are replaced with |A| entities.

Interfacing LL(1) Parsers with Code Generators

Old action. Remove nonterminal from top of syntax stack, call to `print(i)', and push the reverse of the right hand-side of rule i in stack
Revised action. Remove nonterminal from top of syntax stack, push i to stack, and push the reverse of the right hand-side of rule i into the stack. Upon encountering i call `semantics(i)'.

Botom-Up Parsing

BASIC PRINCIPLES

Input: b ( ( a a ) a ) b

Grammar:

1. S --> bAb
2. A --> (B
3. --> a
4. B --> Aa)

"State" = nonterminal symbol augmented with info from production rules

LR(0)

Added Rule:

S' --> S

PARSE TABLE

Rows: states
Columns: terminal, nonterminals, eof ($)
Entries: Shift state-i, Reduces i symbols to nonterminal A

	a	b	(	)	$	A	B	S	S'
I-0		S-1						S-4
I-1	S-5		S-6			S-2
I-2		S-3
I-3	R-3,S	R-3,S	R-3,S	R-3,S	R-3,S
I-4					accept
I-5	R-1,A	R-1,A	R-1,A	R-1,A	R-1,A
I-6	S-5		S-6			S-8	S-7
I-7	R-2,A	R-2,A	R-2,A	R-2,A	R-2,A
I-8	S-9
I-9				S-10
I-10	R-3,B	R-3,B	R-3,B	R-3,B	R-3,B

Not LR(0)

Grammar:

S --> A|B
A --> aAc|a
B --> aB|C
C --> bCc|b

LR(1)

LALR(1)

LR(1)-oriented, where states with identical cores are merged

SLR(1)

LR(0) + computed lookahed symbols for cores

EXAMPLE

Grammar:

E --> E+T|T
T --> T*F|F
F --> (E)|id

SLR(1) but not LR(0)

S'		S
S		AS
		b
A		Sa
		a

FOLLOW(S')	=	{$}
{S}	{}	{$, a}
{A}	{}	{a, b}

LALR(1) but not SLR(1)

S		Aa
		bAc
		dc
		bda
A		d

FOLLOW(S)	=	{$}
{A}	{}	{a, c}

LR(1) but not LALR(1)

S		Aa
		bAc
		Bc
		bBa
A		d
B		d

NOTE: In LALR we should merge states I1 and I9 since they have the same core

Interfacing LR(1) with LL(1) and Code Generator

Push start symbol `<program' to pda stack, and repeatedly act according to the entry on top of the stack.

Nonterminal symbol other than <expr>. Consult LL(1) parse table, pop nonterminal, and push `rule number+right handside' in reverse order.
Terminal. Match against input, and put semantics info in INFO stack.
Rule number. Call semantics action.
Empty. Terminate compilation
<expr>. Replace with start state of LR(1) parser.
State. Shift/reduce according to LR(1) parse table. On reduce call semntics action; on shift push semantics info of token to INFO.

Lex: A Scanner Generator

auxiliary definitions:

 
        letter = A | B | ... | Z
        digit  = 0 | 1 | ... | 9

Translation rules

 
        BEGIN                   {return 1}
        END                     {return 2}
        letter(letter|digit)*   {yyval := lookid(yytext);  /* value */
                                 return 3                  /* class */  }

Longet token has highest priority
Conflicts are resolved by ordering

Yacc: A Parser Generator

shift/reduce conflict by default will resolve to shift reduce/reduce conflict by default will resolve in favor of earliest rule
users can change the above default rules
`$i'--reference to value of i'th symbol in right-hand side of rule.
`$$ = ...'--assignment of value to symbol on left-hand side of rule.

Symbol Tables

Linear
Hash-function(id)
Stack for blocks

Handling labels for goto's

      L1: goto L4
      L2: goto L2
          BEGIN
                 goto L1
                 goto L3
                 goto L4
             L1: goto L2
          END
      L4: goto L1
      L5:

Tree structures for multi-pass compilations

Storage Organization

Scalars. address=(data area number,offset)
Arrays. 1 dimension. Continuous memory: address = base + c * i. 2 dimensions. Continuous memory: address = base + c * row + d * col. Tree structure with root for pointers to rows and a continuous area for each row: row(a + i) + c * j + d. Hash functions for sparse arrays. Dynamic Arrays. Use dope vectors
Sets. Bit patterns
Strings. Bounded and unbounded length.

Run-Time Storage Managment

Static (e.g., Fortran)
Dynamic
- Data area per execution
- Data areas placed in a stack
- Fields in data area
- Procedure calls
- Parameters passing

Code Generation for Basic Blocks

Straight-line
Directed acyclic graphs (DAGs)
Trees

Program Analysis

Control Flow Analysis.

Partition into basic blocks. Mark: first instruction, each target of a goto, each successor of a goto.
Determine Successor relationships between Basic Blocks

Depth first ordering.

Denominators.

Loop detection.

Live variable analysis.

UD (usage-define) chaining.

Code Improvement

[prev] [prev-tail] [front] [up]