Top-Down Parsing: Choosing the Correct Answer

Verified Sources

Sep 13, 2026

In compiler construction, parsers are broadly classified as top-down or bottom-up based on the direction in which they build the parse structure. A keywordtop-down parser expands productions starting from the start symbol, while keywordbottom-up parsers infer productions by reducing input toward the start symbol.

For the question: “________ is a top-down parser. (i) Operator precedence parser (ii) An LALR (k) parser (iii) An LR (k) parser (iv) Recursive descent parser”, the correct choice is (iv) Recursive descent parser, because recursive descent implements top-down parsing using recursive procedures that correspond to grammar productions.

Key options in the question:

Recursive descent parser: top-down
LR(k) parser: bottom-up (LR family is bottom-up)
LALR(k) parser: bottom-up (LALR is a variant of LR, hence bottom-up)
Operator precedence parser: commonly treated as a bottom-up method that handles precedence/associativity via precedence relations

Recursive descent parser - Wikipedia - Describes recursive descent as a top-down parsing technique using recursive procedures. ↩
LR parser - Wikipedia - Defines LR parsing as a bottom-up shift-reduce parsing method. ↩
LALR parser - Wikipedia - States LALR parsers are LR parsers with merged lookahead states (still bottom-up shift-reduce). ↩
Operator-precedence parsing - Wikipedia - Discusses operator precedence parsing using precedence relations in a shift-reduce framework, typically categorized as bottom-up. ↩

Top-Down vs Bottom-Up Parsing (Intro)

Visual intuition (direction of parsing)

1S -> ... (expand using grammar rules)
2then match terminals with input

How to pick the correct option (classification method)

1
Step 1
Look at whether the option is recursive descent (procedure-per-production) or LR/LALR (LR-family parsing tables).
2
Step 2
Use the standard compiler construction classification: LR/LALR are bottom-up, recursive descent is top-down, and operator precedence is typically bottom-up via precedence relations.
3
Step 3
From the given list, only recursive descent is top-down, so choose (iv).

Pro Tip

A fast exam heuristic: “LR/LALR = bottom-up” and “Recursive descent = top-down.” This usually makes the correct option immediate.

Common pitfall

Do not confuse operator precedence with recursive descent; operator precedence parsers are generally treated as bottom-up methods that rely on precedence/associativity relations to reduce/shift appropriately.

Where these parsers fit conceptually

Recursive Descent

Top-down

Start from the grammar start symbol and recursively expand productions."

Operator Precedence

Bottom-up

Use precedence relations to guide shift/reduce actions over input tokens."

LR(k)

Bottom-up (LR family)

Shift/reduce parsing driven by LR parsing automata and tables."

LALR(k)

Bottom-up (LR family)

A space-optimized LR variant using fewer states (still bottom-up)."

Final answer

(iv) Recursive descent parser is the correct top-down parser.

Parsing Technique Quick Checks

1 / 5

Question · Term

Top-down parser definition

Click to reveal

Answer · Definition

Builds the parse structure starting from the start symbol and expanding toward the input terminals.

Knowledge Check

Question 1 of 4

Q1Single choice

Which one of the following is a top-down parser?

Operator precedence parser

An LALR (k) parser

An LR (k) parser

Recursive descent parser

Explore Related Topics

Which Automaton Accepts Regular Languages? The Correct Answer Is DFA

The deterministic finite automaton (DFA) is the canonical model that exactly accepts regular languages, whereas PDA, LBA, and Turing machines recognize strictly larger language families.

A language is regular iff some DFA $M=(Q,\Sigma,\delta,q_0,F)$ accepts it: $L(M)=\{w\in\Sigma^* \mid \delta^*(q_0,w)\in F\}$ .
DFA ↔ regular languages; PDA ↔ context‑free; LBA ↔ context‑sensitive; Turing machine ↔ recursively enumerable.
Regular languages form the base of the hierarchy: $\text{Regular} \subset \text{Context-Free} \subset \text{Context-Sensitive} \subset \text{Recursively Enumerable}$ .
DFA’s finite memory limits it to patterns like “ends with 01” or “even number of 1’s”, but it cannot handle unbounded counting such as $\{a^n b^n\mid n\ge0\}$ .

Linear Grammar in the Chomsky Hierarchy (CF Grammar with ≤ 1 Nonterminal on RHS)

Lexical Analyzer Output in Compiler Design

In compiler design, the lexical analyzer’s sole output is a stream of tokens derived from the source code character stream.

It scans characters left‑to‑right, grouping them into lexemes that match language patterns.
Each lexeme is classified into a token category (e.g., ID, NUM, PLUS) possibly with attributes.
The token stream is handed to the parser, which builds the parse tree or AST.
Machine code, intermediate code, and parse trees are produced in later compilation phases, not by the lexer.

Browse all research articles