EXPRESSION, STATEMENTS AND SIMPLE I/O

1. EXPRESSIONS

• Expressions are composed of one or more operands whose values are combined by operators.
• Typical operators include the maths operators +, -, *, /.
• Example:

  NUM_I + (2 * NIM_J)
  

• Evaluation of an expression produces a value (an anonymous data item).
• Expressions can therefore be used to assign values to variables.

Boolean expressions

Boolean expression return the values true or false. Well know Boolean operators include:

The first 6 of the above are sometimes referred to as comparison operators and the remaining 3 as logical operators. Examples of Boolean expressions:

A_VALUE < 50

B_VALUE = 0

X_VALUE >= 10 and X_VALUE < = 20

X_VALUE < 10 or X_VALUE > 20

A_VALUE < 20.0 and (B_VALUE /= 'q' or testFun(A_VALUE, C_VALUE) = 1)

These can be interpreted as follows:

1. Return TRUE if value for data item A_VALUE is less than 50, otherwise return FALSE.
2. Return TRUE if value for data item B_VALUE is equal to 0, otherwise return FALSE.
3. Return TRUE if value for data item X_VALUE is greater than or equal to 10 and less than or equal to 20 (i.e. X_VALUE is within the range 10..20), otherwise return FALSE.
4. Return TRUE if value for data item X_VALUE is less than 10 or greater than 20 (i.e. X_VALUE not within the range 10..20), otherwise return FALSE.
5. Return TRUE if value for data item A_VALUE is less than 20.0 and either the value for B_VALUE is the character 'q' or the value returned by the test function (which has two arguments A_VALUE and C_VALUE) is equal to 1, otherwise return FALSE.

2. OPERATORS

• The number of operands that an operator requires is referred to as its arrity.
• Operators with one operand are called monadic or unary.
• Operators with two operands are called dyadic or binary.
• Operators can also be classified as prefix, infix or postfix.

Ternary Operators

Some languages support ternary operators (arrity = 3). For example the "ternary condition operator" (?:) supported by C:

<condition> ? <expression1> : <expression2>

Returns expression1 if condition is true and expression2 otherwise. Example:

#include <stdio.h>

main () {
    int number;

    scanf("%d",&number);

    printf("The number %d is an ",number);
    (number/2)*2 == number ? printf("even") : printf("odd");
    printf(" number.\n");
    }

#include < stdio.h>

int division(int, int);

void main(void) {
    printf("Result of ternary operation = %d\(bsn",division(0,2));
    printf("Result of ternary operation = %d\(bsn",division(8,2));
    printf("Result of ternary operation = %d\(bsn",division(2,1));
    printf("Result of ternary operation = %d\(bsn",division(1,0));
    }

int division(int num1, int num2) {
    return(num2 != 0 ? num1/num2 : 0);
    }

2.1. PRECEDENCE OF OPERATORS

• Operators are ordered according to which should be applied first. We say that operators have precedence.
• We also consider levels of precedence to exist.
• Low-level operators have precedence over high-level operators.
• Consequently we say that low-level operators bind their operands more strongly than high-level operators.
• Operators on the same level have the same precedence.

#include < stdio.h>

void main(void) {
    int numA = 2;
    int numB = 4;

    printf("%d\(bsn",numA+numB*numB);
    printf("%d\(bsn",numB*numB+numA);
    printf("%d\(bsn",(numA+numB)*numB);
    printf("%d\(bsn",numA*2==numB);
    printf("%d\(bsn",numA+2==numB*2);
    }

The order of execution of operators on the same level is controlled by associativity:

• Left-associative operators are executed from left to right.
• Right-associative operators are executed from right to left.

If an operator is non-associative it cannot be used in a sequence.

The and Operator and Lazy Evaluation

Consider the following C expression:

(quantity != 4) && (number_x == quantity+value*4) && (number >= 0)

This sequence will be evaluated from left to right (&& is left associative) until the end of the sequence is reached or one of the operands for the and operators fails. This process of not needlessly evaluating each operand is termed lazy evaluation. Lazy evaluation is an important concept in functional languages.

The above is not supported by Ada. In the case of the Ada and operator no order of evaluation (associativity) is specifyed, i.e. all operands for a sequence of and operators will be evaluated regardless of whether this is necessary or not. The effect of "lazy evaluation", as illustrated in the above C example, can be achieved in Ada by writing:

(QUANTITY /= 4) and (NUMBER = QUANTITY+VALUE*4) then (NUMBER >= 0)

C example:

#include < stdio.h>

void main(void) {
    int numA = 2;
    int numB = 4;

    printf("%d\(bsn",numA+numB*numB);
    printf("%d\(bsn",numB*numB+numA);
    printf("%d\(bsn",(numA+numB)*numB);
    printf("%d\(bsn",numA*2==numB);
    printf("%d\(bsn",numA+2==numB*2);
    }

