Computer Science 210 Computer Organization Modular Decomposition Making a Library Separate Compilation

Program Decomposition C programs consist of lots of functions Organize these and save them in libraries (like Python modules) Separately compile them for distribution and link them to client applications

Example: An Assembler Source program listing, error messages (file and/or terminal) Text file Assembler Object file Sym file

Decompose into Modules Scanner Parser Source program listing, error messages (file and/or terminal) Object file Text file CharacterIO Character stream Token stream Symbol tableOpcode table Sym file Tools CharacterIO – handles files, text Scanner – recognizes numbers, symbols, assembler directives Parser – handles syntax checking, code generation

/* This program prints the factorial of 6. */ #include int factorial(int n); // Prototype shows the function specs int main(){ printf("The factorial of 6 is %d\n", factorial(6)); } int factorial(int n){ if (n == 1) return 1; else return n * factorial(n - 1); } Using a Function Prototype A function prototype is a header that appears early, to aid the human reader of the code (like a Java interface, sort of)

Where Should Functions Go? We can put ‘em all in one file with the application; prototypes are at the beginning of the file, and we work top down But this requires recompiling the whole file after one small change Work can’t be divided up among many developers Functions can’t be maintained independently of their clients

Create a Library of Functions Place the function prototypes for a module in a header file (.h extension) Place the completed function definitions for that module in an implementation file (.c extension) Compile the c. file, link it to a test driver, test it, and store it away Example: a mylib library with factorial and gcd

Structure of the Program usemylib.c mylib.c mylib.h Compile time Link time Compile time Header file Implementation file Main function file mylib.c and usemylib.c can be compiled in separate steps, by different people, in different organizations They each rely on the interface in mylib.h

/* Header file for factorial and gcd functions. */ int factorial(int n); // Prototype for factorial function int gcd(int a, int b); // Prototype for gcd function The Header File mylib.h The header file contains function prototypes and may also contain #define macros

/* Implementation file for factorial and gcd functions. */ #include "mylib.h" int factorial(int n){ if (n == 1) return 1; else return n * factorial(n - 1); } int gcd(int a, int b){ if (b == 0) return a; else return gcd(b, a % b); } The Implementation File mylib.c The implementation file also includes its header file (for consistency checking) – note the quotes rather than the

/* Test program uses both mylib functions. */ #include #include "mylib.h" int main(){ printf("The factorial of 6 is %d\n", factorial(6)); printf("The gcd of 9 and 15 is %d\n", gcd(15, 9)); } The Test Driver File usemylib.c

Separate Compilation and Linking Save each implementation file with a.c extension Work bottom up, compile each.c file with gcc –c.c If no errors, link the object files with gcc –o.o....o If no errors, run the program with./

make and Makefiles Many modules to keep track of Which ones are up to date, which ones need to be recompiled? The UNIX make tool and makefiles help to manage this problem

make and Makefiles When you run make, UNIX looks for a file named makefile or Makefile in the current working directory A makefile contains info about the dependencies among program modules and commands to compile and/or link them

Makefile Entries targets : prerequisites commands This is the format of an entry. There are one or more entries in a makefile. A tab must go here Targets are dependent on prerequisites Targets and prerequisites are file names Commands are similar to those we’ve seen already

A Makefile for Compiling mylib mylib.o : mylib.c mylib.h gcc –c mylib.c target prerequisites command

Add Another Entry for usemylib usemylib.o : usemylib.c mylib.h gcc –c usemylib.c mylib.o : mylib.c mylib.h gcc –c mylib.c

Add Another Entry to Link the Program usemylib : usemylib.o mylib.o gcc –o usemylib usemylib.o mylib.o usemylib.o : usemylib.c mylib.h gcc –c usemylib.c mylib.o : mylib.c mylib.h gcc –c mylib.c

How make works > make > make mylib.o The first call compares the time stamps of the targets and prerequisites and runs only those commands that “make” the targets up to date The second call runs only the command whose target is the argument mylib.o