1. Basic Semantics

2. Content Names, attributes, and bindings
Declarations, scope and the symbol table
Overloading
Allocation, lifetimes, and the environment
Variables and constants
Aliases, dangling references, and garbage

3. Names
A fundamental abstraction mechanism in a programming language is the use of names or identifiers to denote language entities or constructs
In most languages, constants, variables, and procedures can have names assigned by the programmer

4. Attributes
The meaning of a name is determined by the attributes associated with the name const int n = 5; /* n is a constant */ int x; /* x is a variable */ double f(int n) { … } /* f is a function */

5. Binding
The process of associating an attribute to a name is called binding const int n = 2; /* static binding */ int x; /* static binding */ x = 2; /* dynamic binding */ int *y; /* static binding */ y = new int; /* dynamic binding */

6. Binding Time Language definition time: int, char, float
Language implementation time: sizeof(int)
Translation time: types of variables
Link time: code body of external functions
Load time: locations of global variables
Execution time: values of variables, locations of local variables

7. Symbol Table
Bindings can be maintained by a data structure called the symbol table
For an interpreter, the symbol table is a function that maps names to attributes Symbol Table Names Attributes

8. Symbol Table
For a compiler, the symbol table is a function that maps names to static attributes Symbol Table Names Static attributes

9. Introduction to Programming Languages
Environment & Memory
The dynamic attributes locations and values can be maintained by two functions environment (memory allocation) and memory (assignment) environment Names Locations memory Locations Values
Basic Semantics

10. Declarations
Declarations are a principal method for establishing bindings
Declarations are commonly associated with a block. These declarations are called local declarations of that block.
Declarations associated with an enclosing block are called nonlocal declarations
Declarations can also be external to any block. These declarations are called global declarations