2.2 HE C POST-INCREMENT AND PRE-INCREMENT OPERATORS

Certain assignment expressions such as:

j = j+1;            J := J+1;
k = k-1;            K := K-1

are so common that some imperative languages (but not Ada) provide a short hand notation for them:

i++;				i--;

The operators are referred to as the post-increment and pre-increment operators.

3. STATEMENTS

Statements are the commands in a language that perform actions and change the "state" (the term is used for historical reasons). The state of a program is described by the values held by its variables at a specific point during its execution. Example statements:

• Assignment statements, which change the values of variables.
• Sequence statements, which define the flow of a program.
• Selection statements, which define alternative courses of action.
• Repetition statements, which define program loops.
• Etc.

Statements are usually separated by some operator (symbol); in Ada, Pascal and C this is a semi-colon symbol (;).

3.1. Assignment Statements

• The value of a variable can always be modified using an assignment statement. Examples in Ada and C:

  NUMBER := 2;                 number = 2;
  

• The operator used here is referred to as an assignment operator.
• The left hand operand is called the destination and the right hand operand the source.
• The source of a value in an assignment is usually an expression referred to as an assignment expression.
• Some imperative languages support multiple assignment.

3.2. Assignment Expressions

Assignment expressions are generally of the form:

<destination> <operator> <something>

Ada and C example:

NUMBER := INDEX*2;                                      number = index*2
VALUE := VALUE+1                                        value = value+1
COUNTER := COUNTER-1                                    counter = counter-1

The last two pairs of examples are so common that some imperative languages (C but not Ada) provide a short hand notation for them:

value++                                                 counter--

The ++ and -- operators used here are sometimes referred to as the post-increment and pre-increment operators.

4. TYPE EQUIVALENCE

• Expressions require their operands to be of a certain type.
• Imperative compilers will thus check that this is the case. This is called equivalence testing (or equivalence checking).
• Strongly typed languages require exact equivalence.
• Broadly we can identify two types of equivalence testing:
  1. Structural equivalence (Algol 68).
  2. Name equivalence (Ada).
• Structural equivalence requires that two types have the same value set and the same operators.
• Name equivalence requires that two types have the same name.
• C uses name equivalence for structures and unions, and structural equivalence for everything else.

5. COERCION, CASTING AND CONVERSION

5.1. Coercion

• In some cases it may be appropriate, when a compiler finds an operand that is "not quite" of the same type to alter the operand so that it is of the right type.
• This is called coercion.
• C supports coercion, Ada does not.
• A special example of coercion is voiding which takes an arbitrary value and converts it to be of type void.

5.2. Casting

• It is sometimes necessary for a programmer to force a coercion.
• This is referred to as a cast.
• Casting is supported by C (but not Ada).
• Example C programme:

  void main(void)
  {
  float j = 2.0;
  int i;
  
  i = (int) (j * 0.5);
  }
  

5.3. Conversion

• Where casting is not supported the most common alternative is explicit conversion. This is supported by Ada.
• Ada conversions have the following form:

  T(N)
  

  where T is the name of a numeric type and N has another numeric type. The result is of type T.
• The distinction between conversion and casting is that the latter relies on the compiler's coercion mechanism to achieve the end result while a conversion obtains the desired result explicitly through a call to a conversion function.

6. OUTPUT OPERATIONS

Outputting a given value comprises two operations:

1. Converting the value to a string
2. Displaying the string

In most imperative languages both operations can best be achieved using specially provided built in library routines. Examples:

Note that in C the user has to carry out the necessary conversion. This is not necessary in Ada. The put statement will work with data of any primitive type. A feature known as polymorphism. Polymorphism is an important concept in modern functional languages such as SML, Haskell and Miranda. Note also that in Ada, by default, numbers are "right justified" in a "field" big enough to hold the largest number for the type - this can be avoided by including a field width indicator (see example given below).

6. INPUT OPERATIONS

When inputting a value its type must be checked dynamically.

C Example

#include <stdio.h>

void main(void)
{
int number;

scanf("%d",&number);
printf("number = %d\n",number);
}

Note the use of an "ampersand" (&) indicating that we are putting something into the address of number.

Ada Example

with CS_IO ; use CS_IO ;

procedure INPUT_EXAMPLE is
        NUMBER: integer;
begin
        get(NUMBER);
        put("NUMBER = ");
        put(NUMBER, width => NUMBER);
        new_line;
end INPUT_EXAMPLE ;

Note that in Ada (also Pascal) there is no need to specify the input type as in the case of C.