### 1) *Compiler: Role, Advantages, and ### 4) *Parse Tree: Rules, Example, and Uses*

Disadvantages* A *parse tree* represents the syntactic structure of a

A *compiler* is a software program that translates high source code statement.
-level source code into machine code, enabling #### *Rules for Constructing a Parse Tree:*
execution by a computer. It performs lexical analysis, 1. Each internal node represents a grammar rule.
syntax analysis, semantic analysis, optimization, and 2. Leaves are tokens from the input string.
code generation. 3. The root represents the start symbol.
#### *Role of a Compiler:* #### *Example:*
- Translates human-readable code into machine- For a + b * c, the parse tree follows operator
understandable instructions. precedence:
- Detects syntax and semantic errors during +
compilation. /\
- Optimizes code for better performance. a *
#### *Advantages:* /\
- Faster execution since compiled programs run directly b c
on hardware. #### *Uses:*
- Detects errors before execution, preventing runtime - Helps in syntax checking and error detection.
crashes. - Used in compiler optimizations.
- Code optimization improves efficiency. - Aids in code generation and translation.
#### *Disadvantages:*
- Compilation time can be long for large programs. ### 5) *Bootstrapping: Definition, Uses, and
- Debugging is harder because errors are reported after Advantages*
compilation. *Bootstrapping* in compilers refers to the process of
- Platform-dependent; compiled code may not run on writing a compiler in the same programming language
different architectures. it compiles.
#### *Uses of Bootstrapping:*
### 2) *Types of Compilers* - Helps in self-hosting a compiler for new languages.
Compilers can be categorized based on how they - Allows gradual improvements without external
process code: dependencies.
1. *Single-Pass Compiler* – Processes the source code - Enables automatic testing and debugging of
in one pass (e.g., Pascal Compiler). compiler features.
2. *Multi-Pass Compiler* – Goes through multiple #### *Advantages:*
phases for optimization and error checking (e.g., GCC). - Makes compiler development more flexible.
3. *Just-In-Time (JIT) Compiler* – Compiles code at - Reduces reliance on manually written assembly or
runtime (e.g., Java’s JVM). machine code.
4. *Cross Compiler* – Generates executable code for a - Ensures consistency in language evolution and
platform different from the one it runs on. extensions.
5. *Incremental Compiler* – Compiles only modified Example: The C compiler (GCC) was initially written in
portions of code instead of the whole program. assembly but later rewritten in C.
6. *Threaded Code Compiler* – Converts code into a
sequence of calls to predefined routines. ### 9) *Difference Between Compiler and Interpreter*
| Feature | Compiler | Interpreter
### 3) *Compiler Phases with Example* |
A compiler works in *six phases*: |------------------|--------------------------------|--------------------------------|
1. *Lexical Analysis* – Converts source code into | *Execution* | Translates entire code before running
tokens. | Translates code line-by-line |
- Example: int a = 10; → Tokens: (int, a, =, 10, ;) | *Speed* | Faster, as execution happens after
2. *Syntax Analysis (Parsing)* – Checks grammatical compilation | Slower, since translation happens at
correctness. runtime |
- Example: int a 10; → Error due to missing = | *Error Handling* | Detects all errors at once after
3. *Semantic Analysis* – Ensures logical correctness. compilation | Detects errors one by one during
- Example: float a = "hello"; → Error due to type execution |
mismatch | *Output* | Generates an executable file | No
4. *Intermediate Code Generation* – Converts code separate executable file |
into an intermediate form. | *Examples* | C, C++ compilers (GCC) | Python,
- Example: a = b + c; → t1 = b + c; a = t1; JavaScript interpreters |
5. *Optimization* – Enhances efficiency by removing Compilers are best for performance-critical
redundancies. applications, while interpreters are better for rapid
- Example: x = 2 * 4; → x = 8; development and debugging.
6. *Code Generation* – Produces final machine code
for execution.

### 6) *What is Lex in Compiler Design?*

*Lex* is a lexical analyzer generator used to create
tokenizers. It processes input text, identifies patterns,
and generates corresponding tokens for a compiler’s
lexical analysis phase.
#### *Features of Lex:*
- Converts input source code into a sequence of
tokens.
- Uses regular expressions to define token patterns.
- Works with YACC (Yet Another Compiler Compiler) for
syntax parsing.
Example Lex rule:

[a-zA-Z]+ { printf("IDENTIFIER"); }
[0-9]+ { printf("NUMBER"); }

This detects words as identifiers and digits as

numbers.

### 7) *Function of Lex*

Lex performs lexical analysis by:
1. *Reading Input* – Scans the source code as a
stream of characters.
2. *Tokenizing* – Recognizes keywords, operators, and
literals.
3. *Pattern Matching* – Uses regular expressions to
define token structures.
4. *Removing Whitespace and Comments* – Ignores
irrelevant characters to optimize parsing.
5. *Generating Token Stream* – Outputs tokens for
syntax analysis.
Lex simplifies compiler design by automating the
tokenization process.

### 8) *Interpreter: Role, Advantages, and

Disadvantages*
An *interpreter* executes source code directly,
translating it line-by-line instead of compiling it first.
#### *Role of an Interpreter:*
- Reads and executes code at runtime without
producing machine code.
- Provides immediate feedback, making debugging
easier.
- Commonly used in scripting languages like Python
and JavaScript.
#### *Advantages:*
- No compilation step, enabling faster development.
- Easier debugging as errors stop execution
immediately.
- Platform-independent since source code is interpreted
dynamically.
#### *Disadvantages:*
- Slower execution compared to compiled programs.
- Requires the interpreter to run the program.
- Not optimized for performance.