Texas College of Management and IT

Compiler Design and

Construction
Explore, Learn and Excel

Assignment 1

Submitted By: Submitted To:

Name:Abhishek Bhandari Department Of IT
LCID:00170001568
Program: BIT
Sections: D
Date:26 June 2024
1.What is a compiler, and why is it important in programming? Describe
the main phases of a compiler and their roles.

Ans: A compiler is a particular program that deciphers code written in an undeniable

level programming language (like C, Java, or Python) into a lower-level language,
frequently machine code, that a PC's processor can execute. The interpretation
interaction performed by a compiler is vital on the grounds that significant level dialects
are more lucid and simpler for people to compose and keep up with, while machine
code is important for the PC to play out the ideal tasks. Significance of Compilers in
Programming Compilers bridge the gap between human programmers and computer
hardware by transforming code that can be read by humans into code that can be
executed by machines. Optimization: Code can be optimized by compilers to run more
quickly and use fewer resources. Error Detection: Compilers detect errors in code by
performing syntax and semantic checks and providing developers with feedback about
those errors. This helps debug problems and improve code quality. Versatility: By
aggregating undeniable level code into machine code for various models, compilers
empower programming to run on different equipment stages without adjustment of the
source code. Fundamental Periods of a Compiler Scanning Lexical Analysis: This
phase's function is to read the source code and turn it into a stream of tokens. Tokens
are the fundamental structure blocks like watchwords, administrators, identifiers, and
images. Yield: A grouping of tokens. Instruments utilized: Lexes or scanners. Analysis
of Syntax (Parsing): Job: This stage takes the symbolic stream from the lexical
investigation and organizes them into a tree structure called a grammar tree or parse
tree, which addresses the syntactic design of the source code. A parse tree or abstract
syntax tree (AST) is the output. Devices Utilized: Parsers. Analytical Semantics: Role:
This phase ensures that the code adheres to the language's rules and type systems and
checks the parse tree for semantic errors. It includes type checking, scope goal, and it
are semantically substantial to guarantee that activities. Yield: A clarified grammar tree
with extra semantic data. Semantic analyzers are used. Development of Intermediate
Code: Job: This stage interprets the clarified sentence structure tree into a moderate
portrayal (IR) that is simpler to advance and can be all the more effectively changed
into machine code. Yield: Moderate code (IR), which is in many cases as a three-address
code or another transitional language. Intermediate code generators are the tools used.
Optimization: Job: This stage works on the halfway code to make it run all the more
effectively, either concerning rate or memory utilization. Improvements can be
neighborhood (inside a fundamental block) or worldwide (across the whole program).
Optimized intermediate code is the output. Optimizers are the tools used. Generating
code: Job: This stage interprets the advanced middle of the road code into the objective
machine code or low level computing construct, which the PC can execute
straightforwardly. Yield: Machine code or get together code. Devices Utilized: Code
generators. Linking and assembling code: Job: This last stage includes connecting
together different code modules and libraries into a solitary executable program. It settle
addresses, joins machine code documents, and handles library calls. Yield: An
executable program. Apparatuses Utilized: Linkers and constructing agents.
 2.Difference between compiler and interpreter.

The difference between compiler and interpreter are

Compiler Interpreter
1. Interpretation: A compiler translates the Interpretation: An interpreter translates
entire high-level program into machine code high-level code into machine code line-by-
before execution. line or statement-by-statement during
execution.
2. Execution: The processor of the
computer directly executes the compiled Execution: Executes each line of code
machine code. immediately after translating it.

3. Output: Produces an executable file. Output: No separate executable file; the

interpreter executes the code directly.
4. Speed: Usually faster because the
translation is done once in advance. Speed: Slower because translation and
execution occur simultaneously.
5. Error Detection: Identifies errors before
the program runs during the compilation Error Detection: Identifies errors at runtime
process
as it encounters each line of code.

3.Discuss various tools used in compiler construction and their

purposes.
In order to convert high-level programming code into code that can be executed by a machine,
compiler construction involves a variety of tools and methods. The primary functions of the
various tools utilized in the various phases of compiler construction are as follows:

