CSC447

Scope

• Scope of an identifier
  • region of text in which it may be used

Common Scope Rules

• x is in scope after its declaration until end of block

#include <stdio.h>
int x = 4;
int main () {
  printf ("x=%d\n", x);
  int x = 5;
  printf ("x=%d\n", x);
}

x=4
x=5

Common Scope Rules

• x is in scope for the entire block

val x = 4
def f () = 
  println (x)
  val x = 5
  println (x)

-- [E039] Reference Error: -----------------------------------------------------
2 |  println (x)
  |           ^
  |           x is a forward reference extending over the definition of x

Terminology: Occurrences

• Occurrences of identifiers classified as one of
  • free occurrence has no matching binding

    y = 5*x;   // Free occurrences of x and y

  • binding occurrence declares the identifier

    int y;    // binding occurrence of y

  • bound occurrence follows matching declaration

    int y;    // Binding occurrence of y
    int x;    // Binding occurrence of x
    
    x=6;      // Bound occurrence of x
    y = 5*x;  // Bound occurrences of x and y

Terminology: Occurrences

• Complete programs usually have no free occurrences
• Dynamic languages often that the convention that free occurrences are bound at top level

def declareX():
    global x
    x = 0

def useX():
    x 

useX() # runtime error
declareX()
useX() # no problems 

Scope

• Area of the text of a program where a binding holds
• Static/Compile-time concept

def makeList (len : Int, factor : Int, addend : Int) : List[Int] =
  val xs = (0 to len).map(x => x * factor + addend).toList
  xs
def main () =
  val as = makeList (5, 10, 11)
  println (as)

Lifetime

• Period during which a value exists
• Dynamic/Run-time concept

def makeList (len : Int, factor : Int, addend : Int) : List[Int] =
  val xs = (0 to len).map(x => x * factor + addend).toList
  xs
def main () =
  val as = makeList (5, 10, 11)
  println (as)

Closures

• Runtime support for nested functions
  • particularly when lifetimes do not nest

def mkCounter () = 
  var x = -1
  val count = 
    () => 
      x = x + 1
      x
  count
val c = mkCounter()
val x = c()
val y = c()
val z = c()

...
val x: Int = 0
val y: Int = 1
val z: Int = 2

Top-Level Functions

• Function declarations made at top level
• Not hidden by scope

int loop (int n, int result) {
  if (n <= 1) {
    return result;
  } else {
    return loop (n - 1, n * result);
  }
}
int fact (int n) {
  return loop (n, 1);
}

Nested Functions - GCC

• Nested functions allow for reuse of inner function name
• Allowed by GCC, but not C standard

int fact (int n) {
  int loop (int n, int result) {
    if (n <= 1) {
      return result;
    } else {
      return loop (n - 1, n * result);
    }
  }
  return loop (n, 1);
}

$ gcc -c nested-fact.c 
$ gcc -pedantic -c nested-fact.c 
function.c: In function ‘fact’:
function.c:2:3: warning: ISO C forbids nested functions [-pedantic]

Nested Functions - GCC

• Access variables from enclosing context
  • requires some runtime support

int fact (int n) {
  int loop (int i, int result) {
      if (i > n) {
      return result;
    } else {
      return loop (i+1, i * result);
    }
  }
  return loop (1, 1);
}

Nested Functions - Scope vs Lifetime

• Limit scope of inner function
• Lifetime of inner function vs lifetime of outer function?
• Potentially unsafe, and requires more runtime support
  • more support than accessing variables from enclosing function

Nested Functions - GCC

• From GCC Nested Functions (GCC extensions)

• Lifetime problems!
• Lexical Closures for C++ (T. M. Breuelm, 1988)

Nested Functions - GCC

• Lifetime problems caused by nested functions

#include <stdio.h>
#include <stdlib.h>
typedef void (*funcptr) (int);
funcptr f (int x) {
  void g (int y) {
    printf ("x = %d, y = %d\n", x, y);
  }
  g (1);
  return &g;
}
int main (void) {
  funcptr h = f (10);
  (*h) (2);
  f (20);
  (*h) (3);
}

