Lex/Flex tool overview in Compiler Design - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary purpose of Lex/Flex?

Lex/Flex is a tool used in compiler design. What is its main function?

A To parse tokens into a syntax tree

B To optimize machine code for faster execution

C To generate lexical analyzers that break input text into tokens

D To generate executable binary files from source code

💡 Hint

Think about the first step in processing source code in a compiler.

Lex/Flex generates lexical analyzers, also called scanners, which read input text and split it into meaningful pieces called tokens. This is the first step in compiling source code.

📋 Factual

intermediate

Which language is used to write Lex/Flex specifications?

Lex/Flex specifications combine patterns and actions. What language are the actions written in?

A C or C++

B Java

C Python

D Assembly

💡 Hint

Lex/Flex was originally designed to work with a specific programming language.

Lex and Flex generate C code for lexical analyzers, so the actions in the specification are written in C or C++.

🔍 Analysis

advanced

What happens if a Lex/Flex pattern matches multiple rules?

If two or more patterns in a Lex/Flex specification match the same input text, how does Lex/Flex decide which action to execute?

A It chooses the rule that appears first in the specification

B It raises a syntax error and stops

C It chooses the rule with the shortest pattern

D It chooses the rule that matches the longest input text

💡 Hint

Lex/Flex always tries to match as much input as possible.

Lex/Flex uses the longest match rule: it selects the pattern that matches the longest portion of the input text. If there is a tie, it chooses the rule that appears first.

❓ Comparison

advanced

How does Flex differ from the original Lex tool?

Flex is a modern alternative to Lex. Which of the following is a key difference?

A Flex is open source and faster than the original Lex

B Flex only supports Java actions, Lex supports C

C Flex cannot generate scanners for multiple languages

D Flex requires manual memory management unlike Lex

💡 Hint

Consider licensing and performance improvements.

Flex is an open-source tool that is generally faster and more flexible than the original proprietary Lex tool.

❓ Reasoning

expert

What is the output of this Lex/Flex specification snippet?

Given the following Lex/Flex rules, what will be the output when the input text is "abc123"? %{ #include %} %% [a-z]+ { printf("Word\n"); } [0-9]+ { printf("Number\n"); } . { /* ignore other characters */ } %% int main() { yylex(); return 0; }

Compiler Design

%{
#include <stdio.h>
%}

%%
[a-z]+    { printf("Word\n"); }
[0-9]+    { printf("Number\n"); }
.        { /* ignore other characters */ }
%%

int main() {
  yylex();
  return 0;
}

A

Number
Number
Word

B

Word
Number

C

Number
Word

D

Word
Word
Number

💡 Hint

Lex/Flex matches the longest possible token at each step.

The input "abc123" is scanned left to right. The pattern [a-z]+ matches "abc" first, printing "Word". Then [0-9]+ matches "123", printing "Number".

Practice

1. What is the primary purpose of the Lex/Flex tool in compiler design?

easy

A. To optimize the compiled program

B. To generate machine code from source code

C. To break input text into meaningful tokens

D. To manage memory allocation during execution

Solution

1. Step 1: Understand Lex/Flex role

   Lex/Flex is a tool used to scan input text and split it into tokens based on patterns.

2. Step 2: Differentiate from other compiler parts

   Generating machine code and optimization are done by other compiler stages, not Lex/Flex.

3. Final Answer:

   To break input text into meaningful tokens -> Option C

4. Quick Check:

   Lex/Flex = Tokenizer [OK]

Hint: Lex/Flex splits text into tokens, not code generation [OK]

Common Mistakes:

• Confusing Lex/Flex with code generator
• Thinking Lex/Flex optimizes code
• Assuming Lex/Flex manages memory

2. Which of the following is the correct way to define a pattern in a Lex/Flex file?

easy

A. action { pattern }

B. action : pattern

C. pattern -> action

D. pattern { action }

Solution

1. Step 1: Recall Lex/Flex syntax

   In Lex/Flex, patterns are written first, followed by actions enclosed in braces.

2. Step 2: Verify option formats

   Only pattern { action } matches the correct syntax: pattern { action }

3. Final Answer:

   pattern { action } -> Option D

4. Quick Check:

   Pattern before action with braces [OK]

Hint: Pattern comes first, then action in braces [OK]

Common Mistakes:

• Reversing pattern and action order
• Using colons or arrows incorrectly
• Placing action outside braces

3. Given the Lex/Flex rule:
[0-9]+ { printf("Number: %s\n", yytext); }
What will be printed when the input is 123abc?

medium

A. Number: 123abc

B. Number: 123

C. Number: abc

D. No output

Solution

1. Step 1: Understand the pattern

   The pattern [0-9]+ matches one or more digits only, so it matches '123' at the start.

2. Step 2: Analyze input processing

   Lex/Flex matches '123' and executes the action printing 'Number: 123'. The 'abc' part does not match this pattern.

3. Final Answer:

   Number: 123 -> Option B

4. Quick Check:

   Digits matched only = Number: 123 [OK]

Hint: Pattern matches digits only, stops before letters [OK]

Common Mistakes:

• Assuming whole input matches pattern
• Including letters in digit pattern
• Expecting no output for partial matches

4. Identify the error in this Lex/Flex rule:
[a-z]+ printf("Word: %s\n", yytext);

medium

A. Missing braces around the action

B. Pattern syntax is incorrect

C. Missing semicolon after pattern

D. yytext is undefined

Solution

1. Step 1: Check rule syntax

   Lex/Flex requires actions to be enclosed in braces { } after the pattern.

2. Step 2: Identify missing braces

   The given rule lacks braces around the printf action, causing a syntax error.

3. Final Answer:

   Missing braces around the action -> Option A

4. Quick Check:

   Actions need braces { } [OK]

Hint: Always put actions inside braces { } [OK]

Common Mistakes:

• Omitting braces for single actions
• Confusing pattern syntax with action syntax
• Assuming semicolon needed after pattern

5. How can you modify a Lex/Flex rule to ignore whitespace characters (spaces, tabs) while scanning input?

hard

A. [ \t\n]+ { /* do nothing to skip whitespace */ }

B. [ \t\n]+ { printf("Whitespace found\n"); }

C. [a-z]+ { /* skip whitespace here */ }

D. Whitespace cannot be ignored in Lex/Flex

Solution

1. Step 1: Understand whitespace handling

   To ignore whitespace, define a pattern matching spaces, tabs, newlines with an empty action.

2. Step 2: Check options for correct ignoring

   [ \t\n]+ { /* do nothing to skip whitespace */ } matches whitespace characters and has an empty action, effectively skipping them.

3. Final Answer:

   [ \t\n]+ { /* do nothing to skip whitespace */ } -> Option A

4. Quick Check:

   Empty action skips matched whitespace [OK]

Hint: Use empty action for whitespace pattern to skip [OK]

Common Mistakes:

• Printing message instead of skipping
• Using wrong pattern for whitespace
• Believing whitespace cannot be ignored