Basic Semantics

1. Basic Semantics Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the Symbol Table Name Resolution and Overloading Allocation, Lifetimes, and the Environment Variables and Constants

2. Attributes • Attributes • The properties of language entities, typically identifiers • For other language entities, say operator symbols, the attributes of which are often predetermined. • Examples of Attributes • the location of a variable: the place holder • the value of an expression: the storable quantity • the types of identifiers: determine the operations applicable • the code of a procedure: the operation of the procedure • the size of a certain type: determines the value range Programming Languages

3. Binding • Binding • The process of associating an attribute to a name • Declarations (including definitions) bind the attributes to identifiers • Example of Binding // C++ example int x, *y; x = 2; y = new int(3); x Type: integer Value: 2 y Type: integer pointer Value: ∙ → 3 Programming Languages

4. Binding Time • The time when a binding occurs • Large Categories of Binding Times • Static binding: the binding occurs prior to the execution • Dynamic binding: the binding occurs during the execution • Further Refined Binding Time Categories • Language definition time • Language implementation time • Program translation time • Link time • Load time • Execution time (run time) Programming Languages

5. Binding Time Examples • The value of an expression • execution time if it contains variables • translation time if it is a constant expression • The type of an identifier • translation time in a compilation system (say, Java) • execution time in an interpreter (say, LISP) • The maximum number of digits of an integer • language definition time for some languages (say, Java) • language implementation time for others (say, C) • The location of a variable • load time for static variables (static in C) • execution time for dynamic variables (auto in C) Programming Languages

6. Declarations • A principal method for establishing bindings • implicit binding: implicitly assumed by a declaration • explicit binding: explicitly specified by a declaration • example) In the following C declaration, int x; • the type binding is an explicit binding • the location binding is an implicit binding Programming Languages

7. Different Terms for Declarations • Some languages differentiate definitions from declarations • Definition: a declaration that binds all potential attributes • Declaration: a declaration that binds only a part of attributes • C language example • a function declaration (prototype) binds only the type (the interface) of the function Programming Languages

8. Examples of C Declarations • int x = 0; • Explicitly specifies data type and initial value. • Implicitly specifies scope (explained later) and location in memory. • int f(double); • Explicitly specifies type (double int) • Implicitly specifies nothing else: needs another declaration specifying code • The former is called a definition in C, the latter is simply a declaration. Programming Languages

9. Block and Locality • Block • a standard language construct which may contain declarations • unit of allocations • Locality of the Declarations or the References • Local: the declaration and the reference for a name are in the same block • Non-Local: the declaration of a name is not in the block which contains the reference for the name • Note that we need some rules to locate corresponding declarations for non-local references. Programming Languages

10. Block-Structured • Block-Structured Program • The program consistsof blocks, which may be nested • Most Algol descendants exploit this structure • Kinds of Blocks • procedural block: Pascal • non-procedural block: Ada, C -- Ada example declare x: integer; begin … end (* Pascal example *) program ex; var x: integer begin … end Programming Languages

11. Scope • Scope of a Binding • the region of the program over which the binding is maintained • Scope and Block • Declaration before Use Rule: The scope is typically extends to the end of the block which contains the declaration • In some constructs, the scope may extend backwards to the beginning of the block (classes in Java and C++, top-level declarations in Scheme) Programming Languages

12. Scope Rules • Lexical Scope (Static Scope) Rule • the scope of a binding is the inside of the block which contains the corresponding declaration • the standard scope rule of most block-structured languages • Dynamic Scope Rule • the scope of a binding is determined according to the execution path • the symbol table (or the environment) should be managed dynamically Programming Languages

13. int x; void p(void) { char y; ... } /* p */ void q(void) { double z; ... } /* q */ main() { int w[10]; ... } Lexical Scope Example (C) x In C, the declaration before use rule apply. p y q z main w Programming Languages

14. Scope Holes • What is a scope hole? • a local declaration of a name can mask a prior declaration of the same name • in this case, the masked declaration has a scope hole over the corresponding block • Visibility and Scope • Visibility: the region where the declared name is visible (excluding scope holes) • Scope: the region where the binding exists (including scope holes) Programming Languages

15. The global integer variable x has a scope hole in the body of p. In C, the global x cannot be referenced in p. In C++, the global x can be referenced in p using a scope resolution operator ::. Ada also has a scope resolution operator .. // C++ example int x; void p(void) { char x; x = 'a'; // local x ::x = 42; // global x ... } /* p */ main() { x = 2; // global x ... } Scope Resolution Operator Programming Languages

16. File Scope in C • File Scope • In C, a global name can be turned into a file scope name by attaching the keyword static. • A file scope name can only be referenced in that file. • Example File 1 File 2 File 3 extern int x; ... x ... int x; ... x ... static int x; ... x ... Programming Languages

