Faculty of Computing

SE-314: Software Construction

Class: BESE 13AB

Lab 13: Open Ended Lab

CLO-03: Design and develop solutions based on Software

Construction principles.
CLO-04: Use modern tools such as Eclipse, NetBeans etc. for software
construction.
Name: Jaweria Manahil
CMS ID: 419118

Date: 16th Dec 2024

Time: 10:00 AM - 12:50 PM

02:00 PM – 04:50 PM

Instructor: Dr. Mehvish Rashid

Lab Engineer: Mr. Aftab Farooq

SE-314: Software Construction Page 1

 Lab 13: Open Ended Lab

Task: Exploration of an Existing Parser Generator

Objective: The objective of this task is to explore and analyze the features, capabilities, and
usage of an existing parser generator tool. The selected tool will be instrumental in generating
parsers for a chosen programming language.

Task Description:

1. Select a Parser Generator:

 Choose a widely used parser generator tool, such as ANTLR, Bison, JavaCC,
Yacc, PLY, or any other of your preference.

 Ensure the selected tool supports a programming language of interest.

2. Introduction to Parser Generators:

 Research and provide a brief overview of parser generators, highlighting their

role in compiler construction and language processing.

3. Tool Features:

 Explore the features and capabilities of the chosen parser generator tool.

 Investigate its support for different parsing algorithms (LL, LR, etc.).

 Examine its ability to handle syntactic and semantic analysis.

4. Syntax Specification:

 Investigate how the tool allows the specification of the grammar for the
programming language.

 Explore the syntax used for defining production rules and symbols.

5. Code Generation:

 Analyze the code generation capabilities of the parser generator.

 Explore how the tool generates parsing code for the specified grammar.

6. Error Handling:

 Examine the mechanisms provided by the parser generator for error detection
and recovery.

SE-314: Software Construction Page 2

  Investigate how gracefully the tool handles syntactic errors.

7. Integration with IDEs:

 Explore whether the parser generator integrates well with popular Integrated
Development Environments (IDEs) like Eclipse, IntelliJ, or Visual Studio
Code.

8. Real-world Applications:

 Research and provide examples of real-world applications or projects that

have successfully used the chosen parser generator.

9. Comparison with Alternatives:

 Optionally, compare the selected parser generator with alternative tools,

highlighting its strengths, weaknesses, and any unique features.

Submission: Prepare a comprehensive report summarizing your findings. Include sections on

the selected parser generator's features, syntax specification, code generation, error handling,
integration with IDEs, real-world applications, and any relevant comparisons. The report
should be well-organized and include references to the sources of information.

Assessment: Your evaluation will be based on the depth of your exploration, clarity in
presenting findings, and the overall quality of your report. Additionally, consider the
relevance of the selected parser generator to real-world software engineering practices.

Note: This task aims to provide you with a practical understanding of parser generators and
their significance in software development. Ensure to document your exploration thoroughly
and draw insights that can contribute to a deeper understanding of these tools in the context
of software construction.

Deliverables:
Compile a single word document by filling in the solution part and submit this Word file on
LMS. In case of any problems with submissions on LMS, submit your Lab assignments
by emailing it to [email protected].

SE-314: Software Construction Page 3

 Solution to manual:
1. Introduction to Parser Generators

Parser generators automate the creation of parsers, essential for processing and interpreting
programming languages, domain-specific languages, and structured data formats. They convert
grammar specifications into executable code that parses and validates input based on syntax rules.
These tools are vital in compiler construction, making the parsing process efficient, error-resilient,
and easy to manage.

2. Chosen Tool: ANTLR

ANTLR (Another Tool for Language Recognition) is a powerful, widely used and versatile parser
generator that supports multiple programming languages. Developed by Terence Parr, ANTLR
supports various programming languages like Java, Python, JavaScript, C#, and more. It is widely
used in language processing, domain-specific languages, and compiler construction. It is particularly
valued for its user-friendly syntax, robust error-handling capabilities, and support for complex
grammars.

From a formal language description called a grammar, ANTLR generates a parser for that language
that can automatically build parse trees, which are data structures representing how a grammar
matches the input. ANTLR also automatically generates tree walkers that you can use to visit the
nodes of those trees to execute application-specific code.

3. Tool Features

 Parsing Algorithms: ANTLR employs the LL(*) algorithm, which extends traditional LL(k)
