Precedence, Sequence points, and Byte Ordering

"As soon as we started programming, we found to our surprise that it wasn't as easy to get programs right as we had thought. Debugging had to be discovered. I can remember the exact instant when I realized that a large part of my life from then on was going to be spent in finding mistakes in my own programmes." -- Maurice Wilkes discovers debugging, 1949.

L-value vs. R-value in a Nutshell (Review)

• An l-value (or lval) represents a memory location or storage address.
• An r-value (or rval) represents the contents of a memory location or storage address.
• Literals are r-values
• Variables can be either l-values or r-values, depending on their use
• Usually
  • if the variable can be used on the left side of the assignment operator, it's an l-value
  • if the variable can be used on the right side of the assignment operator, it's an r-value
• Hence the names, lvalue and rvalue
• A common error from MSVC++ when using an r-value incorrectly is:

  error C2106: '=' : left operand must be l-value
  

int main(void)
{
    // ASSUME:
    // address of i is 100
    // address of j is 200
    // address of pi is 300
  int i, j; // 2 ints, i and j
  int *pi;  // pointer to an int

    // Ok
  i = 3;   // put 3 (literal) into location 100
  j = i;   // put 3 (contents of location 100) into location 200
  pi = &i; // put 100 (address of i) into location 300;
  j = *pi; // put 3 (contents of address 100) into location 200;
  *pi = 3; // put 3 (literal) into location 100 (not 300)

    // Errors
  pi = 3;  // Attempting to put 3 (literal) into location 300. 
           //   Error: 'int *' differs in levels of indirection from 'const int'
           
  3 = i;   // Error: left operand must be l-value
  
  return 0;
}

• Any expression can be used as an r-value (on the right side of an assignment)
• If an expression can represent an address, it can be used as an l-value (left side of an assignment, can be assigned to)
• Some expressions can be used as either an l-value or an r-value and the compiler determines the context

Expression Evaluation

• Operator precedence
• Operator associativity

int x = a * b + c * d + e * f;

int PrintAndReturn(int value)
{
  printf("%i\n", value);
  return value;
}

int main(void)
{
  int x, y;
  x = PrintAndReturn(1) + PrintAndReturn(2) + PrintAndReturn(3);
  printf("x = %i\n", x);
  y = PrintAndReturn(1) + PrintAndReturn(2) * PrintAndReturn(3);
  printf("y = %i\n", y);
  
  return 0;
}

Sequence Guarantee Points

a = (b + c) * d / (e - 4) * (f + 5 * g);

• Usually, the order that the subexpressions are evaluated is unimportant.
• The order is important when the subexpressions contain the same variable and the variable's value is modified.
• This modification is called a side-effect.
• When side effects are present, the value of the entire expression is not always predictable.

int a[4] = {1, 2, 3, 4};
int b[4] = {5, 6, 7, 8};
int i = 0;

int c = a[i++] + b[i]; /* i++ causes a side-effect */

a[i] + b[i]

  or

a[i] + b[i + 1]

• If i is incremented before b[i] is evaluated, the value of c is 7.
• If b[i] is evaluated before i is incremented, the value of c is 6.
• a[i++] will always evaluate to 1. Why?

warning: operation on `i' may be undefined

Sequence Guarantee Operators

There are 4 sequence guarantee operators:

     Operator          Symbol      Syntax
------------------------------------------------------
logical AND operator     &&     expr1 && expr2
logical OR operator      ||     expr1 || expr2 
conditional operator     ? :    expr1 ? expr2 : expr3 
comma operator           ,      expr1, expr2

There are several side-effect operators:

     Operator                  Meaning
-------------------------------------------------------
=                          Assignment
++  --                     Pre/Post increment/decrement
+=, -=, *=, /=, %=         Arithmetic assignments
&=, !=, ^=, <<=, >>=       Bitwise assignments

What do the following functions print?

void TestCommaSequence1(void)
{
  int a = (1, 2, 3, 4);  

  printf("a = %i\n", a);
}

void TestCommaSequence2(void)
{
  int a, b;
  
  a = printf("1\n"), printf("22\n"), printf("333\n"), printf("4444\n");
  printf("a = %i\n", a);

  b = (printf("1\n"), printf("22\n"), printf("333\n"), printf("4444\n"));
  printf("b = %i\n", b);
}

When using side-effect operators (and you will use them all the time), you need to make sure that the meaning of the entire expression is not ambiguous. If it is ambiguous (ill-formed or mal-formed), it is not guaranteed to evaluate the same in all situations (read: compilers).

GNU's gcc compiler warns about the function above:

warning: left-hand operand of comma expression has no effect

Sequence Points and Expression Evaluation
Sequence Points Overcomplex statements can confuse your compiler. Knowing where the sequence points are can help make your intentions clear
Microsoft's implementation of its sequence guarantee points.

TIFF picture with byte-order encoded in first 16-bit word. You'll need to open the file in a hex editor to see the bytes.

Introduction to Endian "One, little two, little three little Endians..." This page gives a brief overview of big vs. little endian.

Some file formats and their endianness

Exercise: Write a function that determines whether your computer is little-endian or big-endian.