Chapter_7_tucker_noonan_programmng_lang.ppt

CSC321: Programming Languages 7-1
Programming Languages
Programming Languages
Tucker and Noonan
Tucker and Noonan
Chapter 7: Semantics
7.1 Motivation
7.2 Expression Semantics
7.3 Program State
7.4 Assignment Semantics
7.5 Control Flow Semantics
7.6 Input/Output Semantics
7.7 Exception Handling Semantics

Motivation
Motivation
• To provide an authoritative definition of
the meaning of all language constructs
for:
1. Programmers
2. Compiler writers
3. Standards developers
• A programming language is complete
only when its syntax, type system, and
semantics are well-defined.

• Semantics is a precise definition of the meaning of a
syntactically and type-wise correct program.
• Three approaches
– Operational semantics
• The meaning attached by compiling using compiler C and
executing using machine M. Ex: Fortran on IBM 709.
• Direct and straightforward program meaning
– Axiomatic semantics
• Axiomatize the meaning of statements -- Chapter 12
• Exploration of formal properties of programs
– Denotational semantics
• Statements as state transforming functions
• High-level mathematical precision of program meaning
• This chapter uses an informal, operational model.
Semantics
Semantics

Expression Semantics
Expression Semantics
• Notation – Expression tree
• Meaning
– Mathematics: (a + b) - (c * d)
– Polish prefix notation:
• - + a b * c d
• Preorder traversal
– Polish postfix notation
• a b + c d * -
• Postorder traversal
– Cambridge Polish:
• (- (+ a b) (* c d))
• Operator precedes operands
• Parentheses

Infix Notation
Infix Notation
• Mathematics meaning
– (a + b) - (c * d)
• Uses associativity and precedence to
disambiguate
– Associativity of Operators
Language + - * / Unary - ** == != < ...
C-like Left Right Left
Ada Left non non non
Fortran Left Right Right Left
– Meaning of a < x < b in C-like
• a < x && x < b ?
• If (a < x) 1 < b else 0 < b

Precedence of Operators
Precedence of Operators
Operators C-like Ada Fortran
Unary - 7 3 3
** 5 5
* / 6 4 4
+ - 5 3 3
== != 4 2 2
< <= ... 3 2 2
Unary not 7 2 2
Logical and 2 1 1
Logical or 1 1 1

Short Circuit Evaluation
Short Circuit Evaluation
• a and b evaluated as:
if a then b else false
• a or b evaluated as:
if a then true else b
• Benefits
– Efficiency
– Shorter code
– Clearer code
• Example in C-like
– x < Math.pow(y, 3) || b – bad?
– x<1 && (y*y > 100 || y>x) – good?

More Example
More Example
1. Node p = head;
while (p != null && p.info != key) p = p.next;
3. boolean found = false;
while (p != null && ! found) {
if (p.info == key) found = true;
else p = p.next;
} // avoiding break
2. while (p != null && ! found) {
if (p.info == key) break;
else p = p.next;
} // using break

Expression Meaning
Expression Meaning
• Number precision
– data type size
– (a+b)+c == a+(b+c) ?
• Side effect
– A change to any non-local variable or I/O.
– What is the value of:
• i = 2; b = 2; c = 5;
• x = b * i++ + c * i; // 19
• y = c * i + b * i++; // 14
– Consider
• y = x++;
• y = x+1;

Program State
Program State
• The state of a program is the collection of all active
objects and their current values.
• Two maps:
1. Active objects to specific memory locations
2. Active memory locations to specific values.
• State = memory  environment
• The current statement (portion of an abstract syntax tree)
to be executed in a program is interpreted relative to the
current state.
• The individual steps that occur during a program run can
be viewed as a series of state transformations.
• For simplicity, ignore the memory location

1 void main ( ) {
2 int n, i, f;
3 n = 3;
4 i = 1;
5 f = 1;
6 while (i < n) {
7 i = i + 1;
8 f = f * i;
9 }
10 }
n i f
undef undef undef
3 undef undef
3 1 undef
3, 3, 3 1, 2, 3 1, 2, 6
3, 3 1, 2 1, 2
3, 3 2, 3 1, 2
3, 3 3, 3 2, 6
3 3 6
Program: compute the
factorial of n
Program State Transformation
Program State Transformation
State Transformation

Assignment Semantics
Assignment Semantics
• Issues
– Multiple assignment
• Example:
–a = b = c = 0;
– Sets all 3 variables to zero.
– Problems???
– Assignment statement vs. expression
– Copy vs. reference semantics

