W1201 Scope

From Coder Merlin
Jump to navigation Jump to search
Scope

Prerequisites[edit]

Research[edit]

Introduction[edit]

The lifetime of a variable is the time period in which the variable has memory allocated to it and may legitimately be referenced.

The scope of a declaration is that part of the code in which the declaration is in effect. Scope is closely related to binding, the association of a particular name (string of characters) to a specific object within a specific context.[1]

The visibility of a declaration refers to that part of the code in which the declaration is accessible (not hidden) by an identical declaration in another scope.

To best understand these terms, we'll look at several examples below. Beforehand, however, let's revisit our discussion about L-Values.

ComingSoonIcon.png
Coming Soon
  • Discussion regarding scope of functions and function invocation

Not All L-Values are Created Equal[edit]

Typical Memory Layout

Review our previous discussion about W1038 L-Values and R-Values. It's clear that the defining difference is that L-Values persist beyond a single expression, and are addressable somewhere in main memory. The big question is, where? To better understand this, we'll need to take a deeper look at the typical memory layout of a program.

Program Memory Layout[edit]

TEXT[edit]

Program memory is divided into several different sections, often called segments. Logically, every program must have a least one segment, the executable code itself. This is typically stored as read-only (i.e. it may not be modified) and is referred to as "TEXT".

func f() {
    print("Hello, World!")
}

DATA[edit]

The next segment is referred to as "DATA". It contains initialized memory, generally global or static variables assigned a specific value. The values themselves are actually stored in the TEXT segment and copied to the DATA segment during program startup. This segment is read-write.

let x = 7

BSS[edit]

The "BSS" segment contains uninitialized memory, generally global or static variables which have not been assigned a specific value. This segment is read-write.

let x : Int

The remainder of memory is read-write and managed dynamically, likely changing frequently as the program executes. It's divided into two main areas.

The Heap[edit]

The heap area begins where the DATA and BSS segments end. Memory is allocated dynamically within this area, as needed.

The Stack[edit]

The stack area begins from a high-point in memory and usually grows downward, toward the heap. It's a very important structure and is responsible for the orderly execution of function invocations. The stack area is organized into a series of frames, one for each function invocation. The frame contains the return address, i.e. the location in memory to which the function will return when it completes execution, as well as any local variables, parameters and the return-value.


L-Value Storage[edit]

While L-Values can be stored in a variety of locations, for our current purposes we'll only consider storage on the stack. Remember that each time a function is invoked a new stack frame is established on the stack. Thus, each invocation of a function includes its own separate and distinct set of variables.

Experiment[edit]

Create a directory within your "project" directory.

cd ~/projects
mkdir project-1201
cd project-1201

Edit a new file named "main.swift"

emacs main.swift

For each question, be sure to understand the behavior before proceeding to the next question. It will be helpful to record your answers and reasoning for later review.

HintIcon.png
Helpful Hint
For this project you'll repeatedly edit the same file. It's probably easiest to test this file within emacs by using the async-shell-command and observing the results. The async-shell-command can be executed with ALT-SHIFT-7. The command to execute each time is: swift main.swift


1

let x = 10
print(x)

What is output? (Ignore whitespace)

23
Compile or runtime error
21
10

2

let x = 10
print(x)
print(y)

What is output? (Ignore whitespace)

21 23
Compile or runtime error
10 10
10 21

3

let x = 10
print(x)
let x = 21
print(x)

What is output? (Ignore whitespace)

10 10
21 23
10 21
Compile or runtime error

4

let x = 10
print(x)
var x = 21
print(x)

What is output? (Ignore whitespace)

Compile or runtime error
21 23
10 21
10 10

5

let x = 10
print(x)
do {
    let x = 21
    print(x)
} //

Compile or runtime error
10 21
21 21
10 10

6

let x = 10
print(x)
do {
    let x = 21
    print(x)
} //
print(x)

10 21 10
10 21 21
Compile or runtime error
10 10 10

7

let x = 10
print(x)
repeat {
    let x = 21
    print(x)
} while x == 21
print(x)

Compile or runtime error
10 21 21
10 21 10
Infinite loop

8

let x = 10
print(x)
while x == 21 {
    let x = 21
    print(x)
} //
print(x)

10 21 10
Infinite loop
Compile or runtime error
10 10

9

let x = 10
print(x)
for x in 11 ... 11 {
    print(x)
    let x = x + 10
    print(x)
} //
print(x)

Compile or runtime error
10 11 21 10
Infinite loop
10 10 20 10

10

let x = 10
print(x)
for x in 11 ... 11 {
    print(x)
    x = x + 10
    print(x)
} //
print(x)

Compile or runtime error
10 10 20 10
Infinite loop
10 11 21 10


KeyConceptsIcon.png
Key Concepts
  • The lifetime of a variable is the time period in which the variable has memory allocated to it and may legitimately be referenced.
  • The scope of a declaration is that part of the code in which the declaration is in effect.
  • The visibility of a declaration refers to that part of the code in which the declaration is accessible (not hidden) by an identical declaration in another scope.
  • Program Memory Layout
    • TEXT - A read-only segment containing the executable code
    • DATA - A read-write segment containing initialized memory
    • BSS - A read-write segment containing uninitialized memory
    • Heap - Dynamically allocated, read-write memory
    • Stack - Manages orderly execution of function invocations containing the return address, parameters, local variables, and the return value

References[edit]

  1. James Cheney. Toward a General Theory of Names, Binding and Scope. MERLIN’05 September 30, 2005, Tallinn, Estonia.


Designed with pride in Silicon Valley, CA, USA