Symbol table design and management in Compiler Design - Mini Project: Build & Apply

Symbol Table Design and Management

📖 Scenario: You are designing a simple symbol table for a compiler. The symbol table will store variable names and their data types as the compiler processes a program.This helps the compiler check if variables are declared before use and what type they have.

🎯 Goal: Build a basic symbol table using a dictionary to store variable names and their types, add a configuration for allowed data types, insert variables with their types, and finalize the table with a method to check if a variable exists.

📋 What You'll Learn

Create a dictionary called symbol_table with three variables and their types

Create a list called allowed_types with 'int', 'float', and 'string'

Add a new variable to symbol_table only if its type is in allowed_types

Add a function is_declared that checks if a variable name exists in symbol_table

💡 Why This Matters

🌍 Real World

Symbol tables are used in compilers and interpreters to keep track of variables, their types, and scopes during program analysis and code generation.

💼 Career

Understanding symbol table design is essential for compiler developers, language designers, and software engineers working on tools that analyze or transform code.

1

Create the initial symbol table

Create a dictionary called symbol_table with these exact entries: 'x': 'int', 'y': 'float', and 'name': 'string'.

Compiler Design

# Create the symbol_table dictionary with given variables and types
# Your code here

Hint

Use curly braces to create a dictionary with keys as variable names and values as their types.

2

Define allowed data types

Create a list called allowed_types containing the strings 'int', 'float', and 'string'.

Compiler Design

symbol_table = {'x': 'int', 'y': 'float', 'name': 'string'}
# Create the allowed_types list with 'int', 'float', and 'string'
# Your code here

Hint

Use square brackets to create a list of allowed data types.

3

Add a variable with type check

Add a new variable 'z' with type 'int' to symbol_table only if 'int' is in allowed_types.

Compiler Design

symbol_table = {'x': 'int', 'y': 'float', 'name': 'string'}
allowed_types = ['int', 'float', 'string']
# Add 'z' with type 'int' to symbol_table only if 'int' is allowed
# Your code here

Hint

Use an if statement to check if 'int' is in allowed_types before adding 'z'.

4

Add a function to check variable declaration

Define a function called is_declared that takes a variable name var and returns True if var is a key in symbol_table, otherwise False.

Compiler Design

symbol_table = {'x': 'int', 'y': 'float', 'name': 'string'}
allowed_types = ['int', 'float', 'string']
if 'int' in allowed_types:
    symbol_table['z'] = 'int'
# Define is_declared function to check if a variable is in symbol_table
# Your code here

Hint

Use the in keyword to check if the variable name exists in the dictionary keys.

Practice

1. What is the primary purpose of a symbol table in a compiler?

easy

A. To optimize the program's runtime speed

B. To execute the program code

C. To store names of variables, functions, and their attributes

D. To display the program's output

Solution

1. Step 1: Understand the role of a symbol table

   A symbol table is used by a compiler to keep track of identifiers like variable names and function names along with their details such as type and scope.

2. Step 2: Differentiate from other compiler tasks

   Executing code, optimizing speed, or displaying output are handled by other parts of the compiler or runtime, not the symbol table.

3. Final Answer:

   To store names of variables, functions, and their attributes -> Option C

4. Quick Check:

   Symbol table = stores names and details [OK]

Hint: Symbol table stores names and info, not runs code [OK]

Common Mistakes:

• Confusing symbol table with code execution
• Thinking symbol table handles output display
• Assuming symbol table optimizes runtime

2. Which of the following is the correct operation supported by a symbol table?

easy

A. Compiling source code into machine code

B. Inserting a new identifier with its attributes

C. Running the program in a virtual machine

D. Formatting the source code for readability

Solution

1. Step 1: Identify symbol table operations

   Symbol tables support operations like inserting new identifiers, looking them up, and removing them.

2. Step 2: Exclude unrelated operations

   Compiling code, running programs, or formatting source code are tasks outside the symbol table's scope.

3. Final Answer:

   Inserting a new identifier with its attributes -> Option B

4. Quick Check:

   Symbol table operation = insert identifier [OK]

Hint: Symbol table inserts and looks up names, not compiles code [OK]

Common Mistakes:

• Mixing symbol table with compiler backend tasks
• Thinking symbol table runs or formats code
• Confusing symbol table with code execution environment

3. Consider a symbol table that uses a hash table for storage. What is the expected time complexity for looking up an identifier?

medium

A. O(1), average case due to hashing

B. O(log n), using binary search

C. O(n^2), due to collisions

D. O(n), where n is the number of identifiers

Solution

1. Step 1: Understand hash table lookup

   Hash tables provide average constant time O(1) lookup by computing a hash and accessing the bucket directly.

2. Step 2: Consider collision handling

   While collisions can degrade performance, good hash functions and resizing keep average lookup at O(1).

3. Final Answer:

   O(1), average case due to hashing -> Option A

4. Quick Check:

   Hash table lookup = O(1) average [OK]

Hint: Hash tables give average O(1) lookup time [OK]

Common Mistakes:

• Assuming lookup is always O(n)
• Confusing hash tables with sorted arrays
• Ignoring average case vs worst case

4. A compiler's symbol table is not correctly handling nested scopes. Which of the following is a likely cause?

medium

A. Using a single global table without scope management

B. Using a hash table for storage

C. Storing variable types along with names

D. Inserting identifiers in alphabetical order

Solution

1. Step 1: Understand scope management in symbol tables

   Nested scopes require separate handling, often with a stack or linked tables to manage visibility.

2. Step 2: Identify the problem cause

   Using a single global table without scope separation causes conflicts and incorrect lookups for nested scopes.

3. Final Answer:

   Using a single global table without scope management -> Option A

4. Quick Check:

   Scope errors = missing nested scope handling [OK]

Hint: Nested scopes need separate tables or stack [OK]

Common Mistakes:

• Blaming hash tables for scope issues
• Ignoring the need for scope separation
• Thinking alphabetical order affects scope

5. You need to design a symbol table that supports fast insertion, lookup, and also manages multiple nested scopes efficiently. Which data structure approach is best suited?

hard

A. An array sorted by identifier names

B. A single flat hash table for all scopes

C. A linked list of all identifiers without hashing

D. A stack of hash tables, one per scope

Solution

1. Step 1: Analyze requirements for nested scopes

   Managing nested scopes requires keeping track of identifiers per scope and allowing shadowing and removal when exiting a scope.

2. Step 2: Evaluate data structure options

   A stack of hash tables allows pushing a new table on entering a scope and popping it on exit, enabling fast insertion and lookup per scope.

3. Step 3: Exclude less efficient options

   A single flat table cannot separate scopes well; linked lists are slow; sorted arrays have slower insertion and lookup.

4. Final Answer:

   A stack of hash tables, one per scope -> Option D

5. Quick Check:

   Nested scopes = stack of hash tables [OK]

Hint: Use stack of hash tables for nested scopes [OK]

Common Mistakes:

• Using one global table for all scopes
• Choosing linked lists causing slow lookup
• Sorting arrays which slows insertion