17. Recursive Declaration • Recursive functions are generally well-defined int factorial(int n) { ... factorial(n – 1) ... } • How about recursive variables? int x = x + 1; • Not allowed in Ada or Java • Allowed in C/C++ for local variables but meaningless • Dealing with mutual recursions in the context of declaration before use rule. • forward declarations in Pascal • prototype declarations in C/C++ Programming Languages

18. In a class declaration, the scope of a declaration is the entire class. Note the underlined declaration. The result may differ according to the scope rules. The above code prints 2. (Java adopts lexical scope rule) Under dynamic scope rule, the code would print 3. public class Scope { public static void f() { System.out.println(x); } public static void main(String[] args) { int x = 3; f(); } public static int x = 2; } Java Scope Example In Java classes, the declaration before use rule does not apply. Programming Languages

19. Dynamic Scope Evaluated • Disadvantages of the Dynamic Scope • The scope of a declaration cannot be determined statically. (Hand-simulation is needed to find the applicable declaration.) • The types of identifiers cannot be determined statically. (A static type-checking is impossible) • Historical Note • Originally used in Lisp. Scheme could still use it, but doesn't. Some languages still use it: VBScript, Javascript, Perl (older versions). • Lisp inventor (McCarthy) now calls it a bug. Programming Languages

20. Symbol Table Maintenance • In a lexically scoped languages, • The symbol table is maintained like a stack. • The symbol table is maintained statically, i.e. regardless to the execution path. • In a dynamically scoped languages, • All the bindings of the outermost names are constructed. • The bindings are maintained according to the execution path. Programming Languages

21. x x x x x x x x x x x x x int global char local to main int global int global int global int global int global double local to p double local to p double local to p int global int global int global int global int global int global int global y y y y y y y y y y y y char global char global char global int[10] local to b char global char global char global int local to q char global char global char global char global char global char global p p p p p p p p p p p void function void function void function void function void function void function void function void function void function void function void function q q q q q q void function void function void function void function void function void function main main main int function int function int function Symbol Table under Lexical Scope int x; char y; void p(void) { double x; ... { /* block b */ int y[10]; ... } ... } void q(void) { int y; ... } main() { char x; ... } Programming Languages

22. x x x x x x char='b' local to main int=1 global double=2.5 local to p char='b' local to main double=2.5 local to p char='b' local to main char … char … int=1 global int=1 global int=1 global int … int … y y y y y y int=42 local to q char='a' global char='a' global int=42 local to q int=42 local to q int=42 local to q char='a' global char='a' global char='a' global char='a' global p p p p p p void function void function void function void function void function void function q q q q q q void function void function void function void function void function void function main main main main main main int function int function int function int function int function int function ASCII value of 'b' Output Output Output 98 98 98 * ASCII 42 = 'b' Symbol Table under Dynamic Scope #include <stdio.h> int x = 1; char y = 'a'; void p(void) { double x = 2.5; printf("%c\n",y) { /* block b */ int y[10]; } } void q(void) { int y = 42; printf("%d\n",x); p(); } main() { char x = 'b'; q(); return 0; } Programming Languages

23. Overloading • What is overloading? • reusing names for different entities of a kind within the same scope entity1/name1, entity2/name2 (entity1, entity2)/name • the name is overloaded in the above case • operator overloading, function overloading • Overload Resolution • choosing the appropriate entity for the given usage of the overloaded name • the calling context (the information contained in a call) is generally used for overload resolution Programming Languages

24. Overloading Example • In most languages, the operator + is overloaded • integer addition (say, ADDI) • floating point number addition (say, ADDF) • Disambiguating Clue: data types of operands • How about mixed-type expression? 2 + 3.2 • C/C++ adopts promotion (implicit type conversion). • Ada treats the above expression error. Programming Languages

25. Name resolution max(2,3) calls max #1 max(2.1,3.2) calls max #2 max(1,3,2) calls max #3 int max(int x, int y) // max #1 { return x > y ? x : y; } double max(double x, double y) // max #2 { return x > y ? x : y; } int max(int x, int y, int z) // max #3 { return x > y ? (x > z ? x : z) : (y > z ? y : z); } Function Overloading Programming Languages

