Lex/Flex tool overview in Compiler Design - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to specify the section where definitions are placed in a Lex/Flex file.

Compiler Design

%[1]%

Drag options to blanks, or click blank then click option'

Arules

Bdefinitions

Cuser code

Doptions

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing the definitions section with the rules section.

The definitions section in a Lex/Flex file is where you define macros and patterns used later in the rules section.

2fill in blank

medium

Complete the code to write a rule that matches the word 'if' in Lex/Flex.

Compiler Design

"[1]"    { return IF; }

Drag options to blanks, or click blank then click option'

Awhile

Belse

Cif

Dfor

Attempts:

3 left

💡 Hint

Common Mistakes

Using single quotes instead of double quotes.

Writing the keyword without quotes.

In Lex/Flex, rules are written as patterns in quotes. To match the keyword if, you write it as "if".

3fill in blank

hard

Fix the error in the Lex/Flex rule to correctly match an identifier (a letter followed by letters or digits).

Compiler Design

[1]    { return IDENTIFIER; }

Drag options to blanks, or click blank then click option'

A[a-zA-Z][a-zA-Z0-9]*

B[0-9]+

C"[a-zA-Z]+"

D[^a-zA-Z0-9]

Attempts:

3 left

💡 Hint

Common Mistakes

Using only digits in the pattern.

Including quotes around the pattern incorrectly.

The correct pattern for an identifier is a letter followed by zero or more letters or digits, written as [a-zA-Z][a-zA-Z0-9]*.

4fill in blank

hard

Fill both blanks to create a rule that matches whitespace characters and ignores them.

Compiler Design

[1]    { [2]; }

Drag options to blanks, or click blank then click option'

A[ \t\n]+

Breturn

C/* ignore */

D/* skip */

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a token instead of skipping.

Not matching all whitespace characters.

The pattern [ \t\n]+ matches one or more whitespace characters (space, tab, newline). The action /* skip */ indicates to ignore these characters.

5fill in blank

hard

Fill all three blanks to define a Lex/Flex rule that matches a number and converts it to an integer.

Compiler Design

"[1]"    { yylval = atoi(yytext); return [2]; [3] }

Drag options to blanks, or click blank then click option'

A[0-9]+

BNUMBER

C/* convert to int */

Dreturn

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect pattern for numbers.

Forgetting to return the token.

Not converting the text to integer.

The pattern [0-9]+ matches one or more digits. The action converts the matched text to an integer using atoi, returns the token NUMBER, and includes a comment for clarity.

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