11. An Example int x; /* global */ main() { int i, n; /* nonlocal */
while (i < n) {
int m; /* local */
m = i++;
f(m); }

12. Scope
The scope of a binding is the region of the program over which the binding is maintained
We can also refer to the scope of a declaration if all the bindings established by the declaration have identical scopes
In a block-structured language, the scope of a binding is limited to the block in which its associated declaration appears. Such a scope rule is called static (or lexical) scope

13. An Example int x; void p(void) { int i; … } void q(void) int j; … i
main()
int k; … i j k
main q p x

14. Visibility
The local binding of a name will take precedence over the global and nonlocal binding of the name. This causes a scope hole for the global and nonlocal binding of the name
The visibility of a binding includes only those regions of a program where the binding applies

15. An Example int i; void p(void) { int i; … } void q(void) int j; …
main()
int i; … i i
scope hole i i j i
scope hole
scope
visibility

16. Scope Resolution Operators
Scope resolution operators can be used to access the bindings hidden by scope holes

17. An Example /* An example in C++ */ int x; class ex { int x; void f() {
x = 1; /* local variable x */
ex::x = 2; /* x field of class ex */
::x = 3; /* global variable x */ }
void g() {
x = 4; /* x field of class ex */ };

18. Scope Across Files
In C, global variable declarations can actually be accessed across files File 1: extern int x; /* use x in other files */ File 2: int x; /* x can be used by other files */ File 2: static int x; /* x can only be used in this file */

19. The Symbol Table
A symbol table is like a dictionary for names: It must support insertion, lookup, and deletion of names with associated attributes
The maintenance of scope information in a statically scoped language with block structure requires that declarations be processed in a fashion like stack

20. An Example int x; char y; void p(void) { double x; … { int y[10]; …} }
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x

21. An Example int x; char y; void p(void) { double x; … { int y[10]; …} }
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
char
global y

22. An Example int x; char y; void p(void) { double x; … { int y[10]; …} }
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
char
global y
void
function p

23. An Example int x; char y; void p(void) { double x; … { int y[10]; …} }
void q(void)
{ int y; … }
main()
{ char x; … }
double
local to p
int
global x
char
global y
void
function p

24. An Example int x; char y; void p(void) { double x; … { int y[10]; …} }
void q(void)
{ int y; … }
main()
{ char x; … }
double
local to p1
int
global x
int array
local to p2
char
global y
void
function p

25. An Example int x; char y; void p(void) { double x; … { int y[10]; …} }
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
char
global y
void
function p

26. An Example int x; char y; x void p(void) { double x; … { int y[10]; …}
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
char
global y
void
function p
void
function q

27. An Example int x; char y; x void p(void) { double x; … { int y[10]; …}
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
int
local to q
char
global y
void
function p
void
function q

28. An Example int x; char y; x void p(void) { double x; … { int y[10]; …}
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
char
global y
void
function p
void
function q

29. An Example int x; char y; x void p(void) { double x; … { int y[10]; …}
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
char
global y
void
function p
void
function q
void
function
main

30. An Example int x; char y; x void p(void) { double x; … { int y[10]; …}
void q(void)
{ int y; … }
main()
{ char x; … }
char
local to main
int
global x
char
global y
void
function p
void
function q
void
function
main

31. An Example int x; char y; x void p(void) { double x; … { int y[10]; …}
void q(void)
{ int y; … }
main()
{ char x; … }
int
global x
char
global y
void
function p
void
function q
void
function
main

32. Symbol Tables for Structures
int a; char b; double c;
} x = {1,'a',2.5};
void p(void)
{ struct {
double a; int b; char c;
} y = {1.2,2,'b'};
printf("%d, %c, %g\n",x.a,x.b,x.c);
printf("%f, %d, %c\n",y.a,y.b,y.c); }
main()
{ p(); return 0; }
struct
global a
int x
char b c
double
void
function p a
double
int b
struct
local to p y c
char

33. Nested Procedures procedure ex is x: integer := 1;
y: character := ‘a’;
procedure p is
x: float := 2.5;
begin
put(y); new_line;
A: declare
y: array (1..10) of integer;
y(1) := 2; put(y(1)); new_line;
put(ex.y); new_line;
end A;
end p;
procedure q is
y: integer := 42;
begin
put(x); new_line; p;
end q;
B: declare
x: character := ‘b’;
q; put(ex.x); new_line;
end B;
end ex;

34. Nested Procedures ex procedure x integer x float y character block A p
array of integer q
procedure y
integer B
block x
character

35. Dynamic Scope
Using dynamic scope, the binding of a nonlocal name is determined according to the calling ancestors during the execution instead of the static program text

36. An Example: Static Scope
int x = 1;
char y = ‘a’;
void p(void)
{ double x = 2.5;
printf(“%c\n”, y);
{ int y[10]; …} }
void q(void)
{ int y = 42;
printf(“%d\n”, x); p(); }
main()
{ char x = ‘b’; q();
return 0; } a 1

37. An Example: Dynamic Scope
int = 1
global
int x = 1;
char y = ‘a’;
void p(void)
{ double x = 2.5;
printf(“%c\n”, y);
{ int y[10]; …} }
void q(void)
{ int y = 42;
printf(“%d\n”, x); p(); }
main()
{ char x = ‘b’; q();
return 0; } x
char = ‘a’
global y
void
function p
void
function q
void
function
main

38. An Example int x = 1; x char y = ‘a’; void p(void) { double x = 2.5;
char = ‘b’
in main
int = 1
global
int x = 1;
char y = ‘a’;
void p(void)
{ double x = 2.5;
printf(“%c\n”, y);
{ int y[10]; …} }
void q(void)
{ int y = 42;
printf(“%d\n”, x); p(); }
main()
{ char x = ‘b’; q();
return 0; } x
char = ‘a’
global y
void
function p
void
function q
void
function
main

39. An Example int x = 1; x char y = ‘a’; void p(void) { double x = 2.5;
char = ‘b’
in main
int = 1
global
int x = 1;
char y = ‘a’;
void p(void)
{ double x = 2.5;
printf(“%c\n”, y);
{ int y[10]; …} }
void q(void)
{ int y = 42;
printf(“%d\n”, x); p(); }
main()
{ char x = ‘b’; q();
return 0; } x
int = 42
in q
char = ‘a’
global y
void
function p
void
function q 98
void
function
main

40. An Example * int x = 1; x char y = ‘a’; void p(void) { double x = 2.5;
in p
char = ‘b’
in main
int = 1
global
int x = 1;
char y = ‘a’;
void p(void)
{ double x = 2.5;
printf(“%c\n”, y);
{ int y[10]; …} }
void q(void)
{ int y = 42;
printf(“%d\n”, x); p(); }
main()
{ char x = ‘b’; q();
return 0; } x
int = 42
in q
char = ‘a’
global y *
void
function p
void
function q
void
function
main

41. Issue of Dynamic Scope
When a nonlocal name is used in an expression or statement, the declaration that applies to that name cannot be determined by simply reading the program
Static typing and dynamic scoping are inherently incompatible
Languages that use dynamic scope are Lisp, APL, Snobol, Perl

42. Overloading
An operator or function name is overloaded if it is used to refer to two or more different things in the same scope integer addition floating-point addition error or floating-point addition by automatically converting 2 to 2.0

43. Overload Resolution
Overloading of operators or function names can be resolved by checking the number of parameters (or operands) and the data types of the parameters (or operands) int max(int x, int y); max(2, 3); double max(double x, double y); max(2.1, 3.2); int max(int x, int y, int z); max(1, 3, 2);

44. Overloading & Automatic Conversion
Automatic conversions complicate the process of overload resolution max(2.1, 3);
C++: error, both conversions are allowed
Ada: error, no conversion is allowed
Java: only int to double is allowed

45. Overloading & Automatic Conversion
Since there are no automatic conversions in Ada, the return type of a function can also be used to resolve overloading function max(x:integer; y:integer) return int function max(x:integer; y:integer) return float a: integer; b: float; a := max(2, 3); -- call to max #1 b := max(2, 3); -- call to max #2

46. Operator Overloading
Ada and C++ also allow built-in operators to be extended by overloading
We must accept the syntactic properties of the operator, i.e., we cannot change their associativity or precedence

47. An Example 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;

48. Name Overloading
A name can be used to refer to completely different things class A {
A A(A A) {
A: for(;;)
{ if (A.A(A) == A) break A; }
return A; }

49. Environment
Depending on the language, the environment may be constructed statically (at load time), dynamically (at execution time), or a mixture of the two
FORTRAN uses a complete static environment
LISP uses a complete dynamic environment
C, C++, Ada, Java use both

50. Location Allocation
Typically, global variables are allocated statically
Local variables are usually allocated automatically and dynamically in stack-based fashion
The lifetime or extent of an allocated location is the duration of its allocation in the environment

51. An Example main() { 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 */
return 0; }

52. An Example x y x y a x y x y b x y b x y b x y enter A enter B exit BC
enter D
exit D
exit C

53. Manually Location Allocation
Many languages also provide mechanisms to manually allocate (or deallocate) memory for variables C: malloc, free library functions C++: new, delete built-in operators Java: new built-in operators

54. Structure of an Environment
static
stack
heap

55. Static Local Variables
In C, the allocation of a local variable can be changed from stack-based to static

56. An Example int p(void) {
static int p_count = 0; /* initialized only once */
p_count += 1;
return p_count; }
main() {
int i;
for (i = 0; i < 10; i++)
if (p() % 3) printf("%d\n",p());
return 0;

57. Variables
A variable is an object whose stored value can change during execution
A variable is specified by its attributes, which include its name, its location, its value, and others
Name
Value
Location
Other
Attributes

58. Assignments
The semantics of the assignment x = e are that e is evaluated to a value, which is then copied into the location of x x = y y x

59. R-Value & L-Value
The variable y on the right-hand side of x = y stands for the value of y, while the variable x on the left-hand side stands for the location of x
We sometimes call the value stored in the location of a variable its r-value, while the location of a variable its l-value

60. R-Value & L-Value
ML, Algol68, and BLISS are languages that make r-values and l-values explicit. In ML, val x = ref 0; val y = ref 1; x := !y; x := !x + 1; z : int -- not assignable (like a constant) x : int ref -- assignable reference cell

61. Address-of & Dereferencing
In C, the address-of operator & explicitly returns the location of a variable, while the dereferencing operator * explicitly takes the value of a variable and returns it as a location int x, y, *xptr; xptr = &x; *xptr = y;

62. Semantics of Assignments
The usual semantics of an assignment, which copies the value of a location to another location, is called storage semantics
In some languages, like Java and LISP, an assignment copies the location to another location. This semantics is called pointer semantics

63. Pointer Semantics
Pointer semantics are usually implemented using implicit pointers and implicit dereferencing
Java y y
x = y x x

64. An Example class ArrTest { public static void main(String[] args) {
int[] x = {1, 2, 3};
int[] y = x;
x[0] = 42;
System.out.println(y[0]); }
/* y[0] = 42 */

65. Constants
A constant is a language entity that has a fixed value for the duration of its existence
A constant can be a literal like 123 or ‘a’. Or it can be a name for a value, called symbolic constants. Once its value is computed, it cannot change

66. Symbolic Constants
A symbolic constant is like a variable, except that it has no location attribute, but a value only. The location of a symbolic constant cannot be explicitly referred to
Name
Value
Other
Attributes
const int a = 2;
int *x;
x = &a; /* Illegal C code */

67. Initialization of Constants
/* compile-time constant */
const int a = 2; /* manifest constant */
const int b = * 2;
const int b = 27 + a * a; /* C illegal, C++ ok */
/* static (or load-time) constant */
const int c = (int) time(0); /* C illegal, C++ ok */
/* dynamic constant */
int f(int x) {
const int d = x + 1; return b + c; }

68. Function Constants
Function definitions are definitions of constants whose values are functions
int gcd(int u, int v) {
if (v == 0) return u;
else return gcd(v, u % v); }

69. Function Variables
C has function variables, which must be defined as pointers. However, dereferencing is not required to access the value of function variables int (*fun_var) (int, int); fun_var = gcd; main() { printf(“%d\n”, fun_var(15, 10)); return 0; }
A little inconsistant

70. Functions in Functional Languages
Functional languages do a much better job of making clear the distinction between function constants, function variables, and function literals. In ML, fn(x:int) => x * x (* literal *) (fn(x:int) => x * x) 2; val square = fn(x:int) => x * x; (* constant *) fun square (x:int) = x * x; (* constant *)

71. Aliases
An alias occurs when the same location is bound to two different names at the same time
An alias can occurs at call-by-reference parameter passing
An alias can occurs at pointer assignment
An alias can occurs at assignment with pointer semantics
An alias can occurs in the EQUIVALENCE declaration of FORTRAN

72. An Example: Call by Reference
void incr(int &i)
{ i++;}
void f( ) {
int x = 1;
incr(x);
printf(“%d\n”, x); }
/* x = 2 */

73. An Example: Call by Reference1 x x 1 i x 2 x 2 i

74. An Example: Pointer Assignment
int *x, *y;
x = (int *) malloc(sizeof(int));
*x = 1;
y = x;
*y = 2;
printf(“%d\n”, *x);
/* x = 2 */

75. An Example: Pointer Assignment1 y y y x 1 x 2 y y

76. An Example: Pointer Semantics
class ArrTest {
public static void main(String[] args) {
int[] x = {1, 2, 3};
int[] y = x;
x[0] = 42;
System.out.println(y[0]); }
/* y[0] = 42 */

77. Dangling References
A dangling reference is a pointer that points to a location that has been deallocated.
int *dangle(void) { int x; return &x; }
int *x, *y; x = (int *) malloc(sizeof(int)); *x = 2; y = x; free(x); printf(“%d\n”, *y);

78. Garbage
Garbage is locations that have been allocated but that have become inaccessible to the program
int *x; x = (int *) malloc(sizeof(int)); x = 0;
void p(void) { int *x; x = (int *) malloc(sizeof(int)); *x = 2; }

79. Garbage Collection
It is useful to remove the need to deallocate memory explicitly from the programmer, while at the same time automatically reclaiming garbage for further use. This mechanism is called garbage collection
Most functional. logic, and object-oriented languages provide garbage collection