Make Guide, Meaning , Facts, Information and Description
make is a computer program that automates the compilation of programss whose filess are dependent on each other. A program typically consists of several files, and a programmer usually only works on a few of them at a time. Make will only recompile the files that need to be updated (files that have been modified since the last compile, or that depend on modified files), which is much faster than simply recompiling the whole program each time.Make was originally created by Dr. Stuart I. Feldman in 1977. Dr. Feldman was working at Bell Labs at the time. Since it is old, many derived tools have appeared that work better. Among these are BSD make, GNU make and A-A-P.
Other installation and configuration methods are used for programss without dependencies.
Although this is its most typical use, Make is also used in other programs as a way of defining what to do when something has changed, and thus triggering appropriate responses within the program.
Makefile utilities are frequently used to handle the compilation and/or installation of large pieces of software. Make reads the makefile at current working directory by default, which is a common practice among computer programmers. If no makefile is explicitly named in the make command, make will first look for the default file named "makefile" and then "Makefile" in the current directory. These can be hidden files.
It can be used to compile only certain subsets of an item or suite of software, and can account for dependencies between various parts of the software.
Its input is a list of specifications (usually known as a makefile) describing dependency relationships between the generation of files and programs.
The file commonly is maintained in the base directory of a project during the development process. This file lists all of the files in the project and describes the action that needed to be taken on that file to create it or bring it up to date. The Makefile is used by the command 'make'. The 'make' program has some intelligence built in and will not attempt to re-make files that are not out of date. For example it will typically not recompile source that has not changed since its last compile (determined by comparison of dates of files).
A makefile consists of commands like this:
foo.o: foo.c foo.h bar.h
gcc -o foo.o foo.c
logobig.ppm: logo.pov
$(POVRAY) logo.pov -k0 -o logobig.ppm
The first command means that if foo.c, foo.h, or bar.h is newer than foo.o, then foo.o should be remade by running gcc. foo.o is said to depend on foo.c, foo.h, and bar.h. The second says that logobig.ppm depends on logo.pov and can be made by running POV-Ray.
Most Makefiles are used to compile programss, but they can be used in any situation where files are made from one another by programs that can be called from the command line.
| Table of contents |
|
2 Obtaining make 3 Limitations 4 Other make-like tools 5 References |
# Specify compiler options
CFLAGS ?= -g
LDFLAGS ?= -L/usr/openwin/lib
LDLIBS ?= -lX11 -lXext
# Needed to recognize .c as a file suffix
.SUFFIXES: $(SUFFIXES) .
# Executable name
PROG = life
# List of object file needed for the final program
OBJS = main.o window.o Board.o Life.o BoundedBoard.o
all: $(PROG)
# Program compilation and linking steps
$(PROG): $(OBJS)
$(CC) $(CFLAGS) $(LDFLAGS) $(LDLIBS) -o $(PROG) $(OBJS)
.cpp.o:
$(CC) $(CFLAGS) -c $*.c
FSF GNU/Linux: GNU make + manual.
Cygwin users should consult their administrator for more information. Individual users without an administrator should consult the Cygwin package search on the cygwin website at www.cygwin.com.
Make has limitations that may make it unsuitable for some projects.
Reasons include:
This is an Article on Make. Page Contains Information, Facts Details or Explanation Guide About Make A sample makefile
# Specify compiler
CC ?= gcc
Obtaining make
Limitations
Other make-like tools
Most Integrated Development Environments also automate the compilation of large software projects. Dependencies are automatically computed from the programs' source code, freeing the user from the task of specifying dependencies. However, these tools are generally specific to a particular programming language.References