CS 241 - WLP4 Programming Language Tutorial

WLP4 in a nutshell for C or C++ Programmers

A WLP4 program is a sequence of C++ functions (we use the terms 'procedure' and 'function' interchangeably in this document), the last of which is is the main function and is called wain. Functions may have any number of parameters, but the main function wain has two parameters. The type of the first parameter of wain is either long or long*. The type of the second parameter of wain is long. The type of the result of every procedure is long.

Declarations, control structures and statements that may be used in WLP4 are restricted to:

long or long*(declaration of a single long or long* variable with an unsigned integer constant or NULL initializer; all declarations in WLP4 must precede all statements and control structures; every declaration must include an integer constant or NULL initializer)
if (must have an else clause)
while
return (must be the last statement in function)
println
putchar
= (i.e. assignment)
delete [] (i.e. deallocation)

The clauses of if and while containing statements must be enclosed in braces (i.e. {}).

Expressions may contain only variable names, integers (written in decimal without a sign), function calls, memory allocation (i.e., operator new), unary & and *, and the binary (two operand) versions of the following operators:

    + - * / % == != <= >= < >

Arrays of consecutive integers may be dynamically allocated using new and delete [], but their elements can be accessed only using pointer dereferences, because WLP4 does not include the C++ operator []. The // notation (and only the // notation) may be used for comments.

Example WLP4 Program

//
// WLP4 Program to compute:
//   a^b if 0 <= a,b < 10
//   -1 otherwise
//

long wain(long a, long b) {
   long counter = 0;
   long product = 0;
   product = 0-1;  // only binary minus
   if (a >= 0) {
      if (b >= 0) {
         if (a < 10) {
            if (b < 10) {
               product = 1;
               counter = 0;
               while (counter < b) {
                  product = product * a;
                  counter = counter + 1;
               }
            } else {} // must have else
         } else {} 
      } else {} 
   } else {}
   return product;
}

Notable differences between WLP4 and C/C++

Functions

Functions in WLP4 can only have one return statement, which must be at the very end.

long max(long a, long b){
  if (a > b){
    return a; // cannot return here
  } else {
    return b; // or here
  }
  // must return here
}

Fixed for WLP4, the above code looks like this:

long max(long a, long b){
  long answer = 0;
  if (a > b){
    answer = a;
  } else {
    answer = b;
  }
  return answer;
}

Local Variable Declarations

Within a function body, all the local variables must be declared at the beginning of the function, before any other code.
Variables can only be initialized to a single number or NULL.

long average(long a, long b){
  long sum = 0;
  sum = a + b;
  long average = sum / 2;
  return average;
}

Fixed for WLP4:

long average(long a, long b){
  long sum = 0;
  long average = 0;
  sum = a + b;
  average = sum / 2;
  return average;
}

if-statements

if-statements must have an else statement (though it can be empty). The conditions for an if or a while must be singular - logical AND (&&) and OR (||) do not exist in WLP4. There is no else if in WLP4.

long max3(long a, long b, long c){
  long answer = 0;
  if (a > b && a > c){ // cannot use "&&"
    answer = a;
  } else if (b > a && b > c){ // or "else if"
    answer = b;
  } else {
    answer = c;
  }
  return answer;
}

Fixed for WLP4:

long max3(long a, long b, long c){
  long answer = 0;
  if (a > b) {
    if (a > c) {
      answer = a;
    } else {
      answer = c;
    }
  } else {
    if (b > c){
      answer = b;
    } else {
      answer = c;
    }
  }
  return answer;
}

Arrays

There are no "arrays" in WLP4, though pointers can be dereferenced to achieve the same effect.

long getlast(long* begin, long size){
  return begin[size - 1]; 
}

Fixed for WLP4:

long getlast(long* begin, long size){
  return *(begin + size - 1); 
}

Blocks of memory can be allocated using new and deallocated using delete just like in C++. The expression new long[n] will allocate a block of n 32-bit words, each of which holds a single long, and return a pointer to the start of the block. You can then treat this block as an "array of longs" by accessing it through the pointer.

long wain(long* begin, long size){
  long* copy = NULL;
  long i = 0;
  copy = new long[size];
  while(i < size) {
    *(copy+i) = *(begin+i);
    i = i + 1;
  }
  delete [] copy;
  return 0;
}

The code above does nothing useful (it creates a copy of an array and then immediately deletes it) but demonstrates how to use new and delete in WLP4.

I/O

WLP4 provides standard input and output functions. For character-at-a-time I/O, it provides putchar and getchar. putchar is implemented as a statement, but it has the same form as it would have in C or C++: putchar(c);. The argument is an long, but only the low 8 bits are used; one byte is output to standard output. getchar returns a long of which only the low bits are set as a single byte from standard input, unless end of file was reached, in which case it returns -1.

In addition, it provides a println statement that prints an integer in base 10 to standard output, with a newline (i.e., on a line of its own). Like putchar, it's implemented as a statement, but has the same form as it would have in C or C++ as a function call: println(i);.