Actions which manipulate the contents of variables

An excellent site for learning Ada is: http://www.scism.sbu.ac.uk/law/lawhp.html)

Variables: Variables are “named” storage locations, which have a program defined identifier associated with a “block” of storage somewhere in memory. Variables are created via the process of “declaration” where an identifier (legal name in some programming language) is associated with storage, the size of which is determined by the variables “type”. As variables are used it may take on many different values throughout the life of the program. Each time an assignment is performed, the pervious value of the variable is lost.

int x;

printf(“%d”, x);

The collection of identifiers and their associated values and the location of control in the program constitute the “state” of the program. The state is a logical model of storage which is an association between memory locations and values. A program in execution generates a sequence of states. The transition from one state to the next is determined by assignment operations and sequencing commands (alter the flow of control).

Programs are a sequence of individual actions which together perform some computation. Unless carefully written an imperative program can only be understood in terms of its execution behavior. IE: for the most part there are no restrictions on how a programmer can write a program. The reason is that during the execution of the code, any variable may be referenced, control may be transferred to any arbitrary point and any variable binding may be changed (variables and a value is bound by an assignment). Thus the whole program may need to be examined in order to understand even a small portion of code.
When imperative programming is combined with subprograms it is called procedural/structured programming. Structured programming is a style of programming that emphasizes hierarchical program structures in which each command has one entry point and one exit point. The goal of structured programming is to provide control structures that make it easier to reason about imperative programs (subprograms, conditional statements, and constructs for iteration.)

An program written in an imperative programming language is structured as a set of one or more “subprograms”: Procedures or Functions:

int main ()

