USING THE C COMPILER: THE CC COMMAND

SPECIFYING AN INCLUDE FILE DIRECTORY

• When the C compiler processes a directive of the form

  	#include "sin.h"
  	

  it looks in the current directory for a file named sin.h and reads that.

• The KWIC system is organized so that all .h files are collected together in a single directory named include.

• The C compiler has an option to tell it where to look for #include files. For example:

  	cc -o prog -I../include main.c sin.c menu.c
  	

  would cause the C compiler to look in a sibling directory named include for the .h files.

SEPARATE COMPILATION WITH THE CC COMMAND

• If we execute the command

  		cc -c main.c
  	

  the C compiler creates a binary object file named main.o. The main.o file is not executable, because it needs to be linked with other modules and library functions before it is a complete program.

• We can create binary object files for all our modules with multiple invocations of the C compiler:

  	cc -c main.c
  	cc -c sin.c
  	cc -c menus.c
  	

  The order is not important. The result is three .o files. These .o files can be linked using one further invocation of the cc command:

  	cc -o prog main.o sin.o menus.o
  	

• If we subsequently find and correct an error in one file, say sin.c, we can build a new version of our program by executing:

  	cc -c sin.c
  	cc -o prog main.o sin.o menus.o
  	

  Note that we do not have to recompile main.c or menus.c, because they did not change.

  For large programs with many modules, separate compilation is much faster than recompiling everything.

USEFUL OPTIONS OF THE CC COMMAND

• Different Unix systems have different implementations of the C compiler. Some of the command-line options differ from one system to another. A complete list of options and their usage should be obtainable by executing

  	man cc
  	

• Some of the options common to the C compilers on malun1 are listed below. Many of these options will be needed only later in the course (they are shown now only for completeness). The string xx used below represents an arbitrary file name.

  -c

  separate compilation -- create a .o file from a .c file

  -o xx

  give the created program the name xx

  -Ixx

  (Note: the I is an upper-case letter i) search in the directory named xx for missing .h files.

  -E

  perform preprocessing only; the expanded source code is sent to standard output. (This option is sometimes useful for debugging compile-time errors in the program.)

  -g

  attach information useful to the dbx and gdb debuggers to the generated .o files or to the generated program. This option should always be supplied while the program is being developed and debugged.

  -p

  enable profiling (used in conjunction with the prof program).

  -pg

  enable profiling (used in conjunction with the gprof program).

  -lX

  (Note: the l is a lower-case letter `L') search the library named libX.a for any missing functions called by the program. To use math functions like sin and cos, for example, the compiler option -lm must be supplied on the final cc invocation that creates an executable program. The -lX option may be supplied several times if there is more than one library to search.

  -Lxx

  search in directory xx for any library files named in -lX options.

  -O

  optimize the program to make it run faster.

  -O2

  same as -O but perform even more optimizations. Neither form of -O option should be used while the program is still being developed. Optimizing often makes the program harder to debug.

• An additional option for the cc compiler that may be useful is:

  -w

  suppress output of warning messages about suspected problems in the C source code.

USING MAKE TO PERFORM RE-COMPILATIONS

• In a program with many modules, it is hard to remember which files need to be re-compiled after some changes have been made. It can also become painful to type all those cc commands, especially if there are many command line options.

• The make command can be configured to issue re-compilation commands as required. The configuration instructions are normally placed in a file whose name is Makefile.

• Here is a very simple Makefile:

  	# Makefile for the prog program
  		
  	prog: main.o sin.o menus.o
  		cc -o prog -I../include main.o sin.o menus.o
  
  	main.o: main.c sin.h menus.h
  		cc -c -I../include main.c
  
  	sin.o: sin.c sin.h
  		cc -c -I../include sin.c
  
  	menus.o: menus.c menus.h
  		cc -c -I../include menus.c
  	

  The `#' character introduces a comment; the comment continues to the end of the line.

  The label prog: (in line 3) defines a target. To build this target we need the files listed after the label, i.e., we need the files main.o, sin.o, and menus.o. These are called the prerequisites for the target. The line following prog: contains the Unix command which will build the target file, provided that all the prerequisite files exist.

  Note that the label must begin in column 1 and that the lines containing Unix commands must start with a tab character. (Spaces do not work.)

  A prerequisite like sin.o may not exist or may need to be re-created. Therefore, our Makefile contains lines that define sin.o as a target. To create sin.o, we require a source code file sin.c; assuming that sin.c #includes the file sin.h, we list that file too. We compile sin.o with the -c flag because sin.c we wish to create a .o file but not an executable program.

• Make may be invoked by typing just the command:

  		make
  	

  This causes make to look for a file named Makefile in the current directory.

  Make checks whether all the specified files exist and whether the derived files are up-to-date. A file like sin.o is out of date if the creation time of the file sin.o is earlier than the time of last modification for either of the files sin.c or sin.h.

  If derived files are out of date or non-existent, make issues the commands shown below each selected target.

• Make provides supports simple parameterization, which reduces the size of the Makefile and simplifies changes to the Makefile. For example:

  	# Makefile for the prog program
  		
  	INCLDIR = ../include
  		
  	prog: main.o sin.o menus.o
  		cc -o prog -I$(INCLDIR) main.o sin.o menus.o
  
  	main.o: main.c sin.h menus.h
  		cc -c -I$(INCLDIR) main.c
  
  	sin.o: sin.c sin.h
  		cc -c -I$(INCLDIR) sin.c
  
  	menus.o: menus.c menus.h
  		cc -c -I$(INCLDIR) menus.c
  	

• A Makefile can define several targets. For example:

  	# Makefile for the prog program
  		
  	INCLDIR = ../include
  	SRCFILES = main.c sin.c sin.h menus.c menus.h
  		
  	prog: main.o sin.o menus.o
  		cc -o prog -I$(INCLDIR) main.o sin.o menus.o
  
  	main.o: main.c sin.h menus.h
  		cc -c -I$(INCLDIR) main.c
  
  	sin.o: sin.c sin.h
  		cc -c -I$(INCLDIR) sin.c
  
  	menus.o: menus.c menus.h
  		cc -c -I$(INCLDIR) menus.c
  
  	print:
  		lpr $(SRCFILES)
  
  	clean:
  		rm -f *.o core
  	

  With this Makefile, the user can now type the command:

  		make print
  	

  and the command to send all the source files to the printer will be executed. (The Make command is fooled into thinking that you want to create a file named print; when it finds that this file does not exist, it runs the Unix command listed below the print target.)

  Similarly, the command

  		make clean
  	

  executes a command to remove all non-essential files. The .o files are expendable because they can be re-created by running the C compiler; a large file named core is a common result of testing buggy programs.

• Last comment: an overlong line in a Makefile can be split into several lines by using the backslash line continuation character. For example:

  	foo: main.c foo.o bar.o jack.o jane.o jill.o
  	

  could have been typed as

  	foo: main.c foo.o    \
  		bar.o jack.o   \
  		jane.o jill.o