parsing to handle non-deterministic and context-sensitive grammars.

 Multi-Language Support: ANTLR can generate parsers in Java, Python, JavaScript, C#, Go,
and Swift, among others.

 Tooling Ecosystem: Includes ANTLRWorks, an integrated grammar editor with debugging

and visualization tools.

 Listener and Visitor Patterns: Supports two tree-traversal strategies for semantic analysis.

 Extensibility: Allows custom actions and semantic predicates within grammars.

 Integration: Can be embedded into larger applications for on-the-fly parsing tasks.

SE-314: Software Construction Page 4

4. Syntax Specification

 Grammar Definition: ANTLR uses a simple and readable grammar syntax. Rules are
defined with a combination of terminals and non-terminals.

 Grammar Files: Grammar rules are written in .g4 files.

 Lexical Rules: Identify tokens using regular expressions (e.g., keywords, identifiers, literals).

o Example:

grammar Hello;

hello: 'hello' ID;

ID: [a-zA-Z]+; // Matches identifiers.

WS: [ \t\r\n]+ -> skip; // Skips whitespace.

 Production Rules: Defined using a clean syntax, where alternatives are separated by the |
operator.

 Precedence and Associativity: Handles operator precedence and associativity through rule
definitions.

 Lexical Rules: Define tokens with regular expressions.

 Parsing Rules: Define the structure of valid sentences using a combination of terminals and
non-terminals.

o Example:
hello: 'hello' ID; // Matches "hello" followed by an identifier.

5. Code Generation

 Generated Code: ANTLR creates classes for parsers, lexers, and listeners/visitors in the
target language.
 Integration: The generated code is modular, allowing developers to embed it easily into
applications.
 Custom Actions: Supports embedding code snippets within grammar rules for customized
processing.
o Example in Java:
expr: expr '+' expr { System.out.println("Addition operation"); };

SE-314: Software Construction Page 5

6. Error Handling
 Built-in Mechanisms:
o Automatic error detection and reporting.
o Default strategies for recovering from errors, allowing parsing to continue.
 Custom Error Listeners: Developers can define custom error listeners to provide user-
friendly error messages.
o Example of Recovery: ANTLR skips invalid tokens or inserts missing tokens to
maintain parsing flow.
o Semantic Errors: Allows developers to integrate semantic checks for additional
validation.

7. Integration with IDEs

 Supported IDEs:
o Eclipse/IntelliJ IDEA: Plugins available for integrating ANTLR grammar files
directly.
o Visual Studio Code: ANTLR4 grammar extension provides syntax highlighting and
validation.
 Debugging: ANTLRWorks aids in debugging grammars with visual parse tree generation and
error visualization.

8. Real-world Applications

 Compilers and Interpreters: Used in the development of language compilers like Groovy
and SQL parsers.
 Domain-Specific Languages (DSLs): Creates DSLs for configuration, testing, and data
manipulation.
 Software Tools: Powers tools like Elasticsearch for query parsing and data processing.
 Data Transformation: Applied in XML, JSON parsing, and data transformation pipelines.

9. Comparison with Alternatives

Feature ANTLR Bison JavaCC PLY

Parsing Algorithm LL(*) LALR(1) LL(1) LALR(1)
Ease of Use High Moderate Moderate High
Language Support Multi-language C/C++ Java Python

SE-314: Software Construction Page 6

 Error Handling Advanced Basic Moderate Moderate
Tooling ANTLRWorks IDE Command-line Command-line Python REPL

ANTLR has contributed to the theory and practice of parsing including:

 linear approximate lookahead
 semantic and syntactic predicates
 ANTLRWorks
 tree parsing
 LL(*)

Unique Strengths of ANTLR:

 Intuitive grammar syntax.
 Robust ecosystem of tools and libraries.
 Excellent error reporting and recovery mechanisms.

10. References
1. ANTLR Official Website: https://www.antlr.org
2. Parr, T. (2013). The Definitive ANTLR 4 Reference. Pragmatic Bookshelf.
3. Eclipse ANTLR Plugin: https://github.com/antlr
4. Real-world Applications: Elasticsearch documentation, Groovy Compiler.

SE-314: Software Construction Page 7

SE-314: Software Construction Page 8
SE-314: Software Construction Page 9
SE-314: Software Construction Page 10
SE-314: Software Construction Page 11
SE-314: Software Construction Page 12
SE-314: Software Construction Page 13
SE-314: Software Construction Page 14