1. Tools for Lexical Analysis

 Lexers and Scanners: Lexical analyzers are made with tools like Flex (Fast Lexical
Analyzer). They convert the source code into a stream of tokens by recognizing
keywords, operators, literals, and other symbols.
2. Tools for Analyzing Syntax

 Parsers: Instruments like Yacc (Yet Another Compiler Compiler) and Bison (GNU
version of Yacc) are used to create parsers that convert token streams into syntax trees or
abstract syntax trees (AST). These tools help ensure that the programming language's
grammar rules are followed in the source code.
 ANTLR: (Another Tool for Language Recognition) is another powerful tool for creating
parsers and lexers.

3. Tools for Semantic Analysis

 Symbol Tables: Data structures that are used to store information about variables,
functions, objects, and their attributes. They help in type checking and scope resolution.
 Attribute Grammars: Define both semantic and syntactic rules to ensure the correct
interpretation of the parsed code.

4. Tools for Intermediate Code Generation

 Intermediate Representations (IRs): Instruments and libraries like LLVM (Low-Level

Virtual Machine) provide frameworks to generate and optimize intermediate code. IRs
bridge the gap between machine code and source code.

5. Tools for Optimization

 Optimizers: Compiler-integrated tools and libraries (like LLVM optimizations) that

optimize code for speed, memory efficiency, and performance. They can optimize locally
(within a basic block) or globally (throughout the entire program).

6. Tools for Code Generation

 Code Generators: Components of compiler backends that are responsible for

transforming optimized intermediate code into machine code. They handle the specifics
of the target architecture.
 Backend Libraries: Libraries like LLVM additionally aid the final translation of IR to
machine-specific code.

7. Tools for Linking and Assembling Code

 Assemblers: Tools that translate assembly language code into machine code. GNU
Assembler (GAS) is one example.
 Linkers: Tools that resolve references between multiple object files and combine them
into a single executable. Examples include GNU Linker (LD).
8. Environments for Integrated Development (IDEs)

 IDEs: Devices like Eclipse, Visual Studio, and JetBrains IntelliJ IDEA often
incorporate built-in compilers, debuggers, and other utilities that facilitate the entire
compilation process from code writing to execution.

9. Tools for Debugging and Profiling

 Debuggers: Tools like GDB (GNU Debugger) make it easier to examine the behavior of
compiled programs, find bugs, and fix them.
 Profilers: Tools like gprof and Valgrind help with analyzing program performance and
memory usage to further optimize code.

4.Define syntax and explain the concept of syntax-directed translation?

Ans. Syntax is the set of rules that define the structure of valid sentences or expressions ina
programming language, specifying how symbols, keywords, and operators can be

combined. Syntax-Directed Translation

Syntax-Directed Translation is a method in compilers where translation is guidedbythe syntactic

structure of the source code. It involves associating actions with

grammar rules, so as the parser builds the parse tree or abstract syntax tree (AST), it

performs translations based on these actions. Key Concepts

1. Grammar Rules: Define the structure of the language. 2. Semantic Actions: Specify translations
attached to grammar rules.

3. Attributes: Carry information like types and values. They are of two types:

1. Synthesized Attributes: Derived from child nodes. 2. Inherited Attributes: Passed from parent or
sibling nodes. Example

Given the grammar rules for arithmetic expressions:

E→E+T

E → TT → T * FT → FF → ( E )F → id
Semantic Actions:

E → E1 + T { E.val = E1.val + T.val; }

E → T { E.val = T.val; }T → T1 * F { T.val = T1.val *

F.val; }T → F { T.val = F.val; }F → ( E ) { F.val =

E.val; }F → id { F.val = id.val; }

For 3 + 4 * 5, the translation process computes values as it parses: 4 * 5 gives 20

3 + 20 gives 23

Benefits

Modularity: Separates parsing and translation. Flexibility: Adaptable for code generation,
optimization, etc. Efficiency: Allows translation during parsing, reducing additional passes.

5.What is a symbol table, and how is it utilized in a compiler?

