1

Unit-05/Lecture-01

Exception Handling

Exception Handling is a programming language construct designed to handle the occurrence

of exceptions.

Exceptions are runtime unusual conditions that a program may encounter while executing.

Types of Exceptions

i. Synchronous Exception- The errors that are caused by the events in the control of
program are called as synchronous exceptions. Examples are: out of index, overflow.
ii. Asynchronous exception- The errors that are caused by the events beyond the
control of program are called as asynchronous exception. Examples are: keyboard
interrupts, out of memory.

Exception Propagation:-

If an exception is not handled in the subprogram in which it was raised, this exception is
propagated to the subprogram that called it. A handler for the exception is searched for in
the calling subprogram. If no handler is found there then the exception is propagated again.
This continues until either an exception handler is found, or the highest level of the current
task is reached, in which case the task is aborted.

Exception Handler in C++

An exception is a problem that arises during the execution of a program. A C++ exception is
a response to an exceptional circumstance that arises while a program is running, such as an
attempt to divide by zero.

Exceptions provide a way to transfer control from one part of a program to another. C++
exception handling is built upon three keywords: try, catch, and throw.

 throw: A program throws an exception when a problem shows up. This is done using
a throw keyword.
 catch: A program catches an exception with an exception handler at the place in a
program where you want to handle the problem. The catch keyword indicates the
catching of an exception.
 try: A try block identifies a block of code for which particular exceptions will be
activated. It's followed by one or more catch blocks.
 2

Throwing Exceptions:

Exceptions can be thrown anywhere within a code block using throw statements. The
operand of the throw statements determines a type for the exception and can be any
expression and the type of the result of the expression determines the type of exception
thrown.

Following is an example of throwing an exception when dividing by zero condition occurs:

double division(int a, int b)

if( b == 0 )

throw "Division by zero condition!";

return (a/b);

Catching Exceptions:

The catch block following the try block catches any exception. You can specify what type of
exception you want to catch and this is determined by the exception declaration that
appears in parentheses following the keyword catch.

try

// protected code

}catch( ExceptionName e )

// code to handle ExceptionName exception

}
 3

#include <iostream>

double division(int a, int b)

if( b == 0 )

throw "Division by zero condition!";

return (a/b);

int main ()

int x = 50;

int y = 0;

double z = 0;

try {

z = division(x, y);

cout << z << endl;

}catch (const char* msg) {

cout << msg << endl;

return 0;

}
 4

Unit-05/Lecture-02

Multiple Catch Statements

When an exception is thrown, the exception handlers are searched in order for an
appropriate match. The first handler that yields a match is excuted. After executing the
handler; the control goes to the first statement after the last catch block for that try. When
no match is found, the program is terminated.

#include<iostream.h>

#include<conio.h>

void test(int x)

try

if(x>0)

throw x;

else

throw 'x';

catch(int x)

cout<<"Catch a integer and that integer is:"<<x;

catch(char x)

