Scope resolution in Compiler Design - Mini Project: Build & Apply

Understanding Scope Resolution

📖 Scenario: Imagine you are designing a simple programming language. You need to understand how variables are found when there are multiple places they could be defined. This is called scope resolution. It helps the computer know which variable to use when there are several with the same name.

🎯 Goal: You will build a simple example that shows how to find the right variable value by checking different scopes step-by-step.

📋 What You'll Learn

Create a dictionary called global_scope with variables and their values.

Create a dictionary called local_scope with variables and their values.

Write a function called resolve_variable that takes a variable name and returns its value by first checking local_scope, then global_scope.

Add a final test call to resolve_variable for a variable and store the result in result.

💡 Why This Matters

🌍 Real World

Scope resolution is a key concept in programming languages and compilers to decide which variable to use when names overlap.

💼 Career

Understanding scope resolution helps in debugging code, designing programming languages, and working with compilers or interpreters.

1

Create the global scope dictionary

Create a dictionary called global_scope with these exact entries: 'x': 10, 'y': 20, and 'z': 30.

Compiler Design

# Create the global_scope dictionary with variables and values
# Your code here

Hint

Use curly braces {} to create a dictionary with keys and values.

2

Create the local scope dictionary

Create a dictionary called local_scope with these exact entries: 'x': 100 and 'a': 50.

Compiler Design

global_scope = {'x': 10, 'y': 20, 'z': 30}
# Create the local_scope dictionary with variables and values
# Your code here

Hint

Remember, local variables can have the same names as global variables but different values.

3

Write the scope resolution function

Write a function called resolve_variable that takes a parameter var_name. It should return the value from local_scope if var_name exists there; otherwise, return the value from global_scope. If the variable is not found in either, return None.

Compiler Design

global_scope = {'x': 10, 'y': 20, 'z': 30}
local_scope = {'x': 100, 'a': 50}
# Define the resolve_variable function below
# Your code here

Hint

Check local_scope first, then global_scope. Use if, elif, and else statements.

4

Test the scope resolution and store the result

Call the function resolve_variable with the argument 'x' and store the returned value in a variable called result.

Compiler Design

global_scope = {'x': 10, 'y': 20, 'z': 30}
local_scope = {'x': 100, 'a': 50}

def resolve_variable(var_name):
    if var_name in local_scope:
        return local_scope[var_name]
    elif var_name in global_scope:
        return global_scope[var_name]
    else:
        return None

# Call resolve_variable with 'x' and store the result
# Your code here

Hint

Use the function name exactly and assign its output to result.

Practice

1. What is the main purpose of the :: operator in scope resolution?

easy

A. To specify which scope a variable or function belongs to

B. To declare a new variable

C. To perform arithmetic operations

D. To create a loop

Solution

1. Step 1: Understand the role of scope resolution

   The :: operator is used to access variables or functions that belong to a specific scope, especially when multiple scopes have the same name.

2. Step 2: Identify the correct use of ::

   It helps avoid confusion by explicitly stating which scope to use, such as a global variable or a class member.

3. Final Answer:

   To specify which scope a variable or function belongs to -> Option A

4. Quick Check:

   Scope resolution operator = specify scope [OK]

Hint: Remember :: means 'from this scope' [OK]

Common Mistakes:

• Confusing :: with assignment operator
• Thinking it declares variables
• Using it for arithmetic

2. Which of the following is the correct syntax to access a global variable named x inside a function when a local variable with the same name exists?

easy

A. global x

B. ::x

C. global::x

D. ::x

Solution

1. Step 1: Identify the correct scope resolution syntax

   In many languages like C++, the global scope resolution operator is :: placed before the variable name to access the global variable.

2. Step 2: Choose the syntax that correctly uses the operator

   The correct syntax is ::x to access the global variable x inside a function where a local x exists.

3. Final Answer:

   ::x -> Option B

4. Quick Check:

   Global variable access = ::x [OK]

Hint: Use :: before variable for global access [OK]

Common Mistakes:

• Using 'global x' which is not scope resolution
• Writing 'global::x' which is invalid syntax
• Omitting the operator

3. Consider the following code snippet:

int x = 10;
void func() {
  int x = 20;
  print(::x);
}

What will be printed when func() is called?

medium

A. 20

B. 0

C. 10

D. Error

Solution

1. Step 1: Identify the scopes of variable x

   There is a global x with value 10 and a local x inside func() with value 20.

2. Step 2: Understand ::x usage in print(::x)

   The ::x accesses the global x, ignoring the local one.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Scope resolution prints global x = 10 [OK]

Hint: <::x> always means global variable [OK]

Common Mistakes:

• Printing local x instead of global
• Confusing syntax causing error
• Assuming default prints local variable

4. Identify the error in the following code snippet:

int x = 5;
void func() {
  int x = 10;
  print(x::);
}

medium

A. Incorrect use of scope resolution operator

B. Variable redeclaration error

C. Missing semicolon

D. No error

Solution

1. Step 1: Analyze the syntax of scope resolution operator

   The scope resolution operator :: must precede the variable or function name, not follow it.

2. Step 2: Identify the incorrect usage in print(x::);

   Here, x:: is invalid syntax; it should be ::x to access global scope or just x for local.

3. Final Answer:

   Incorrect use of scope resolution operator -> Option A

4. Quick Check:

   Operator must be before variable [OK]

Hint: Scope operator goes before name, not after [OK]

Common Mistakes:

• Placing :: after variable name
• Confusing with member access operator
• Ignoring syntax rules

5. Given two nested namespaces:

namespace Outer {
  int value = 100;
  namespace Inner {
    int value = 200;
    int getValue() {
      return Outer::value + value;
    }
  }
}

What will Outer::Inner::getValue() return?

hard

A. Compilation error

B. 200

C. 100

D. 300

Solution

1. Step 1: Identify values in each namespace

   Outer::value is 100, and Inner::value is 200.

2. Step 2: Calculate the return value of getValue()

   The function returns Outer::value + value, where value refers to Inner::value. So, 100 + 200 = 300.

3. Final Answer:

   300 -> Option D

4. Quick Check:

   Outer + Inner values = 300 [OK]

Hint: Add outer and inner values using scope operator [OK]

Common Mistakes:

• Assuming only inner value is returned
• Confusing namespaces and scopes
• Expecting compilation error due to nested namespaces