{

declarations

executable statements

>

A C program consists of one or more functions one of which MUST be named main. C only supports one type of subprogram and that is the function.
Execution of a C program is initiated with the function main.
There are many types of compiler directives, but to begin with we will just consider 2.

1. 
   #include <.ksfk> refers to s system library header file,
   
2. 
   #include “ “ refers to a user defined header file.
   

Header files give our programs access to pre-built resources such as the definitions of constants, data types, and function prototypes. These resources are typically grouped by type, based on similar purpose. Ie: stdio.h - io functions
The implementation of functions declared in the system header files are contained in the C run-time library. The header file provides information about the resources to the compiler and the linker causes the function bodies to be included in the program .
The C compiler pre-processor replaces the #include statement with the contents of the appropriate header file
#include

provides our program with access to the standard i/o functions

#include

provides our program with access to the mathematical functions that constitute the math library.

A second useful compiler directive is #define

#define name value

is a way to define constants in our program….. These are not variable constants….
#define MAXIMUM 100 ---tradition is to use uppercase letters..
The preprocessor replaces the string “name” everywhere it appears in our program except within comments with the literal string “value”. The compiler makes NO attempt at verification, and the replacement could cause a compiler error.

In C all statements end with a semicolon ----------- ;

Comments begin with /* and end with */ and can continue across several lines…
Look at example 1

Variables & bindings:
Imperative programs are characterized by a sequence of “bindings” in which a name is bound to a value at one point in the program and later bound to a different value. Most descriptions of IPL’s are tied to hardware and implementation considerations where a name is bound to an address, a variable to a storage cell and a value to a bit pattern. An identifier is tied to three bindings, a binding to a location, a binding to a data type, and to a value. The location is called the lvalue, and the value is called the rvalue.
X = X +1;
The x on the Left of the assignment denotes a location while the X on the right hand side denotes a value. Assignment change the value at a location.

When a binding occurs varies: A programming language may have static or dynamic bindings. A binding is static is it occurs before runtime, or dynamic if it occurs at run time. Languages such as C and Ada, statically bind a data type to a variable at compile type. An “lvalue” may be bound at compile time (rare), or a load time (for languages with static allocation: C, Ada, Pascal) or at run time (for languages with dynamic allocation. The “rvalue” associated with a variable may change many times during the execution of a program, so the “rvalue” binding is dynamic.

Variable declarations are used to determine the amount of storage required by a program.
Forms:

C: Type name;

Ada: name: Type;
Every programming language has it’s own set of “data types” which define both the types of values that can be stored in a variable, and the amount of storage that will be allocated to the variable.
C:

Short, long, & int: integer types in the range 2-4 bytes

Int x = 10;

Float & Double: Floating point numbers, 4 & 8 bytes respectively

Float y = 4.5;

Char: Character variables, 1 byte

Char z = ‘a’;

Identifiers: a-z, A-Z, 0-9 and “_”. First character can not be a digit. Identifier length can vary between operating systems and C compilers. Ansi C considers the first 31 only, and disregards the remainder.
Ada:

Integer: Whole numbers

X : integer := 10;

Float: Real Numbers, and integer part , a decimal portion with a decimal point in between.

Y: float := 10.50;

Boolean: True & False

flag: boolean := true;

String: Data consisting of one or more characters. letters, digits or special symbols. It must have a defined length.

name: string (1..25) := “Camille Hayhurst”;
Character: single character.

C: char := ‘c’;

identifiers (names): (A-Z & a-z, 0-9), and underline, must begin with a letter. Not case sensitive.


NOTE: integer, char, enumeration and Boolean data types are often referred to as discrete types, because they have a predefined, limited set of values.

Note: Variables are different than named constants.. the value associated with a variable can change throughout the program execution, while the value associated with a constant can not:

In ada we define constants like variables, but use the KEYWORD “constant”. Constants must be assigned an initial value when they are declared!!!.

Ada PI: constant float := 3.1415;
C basically offers two types of constants:
C:

Const type identifier=initial value;
const int X = 12;

Defines a named constant, which is a variable whose value can not be changed. These are treated as variables by the compiler, and allows the compiler to perform consistency checking when a program is compiled.

#define identifier value
#define MAX 100
defines a “symbolic” constant, which is simply a literal string, that can be included in header file. The preprocessor simply does a “blind” substitution of the value anywhere that the “identifier” is encountered in the program text. This can cause compilation errors.

Binding of values

The variable and a value is Bound by an assignment statement:
C: V = E;

Ada: V := E;

Where V is a variable name, and E is some expression. Either a constant or an expression which yields some value. Assignment is what distinguishes imperative programming languages from other programming languages, it is read “assign the name V to the value of the expression E until the name V is reassigned to another value.
X := 3

X := X +1

There are many kinds of assignments:
X := X op E --- calculation X = X + 1

X := V -- V is a literal value X = 3

“C” X op= E
multiple assignment

X0:= X1:=X2:= E;

C is NOT a strongly typed language, which means we can have variables of different types in the same expression. Ada IS a strongly typed language. We may not have variables of differing types in the same expression, unless we explicitly perform a type conversion.
In Ada:
X: integer =0;

Y: float := 3.4;

X := integer(Y) +1;

A type conversion is C is called “casting”. Where we basically coerce a value of one type into another. X = (int) Y +1;


Flow of Control:
The order in which statements are executed is the “flow of Control” within a program. The default “flow” of control is sequential, statements are executed one after the other in the order in which they occur in the file.

Control Structures: Are syntactic structures that define the order in which executable statements are performed. These are sequence control mechanisms and fall into 4 categories :sequential composition, alternation and iteration.

Sequential Composition: Sequential composition specifies a linear ordering for the execution of commands. It is the default flow of control, where statements are executedc one after the other in the order in which they occur in the file. It is usually indicated by placing commands in textual sequence and a special symbol (ie: ;) is used as either a line separator or line terminator the termination.

C & Ada: ; is a line terminator

Sequential composition is a sequence of two or more commands, it is the simplest form of composition, and available in every imperative language:

s0;s1;s2

C: Hello World

#include "stdio.h"

int main (void)

{

printf ("HELLO WORLD\n");

return;

}

Ada: Hello World

with Text_Io;
procedure Hello is

begin

Text_Io.Put(“Hello World!!”);

Text_Io.New_line;

Text_io.Put(“I am Camille”);

end Hello;

Selection: (alternation): Selection permits the specification of alternate sequences of actions (commands), where the selection of a particular sequence to execute is based on the value of a logical expression. Examples of these statements are the if & case (switch) constructs.


Alternation: may contain a number of alternative sequences of command from which EXACTLY ONE is chose to be executed: if, nested if, and case.

Classic forms: of selection statements are: E represents a logical expression which can be evaluated to true or false, and S, S1 & S2 represent sets of one or more executable statements.

If E Then S1; If the logical expression E is true, then execute step S1, other wise continue with the next executable statement

In C the basic if statement has the following format:

if (logical expression) statement;

A logical expression in C consists of a series of one or more conditional expression. A conditional expression has the form:

Value1 relational-operator value2
Where value1 & value2 can be a variable name, a literal value, or the value returned from a function call. In C, the execution of a conditional statement has a numeric value. A value of 0 (zero) is defined as “false” and every thing else is considered as true!!!!
Relational operators: <, >, <=, >=, = = , != (left to right associatively)

Compound logical expressions contain a series of 2 or more conditional expressions, joined with the logical and (&&), or the logical or (||) operators. The logical not (!) negates (reverses) the initial value of an expression.

Truth table:

P	Q	P && Q	P || Q	!P
True	True	True	True	False
True	False	False	True	False
False	True	False	True	True
False	False	False	False	True

Sample expressions:

1 < 9
X = = y
X > 0 && X < 10
Peculiarities:

int a = 5;

if ( a == 10) is false
if ( a = 10) is TRUE… Assignment is frequently incorrectly used in place of the equality operator with is two equal signs. This assignment would assign the value of 10 to a, this non zero value is interpreted as true!!!!!
Short circuit evaluation; The evaluation of multiple logical expressions ( with the && and ||), evaluation stops as soon as the truth of the expression is known:
P && Q if P is true then Q is evaluated. If P is false there is no need to evaluate Q.

P || Q if P is false then Q is evaluated. If P is true then there is no need to evaluate Q.

Ada
In Ada, the general format of the IF statement is:

if condition then statement (s) end if;
The relational operators are:

=, /=, <, <=, >, >=
The logical operators are: and, or, not
Short circuit evaluation of expressions is NOT performed, there are special “short circuit operators”: and then, and the or else

Sample 1- C:, simple if with one executable statement.

#include

int main(void)

{

int num;

printf ("enter a number: ");

scanf ("%d", &num);

if (num > 0)

printf("number is positive");

printf ("All done");

return;

}

with Text_Io;
package Int_io is new Text_io.Integer_io (num=>Integer);
procedure if_demo is

num: integer;

begin

Text_io.Put(“enter a number: ”);

text_io.new_line;

Int_io.Get(item=> num);

if (number > 0 ) then

Text_io.put(“number is positive”);

end if;

text_io.New_line;

Text_io.put(“All done”);
end if_demo;


The second general from of the IF statements is the “if then else” construct. Which specifies a series of actions to perform if the expression is true, and an alternate group of statements if the expression is false.
If E Then S1 Else S2;

If then Else example

C
#include
int main (void)

{

int magic;

int guess;

int i;
magic = 1325;

printf ("Enter your guess: ");

scanf ("%d", &guess);

if (guess == magic)

printf (" You are RIGHT!!!");

else

printf ("... Sorry you are wrong..");

}

return;

}

Ada

with Text_Io;
package Int_io is new Text_io.Integer_io (num=>Integer);
procedure if_demo is

number, guess: integer;

begin

number := 2;

Text_io.Put(“Guess a number between 1 and 10”);

text_io.new_line;

Int_io.Get(item=> guess);
if number = guess then

Text_io.put(“you guessed correctly good for you!”);

else

Text_io.put(“Sorry, you guessed wrong”);

end if;
end if_demo;

Multiple executable statements in an if clause:
C
#include
int main (void)

{

int magic;

int guess;

int i;
magic = 1325;

printf ("Enter your guess: ");

scanf ("%d", &guess);

if (guess == magic)

{

printf (" You are RIGHT!!!");

printf (“the number was: %d, magic);

}

else

printf ("... Sorry you are wrong..");

}

return;

}


