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, PressurePRINT *, 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