Ans. An image table is an information structure utilized by compilers to store data about the
factors, capabilities, classes, and different identifiers experienced during the gathering system. It
fills in as a focal store for overseeing image-related information and assumes an essential part in
different periods of the gathering system, including lexical examination, parsing, semantic
investigation, and code age.

Key Parts of an Image Table:

 Image Entry: Every section in the image table compares to a novel identifier in the
source code. It ordinarily incorporates data, for example,
o Name: The identifier's name.
o Type: The information type related to the identifier (e.g., int, float, class name).
o Scope: The extension where the identifier is characterized (e.g., worldwide
degree, capability scope, block scope).
o Memory Area: The memory address or capacity area assigned to the identifier.
o Extra Credits: Different properties like perceivability, access modifiers,
instatement status, and so forth.
 Scope Management: Image tables assist with overseeing extensions in the source code.
They track where identifiers are proclaimed and the way in which they are available
inside various extensions (e.g., worldwide degree, capability scope, block scope). This
 data is vital for name goal and guaranteeing legitimate perceivability and adherence to
perusing rules.
 Type Checking: Image tables store type data related to identifiers. During semantic
examination, compilers utilize the image table to perform type checking, guaranteeing
that tasks and tasks including identifiers are type-protected by the language's standards.
 Mistake Recognition: Image tables help in identifying blunders like vague factors or
redeclaration of identifiers inside a similar degree. By keeping a record of identifiers and
their extensions, compilers can recognize and report such mistakes during the gathering
system.

Use in Compiler Stages:

 Lexical Examination: The image table beginnings populating during lexical examination
as identifiers are experienced in the source code. Sections are made for every identifier
alongside their related qualities.
 Parsing: During parsing, the image table aids name goal and extension the executives. It
guarantees that identifiers are utilized by the perusing rules characterized by the
programming language.
 Semantic Examination: The image table assumes a basic part in semantic examination,
particularly in type checking and trait goal. It verifies the correctness of tasks involving
identifiers based on their sorts and extensions.
 Code Generation: In the code age stage, the image table gives data about memory areas
and information types required for producing machine code or intermediate code. It helps
with allotting memory, getting to factors, and taking care of capability calls.

6.Why are regular expressions used in token specification? Write the regular expres
sion to specify the identifier like in C.

Ans. Regular expressions are utilized in token specification since they give a compact and
adaptable method for depicting examples of characters that structure tokens in a programming
language. With regards to lexical investigation, normal articulations assist with characterizing the
sentence structure rules for distinguishing tokens like identifiers, catchphrases, administrators,
literals, and images. By utilizing ordinary articulations, compilers can proficiently tokenize the
source code, which is a critical stage in the gathering system.

In C, an identifier is normally characterized as a grouping of letters (capitalized or lowercase),

digits, and underscores, beginning with a letter or an underscore. Here is a normal articulation to
determine identifiers in C:

regex
Copy code
[a-zA-Z_][a-zA-Z0-9_]*
Clarification of the standard articulation:

 [a-zA-Z_]: Matches any capitalized letter (A-Z), lowercase letter (a-z), or underscore (_)
as the main person of the identifier.
 [a-zA-Z0-9_]*: Matches at least zero events of capitalized letters (A-Z), lowercase
letters (a-z), digits (0-9), or underscores (_) after the main person.

In this way, the normal articulation [a-zA-Z_][a-zA-Z0-9_]* determines that an identifier in C

should begin with a letter or underscore and can be trailed by any blend of letters, digits, and
underscores.

7.Explain the concept of an abstract stack machine and its use in compiling.

Ans. A theoretical stack machine is a hypothetical model of a PC or computational gadget that

involves a stack as its essential information structure for executing directions. It's classified
"dynamic" since it addresses a worked on form of a genuine machine, zeroing in on the stack-
based tasks ordinarily utilized in programming dialects and compilers. This model is broadly
utilized in accumulating in light of the fact that it gives an effective and organized method for
producing and executing code.

Parts of a Theoretical Stack Machine:

