CS360 Lab #3 -- Fakemake

Jian Huang

CS360

Description of fakemake

The syntax of fakemake is as follows:

fakemake [ description-file ]

Each line of the description file may be one of six things:

• A blank line (i.e. a line containing only white space).

• A specification of C source files that are used to make the executable:

  C list-of-files
  

  All files thus specified should end with .c. Multiple files can be separated by whitespace. The list may be empty, and there can be multiple lines starting with C.

• A specification of C header files that may be included by any source file:

  H list-of-files
  

  The H list is formatted just like the C list, and there can be multiple lines starting with H.

• A specification of the name of the executable:

  E name
  

  There can be only one executable name; thus, there can be only one line starting with E. It is an error if there is no E line in the entire description file.

• A specification of compilation flags:

  F flags
  

  These flags will be included right after gcc whenever it is called. As before, the flags are separated by whitespace, and there can be multiple F lines. This can be empty as well.

• A specification of libraries or extra object files for linking

  L list-of-libraries
  

  As before, multiple files should be separated by whitespace. The list may be empty, and there can be multiple lines starting with L. This list is included at the end of the final gcc command that makes the executable.

What fakemake does is compile all the .c files into .o files (using gcc -c), and then compile all the .o files into the final executable. Like make, it doesn't recompile files if it is not necessary. It uses the following algorithm to decide whether or not to compile the .c files:

• If there is no .o file corresponding to the .c file, then the .c file must be compiled (with -c).
• If there is a .o file corresponding to the .c file, but the .c file is more recent, then the .c file must be compiled (again with -c).
• If there is a .o file corresponding to the .c file, and any of the .h files are more recent than the .o file, then the .c file must be compiled.

Obviously, if a .c or .h file is specified, and it does not exist, fakemake should exit with an error. If there are any compilation errors mid-stream, fakemake should exit immediately.

Example

UNIX> cp ~cosc360/lab3/* .
UNIX> ls
f.c             f.h             f2.c            makefile        mysort.fm
f.fm            f1.c            lab.html        mysort.c
UNIX> make
gcc -c -g f.c
gcc -c -g f1.c
gcc -c -g f2.c
gcc -g -o f f.o f1.o f2.o
gcc -c -g -I/home/cosc360/include mysort.c
gcc -g -o mysort mysort.o /home/cosc360/objs/libfdr.a 
UNIX> f
This is the procedure F1 -- in f1.c
This is the procedure F2 -- in f2.c
UNIX> mysort < f.c
  f1();
  f2();
main()
{
}
UNIX> make clean
rm -f core *.o f mysort
UNIX> ls
f.c             f.h             f2.c            makefile        mysort.fm
f.fm            f1.c            lab.html        mysort.c
UNIX>

UNIX> ~cosc360/lab3/fakemake
fakemake: fmakefile No such file or directory
UNIX> ~cosc360/lab3/fakemake f.fm
gcc -c -g f.c
gcc -c -g f1.c
gcc -c -g f2.c
gcc -o f -g f.o f1.o f2.o
UNIX> touch f.c         
UNIX> ~cosc360/lab3/fakemake f.fm
gcc -c -g f.c
gcc -o f -g f.o f1.o f2.o
UNIX> rm f
UNIX> ~cosc360/lab3/fakemake f.fm
gcc -o f -g f.o f1.o f2.o
UNIX> touch f.h
UNIX> ~cosc360/lab3/fakemake f.fm
gcc -c -g f.c
gcc -c -g f1.c
gcc -c -g f2.c
gcc -o f -g f.o f1.o f2.o
UNIX> touch f.h
UNIX> touch f.o f1.o
UNIX> ~cosc360/lab3/fakemake f.fm
gcc -c -g f2.c
gcc -o f -g f.o f1.o f2.o
UNIX> ~cosc360/lab3/fakemake f.fm
f up to date
UNIX> f
This is the procedure F1 -- in f1.c
This is the procedure F2 -- in f2.c
UNIX> ~cosc360/lab3/fakemake mysort.fm
gcc -c -g -I/home/cosc360/include mysort.c
gcc -o mysort -g -I/home/cosc360/include mysort.o /home/cosc360/objs/libfdr.a
UNIX> mysort < f.c
  f1();
  f2();
main()
{
}
UNIX> rm f.h
UNIX> ~cosc360/lab3/fakemake f.fm
fmakefile: f.h: No such file or directory
UNIX> 

Details

To execute a string, you use the system() procedure. It executes the given string as if that string is a shell command (sh, not csh, although it shouldn't matter). If it returns zero, the command succeeded. If it returns anything else, the command failed.

Strategy

• Wrote the code to figure out the name of the description file. Made my makefile, and tested the code.
• Wrote the main loop to read the description file (using the fields library). This loop just calls get_line and prints each line to stdout.
• Wrote the code to recognize blank lines.
• Wrote code to recognize the C lines. All other lines are ignored.
• Wrote a subroutine to read the C files into a dlist. After reading the entire description file, I print out the contents of this dlist.
• Wrote code to recognize the H lines, and used the same subroutine as above to read the H files into another dlist. Tested this code.
• Wrote code to recognize and read the L lines -- this used the same subroutine and the filenames went into a third dlist.
• Wrote code to read in the executable name. Tested this code.
• Wrote code to recognize and read in the F lines. This again used the same subroutine as the C, H, and L lines. The flags are read into another dlist.
• Wrote code to flag an error for any unprocessed line. Also flagged an error if there is no E line.
• Wrote code to process the header files. This code traverses the H dlist, and calls stat on each file. It flags an error if the file doesn't exist. Otherwise, it returns the maximum value of st_mtime to the main() program.
• Wrote code to start processing the C files. This code traverses the C dlist, and calls stat on each file. It flags an error if the file doesn't exist. Otherwise, it looks for the .o file. If that file doesn't exist, or is less recent than the C file or the maximum st_mtime of the header files, then I printed out that I need to remake that file. I tested this code extensively.
• Wrote code to actually remake the .o files. This means creating the ``gcc -c'' string and printing it out. Once this looked right, I had the program call system() on the string.
• Finished up the C file subroutine by having it return whether any files were remade, or if not, the maximum st_mtime of any .o files, to the main() program.
• Wrote code to test whether or not the executable needed to be made.
• Finally, I wrote code to make the executable. First I wrote code to create the ``gcc -o'' string, and then I printed out the string. After testing that, I had the program call system() on the string.
• Put finishing touches on the program, and did more testing.