Separate Compilation

$ cd myfileio
$ ls
demo.c  in1.txt  Makefile  myfileio.h  myfileio.c  test_ex1.c

In Lab 6 you saw how to organize source code into different files. In particular, you added functions to a small library called myfileio, implemented with files myfileio.h and myfileio.c. Then you tested this library with separate driver programs (ex: demo.c, test_ex1.c). To build a program that tests this library, you used this gcc command:

gcc -Wall -std=c99 myfileio.c demo.c -o demo

Another approach is separate compilation, where .c source files are compiled separately into object files and then linked to create a single executable. Here we will walk through the steps for separate compilation to build the program "demo" from the last lab.

First, call gcc as follows. Note the use of option -c:

$ gcc -Wall -std=c99 -c myfileio.c 
$ gcc -Wall -std=c99 -c demo.c 

$ ls *.o
demo.o myfileio.o 

Next, run this gcc command to link object files into a new executable. (Note .o files are used as input to gcc, not .c files):

$ gcc demo.o myfileio.o -o demo

You can now execute the program demo at the command line, just as you did in last week's lab:

$ ./demo in1.txt
Calling show_file() ...
100
110
120
125
130

$ gcc -Wall -std=c99 -c test_ex1.c
$ gcc test_ex1.o myfileio.o -o test_ex1
$ ./test_ex1 in1.txt
Number of lines in in1.txt: 5

If we update file myfileio.h or myfileio.c then the object file myfileio.o must be rebuilt. So we say that myfileio.o depends on myfileio.h and myfileio.c. When working with large software projects, it can be very cumbersome to remember which object files must be recompiled. To manage this process, programmers use makefiles to describe dependencies among files, and ensure that a file is recompiled only when its dependent files are changed. Below we will show how to use make to build the executable file test_ex1 in a single step.

Basics: Calling make

Users run make with commands such as the following:

  $ make target

This command searches the current directory for a file named Makefile, and then tries to update target if it is out of date. You will read more about rules and targets below.

If no target is specified, as shown here:

  $ make

then make will use the first one in the makefile.

Follow these steps to rebuild the program test_ex1. First remove object files and executables that you already built above:

$ rm *.o
$ rm test_ex1 

$ make
gcc -g -Wall    -c -o myfileio.o myfileio.c
gcc -g -Wall    -c -o test_ex1.o test_ex1.c
gcc -g myfileio.o test_ex1.o -o test_ex1
$ ls test_ex1
test_ex1

Structures

   struct mypoint
   {
     double x;
     double y;
   };

A variable of type struct mypoint can be declared as:

   struct mypoint p1;

   struct mypoint p1;
   p1.x=1.0;
   p1.y=5.0;

   struct mypoint p1 = {1.0,5.0};

You can declare pointers to structures. For example, a pointer to p1 would be:

   struct mypoint * p_p1 = &p1;

   printf("Point p1: (%.2f,%.2f)\n",p_p1->x,p_p1->y);

• mypoint.h: A header file for the (incomplete) mypoint module.
• distance.c: A program that uses this mypoint module to compute the distance between two points.

• Add a declaration for a structure type to represent 2-dimensional points, struct mypoint. You may use the above example. You will add this structure declaration in header file mypoint.h.
• Implement the function get_distance() in file mypoint.c.

  double get_distance( struct mypoint * p_p1, struct mypoint * p_p2);
  

  Note that this function is call-by-reference, since its arguments are pointers to structures.

• Initialize the variables p1 and p2 with data in the argv[] array (ie, using command line arguments). The order of the arguments on the command line should be:

  ./distance <x1> <y1> <x2> <y2> 
  

  for points p1=(x1,y1) and p2=(x2,y2). You can use the function atof() in stdlib.h to convert a string to a double. (You should then also include stdlib.h.)
• Run and test your program. The result should look something like this:

     $./distance 1 5 4 9
     Distance between (1.00,5.00) and (4.00,9.00): 5.00
  

Exercise 2

• The makefile creates an executable called distance that calls the function main() in distance.c.
• The makefile creates object files mypoint.o and distance.o.
• The makefile must include rules for targets all and clean as described above.
• The compiler and the compiler flags are specified by variables CC and CFLAGS. Compiler options are: -g -Wall -std=c99 (in any order).
• Linker flags are set so that -lm is used in linking. You can do this by setting the variable LDFLAGS:

  LDFLAGS = -lm
  

$ make clean
rm -f mypoint.o distance.o distance
$ make
gcc -g -Wall -std=c99   -c -o mypoint.o mypoint.c
gcc -g -Wall -std=c99   -c -o distance.o distance.c
gcc -lm mypoint.o distance.o -o distance
$ ./distance 1 5 4 9
Distance between (1.00,5.00) and (4.00,9.00): 5.00

Submitting your assignment

Lab 7 is due: Saturday, Aug 13 at 11:59pm

You may submit the contents of the mypoint directory for this lab. But, call make clean before you submit! This should remove files mypoint.o, distance.o, and distance.

I will grade your work in these files:

• Exercise 1: mypoint.h, mypoint.c, and distance.c
• Exercise 2: Makefile in the mypoint directory

Be sure that every source file you submit includes this information in comments at the top of the file:

• Your first and last name
• Your username
• Any other comments you want to add about your program (optional)

Also include a simple README file in your lab7 directory with your name, username, and any other comments or questions for the Lab TA.

Do not submit any compiled binary files

You will submit this lab with the hwsubmit program.

$ hwsubmit cspp50101lab <path to your lab7 directory>

Submit to cspp50101lab, NOT cspp50101.

prepared by Sonjia Waxmonsky