1. Stack: The stack is a Toward the end In-First-Out (LIFO) information structure where
components are pushed onto the highest point of the stack and popped from the top. In a
theoretical stack machine, the stack is utilized to store operands, middle qualities, and
return addresses during program execution.
2. Directions: The theoretical stack machine works in view of a bunch of guidelines, each
playing out a particular procedure on the stack. Normal guidelines incorporate push (to
add a thing to the stack), pop (to eliminate a thing from the stack), number-crunching
tasks (option, deduction, duplication, division), control stream activities (hop, restrictive
leap), and capability call/bring tasks back.
3. Registers: Some theoretical stack machines might incorporate a set number of registers
for putting away brief qualities or tending to explicit memory areas.

Use in Accumulating:

1. Halfway Portrayal: Dynamic stack machines are much of the time utilized as a
moderate portrayal (IR) during the arrangement interaction. Compilers make an
interpretation of source code into a middle language that intently looks like the activities
of a theoretical stack machine. This IR fills in as a scaffold between the significant level
source code and the objective machine code.
2. Advancement: By utilizing a theoretical stack machine as a transitional portrayal,
compilers can apply different enhancements at the IR level. Advancements like consistent
collapsing, dead code disposal, and normal subexpression end can be performed all the
more really on stack-based portrayals.
3. Code Age: When the improvements are applied, the compiler produces target machine
code or bytecode from the theoretical stack machine portrayal. This target code can be
executed straightforwardly on a stack-based virtual machine or further converted into
local machine code for the objective design.
4. Versatility: Dynamic stack machines offer a degree of conveyability since they unique
away the particular subtleties of the hidden equipment engineering. This permits
compilers to produce code that can run on various stages without broad alterations.

8.Given the following string, identify and list all the tokens

