Basic Semantics Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the...

Basic Semantics

Attributes, Bindings, and Semantic FunctionsDeclarations, Blocks, Scope, and the Symbol TableName Resolution and OverloadingAllocation, Lifetimes, and the EnvironmentVariables and Constants

Programming Languages 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


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


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)


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)


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


Different Terms for Declarations Some languages differentiate

definitions from declarations– DefinitionDefinition: a declaration that binds all

potential attributes– DeclarationDeclaration: 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


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.


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.


Block-Structured Block-Structured Program

– The program consists of 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: integerbegin …end


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)


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


Lexical Scope Example (C)int x;

void p(void){ char y; ...} /* p */

void q(void){ double z; ...} /* q */

main(){ int w[10]; ...}

w main

q

p x

z

y

In C, the declaration before use rule apply.


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)


Scope Resolution Operator 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 ...}


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

extern int x;...x...

File 1int x;...x...

File 2static int x;...x...

File 3


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++


Java Scope Example

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;}

In Java classes, the declaration before use rule does not apply.


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.


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.


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; ...}

xint

global

ycharglobal

xint

global

pvoid

function

ycharglobal

xint

global

pvoid

function

ycharglobal

xint

globaldoublelocal to p

pvoid

function

xint


ycharglobal

int[10]local to b

pvoid

function

ycharglobal

xint


pvoid

function

ycharglobal

xint

global

pvoid

function

ycharglobal

xint

global

qvoid

function

pvoid

function

xint

global

qvoid

function

ycharglobal

intlocal to q

pvoid

function

ycharglobal

xint

global

qvoid

function

pvoid

function

ycharglobal

xint

global

qvoid

function

mainint

function

pvoid

function

ycharglobal

qvoid

function

mainint

function

xint

globalchar

local to main

pvoid

function

ycharglobal

xint

global

qvoid

function

mainint

function


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;}

pvoid

function

ychar='a'

global

qvoid

function

mainint

function

xint=1global

pvoid

function

ychar='a'

global

qvoid

function

mainint

function

xint=1global

char='b'local to main

pvoid

function

ychar='a'

global

qvoid

function

mainint

function

xint=1global


int=42local to q

pvoid

function

ychar='a'

global

qvoid

function

mainint

function

xint=1global


int=42local to q

98OutputASCII value of

'b'

pvoid

function

ychar='a'

global

qvoid

function

mainint

function

xint…

char…

int=42local to q

98Output

double=2.5local to p

pvoid

function

ychar='a'

global

qvoid

function

mainint

function

xint…

char…

int=42local to q

double=2.5local to p

98*

Output

ASCII 42 = 'b'


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


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.


Function Overloading

Name resolutionmax(2,3) calls max #1max(2.1,3.2) calls max #2max(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); }


Overload Resolution Issues Implicit conversions may cause ambiguous

callsmax(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


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;}


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.

typedef struct A A; struct A { int data; A * next; };

C exampleclass A { A A(A A) { A: for(;;) { if (A.A(A) == A) break A; } return A; } }

Java example

structure tag name

type name

Which is which?• class name• method name• parameter

name• label name


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)


Typical Environment Components of Typical Algol-

style Languages– static area for static allocation– stack for LIFO-style dynamic

allocation– heap for on-demand dynamic

allocation


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


Run-Time Stack ManipulationA: { 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 */

point 1



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 */

point 2



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 */

point 3



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 */

point 4



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 */

point 5


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)


Pointer and Dereferencing 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


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


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 !


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


Diagrams for Variables Schematic Representation

Box-Circle Diagram


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


Assignment General Syntax

– infix notationvariable assingmentOpertor expression

Semantics– storage semantics

• assignment by value-copying

– pointer semantics• assignment by sharing (shallow copying)• assignment by cloning (deep copying)


Assignment by Value-Copying The value of the variable is copied.

x = y


Assignment by Sharing The location of the variable is copied.

x = y


Assignment by Cloning The location and the value of the

variable is duplicated.x = y


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 Javax = y


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.


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


Aliases Aliases

– two or more different names for the same object at the same time

– bad for readability (may cause potentially harmful side effects; see the next slide)

Side Effect– any change persists beyond the execution

of a statement Potentially Harmful Side Effect

– the side effect cannot be determined from the written statement

– the previous code should also be read


An Example of Harmful Aliases

main(){ int *x, *y; x = (int *) malloc(sizeof(int)); *x = 1; y = x; /* *x and *y now aliases */ *y = 2; printf("%d\n",*x); return 0;}


What makes aliases? What makes aliases?

– pointer assignment– call-by-reference parameters– assignment by sharing– explicit-mechanism for aliasing: EQUIVALENCE and COMMON in FORTRAN

– variant records

Why explicit-mechanism for aliasing in FORTRAN?– in order to save memory– the memory was a valuable resource at that

time


Dangling References Dangling References

– locations accessible but deallocated– the locations are deallocated too early– dangerous!

What makes dangling references?– pointer assignment and explicit

deallocation– pointer assignment and implicit

deallocation• by block exit• by function exit


An Example of Dangling References

main(){ int *x, *y; x = (int *) malloc(sizeof(int)); *x = 1; y = x; /* *x and *y now aliases */ free(x); /* *y now a dangling reference */ printf("%d\n",*y); /* illegal reference */ return 0;}


Garbage Garbage (Dangling Objects)

– inaccessible memory locations that are allocated

– the locations are deallocated too late– a waste of memory but not harmful

What makes garbage?– explicit allocation and the access point is

lost due to• assignment• deallocation of the access point


An Example of Garbagemain(){ int *x; x = (int *) malloc(sizeof(int)); x = 1; /* OOPS! */ ... return 0;}


Garbage Collection A language subsystem that

automatically reclaims garbage. Most functional language

implementations and some object-oriented language implementations are using garbage collectors.(See Section 8.5)

Basic Semantics Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the...

Documents

Transcript of Basic Semantics Attributes, Bindings, and Semantic Functions Declarations, Blocks, Scope, and the...