to CS034
Intro Systems Programming
Doeppner & Van Hentenryck
Lab 2.1
Out: 9 February 2005 What youll learn.
In the rst part of this lab, you will practice using bitwise operators. In the second part, you will open an image and read formatted data from it. The le format you will be reading is an image format called PPM (Portable PixMap). You can view any .ppm le by typing: xv <filename>
How youll do it.
First, youll be reusing your code from Lab 1 in order to get input from the user. Remember that a string in C is really just an array of chars. Youll be printing out the chars in binary form, using bitwise operators. In the second part of the lab, you will treat the string of user input as a lename. You will use the fopen() function, giving it the user input as the lename. Once you have opened the le, you will read in the data from the le and output it as a binary representation.
Task 1: Print out a binary representation of user input
Data Types
We need to understand exactly how C stores values in memory so that we will know what a string actually looks like in binary. In C, there are several basic data types for representing values. char is probably the simplest of all the data types. The length of a char is one byte, which is equivalent to eight bits of information. Because it has eight bits, a char can take on any of 256 possible values. There is a standardized mapping (called ASCII) of each of these values to one particular letter or symbol. Just as an int can be either signed or unsigned, so can a char. The most common ASCII symbols fall in the range of 0 to 127, however, there are other symbols in the 128 to 255 range which can be represented only by unsigned chars. Here are a few useful ASCII conversions. These binary representations are each 8 bits long with the least signicant bit on the right:
CS034 value 0 10 32 48 65 97 binary 00000000 00001010 00100000 00110000 01000001 01100001 character \0 \n 0 A a
Lab 2.1
9 February 2005
meaning null character represents the end of a string) newline space zero (the digits range from 48 to 57) Capital A (capital letters range from 65-90) lowercase a (lowercase letters range from 97-122)
Here is a simple string translated into binary: Hello world. 01001000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100 00101110 00000000
Bitwise Operators
Now that we know what a string should look like in binary, we need to know how to extract each binary bit one at a time. To accomplish this, we will use bitwise operators. Bitwise operators get their name because they apply to each bit of the data individually. When you use ordinary operators, such as the binary operators +, -, *, /, and %, it is possible to mix and match dierent data types in a single expression. For example, it is possible to multiply an int by a float and then place the result in an int (this is really done by rst converting the int to a float, multiplying the two floats, and then truncating the result back to an int). However, when you use bitwise operators, these semantics are thrown out the window. You have direct control over the bits of data. Furthermore, data types are sometimes represented dierently depending on which architecture or compiler you are using, so you have to be very careful when using bitwise operators. Here are some of the commonly used bitwise operators performed on four bit numbers (remember that a char is actually eight bits): A = 5 = 0101, operator << >> & | ^ ~ B = 1 = 0001, n = 1 example A << n A >> n A&B A|B A^B ~B result 1010 = 0010 = 0001 = 0101 = 0100 = 1110 =
meaning left shift right shift AND OR XOR complement
10 2 1 5 4 14
Left Shift (A << n): The result is equal to A shifted n bits to the left. This is equal to A 2n Right Shift (A >> n): The result is equal to A shifted n bits to the right. This is equal to A/2n AND/OR/XOR (A & B, A | B, A ^ B): Each resulting bit is determined by the logical AND/OR/XOR of the corresponding bit in the left and right operands. 2
CS034
Lab 2.1
9 February 2005
Complement ( A): This is a unary operator. Each resulting bit is the opposite of the corresponding bit in the operand. Each of these operators (except complement) can also be used in a compound assignment statement, similar to the += operator. For instance: A &= B is equivalent to A = A & B A |= B is equivalent to A = A | B A <<= B is equivalent to A = A << B Here are some useful techniques to use in conjunction with bitwise operators. Note that for an unsigned char, n should range from zero to seven: Creating a mask: A mask is a dummy value with a particular bit or combination of bits set explicitly to one. We will see later how this can be used. Heres how to create a mask with only the nth bit set to one: mask = 1 << n Setting a bit to one: We can explicitly set a bit to 1 without changing the value of the other bits. Note that if the bit happened to have been set already, this operation has no eect. mask = 1 << n value |= mask Clearing a bit to zero: We can explicitly clear a bit to zero without changing the value of the other bits. If the bit happened to have already been zero, this operation would have no eect. mask = 1 << n value &= ~mask Testing a bit: We can also use bitwise operations in conjunction with conditional statements. Heres how to set up a conditional statement that only succeeds if the nth bit is set to 1. mask = 1 << n if(value & mask) ... Task: Create a le called print bits.c. As you did in Lab1, read in a maximum of 100 characters of input from the user. Make sure that you remove any trailing newline character, and that the string is terminated with a null character (\0). Now, for each char in the string, print out the component bits of the char. Make sure that you print the most signicant bit rst for each character. Adding a space between each set of eight bits will make your output more readable.
3
CS034
Lab 2.1
9 February 2005
Task 2: Open a PPM le, read the data, and print it out in binary.
File Operations
Before we can use a le in any way, we must rst open the le. The C language provides some standard functions for dealing with les, using the FILE struct. There are other methods for dealing with les including le descriptors in UNIX, and le streams in C++, but the FILE semantics are very easy to use, and are guaranteed to work with any architecture for which you happen to be compiling. Opening the le gives you a pointer to a FILE struct, which you can later use to read or write to the open le. Make sure to always close your open les before exiting the program. What follows is a very brief introduction to the most common le operations. For more information, see the manpages. FILE *fopen(const char *path, const char *mode); Attempts to open the le at the specied path with the permissions specied by mode. Upon success, a pointer to a FILE struct is returned, otherwise, the function returns NULL1 . There are several options for mode. The most useful ones are r (read only) and r+ (read and write). int fclose(FILE *stream); Closes the le that was previously opened using fopen(). You should call this function once for each le you open before exiting your program. int fseek(FILE *stream, long offset, int whence); Sets the oset into the le at which subsequent writes/reads will happen. See man fseek for info on parameters.
Formatted Files
In its simplest form, a le can be thought of as an array of chars. To make this more useful, a le often is formatted so that discrete values can be extracted from it. You have already seen the printf() function. printf() is for formatting output so that it is presented to the user in an organized fashion. printf() has a cousin called fprintf() which operates on les rather than terminal output. 2
If fopen() returns NULL, you can print a nice error message using the perror() function. See man perror for more info. 2 In fact, you can also use fprintf() to write to the terminal by using a special global FILE * called stdout. This is what printf() does under-the-hood.
1
4
CS034
Lab 2.1
9 February 2005
int fprintf(FILE *stream, const char *format, ...); fprintf() takes as parameters a le, a format string, and then some number of values determined by the format string. The values are inserted into the format string. The return value is the number of bytes actually written to the le. The le position is also automatically advanced by this amount. [f]printf() also has a relative that is able to read in from a le based on a specied format string: int fscanf(FILE *stream, const char *format, ...); fscanf() uses the same style of formatting string as the printf() family of functions. To fully understand how it works, youll need to read the man page, but here is one example to get you started: #include <stdio.h> int main() { FILE* file = fopen("filename", "r"); int grade; char gradeLetter; char name[11]; fscanf(file, "%10s %d %c", name, &grade, &gradeLetter); printf("name = %s\ngrade = %d (%c)\n", name, grade, gradeLetter); return 0; } The code fragment above rst opens the le called lename. Then, it tries to read values from the le in the following order: an arbitrary amount of whitespace (implicit at the beginning of any scanf format string), a string having up to 10 characters, more whitespace, an int, more whitespace, and a character. For example, if the le contains the following string: wgates 34 F
The program will output: name = wgates grade = 34 (F)
5
CS034
Lab 2.1
9 February 2005
PPM File Format
There are literally hundreds of image le formats out there, but weve chosen to work with PPM because its one of the easiest to parse. Heres an example of a valid PPM le: P3 22 255 200 2 1 199 0 56 81 0 174 16 0 239 The rst two characters of the le must be P3. These two characters serve no purpose other to ensure that we are actually looking at a color PPM le. The next two elds are integers. The rst species the width of the image, and the second species the height. The next eld is an integer representing the maximum value. In this case, the maximum is 255. Zero is black and white is the maximum value. All the values in between are shades with varying intensity. Following that is some number of triplets, each representing one pixel. The number of triplets should be width height. The pixels are in row-major order. That is, all the pixels in the top row come rst, from left to right, then the pixels in the second row, and so on. Each triplet consists of three integers. The rst integer is the red channel, the second is the green channel, and the third is the blue. All the color values must fall in the range of [0, max] inclusive, so [0, 255] in this case. Note that the le above has newlines inserted for clarity. In an actual le, newlines are entirely optional, and are treated as whitespace. Lucky for us, fscanf() treats a in the formatting string as an undetermined amount of arbitrary whitespace (including newlines), and will automatically skip any whitespace at the beginning of lines. There are several PPM les for your enjoyment in /course/cs034/images/. To view a PPM le: xv <filename>
Structs
A struct is a simple construct in C for collecting several basic data types into one concise unit, similar to a Java class without any methods. Often, we dene structs to group related data together. structs not only make for cleaner and more organized code, but they allow us to pass these bundles of data around using only a single pointer instead of the many pointers that would be required to pass each piece of data separately. We often
6
CS034
Lab 2.1
9 February 2005
put struct denitions within a header le so that many C programs can make use of the same kind of struct simply by including the corresponding header le. Heres an example of how to dene a new type, called color t as a struct that would be useful for keeping track of a single pixel in an image: typedef struct color { unsigned char r; unsigned char g; unsigned...