ada

with Text_Io;
package Int_io is new Text_io.Integer_io (num=>Integer);
procedure if_demo is

number, guess: integer;

begin

number := 2;

Text_io.Put(“Guess a number between 1 and 10”);

text_io.new_line;

Int_io.Get(item=> guess);
if number = guess then

Text_io.put(“you guessed correctly good for you!”);

Text_io.put(“You are so smart!”);

else

Text_io.put(“Sorry, you guessed wrong”);

Text_io.put(“You big dummy!”);

end if;

end if_demo;

Nesting of If statements:

It is possible to include additional if-then-else constructs inside the set of executable statements for an if statement. When this occurs this is called “nesting”, because one if statement in contained inside another:

C

#include

int main(void)

{

int a,b;

char ch;
printf ("Do you want to Add, Subtract, Multiply or Divide?\n");

printf ("Please enter the first letter of what you would like to do?");

ch = getchar();

printf ("Enter first number: ");

scanf ("%d", &a);

printf ("Enter second number: ");

scanf ("%d", &b);

if (ch == 'A')

printf ("Answer is %d", a+b);

else {

if (ch == 'S')

printf ("Answer is %d", a-b);

else {

if (ch == 'M')

printf ("Answer is %d", a*b);

else {

if (ch == 'D' && b!=0)

printf ("Answer is %d", a/b);

}

}

}

return;

}

Ada

with Text_io;
procedure nestedif is
package Int_io is new Text_Io.Integer_Io(Num=>Integer);
number1, number2, result: integer:=0;

operator: char;

begin

Text_io.put(“please enter 2 integer numbers: “);

Int_Io.Get(number1);

Int_Io.Get(number2);

Text_Io.new_line(2);
Text_Io.put(“Please enter an arithmetic operator”);

Text_Io.get(operator);