{
 5

cout<<"Catch a character and that character is:"<<x;

void main()

clrscr();

cout<<"Testing multiple catches\n:";

test(10);

test(0);

getch();

Output:

Testing multiple catches

Catch a integer and that integer is: 10

Catch a character and that character is: x

 6

Unit-05/Lecture-03

Exception Handling in Java

[RGPV JUNE 2013 (10 MARKS)]

Exceptions are errors which occur when the program is executing. Consider the Java
program below which divides two integers.

import java.util.Scanner;

class Division {

public static void main(String[] args) {

int a, b, result;

Scanner input = new Scanner(System.in);

System.out.println("Input two integers");

a = input.nextInt();

b = input.nextInt();

result = a / b;

System.out.println("Result = " + result);

Java provides a powerful way to handle such exceptions which is known as exception
handling. In it we write vulnerable code i.e. code which can throw exception in a separate
block called as try block and exception handling code in another block called catch block.
Following modified code handles the exception.

class Division {

public static void main(String[] args) {

int a, b, result;
 7

Scanner input = new Scanner(System.in);

System.out.println("Input two integers");

a = input.nextInt();

b = input.nextInt();

// try block

try {

result = a / b;

System.out.println("Result = " + result);

// catch block

catch (ArithmeticException e) {

System.out.println("Exception caught: Division by zero.");

Whenever an exception is caught corresponding catch block is executed, For example above
code catches Arithmetic Exception only. If some other kind of exception is thrown it will not
be caught so it's the programmer work to take care of all exceptions as in our try block we
are performing arithmetic so we are capturing only arithmetic exceptions. A simple way to
capture any exception is to use an object of Exception class as other classes inherit
Exception class, see another example below:

class Exceptions {

public static void main(String[] args) {

String languages[] = { "C", "C++", "Java", "Perl", "Python" };

try {
 8

for (int c = 1; c <= 5; c++) {

System.out.println(languages[c]);

catch (Exception e) {

System.out.println(e);

Output of program:

C++

Java

Perl

Python

java.lang.ArrayIndexOutOfBoundsException: 5
 9

Unit-05/Lecture-04

LOGIC PROGRAMMING

[RGPV JUNE 2012( 10 MARKS), JUNE 2013(10 MARKS)]

A logic program consists of a set of axioms and a goal statement. The rules of inference are
applied to determine whether the axioms are sufficient to ensure the truth of the goal
statement. The execution of a logic program corresponds to the construction of a proof of
the goal statement from the axioms.

In the logic programming model the programmer is responsible for specifying the basic
logical relationships and does not specify the manner in which the inference rules are
applied. Thus

Logic + Control = Algorithms

Logic programming is based on tuples. Predicates are abstractions and generalization of the
data type of tuples.

Languages used for logic programming are called Declarative languages becaue programs
written using them consists of declarations rather than assignments and control flow
statements. These declarations are actually statements or propositions in symbolic logic.

Declarative semantics is simpler than the semantics of imperative languages. For example,
the meaning of a given proposition in a logic programming language can be determined
from the statement itself. In an imperative language, the semantics of a simple assignment
statement requires examination of local declarations, knowledge of scoping rule of the
language, data type of variable etc.

Facts, Predicates and Atoms

Facts are a means of stating that a relationship holds between objects.

father(bill,mary).

plus(2,3,5).

...

This fact states that the relation father holds between bill and mary. Another name for a
relationship is predicate.
 10

Queries

A query is the means of retrieving information from a logic program.

?- father (bill,mary).

?- father (bill, jim).

Introduction to Prolog

A prolog term is a constantan, a variable, or a structure. A fact statement is simply a

proposition that is assumed to be true.

Ex. female(Shelly). – note: every statement is terminated by a period.

Rule statements state rules of implication between propositions.

Ex. parent(X, Y): - mother(X, Y). This means that if x is a mother of y then x is the parent of y.

A goal statement is one that which requests an answer; the syntactic form of fact
statements and goal statements are identical

Ex. father(X, mike). This asks the question “who is the father of mike?”

parent(sue, bill).

parent(sue, james).

parent(sue, edith).

parent(fred, bill).

parent(fred, james).

parent(arthur, edith).

parent(mary, kylie).

parent(mary, jason).

parent(mary, matilda).

parent(james, kylie).

parent(james, jason).
 11

parent(james, matilda).

parent(edith, david).

parent(william, david).

ancestor(X, Y) :-parent(X, Y).

ancestor(X, Y) :-parent(X, Z), ancestor(Z, Y).

An example query would be? - ancestor (fred, david), "Is fred the ancestor of david" which
would return a no.
 12

Unit-05/Lecture-05

INTRODUCTION TO FUNCTIONAL PROGRAMMING

[RGPV JUNE 2013 (10 MARKS), JUNE 2014 (7 MARKS)]

The functional programming paradigm is based on mathematical functions. LISP is a purely

functional language. ML is a strongly typed functional language with more conventional
syntax than LISP.

Mathematical Functions

A mathematical function is a mapping of members of one set called the domain set to
another set called the range set.

A function definition specifies the domain and range sets along with the mapping. The
mapping is described by an expression; functions are always applied to a particular element
of the domain set and a function return an element of the range set.

1. Simple Functions- Function definitions are often written as a function name,

followed by a list of parameters in parenthesis followed by the mapping expression

Ex- Cube (x) = x*x*x

Where x is real number.

In this definition the domain and range sets are real numbers. The parameter ‘x’
can represent any member of the domain set. The range element is obtained by evaluating
the function mapping expression with the domain element substituted for the occurrences
of the parameter.

Ex- Cube (2.0) returns 8.0

2. Lambda Notation- In functional programming lambda notation provides a method

for defining nameless functions. A lambda expression specifies the parameter and
the mapping of a function. Ex- (ƛ(x) x * x * x)(2) which results in the value 8.
3. Functional Forms- A higher order function or function form is one that either takes
functions as parameters or returns a function as its result or both.

Types of Functional Forms

1. Functional composition- It has two functional parameters and returns a

 13

function whose value is the first actual parameter function applied to the
result of the second. Functional composition is written as an expression1
using o as an operator.

H= f o g

Ex- if f(x) = x+2

g(x)= 3*x

then h is defined as h(x)= f(g(x)) or

h(x)= (3 * x) + 2

2. Construction- Construction is a functional form that takes a list of functions

as parameters. When applied to an argument, construction applies to each of
its functional parameters to that argument and collects the result in a list or
sequence. A construction is denoted by placing the functions in brackets as in
[f, g].

Ex- g(x) = x*x

h(x) = 2 * x

f(x) = x / 2

Then [g, h, f] (4) yields (16, 8, 2)

3. Apply to all- Apply to all is a functional form that takes a single function as a
parameter. If applied to a list of arguments apply to all applies to its
functional parameter to each of the values in the list argument and collects
the result in a list or sequence. Apply to all is denoted by α.

Ex- h(x) = x * x

Then α (h ( 2, 3, 4)) yields (4, 9, 16).

 14

Unit-05/Lecture-06

Fundamentals of Functional Programming

1. TYPES:- Values and Operations

“A type consists of set of elements called values together with a set of functions called
operations”.

Basic Types- A type is basic if its values are atomic- this is, if the values are treated as whole
elements with no internal structure. For Ex- the Boolean values in the set {true, false} are
basic values.

Operation on basic values- Basic values have no internal structure so the only operation
defined for all basic types is a comparison for equality; for example the equality 2 = 2 is true
and the equality 2 != 2 is false.

Product of types- The product A * B of two types A and B consists of ordered pairs written
as (a, b) where a is value of type A and b is value of type B. Thus

 (1, “one”) is a pair consisting of the integer 1 and the string “one”
 A product of n types A1 * A2.... * An consists of tuples written as (a1,
a2... an)

Operations on Pairs- Associated with pairs are operations called projection functions to
extract the first and second elements from a pair.

Projection can be defined as

fun first (x, y) = x;

fun second( x, y) = y;

List of Elements- A list is a finite length sequence of elements. The type A list consists of all
list of elements, where each element belongs to type A.

For Ex- int list

consists of all lists of integers.

List elements is written between brackets [ and ] separated by commas

 15

 The list [1, 2, 3] is a list of three integers 1, 2, 3.

 The list [“red”, “white”, “blue”] is a list of strings.

2. FUNCTION DECLARATION

A function declaration has three parts:

I. The name of the declared function

II. The parameters of the function.
III. A rule for computing a result from the parameters.

 Syntax of Function Declaration

fun <name> <formal- parameter> = <body>;

Paranthesis around the formal parameter is optional.

Ex- fun successor n = n+1;

The keyword fun marks the beginning of function declaration, <name> is the function name,
<formal parameter> is a parameter name and <body> is an expression to be evaluated.

The function is called as follows:

<name><actual parameter>

Where <name> is the name of function, <actual- parameter> is an expression corresponding

to the parameter name in the declaration of the function.

Thus, successor (2 + 3)

Is the application of successor function to the actual parameter (2 + 3).

 Recursive Functions

A function f is recursive if its body contains an application of f.

Ex- The following function len counts the number of elements in a list.

Fun len(x) = if null (x) then 0 else 1 + len( tl(x))

The function is recursive because the body contains an application of len; it is len (tl(x))
 16

Unit-04/Lecture-07

FOURTH GENERATION LANGUAGES

1 GL was machine language or the level of instructions and data that the processor is
actually given to work on (string of 0s and 1s)

2 GL is assembly language. An assembler converts the assembly language statements into

machine language.

Ex- ADD 12, 8

3 GL is a high level language such as C, C++, and Java. A compiler converts the statements of
a specific high level programming language into machine language. A 3GL requires a
considerable amount of programming knowledge.

4 GL is designed to be closer to natural language than a 3GL language. Languages for

accessing databases are often described as 4GLs. The advantage of using 4GL is that we can
write faster code than a 3GL.

For Ex- If we want to access records of employee having name ‘Smith ‘from emp table then
we have to write just the query

Select * from emp where name= ‘Smith’

4 GL [RGPV JUNE 2012 (2 MARKS)]

[RGPV JUNE 2014 (2 MARKS)]

The languages like Oracle, VB++, VC++, and SQL etc are called as 4 GL languages. Most 4G
languages are used to access databases. They allow the programmer to define ‘what’ is
required without telling the computer ‘how’ to implement it.

Features of 4 GL

 Ease of Use- As the syntax of 4GL is closer to human languages, it is easy to

learn. Additionally due to the nonprocedural nature of many of the
languages the techniques for accomplishing things are also simple, while
the results are fast.
 Limited range of Functions- 4GLs are typically designed for a limited set of
functions or specific applications. Because of this, the product becomes
easier to use than a full programming language. For Ex- Oracle is used to
 17

design database while VB is used to design front end.

 Default Options- A user of a 4GL is not required to specify all the
parameters. Instead a compiler or interpreter is capable of making
intelligent assumptions. 4 GLs provides default options is user does not
make a selection.

Ex- if 101 > 100 then 101 – 10 else f ( f (101 + 11))

= 101 – 10

=91

 Outermost Evaluation-

f (100) = if 100 > 100 then 100 -10 else f ( f (100 + 11))

=f(f(100 + 11)) ---------------------------------1

= if f(100 + 11) > 100 then f(100 + 11) – 10

Else f (f(f(100 +11) + 11)

Evaluation of f (100 + 11)

f(100 + 11) = if 100 + 11 > 100 then 100 +11 -10

else f(f(100+11)+11)

=if 111 > 100 then 100 + 11 – 10

else f(f(100 + 11) +11)

= 100 + 11 – 10

= 101

By putting the value of f(100 + 11) in eq 1

f(100) = if 101 > 100 then 101 – 10

else f(f(101 + 11))

= 101 – 10
 18

=91

 Short Circuit Evaluation- The operator “andalso” and “orelse” in ML

performs short circuit evaluation of Boolean expressions in which the right
hand operator is evaluated only if it has to be

Ex- E andalso F

Is false if E is false, it is true if both E and F are true. The evaluation of E andalso F proceeds
from left to right with F being evaluated only if E is true. Similarly the value of expression E
orelse F is true if E evaluates to true. If E is false then E is evaluated. In C operators & and |
performs short circuit evaluation of Boolean expression.
 19

S.NO RGPV QUESTION YEAR MARKS

Q.1 Explain the use of predicate calculus in JUNE 2012, 10 marks

logic programming? JUNE 2014
Q.2 Explain the following types of JUNE 2012 10 marks
statements with respect to PROLOG

(i) Fact statement

(ii) Rule Statement
(iii) Goal Statement

Q.3 Write short notes on the following JUNE 2012 10 marks

(i) Exception Propagation

(ii) PROLOG
(iii) Predicate Calculus
(iv) 4 GL

Q.4 How functions are declared in JUNE 2014 7 marks

functional programming language
Q.5 Write short note on 4GL JUNE 2014 2 marks

Q.6 Discuss the features of PROLOG? JUNE 2013 10 marks

Q.7 What are Exceptions? How are they JUNE 2013 10 marks
handled in Java?
Q.8 Explain the rules for expression JUNE 2013 10 marks
evaluation in functional
programming?
Q.9 What is the purpose of instantiation JUNE 2013 10 marks
matching and unification with respect
to logic programming PROLOG?
20