UNIT-V

• Exception handling, Exceptions, exception Propagation, Exception handler in C++ and Java.

• Logic Programming Language: Introduction and overview of logic programming, basic elements of Prolog, application of logic programming.

• Functional Programming Languages: Introduction, fundamentals.

• Introduction to 4GL.

Exception Handling

It 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

1. 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.

2. 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.

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 }

#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;

}

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)

{

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

Exception Handling in Java

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;

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 {

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

LOGIC PROGRAMMING

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

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.

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).

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.

INTRODUCTION TO FUNCTIONAL PROGRAMMING

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 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).

Fundamentals of Functional Programming

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

The list [1, 2, 3] is a list of three integers 1, 2, 3.  The list [“red”, “white”, “blue”] is a list of strings.

FUNCTION DECLARATION

A function declaration has three parts:

1. The name of the declared function

2. The parameters of the function.

3. 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))

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

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 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

=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 and also 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.