What is parsing in compiler design?

7 min read


Compiler design is a complex and fascinating field that plays a crucial role in software development. One of the fundamental processes in compiler design is parsing, which involves the analysis of the source code to create a structured representation of the program. In this blog, we will explore what parsing is in compiler design, its importance, and two common parsing techniques: shift-reduce parsing and top-down parsing.

What is Parsing in Compiler Design?

Parsing is the process of analyzing a sequence of symbols or tokens to determine their grammatical structure and identify the relationships between them. In the context of compiler design, parsing is the second phase in the compilation process, following lexical analysis (or scanning). The main goal of parsing is to transform the source code into a parse tree or an abstract syntax tree (AST), which represents the program's structure.

Importance of Parsing

Parsing is a crucial step in compiler design for several reasons:

  1. Syntax Checking: Parsing ensures that the source code adheres to the language's syntax rules. It helps identify and report syntax errors to the programmer.
  1. Semantic Analysis: Once the code is parsed, the compiler can perform semantic analysis to check for logical errors and enforce language-specific rules.
  1. Optimization: The parse tree or AST can be used as a basis for various compiler optimizations to improve the efficiency of the generated code.
  1. Code Generation: After parsing, the compiler can proceed with code generation, where it transforms the high-level source code into machine code or an intermediate representation.

Now that we understand the significance of parsing, let's delve into two common parsing techniques: shift-reduce parsing and top-down parsing.

shift reduce parsing in compiler design

shift reduce parsing in compiler design is a bottom-up parsing technique, which means it starts from the input tokens and works its way up to the root of the parse tree or AST. This technique is often used in parser generators like YACC and Bison. Let's break down the key steps involved in shift reduce parsing in compiler design.

Shift Operation

  1. Shift: In the shift operation, the parser reads the next input token and pushes it onto a stack. The stack keeps track of partially matched constructs.
  1. Reduce: After a series of shifts, the parser may identify a portion of the input that matches a production in the grammar. When such a match is found, a reduce operation is performed.

Reduce Operation

  1. Reduce: In the reduce operation, the parser pops a set of symbols from the stack, representing a right-hand side (RHS) of a production in the grammar. It then pushes the non-terminal symbol on the left-hand side (LHS) of that production onto the stack.
  1. Reduce-Reduce Conflict: In some cases, there may be multiple possible reductions. This situation is called a reduce-reduce conflict and must be resolved using additional grammar rules or precedence declarations.
  1. Shift-Reduce Conflict: A shift-reduce conflict occurs when the parser has the choice to either shift the next input token or reduce the symbols on the stack. Resolving shift-reduce conflicts can be complex and may require the use of precedence and associativity rules.

Shift-reduce parsing continues until the entire input is reduced to the start symbol of the grammar. If this process succeeds, a parse tree or AST is constructed, indicating the valid syntactic structure of the source code. However, if the parser encounters an error or fails to reduce the input to the start symbol, a syntax error is reported.

top down parsing in compiler design

top down parsing in compiler design is the opposite of shift-reduce parsing; it is a top down parsing in compiler design approach that starts with the start symbol of the grammar and tries to match it with the input tokens to construct a parse tree or AST. This technique is often used in recursive descent parsers and LL(k) parsers. Let's explore the key steps in top down parsing in compiler design.

 Recursive Descent Parsing

  1. Start Symbol: The parser begins with the start symbol of the grammar.
  1. Matching: It attempts to match the start symbol with the input tokens. If there is a match, the parser proceeds to expand the start symbol into its constituent productions.
  1. Recursive Expansion: Recursive descent parsers use recursive procedures or functions to expand non-terminal symbols into their productions. Each procedure corresponds to a non-terminal symbol and is responsible for recognizing and handling that symbol's productions.
  1. Backtracking: If the parser encounters a choice between alternative productions for a non-terminal symbol, it may need to backtrack and try different alternatives until it finds a valid match. Backtracking can be costly in terms of performance.

 LL(k) Parsing

In addition to recursive descent parsing, LL(k) parsing is another common top-down parsing technique. LL(k) parsers use a lookahead of k tokens to make parsing decisions. The "LL" stands for "Left-to-right, Leftmost derivation," indicating the parsing strategy.

  1. LL(1) Parsing: In LL(1) parsing, the parser looks at only the current input token to decide which production to use for expansion. This means that for any given input token, there is only one valid production choice.
  1. LL(k) Parsing: In LL(k) parsing, the parser considers a lookahead of k tokens to make parsing decisions. This allows for more complex grammars with greater ambiguity to be parsed efficiently.

 Advantages of Top-Down Parsing

- Readability: Top-down parsers are often easier to implement and understand, especially when using recursive descent parsing.

- Error Recovery: Top-down parsers can provide better error recovery mechanisms because they have more control over the parsing process and can backtrack when necessary.

- Suitable for LL(k) Grammars: Top-down parsing is particularly well-suited for LL(k) grammars, which are commonly used in many programming languages.


In compiler design, parsing is a critical phase that involves analyzing the source code to create a structured representation of the program. Shift-reduce parsing and top-down parsing are two common techniques used for this purpose. While shift-reduce parsing is a bottom-up approach that starts with the input tokens, top-down parsing is a top-down approach that begins with the start symbol of the grammar.

Both parsing techniques have their advantages and are suitable for different types of grammars and parsing requirements. Understanding these parsing techniques is essential for compiler designers and anyone interested in the inner workings of programming languages.

In summary, parsing is the bridge between the source code and the subsequent phases of compilation, making it a fundamental process in the world of compilers and programming language development.

To excel in compiler design, it's crucial to grasp the nuances of parsing, whether you're implementing a parser manually, using parser generators, or exploring the theoretical foundations of formal grammars. So, dive into the world of parsing, explore its intricacies, and unlock the power to create efficient and robust compilers.


Sahil Saini 78
Joined: 10 months ago
In case you have found a mistake in the text, please send a message to the author by selecting the mistake and pressing Ctrl-Enter.
Comments (0)

    No comments yet

You must be logged in to comment.

Sign In / Sign Up

  • Top 20 articles to check out

    NormalizationNormalization organizes attributes and relations of a database to ensure that database integrity constraints properly enforce their dependencies.Cu...

    Enrica Dsouza · 08 August · 4