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