Assignment Statement vs.
Assignment Statement vs.
Expression
Expression
• In most languages, assignment is a statement;
cannot appear in an expression.
• In C-like languages, assignment is an
expression.
– Example: if (a = 0) ... // an error
– while (*p++ = *q++) ; // strcpy
– while (ch = getc(fp)) ... // ???
– while (p = p->next) ... // ???

Copy vs. Reference
Copy vs. Reference
Semantics
Semantics
• Copy: a = b;
– a, b have same value.
– Changes to either have no effect on other.
– Used in imperative languages.
• Reference
– a, b point to the same object.
– A change in object state affects both
– Used by many object-oriented languages.

Control Flow Semantics
Control Flow Semantics
• Turing complete
– a programming language is Turing Complete
if its program are capable of computing any
computable function
• To be complete, an imperative language
needs:
– Statement sequencing
– Conditional statement
– Looping statement

Sequence
Sequence
• Format:
s1 s2
• Semantics: in the absence of a branch:
– First execute s1
– Then execute s2
– Output state of s1 is the input state of s2

Conditional
Conditional
• Format
IfStatement  if ( Expression ) Statement [ else
Statement ]
• Semantics
If the value of Expression is true, the meaning is the
state resulting from evaluating Statement1 in the
current state. Otherwise the meaning is the state
resulting from evaluating Statement2 in the current
state
• Example:
if (a > b)
z = a;
else
z = b;

Various Conditional Statements
Various Conditional Statements
• if <E> then <S> : if <E> is true then execute <S>
• if <E> then <S> else <S2>: if <E> is true then execute
<S>, otherwise execute <S2>
• Dangling-else: Ambiguity. Ways to avoid ambiguity
– Syntax: the else-clause associated with the closest then – e.g. C,
Java
if <E1> then if <E2> then <S1> else <S2>
– Use compound brackets
• A: if <E1> then { if <E2> then <S1> } else <S2>
• B: if <E1> then { if <E2> then <S1> else <S2> }
– Avoid use of nesting in then parts
• A: if !<E1> then <S2> else if <E2> then <S1>
• B: if <E1> && <E2> then <S1> else if <E1> then <S2>

Multiple Branches
Multiple Branches
• Multiple branches – case (selection): use the value of an expression to select one of
several substatements for execution
• Pascal, Modula-2: case x of
<value1>: <statements1>
<value2>: <statements2>
…
[else: <statements>]
end
• Ada: case x is
when <value1> => <statements1>;
when <value2> => <statements2>;
…
[others => <statements>];
• C/C++, Java : Notice: the use of break
switch (x) {
case <value1>: <statements1>;
[break;]
case <value2>: <statements2>;
[break;]
…
[default: <statements>];
}

Multiple Branches
Multiple Branches
• Points:
– Cases can appear in any order, but else/others/default must be
the last one
– The case value of x is discrete, such as 1, 10, 6, 9
– The case values must be distinct
– Some languages allow ranges of case values, such as in
Modula-2, ‘0’..’9’ represents the value either ‘0’, or ‘1’, …, or ‘9’
of x
• Case can be replaced with if—then—else statements
if x == <value1> then <statements1>;
else if x == <value2> then <statements2>;
…
else: <statements>;

Loops
Loops
• Format
WhileStatement  while ( Expression )
Statement
• Semantics
– The expression is evaluated.
– If it is true, first the statement is executed,
and then the loop is executed
again.
– Otherwise the loop terminates.

General Loop Structure
General Loop Structure
• General structure:
Do S1
If C exit
Otherwise Do S2
Repeat
S1
C
S2

Loop Implementation
Loop Implementation
Ada:
while (!C) loop
S2
end loop
C/C++, Java:
while (!C) {
S2
}
Pascal:
while (!C) do
begin
S2
end
Perl:
unless (C) {
S2
}
Ada:
S1
while (!C) loop
S1
end loop
C/C++, Java:
do
S1
while (C)
Pascal:
repeat
S1
until C
Perl:
S1
while (!C) {
S1
}
Ada:
loop
S1
exit when C
S2
end loop
C/C++, Java:
while (t) {
S1
if (C) break;
S2
}
Pascal:
S1;
while (C) do
begin
S2
S1
end
General
loop
While
loop
Repeat
loop

For Loop Implementation
• For statement: definite iteration – for each element do
• General form:
– for (<var> = <initial>; [<step>]; <termination>) do statements
– <var> varies from the initial value to the termination, each loop varies
with a stepwise
– Step can be omitted, default value is 1
– Stepwise can be going either up from small initial to large termination, or
down from large initial to small termination
• Pascal:
– for x := low to high do S
– for x:= high downto low do S
• Fortran/Algol:
– for x:= start step increment until end do S
– increment may be negative to implement “going down”
• Ada:
– for x in low..high loop S end loop;
– for x in reverse low..high loop S end loop
• C/C++/Java:
– for (e1; e2; e3) S