if operator = '*' then result := number1 * number2

elsif operator = '/' then result := number1 / number2

elsif operator = '+' then result := number1 + number2

elsif operator = '-' then result := number1 - number2

else Text_Io.put(“invalid operation”);

end if;
text_io.put(“the result is: “);

int_io.put(result);

text_io.new_line;
end nestedif;

Switch/Case statements can be used to simplify the logic of nested/multiple if statements when only ONE execution path will be executed between all of the alternatives:

C:
#include
int main(void)

{

int a,b;

char ch;
printf ("Do you want to Add, Subtract, Multiply or Divide?\n");

printf ("Please enter the first letter of what you would like to do?");

ch = getchar();

printf ("Enter first number: ");

scanf ("%d", &a);

printf ("Enter second number: ");

scanf ("%d", &b);

switch(ch)

{

case 'A':

printf ("Answer is %d\n", a+b);

break;

case 'S':

printf ("Answer is %d\n", a-b);

break;

case 'M':

printf ("Answer is %d\n", a*b);

break;

case 'D':

if (b!=0)

printf ("Answer is %d\n", a/b);

break;

}

Ada
with Text_io;
procedure nestedif is
package Int_io is new Text_Io.Integer_Io(Num=>Integer);
number1, number2, result: integer:=0;

operator: char;

begin

Text_io.put(“please enter 2 integer numbers: “);

Int_Io.Get(number1);

Int_Io.Get(number2);

Text_Io.new_line(2);
Text_Io.put(“Please enter an arithmetic operator”);

Text_Io.get(operator);

case operator is

when ‘+’ =>

result = number1+ number2;

when ‘-‘ =>

result = number1-number2;

when ‘* ‘=>

result = number1*umber2;

when ‘/ ‘=>

result = number1/number2;

when others =>

Text_Io.put(“invalid operation”);

end case;

text_io.put(“the result is: “);

int_io.put(result);

text_io.new_line;
end nestedif;

Iteration: Iteration specifies that a sequence of commands may be executed zero or more times. At run time the sequence is repeatedly executed, the number of times the repetition occurs is determined by a logical expression. Examples of these statements are while, for, repeat, and loop.

“Definite Iteration “.

In a “definite” iteration the loop is executed a predetermined number of times. In other words by the time control reaches the loop, the number of iterations is already known. The classic construct for definite iteration is the classis “FOR” loop. These type of loop constructs typically specify an index variable, and range of values which the index variable will be assigned. The index is assigned the value of the lower bound during the first iteration through the loop. Then the index variable is incremented (or decremented) during each successive iteration, until the “upper bound” is reached. In Ada, the “for” loop is a definite loop construct:
ADA

--For loops which increment the index variable by 1

for index in lower .. upper loop

statements in loop body

end loop;

-- for loops which “decrement” the index variable by -1

for index in reverse lower .. upper loop

statements

end loop;


EXAMPLE
For I in 1..10 loop

Int_Io.Put(I);

end loop;
Differences with Ada:

1. 
   the Index variable “I” is automatically declared for you, and is a local variable inside the loop.
   
2. 
   It is ILLEGAL to change the value of the index variable inside the loop. I can appear in the right hand side of expressions, but can not be assigned a value inside the loop.
   
3. 
   After the loop terminates, the index variable ceases to exist.
   

Note the for loop in C is not a definite loop construct.

Indefinite Loop constructs:

An “indefinite” iteration is one for which the number of iterations through the loop is not know when the control reaches the loop. The number of iterations is determined through the computations performed inside the loop. The classic indefinite iteration construct is the WHILE loop.

PRE-TEST LOOPS:
The classis while loop is also one type of “pre-test” loops. Pre-test loop are loop constructs where the exit condition is checked at the BEGINNING of each iteration. Therefore the body of a pre-test loop can be executed ZERO OR MORE times.

Ada While Loop:

while condition loop

statements;

end loop;


Example:
I := 10;

while (I <=100) loop

Int_IO.put(I);

I := I+10;

end loop

POST TEST LOOPS

A post-test loop construct checks the exit condition at the END of each iteration through the loop. This means the body of the loop will ALWAYS be executed at least ONCE.

ada:
label:

loop

statements;

exit label when condition;

end label;

example: sum the numbers from 1 to 10
sum, I: integer;
I := 1;

Sum := 0;

Sumit:

Loop

Sum := sum +I;

I := I +1;

Exit sumit when I > 10;

End sumit;

NOTE: In ada the “loop” construct is a generic loop, the exit condition can appear anywhere inside the body of the loop.
Abstraction: A sequence of commands that is named and the name is used to invoke the sequence of commands causing them to be executed : functions, procedures, subprograms