Executable Part
•
This is an important part
of a program
•
This is a list of
statements executed by the machine
•
The statements are of two
kinds:
–
Those
perform operations on the variables
–
control
statements: specify the sequence of statement execution
•
The operations are
determined by the types of variables operated upon.
•
A programming language
provide a rich set of data types for representation of information and
manipulation
•
It also provides a rich set
of control statements
Program Operations
•
Programs
discussed so far have three basic operations and control flow
–
Assignment
–
Expression Evaluation
–
Reading and Writing
– Sequential
Flow of Control
Assignment
•
Specified
by assignment statement, eg.
Prod = x * y
Tot = Tot +
hours * 60 * 60
•
It
has two parts:
–
A LHS which is usually a variable
–
A RHS which is, in general, a mathematical
expression
Expressions
•
Expressions typically
appear on the RHS
•
Fortran Expressions
remarkably close to std. Math. expressions common in scientific domain
•
Major high level feature
introduced by early Fortran that gives its the name Fortran (Formula
Translation)
•
Expressions typically
involve variables, constants and operators, eg.
(Principle
* Year * Rate) /100
(arithmetic expressions)
"Mr."
name // initial // sur_name
(character expressions)
• 100, Mr are Integer and character constants - called
Literals
Expression Types
•
Variables are typed
•
Data types specify
operators that operate on the data
values eg.
–
REAL specifies +, *(multiplication),
/ (division),
* * (exponentiation),
- (minus)
–
CHARACTER allows // (concatenation)
•
Only these operators can
appear in expressions
•
Expressions evaluate to a
value of definite data type, eg.
first expression above is REAL ,
second is CHARACTER type
Type Conformance
•
LHS
variable has a type
•
RHS
expression
–
involve
operations defined by the types of variables on the RHS also has a type, eg.
•
Type
of x+y is REAL (or INTEGER)
when the types of x,y are REAL (INTEGER)
•
In
general, types of LHS variable and the value of the RHS expression should be
the same
•
This
restriction relaxed among the group
of numeric types (Real, Integer).
•
More
on this later
Execution
•
Execution
of an assignments consists of the following steps:
–
Evaluate
the RHS expression to get a value
–
Assign
(i.e., store) the value of this expression to the
(the corresponding memory location of) the LHS variable.
Evaluation
•
It is similar to
mathematical expression evaluation
•
Any variable in an
expression stands for the value stored in the corresponding location
•
Operations are
performed on these values
•
Complex control flow is
abstracted in an expression
•
Use of parenthesis and
implicit precedence rules
•
More on this later
Assignment
•
Assignment updates the
memory location corresponding to the lhs variable
•
Variables retain values
until updated
•
Stored values in
variables are accessed by using the variables on the rhs in later assignment
statements
•
Beware! Two different interpretations for variables
–
Lhs
occurrence refers to the memory location
–
Rhs
occurrence refers to the value stored
Left and Right Values
•
Consider the statement
x = x + y
•
The x on the lhs refers
to the memory location corresponding to x
•
The x on rhs refers to
the value stored in x
•
These two values are
referred as lvalues and rvalues
Run-Time Errors
•
Expression evaluation
may result in errors
–
Overflow
and underflow
–
Divide
by zero
•
Evaluation
results may be unpredictable
–
Reference
to un-initialized variables on the rhs
–
Lhs
variable may be undefined
•
So
checks have to be made before assignment statement execution
•
Explicit
and implicit checks possible
•
More
on this later
Assignment not equal to
equality
•
The
notation = used for assignment is bad and misleading
•
It
resembles conventional equality symbol but different
•
Example:
x = y
and x = x + y
•
New
symbol for new concepts
•
PASCAL
is sensible; it uses := for assignment
•
Fortran
needs standard equality symbol too ==
• more on this later
Arithmetic Expression
Evaluation
•
How to evaluate a * b / c
•
Two possibilities:
–
a*b and then divide by c or
–
b/c and then multiply by a
•
The results are different
•
Unique evaluation order
should be specified
•
Use paranthesis, like
(a*b)/c or a*(b/c)
• An implicit order of evaluation, called PRECEDENCE ORDER is
assumed using which sub expressions are evaluated in unique order
Precedence Order
•
Operators are assigned a
precedence
•
Higher precedence operators
are evaluated before lower ones
•
Given an expression, the
precedence suggests the following evaluation order:
•
First paranthesized sub
expressions are evaluated
–
if
more than one, evaluation proceeds from left to right
–
if
one nested inside another, then innermost first
**,
exponentiation (right to left)
* and / (left to right)
unary + and unary –
+ and -- (left to right)
Precedence Order
(Example)
•
Evaluation of i
+ j / k * *
2 * (3 - m)
–
expression
in brackets evaluated first (3-m)
–
exponentiation
next (k ** 2)
–
division,
multiplication ((j / (k**2)) * (3-m))
–
additions
and subtractions
•
expression equivalent to
(i + (( j / ( k ** 2) ) * (3-m)))
•
put brackets to clarify
evaluation order
• redundant brackets do not harm
Mixing Integers and Reals
•
Arithmetic expressions may
involve both real and integer variables
•
integer variables and sub
expressions are converted to real,eg.
in (x + i), where x is
real and i integer variable,
first i is converted to real and added to x
•
conversion involves change
of internal representation
•
In x = e, where x is a real
variable and e is an integer expression, the integer value of e is converted to
real before assigning to x
•
If x is integer and e is
real then the real value is converted to integer and assigned to x
• Real to integer can cause overflows
Explicit Conversion
•
The
conversion above is implicit and cause surprise
•
Better
not to mix integer and reals
•
If
cannot be avoided, use explicit conversions
• Fortran provides a lot of intrinsic
functions for explicit conversions
Intrinsic Functions
•
real(e)
–
value
of integer expression e changed to real form
–
real(e)
is an expression of type real
•
int(e)
–
value
of real expression e changed to integer
–
fractional
part is ignored
•
nint(e)
– same
as int except that real is converted to the nearest integer
Intrinsic Functions
•
floor(e)
–
largest
integer <= value of e, which is real
•
ceiling(e)
–
smallest
integer >= value of e
•
anint(e)
–
real
converted to nearest integer in real form
– same as real(nint(e))
Functions in Expressions
•
Such
functions can appear in expressions
•
eg.
x + real(i), i * ceiling (r)
•
such
functions have the highest precedence
• arguments evaluated first and then the
functions
READ and PRINT Statements
•
READ statements reads value
of variables from a file or keyboard
•
PRINT statements outputs
the values of specified variables to the printer or a file
•
Every print statement
prints the output in a fresh line
•
typical examples are:
READ
*, Temperature, Pressure
PRINT
*, Volume, Time
•
The * in both refer to default I/O devices, namely keyboard and
printer respectively
•
The * also refers to a
certain default format for printing
•
How to override the default
settings?
• will see later
Sequential Control Flow
•
Programs
seen so far contained one or more assignment statements and READ and PRINT
statements
•
Each
statement appears in a fresh line
•
Assignment,
READ/PRINT statements direct the control to flow to the following statement.
•
Hence
these statements are executed in the order in which present
•
Order
is important; result may vary if order is changed
• There are statements which change the
normal sequential flow which we will see later