Understanding Block Structure

Understanding Block Structure

1. First, recall the rules of nested block structure.
   • A scope is a subsection of a program's text typically corresponding to a procedure/function/method/class or a block of statements.
   • An identifier can have only one definition in a given scope.
   • An identifier can be used in a scope as long as it is either defined in the scope or in a containing scope. (Note: Sometimes forward references are not allowed.)
   • Any use of an identifier refers to the declarations of the identifier occurring in the smallest enclosing scope.

2. A very helpful way to understand such scope rules is to recognize that the nesting is just an alternate way to represent a tree structure:
   • The tree shown in Figure *

     

     A simple tree structure
      

     can be encoded by the nested diagram shown in Figure *,

     

     An alternate representation of a tree structure
      

     or by the textual nesting:

     begin A
             begin B
                     begin E
                     end E
                     begin F
                     end F
             end B
             begin C
             end C
             begin D
                     begin G
                     end G
                     begin H
                     end H
             end D
     end A
     		           
     		           

3. For example, consider the interpretation of identifier references in the program whose skeleton is shown in Figure *.

   public class NestingExample {   
   
       int x; int y;  
   
           class One {   
   
             Two y;  int z;
             
             class In1 {
                 One y;
               }
               
             void m1() { int y;  y = 1;  x = y;  }
           }
           
        class Two {
           Three x;
           void m2()  x.m3();  
           }
           
         class Three {
             Two x; One y;
             
             class In3 extends One {
                 void mIn3() {
                     y.m2();
                     m1();  
                 }
             }
               
             void m3() { /* ... */ }
           }    
   }

   A class definition skeleton illustrating nested declarations
    

   

   Tree of scopes corresponding to Figure *
    

4. Within each node of this tree, we have written the names of the identifiers declared within the scope that corresponds to the tree node.
5. If an identifier is referenced within a given scope in the program, the correct definition can be found by sequentially searching the scopes on the path in this tree from the node for the scope to the root of the tree.
6. Note the interesting contents of the scope for the class In3. Because this class extends the class One. It includes new bindings for the names y, z, m1, and In1. These names are not redeclared. Rather, new bindings to existing declarations are created and added to the scope.
   • To appreciate the difference between adding bindings and new declarations, consider what happens if the method m1 is invoked from within In3. In particular, when that method references x, it must use the binding for x in the scope of the declaration of m1 (i.e. the declaration of x in the outer class) rather than the binding of x within In3.

Understanding Block Structure