• Some languages allow the stepwise to be real or
other data types
– Fortran/Algol: allow real steps such as 0.1, 0.2
– Pascal/Modula-2: allow step type of enumeration
• for x in d do S; where d is a type of enumeration
– Perl: allows enumeration in a list
• foreach $x (@list) S;
– Java: allows enumeration in a collection
• Syntax
foreach (Type variable : collection) statement
• Example
String names[];
……
foreach (String name : names)
do something with name;

Jump Statements
Jump Statements
• Goto: jump to a specific statement (labeled by a label).
Recall jmp, jp in assembly languages
– makes the program difficult to trace, hard to prove
– violates the structured programming style
– destroy the system if goto the kernel of the OS
• Break (C/C++, Java): limited use of Goto as an exit of a
loop or selection
– Used inside a loop: exit the loop
– Used inside a selection (case): exit the case
– Exit in Ada and Modula-2
• Continue(C/C++, Java, Fortran): limited use of Goto
– Begin the next loop, ignore the statements after it in the body

• Binding: open, close
• Access: sequential vs. random
• Stream vs. fixed length records
• Character vs. binary
• Format
• I/O Error handling

Standard Files
Standard Files
• Unix: stdin, stdout, stderr
• C: stdin, stdout, stderr
• C++: cin, cout, cerr
• Java: System.in, System.out, System.err

Input/Output Streams
Input/Output Streams
• Fortran
integer :: i, a(8)
write(8,*) “Enter 8 integers: “
read(*,*) a
write(*,*) a
• Java
– file, pipe, memory, url
– filter
– reader, writer

Formats
Formats
• C
– Codes: d, e, f, c, s (decimal. float, float, char,
string)
– Specifier: % opt-width code
– Ex: %s %5d %20s %8.2f
• Fortran
– Codes: i, f, a (integer, float, string)
– Specifier: op-repeat code width
– Ex: 8i4, f8.2, a20

Exception Handling Semantics
Exception Handling Semantics
• Exception
– an error condition occurring from an operation
that cannot be resolved by the operation itself
• Purposes
– Simplify programming
– Make applications more robust: continue to
operate under all concevable error situations

Exception Handling Basic Structure
Exception Handling Basic Structure
• Exception events: abnormal
– event that the system can not
deal with so that leave to the
programmer, such as
• division by zero,
• get value from a null pointer;
• read a file that doesn’t exist
• Exception handlers
– Deal with the exception events,
such as
• output error
• use default value
• stop the execution
<exceptionevent>
<exception handler>
Automatically
jump

Exception Handling ProgramStructure
Exception Handling ProgramStructure
Ada:
begin
…
exception
when <exception1> =>
exception1-handler;
when <exception2> =>
exception2-handler;
….
end
C++/Java:
try {
….
} catch
(<exception1>) {
exception1-handler;
} catch
(<exception2>) {
exception2-handler;
}
…

Raise/Throw/Catch Exceptions
Raise/Throw/Catch Exceptions
• Raise/throw exception
– Implicitly throw: built-in method/function throw, e.g. division, file access
– Explicitly throw:
• throw <exception> --- C++/Java
• raise <exception> --- Ada
• Catch exception
– If there exists a catch clause to catch a specific exception, the
exception is handled by the corresponding handler. If no handler
exists, the exception is raised/thrown to the caller. To implement this,
the throws must be specified in the method prototype (signature). E.g.
in Java
public void method_sample(…) throws <exception> {
…
throw <exception>;
…
}

Throwing an Exception
Figure 7.13

Exception Post-process
Exception Post-process
• Termination model
– C++/Java, Ada: only enter the exception
handler and execute the finally clause, if any.
• Resumption model
– Eiffel: can use the retry statement to re-
execute the procedure/function in which the
exception occurred

Exception Handling
Figure 7.9

Creating a New Exception Class
Declare Exceptions
Declare Exceptions
• Predefined exceptions (built-in exception)
• User-defined exception: e.g. in Java
Public class MyException extends RuntimeException {
……
}

Java Exception Type Hierarchy
Figure 7.10

Missing Argument Exception

Invalid Input Exception
Figure 7.12

AssertException Class

Assert Class
Figure 7.15

Using Asserts

Chapter_7_tucker_noonan_programmng_lang.ppt

More Related Content

Similar to Chapter_7_tucker_noonan_programmng_lang.ppt (20)

Recently uploaded (20)

Chapter_7_tucker_noonan_programmng_lang.ppt