for (int i = 0; i < 10; i++) {

printf("%d\n", i);

8. Given the following string, identify and list all the tokens

for (int i = 0; i < 10; i++) {

printf("%d\n", i);

Ans:Given the string:

for (int i = 0; i < 10; i++) {printf("%d\n", i);}

The tokens are:

1. for 2. (

3. int4. i

5. = 6. 0

7. ;

8. i

9. <

10. 10
 11. ;

12. i

13. ++

14. )

15. {

16. printf

17. (

18. "%d\n" 19. , 20. i

21. )

22. ;

23. }

These tokens represent the different elements of the C programming language syntax, such
as

keywords (e.g., for, int), identifiers (e.g., i), operators (e.g., =, <, ++), literals (e.g., 0, 10),
punctuators (e.g., ;, (, ), {, }), and string literals (e.g., "%d\n"). The process of identifying
and extracting these tokens from the source code is

typically

performed by the lexical analysis phase of a compiler or interpreter.

9.Discuss Thompson’s Construction for converting a regular expression to an NFA.

Ans. Thompson's Construction is a technique used to convert a regular expression into a Non-
Deterministic Finite Automaton (NFA). This process is fundamental in the field of formal
languages and automata theory, particularly when designing efficient algorithms for pattern
matching and lexical analysis in compilers. Here is an outline of Thompson's Construction:
Fundamental Concepts:

1. Regular Expressions (RE): Regular expressions are symbolic representations of patterns

that describe sets of strings. They consist of characters, operators, and grouping symbols
that define concatenation, alternation, repetition, and other operations.
2. Non-Deterministic Finite Automaton (NFA): An NFA is a computational model used
to recognize strings that match a given pattern specified by a regular expression. It
consists of states, transitions labeled with symbols or ε (epsilon), and an initial state.

Steps in Thompson's Construction:

1. Base Cases:
o Empty String: If the regular expression is ε (epsilon), create an NFA with two
states: an initial state and an accepting (final) state, connected by an ε-transition.
o Single Character: If the regular expression is a single character 'a', create an NFA
with two states: an initial state with a transition labeled 'a' to an accepting state.
2. Concatenation (AB):
o Given two regular expressions A and B, construct NFAs for A and B individually.
o Create an ε-transition from each accepting state of A to the initial state of B.
3. Alternation (A|B):
o Given two regular expressions A and B, construct NFAs for A and B individually.
o Create a new initial state and ε-transitions from this state to the initial states of A
and B.
o Create ε-transitions from the accepting states of A and B to a new accepting state.
4. *Kleene Star (A)**:
o Given a regular expression A, construct an NFA for A.
o Create a new initial state and ε-transitions from this state to the initial state of A
and to a new accepting state.
o Create ε-transitions from the accepting state of A back to the initial state of A and
to the new accepting state.

Example:

Let's use Thompson's Construction to convert the regular expression (a|b)*c into an NFA.

1. Convert (a|b) into an NFA:

o Construct NFAs for 'a' and 'b' individually.
o Create a new initial state with ε-transitions to the initial states of 'a' and 'b'.
o Create ε-transitions from the accepting states of 'a' and 'b' to a new accepting state.
2. Apply Kleene Star to (a|b):
o Create a new initial state with ε-transitions to the initial state of (a|b) and to a new
accepting state.
o Create ε-transitions from the accepting state of (a|b) back to its initial state and to
the new accepting state.
3. Concatenate (a|b)* with 'c':
 o Create ε-transitions from the accepting state of (a|b)* to a new initial state
representing 'c'.
o Create a transition labeled 'c' from the new initial state to a new accepting state.

The resulting NFA will have states representing different combinations of 'a', 'b', and 'c', with
transitions based on the operations defined by the regular expression (a|b)*c.

Thompson's Construction is robust because it systematically breaks down complex regular

expressions into smaller parts, allowing for the construction of NFAs that efficiently recognize
patterns specified by regular expressions. This NFA can then be further transformed into a
Deterministic Finite Automaton (DFA) for more efficient pattern matching algorithms.

10.Construct an NFA for the regular expression (a|b)*abb. And convert NFA to DFA.

Ans. Here's the step-by-step construction of an NFA for the regular expression (a|b)*abbusing
Thompson's Construction:

1. NFA for a:

(start) --a--> (1) --ε--> (2) --ε--> (accept)

2. NFA for b:

(start) --b--> (3) --ε--> (accept)

3. Alternation for (a|b):

/\

(1) (3)

/\/\

εεεε

\/\/

(start) (accept)

4. Kleene Star for (a|b)*:

εε
/\/\

εεεε

\/\/

(1|3)* (accept)

\/

(start) --ε--> (accept)

11.Explain input buffering and its significance in lexical analysis?

Ans. Input buffering is indeed a crucial strategy in lexical analysis during the compilation process.
It involves reading input characters in blocks or pieces from the source code file or input stream,
storing them in a buffer, and then processing these buffered characters to identify tokens and
lexemes.

Meaning of Input Buffering in Lexical Analysis:

Efficient Input Handling: Input buffering allows the lexical analyzer to read input characters in
larger pieces, reducing the frequency of system calls or disk accesses. This improves the overall
efficiency of input handling during compilation.

Reduced Overhead: By reading characters in blocks and storing them in a buffer, the overhead
of repeatedly fetching individual characters from the input stream is reduced. This can lead to
faster lexical analysis and compilation times.

Tokenization: Input buffering facilitates tokenization, where the buffered characters are
processed to identify tokens and lexemes based on the lexical rules of the programming
language. Tokens represent meaningful units like keywords, identifiers, constants, and operators.

Lookahead and Backtracking: Buffered input allows for lookahead, where the lexical analyzer
can peek ahead in the input stream to make decisions about token boundaries or handle
constructs like comments and string literals that span multiple lines. It also enables backtracking,
where the analyzer can rewind the input buffer to reprocess characters if a token boundary is
misidentified initially.

Error Handling: Buffered input helps in error handling and reporting during lexical analysis. If
an unexpected character or lexical error is encountered, the analyzer can provide more context by
examining the surrounding buffered characters.
Optimized Processing: Many lexical analyzers use buffering to optimize processing, especially
when dealing with input sources like files or network streams. Buffering allows for efficient
reading and processing of input data, improving overall compilation performance.

Memory Management: Input buffering involves managing a buffer to store input characters.
Proper memory management techniques ensure that the buffer is appropriately sized to handle
input without excessive memory consumption or buffer overflows.