26. Overload Resolution Issues • Implicit conversions may cause ambiguous calls max(2.1, 3) • C++: too many candidates (max #1 or max #2) • Ada: no candidates • Java: implicit conversions are used only for the cases of no information loss • Whether the return type is included in the calling context or not • C++, Java: not included • Ada: included Programming Languages

27. Operator Overloading in C++ #include <iostream> using namespace std; typedef struct { int i; double d; } IntDouble; bool operator < (IntDouble x, IntDouble y) { return x.i < y.i && x.d < y.d; } IntDouble operator + (IntDouble x, IntDouble y) { IntDouble z; z.i = x.i + y.i; z.d = x.d + y.d; return z; } int main() { IntDouble x = {1,2.1}, y = {5,3.4}; if (x < y) x = x + y; else y = x + y; cout << x.i << " " << x.d << endl; return 0; } Programming Languages

28. C example Java example typedef struct A A; struct A {  int data;    A * next; }; class A { A A(A A)   { A:     for(;;)   { if (A.A(A) == A) break A; }     return A;   } } Other Kinds of Reuse of Names • Reusing names for different kinds of entities • Separate name space for each kind is needed. • These kinds of reusing is not an overloading. • Which is which? • class name • method name • parameter name • label name structure tag name type name Programming Languages

29. Environment • Environment Construction Time • static environment: FORTRAN • dynamic environment: LISP • mixture: most Algol-style languages • Variable Allocation Time in a Algol-style Language • global variables • static allocation • allocated in load time • local variables • mostly dynamic allocation • allocated in the declaration elaboration time (i.e. when the control flow passing the declaration) Programming Languages

30. Components of Typical Algol-style Languages static area for static allocation stack for LIFO-style dynamic allocation heap for on-demand dynamic allocation Typical Environment Programming Languages

31. Activation Record • Activation • an invocation of a subprogram • the subprogram environment should be constructed for each activation • Activation Record • the region of memory allocated for an activation • subprogram environment + bookkeeping information • Run-Time Stack • block enters and exits are LIFO-style • procedure calls and returns are LIFO-style • activation records are stored in the run-time stack Programming Languages

32. A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Run-Time Stack Manipulation point 1 Programming Languages

33. A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Run-Time Stack Manipulation point 2 Programming Languages

34. A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Run-Time Stack Manipulation point 3 Programming Languages

35. A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Run-Time Stack Manipulation point 4 Programming Languages

36. A: { int x; char y; B: { double x; int a; } /* end B */ C: { char y; int b; D: { int x; double y; } /* end D */ } /* end C */ } /* end A */ Run-Time Stack Manipulation point 5 Programming Languages

37. Heap Manipulation • Heap (Free Store) • the memory pool for the objects allocated manually • Heap Deallocation • manual deallocation: special functions or operators are used for deallocation (free in C, delete in C++) • automatic deallocation: garbage collector is used (more safe but somewhat slow, Java) • Ada Approach • Ada does not provide delete operation but allows a user-defined deallocation (Unchecked_Deallocation) Programming Languages

38. Pointer an object whose value is a reference to an object Dereferencing referencing an object via a pointer value In order to manipulate the heap objects, pointers are mandatory (either implicitly or explicitly) /* C example */ int *x; // pointer declaration x = (int*)malloc(sizeof(int)); // memory allocation *x = 5; // dereferencing free(x); // deallocation Pointer and Dereferencing Programming Languages

39. Lifetime • Storable Object • a chunk of memory cells • an area of storage that is allocated in the environment • The Lifetime (or Extent) of an Object • the duration of its allocation in the environment • Lifetime vs. Scope • the lifetime and the scope of variables are closely related but not identical (cf. local static variables in C/C++) • according to the scope: local, global • according to the lifetime: static, dynamic Programming Languages

40. Local Static Variable Example (C) int p(void) { static int p_count = 0; /* initialized only once - not each call! */ p_count += 1; return p_count; } main() { int i; for (i = 0; i < 10; i++) { if (p() % 3) printf("%d\n",p()); } return 0; } The variable p_count counts the number of calls of the function p. Accordingly, p is history sensitive. Guess the output ! Programming Languages

41. Variables and Constants • Variable • an object whose value may change during execution • Constants • an object whose value does not change for its lifetime • Literals • a language entity whose value is explicit from its name • a kind of constants but may never be allocated Programming Languages

42. Diagrams for Variables • Schematic Representation • Box-Circle Diagram Programming Languages

43. L-value and R-value • L-value and R-value of a Variable • l-value (LHS value): the location • r-value (RHS value): the value stored Programming Languages

44. Assignment • General Syntax • infix notation variableassingmentOpertorexpression • Semantics • storage semantics • assignment by value-copying • pointer semantics • assignment by sharing (shallow copying) • assignment by cloning (deep copying) Programming Languages

45. Assignment by Value-Copying • The value of the variable is copied. x = y Programming Languages

46. Assignment by Sharing • The location of the variable is copied. x = y Programming Languages

47. Assignment by Cloning • The location and the value of the variable is duplicated. x = y Programming Languages

48. Java Example • Java supports all the kinds of assignment semantics • assignment of object variables: assignment by sharing • assignment of simple data: assignment by value-copying • object cloning is supported by the method clone. • A closer view of object assignment in Java x = y Programming Languages

49. Constant Semantics • Schematic Diagram for Constants • Constant has Value Semantics • Once the value binding is constructed, the value cannot be changed • The location of a constant cannot be referred to. Programming Languages

50. Classification of Constants • Literals and Named Constants • literals: names denote the exact value • named constants: names for the meaning of the value • Classification of Named Constants • static constants (manifest constants) • compile-time static constants (may never be allocated) • load-time static constants • dynamic constants Programming Languages