Nested Functions - GCC

• Unsafe calls may or may not work

$ gcc -std=c99 nested-gcc.c
$ ./a.out
x = 10, y = 1 <- safe to call g, with x=10
x = 10, y = 2 <- unsafe to call h, created with x=10, GOOD!
x = 20, y = 1 <- safe to call g
x = 20, y = 3 <- unsafe to call h, created with x=10, BAD!

Nested Function - Clang

• Clang and LLVM
• Apple's Blocks extension to C = nested functions
  • Ars Technica - Snow Leopard review (2009)
  • Apple Developer Library: Introduction to Blocks
• Applications (iOS and OSX)
  • Graphical user interface callbacks
  • Collections processing
  • Concurrent tasks

Nested Function - Clang

#include <stdio.h>
#include <stdlib.h>
#include <Block.h>
// ^funcptr for blocks; *funcptr for function pointers
typedef void (^funcptr) (int);
funcptr f (int x) {
  funcptr g;
  g = ^(int y) {
    printf ("x = %d, y = %d\n", x, y); // use x from enclosing defn
  };
  g = Block_copy (g);
  g (1); // OK, f's activation record still allocated
  return g;
}
int main (void) {
  funcptr h = f (10);
  h (2); // OK, because of Block_copy
  f (20);
  h (3); // OK, because of Block_copy
  Block_release	(h);
}

Nested Function - Clang

• Blocks support is not turned on by default on Ubuntu

$ sudo apt-get install libblocksruntime-dev

• Correct output

$ clang -fblocks nested-clang.c -lBlocksRuntime
$ ./a.out
x = 10, y = 1
x = 10, y = 2
x = 20, y = 1
x = 10, y = 3 <- safe to call h, created with x=10, GOOD!

Nested Function - Clang

• Without Block_copy and Block_release

$ clang -fblocks nested-clang.c -lBlocksRuntime
$ ./a.out 
x = 10, y = 1
x = -1035955720, y = 2  <- unsafe to call h, created with x=10, BAD!
x = 20, y = 1
x = -1035955720, y = 3  <- unsafe to call h, created with x=10, BAD!

Nested Function - Swift

• Nested functions work correctly in Swift

func f (_ x:Int) -> (Int) -> () {
  func g (_ y:Int) -> () { print ("x = " + String(x) + " y = " + String(y)) }
  g (1)
  return g
}
func main () {
  let h = f (10)
  h (2)
  let _ = f (20)
  h (3)
}
main()

$ swiftc nested-swift.swift 
$ ./nested-swift
x = 10 y = 1
x = 10 y = 2
x = 20 y = 1
x = 10 y = 3

Nested Function - Scala

• Nested functions work correctly in Scala

def f (x:Int) : Int=>Unit =
  def g (y:Int) : Unit = println ("x = %d, y = %d".format (x, y))
  g (1)
  g

def main () = 
  val h = f (10)
  h (2)
  f (20)
  h (3)

main()

x = 10, y = 1
x = 10, y = 2
x = 20, y = 1
x = 10, y = 3 <- safe to call h, created with x=10, GOOD!

Nested Function - Java 8

• Nested functions work correctly in Java 8

import java.util.function.IntConsumer;
public class NestedFunc1 {
  static IntConsumer f (int x) {
    IntConsumer g = y -> System.out.format ("x = %d, y = %d%n", x, y);
    g.accept (1);
    return g;
  }
  public static void main (String[] args) {
    IntConsumer h = f (10);
    h.accept (2);
    f (20); 
    h.accept (3);
  }
}

Nested Function - Java 8

$ javac NestedFunc1.java 
$ java NestedFunc1
x = 10, y = 1
x = 10, y = 2
x = 20, y = 1
x = 10, y = 3 <- safe to call h, created with x=10, GOOD!