Computer Science 322
Operating Systems

It's good practice to make a directory for each lab assignment, so that would be a good place to start. lab1 would be a good choice. And since you'll be developing a number of programs for this lab, I recommend creating a new subdirectory of lab1 for each program.

I encourage you to work in the Unix environment (Linux, FreeBSD, or Mac OS X) on these, but you may use your own computers if you wish. Be sure that you test your programs on either the Linux systems in Clapp 202, or on the FreeBSD system, mogul.

We begin with a simple "Hello, World!" type of program. You may print whatever you wish in place of "Hello, World!" (within reasonable bounds of decorum and decency). All we are going for here is the basic structure of a very simple C program.

Some things you will need to know:

• Unlike Java or C++, a C program has no classes. All functions (The C equivalent of methods) are declared outside of any other declarations in your C program (as opposed to inside of a class definition).
• All C programs begin execution at the start of a function called main. This function takes parameters that we will consider in a later example. For now, you may declare main to take no parameters and returning an int. A return value of 0 generally indicates a successful execution to the system, so your program should return 0 at the end of main.
• In order to print to the screen, you will need to use the printf function. In our case, you will just pass it the string that you wish to print as its only parameter. Include a \n at the end to print a new line.
• Since we are not writing the function printf, we need to tell the compiler where to find a function prototype for printf. We do this with an include directive - the analog of Java's import. The file we need to include here is called stdio.h - the C standard input/output library. This is accomplished by placing the line

  #include <stdio.h>
  

  in your program before the start of main.

Call your program hello.c and place it in a subdirectory hello.

To compile, you can use the gcc compiler:

        gcc -o hello hello.c

This will create an executable program named hello (rather than the default a.out that we would get if we didn't include the -o hello). If everything went well, you should see no output from the gcc command. If you see warnings or errors, you should investigate and fix these before continuing.

To run your program, you specify its name:

        ./hello

Without the ./, the Unix shell would look for a program named hello in your search path, and might not find the one you just compiled in your current directory (.).

Include a few comments in your program (enclosed in /* */ bounds). Most importantly, include your name! Sure, it's just a "Hello, World!" program, but claim credit for your work.

You have likely seen Java applications that take command-line parameters (the String args[] parameter to main). Write a C program that takes an arbitrary number of command-line parameters, each of which should represent an integer value. Print out the sum of the values provided. Call your C program argadder.c and include a Makefile that guides a simple compilation of your program into an executable argadder. Include these in a subdirectory argadder in your submission.

Some things to know:

• A C program that wishes to make use of command-line parameters must declare two parameters, traditionally named argc and argv.
• The parameter argc to the main function is a count of how many command-line strings are included in argv, which is an array of strings. (See the main function in the C code from the make example.)
• argv[0] is not the first parameter, it is the program name itself, and this array entry for the program name is included in the value of argc.

Next, we will change the "adder" program to take its input from the keyboard rather than from the command line. Your program should read in integer values one by one, accumulating a sum as you go, until you encounter an invalid (non-integer) or the end of the input (someone types Ctrl-d). At that point, print out the sum and exit.

Our main "new thing" here is keyboard input. There are several ways to read in values from the input, but we will use scanf. Some details about scanf may be found in the class example that computes greatest common denominators.

Call your C program inputadder.c and include a Makefile that guides a simple compilation of your program into an executable inputadder. Include these in a subdirectory inputadder in your submission.

For one more bit of practice before getting to the somewhat more interesting tasks, extend your input adder program to remember all the values read in by storing them in a dynamically-allocated array. At the end, the program should print the addition problem and its solution in a standard format. For example, given the input values 9, 4, and 5, the program would print

9+4+5=18

Your task here is to be able to create the array and continue to make it larger as needed. Start with a reasonably-sized array (perhaps 10 slots). If the user inputs 10 or fewer values, you are all set. But if an 11th value is input, you will need to resize the array to make space. Use the same strategy as Java's Vector class - double the size of the array each time it fills.

Some things to consider:

• In C, you can allocate a fixed-size array with a declaration such as

          int a[10];
  

  This allocates space for 10 int values on the call stack. However, this array's size must be specified at compile time, and may not be resized. This will not work for our purposes.

• We will want to allocate an array using dynamic memory allocation. This is the same as what Java requires you to do for all arrays, but the syntax is quite different in C, and there is much less error checking done by the system than what you might be used to from Java. To allocate an array of 10 int values in C, you will need to do something like this:

          int *a = (int *)malloc(10*sizeof(int));
  

  This will request from the system enough space to hold 10 values, each the size of an int, and store a pointer to that space in a. We can then use this pointer in the same way we use the name of an array to access its elements, e.g., a[2].

  And later in the program when we are done with the memory, we will need to return it to the system:

          free(a);
  

• When you need to resize, use the realloc function. This function call will do exactly what you need for the doubling of your array size. For example:

      a = (int *)realloc(a,20*sizeof(int));
  

  will replace the pointer a with a new pointer to a chunk of memory now large enough to hold 20 int values, with the original 10 values copied over if needed.

Call your C program inputadder2.c and include a Makefile that guides a simple compilation of your program into an executable inputadder2. Include these in a subdirectory inputadder2 in your submission.

Finally, you will implement a program specified at the end of Chapter 3 in SG&G.

First, write the program described in Programming Problem 3.15 on p. 143-144. Call your C program forkfib.c and include a Makefile that guides a simple compilation of your program into an executable forkfib. Include these in a subdirectory forkfib in your submission.

Note: we will discuss the fork system call during class. Until then, you can get started on the computing the Fibonacci sequence and add in the fork system call after we have covered it.

Each program will be graded based on design, documentation, style, and correctness. The correctness portion of the lab will be worth 25 points (3 points for the first program, 5 for each of the others, plus 2 points for a correct directory structure in your submission), and the design, documentation, and style will be worth a total of 10 points.

To submit this lab, change into your directory that contains all of the subdirectories that you are to turn in (likely lab1) and and create a "tar file" to submit.

tar cvf c.tar *

This will create a file c.tar in your directory. Send this tar file as an attachment to jteresco AT mtholyoke.edu by 2:40 PM, Monday, February 8, 2010.

Please do not include any additional files, such as emacs backup files, object files, or executable programs.