搜档网
当前位置:搜档网 › 通用Makefile模板及实例

通用Makefile模板及实例

通用Makefile模板及实例
通用Makefile模板及实例

1 通用Makefile——1

实现的功能:

?make——编译和连接程序

?make objs——编译程序,生成目标文件

?make clean——清除编译产生的目标文件(*.o)和依赖文件(*.d)

?make cleanall——清除目标文件(*.o)、依赖文件(*.d)和可执行文件(*.exe)?make rebuild——重新编译连接程序,相当于make clean && make

Usage:

Makefile源代码

# Gneric C/C++ Makefile

####################################################

PROGRAM :=

SRCDIRS :=

SRCEXTS :=

CPPFLAGS :=

CFLAGS :=

CFLAGS +=

CXXFLAGS :=

CXXFLAGS +=

LDFLAGS :=

LDFLAGS +=

SHELL = /bin/sh

SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS)))) OBJS = $(foreach x,$(SRCEXTS),\

$(patsubst %$(x),%.o,$(filter %$(x),$(SOURCES))))

DEPS = $(patsubst %.o,%.d,$(OBJS))

.PHONY: all objs clean cleanall rebuild

all : $(PROGRAM)

%.d : %.c

@$(CC) -MM -MD $(CFLAGS) {1}lt;

%.d : %.C

@$(CC) -MM -MD $(CXXFLAGS) {1}lt;

objs : $(OBJS)

%.o : %.c

$(CC) -c $(CPPFLAGS) $(CFLAGS) {1}lt;

%.o : %.cpp

$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) {1}lt;

$(PROGRAM) : $(OBJS)

ifeq ($(strip $(SRCEXTS)),.c)

$(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS)

else

$(CXX) -o $(PROGRAM) $(OBJS) $(LDFLAGS)

endif

-include $(DEPS)

rebuild: clean call

clean:

@$(RM) *.o *.d

cleanall: clean

@$(RM) $(PROGRAM) $(PROGRAM).exe

2 通用Makefile——2

############################################################################### #

# Generic Makefile for C/C++ Program

#

# Author: whyglinux (whyglinux AT hotmail DOT com)

# Date: 2006/03/04

# Description:

# The makefile searches in directories for the source files

# with extensions specified in , then compiles the sources

# and finally produces the , the executable file, by linking

# the objectives.

# Usage:

# $ make compile and link the program.

# $ make objs compile only (no linking. Rarely used).

# $ make clean clean the objectives and dependencies.

# $ make cleanall clean the objectives, dependencies and executable.

# $ make rebuild rebuild the program. The same as make clean && make all.

#===================================================================== =========

## Customizing Section: adjust the following if necessary.

##==================================================================== =========

# The executable file name.

# It must be specified.

# PROGRAM := a.out # the executable name

PROGRAM :=

# The directories in which source files reside.

# At least one path should be specified.

# SRCDIRS := . # current directory

SRCDIRS :=

# The source file types (headers excluded).

# At least one type should be specified.

# The valid suffixes are among of .c, .C, .cc, .cpp, .CPP, .c++, .cp, or .cxx.

# SRCEXTS := .c # C program

# SRCEXTS := .cpp # C++ program

# SRCEXTS := .c .cpp # C/C++ program

SRCEXTS :=

# The flags used by the cpp (man cpp for more).

# CPPFLAGS := -Wall -Werror # show all warnings and take them as errors

CPPFLAGS :=

# The compiling flags used only for C.

# If it is a C++ program, no need to set these flags.

# If it is a C and C++ merging program, set these flags for the C parts.

CFLAGS :=

CFLAGS +=

# The compiling flags used only for C++.

# If it is a C program, no need to set these flags.

# If it is a C and C++ merging program, set these flags for the C++ parts.

CXXFLAGS :=

CXXFLAGS +=

# The library and the link options ( C and C++ common).

LDFLAGS :=

LDFLAGS +=

## Implict Section: change the following only when necessary.

##==================================================================== =========

# The C program compiler. Uncomment it to specify yours explicitly.

#CC = gcc

# The C++ program compiler. Uncomment it to specify yours explicitly.

#CXX = g++

# Uncomment the 2 lines to compile C programs as C++ ones.

#CC = $(CXX)

#CFLAGS = $(CXXFLAGS)

# The command used to delete file.

#RM = rm -f

## Stable Section: usually no need to be changed. But you can add more.

##==================================================================== =========

SHELL = /bin/sh

SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))

OBJS = $(foreach x,$(SRCEXTS), \

$(patsubst %$(x),%.o,$(filter %$(x),$(SOURCES))))

DEPS = $(patsubst %.o,%.d,$(OBJS))

.PHONY : all objs clean cleanall rebuild

all : $(PROGRAM)

# Rules for creating the dependency files (.d).

#---------------------------------------------------

%.d : %.c

@$(CC) -MM -MD $(CFLAGS) $<

%.d : %.C

@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cc

@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cpp

@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.CPP

@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.c++

@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cp

@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cxx

@$(CC) -MM -MD $(CXXFLAGS) $<

# Rules for producing the objects.

#---------------------------------------------------

objs : $(OBJS)

%.o : %.c

$(CC) -c $(CPPFLAGS) $(CFLAGS) $<

%.o : %.C

$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cc

$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cpp

$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.CPP

$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.c++

$(CXX -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cp

$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cxx

$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

# Rules for producing the executable.

#---------------------------------------------- $(PROGRAM) : $(OBJS)

ifeq ($(strip $(SRCEXTS)), .c) # C file

$(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS) else # C++ file

$(CXX) -o $(PROGRAM) $(OBJS) $(LDFLAGS) endif

-include $(DEPS)

rebuild: clean all

clean :

@$(RM) *.o *.d

cleanall: clean

@$(RM) $(PROGRAM) $(PROGRAM).exe

### End of the Makefile ## Suggestions are welcome ## All rights reserved ###

############################################################################### 下面提供两个例子来具体说明上面 Makefile 的用法。

例一Hello World 程序

这个程序的功能是输出 Hello, world! 这样一行文字。由 hello.h、hello.c、main.cxx 三个文件组成。前两个文件是 C 程序,后一个是 C++ 程序,因此这是一个 C 和 C++ 混编程序。

/* File name: hello.h

* C header file

*/

#ifndef HELLO_H

#define HELLO_H

#ifdef __cplusplus

extern "C" {

#endif

void print_hello();

#ifdef __cplusplus

}

#endif

#endif

/* File name: hello.c

* C source file.

*/

#include "hello.h"

#include

void print_hello()

{

puts( "Hello, world!" );

}

/* File name: main.cxx

* C++ source file.

*/

#include "hello.h"

int main()

{

print_hello();

return 0;

}

建立一个新的目录,然后把这三个文件拷贝到目录中,也把 Makefile 文件拷贝到目录中。之后,对 Makefile 的相关项目进行如下设置:

PROGRAM := hello # 设置运行程序名

SRCDIRS := . # 源程序位于当前目录下

SRCEXTS := .c .cxx # 源程序文件有 .c 和 .cxx 两种类型

CFLAGS := -g # 为 C 目标程序包含 GDB 可用的调试信息

CXXFLAGS := -g # 为 C++ 目标程序包含 GDB 可用的调试信息

由于这个简单的程序只使用了 C 标准库的函数(puts),所以对于 CFLAGS 和 CXXFLAGS 没有过多的要求,LDFLAGS 和 CPPFLAGS 选项也无需设置。

经过上面的设置之后,执行 make 命令就可以编译程序了。如果没有错误出现的话,./hello 就可以运行程序了。

如果修改了源程序的话,可以看到只有和修改有关的源文件被编译。也可以再为程序添加新的源文件,只要它们的扩展名是已经在 Makefile 中设置过的,那么就没有必要修改Makefile。

例二GTK+ 版 Hello World 程序

这个 GTK+ 2.0 版的 Hello World 程序可以从下面的网址上得到:https://www.sodocs.net/doc/20448113.html,/tutorial/c58.html#SEC-HELLOWORLD。当然,要编译 GTK+ 程序,还需要你的系统上已经安装好了 GTK+。

跟第一个例子一样,单独创建一个新的目录,把上面网页中提供的程序保存为 main.c 文件。对 Makefile 做如下设置:

PROGRAM := hello # 设置运行程序名

SRCDIRS := . # 源程序位于当前目录下

SRCEXTS := .c # 源程序文件只有 .c 一种类型

CFLAGS := `pkg-config --cflags gtk+-2.0` # CFLAGS

LDFLAGS := `pkg-config --libs gtk+-2.0` # LDFLAGS

这是一个 C 程序,所以 CXXFLAGS 没有必要设置——即使被设置了也不会被使用。

编译和连接 GTK+ 库所需要的 CFLAGS 和 LDFLAGS 由 pkg-config 程序自动产生。

现在就可以运行 make 命令编译、./hello 执行这个 GTK+ 程序了。

3 通用Makefile——3

####################################################

# Generic makefile - 万能Makefile

# for compiling and linking C++ projects on Linux

# Author: George Foot Modified:Jackie Lee

####################################################

### Customising

#

# Adjust the following if necessary; EXECUTABLE is the target

# executable's filename, and LIBS is a list of libraries to link in

# (e.g. alleg, stdcx, iostr, etc). You can override these on make's

# command line of course, if you prefer to do it that way.

#

#

EXECUTABLE := main # 可执行文件名

LIBDIR:= # 静态库目录

LIBS := # 静态库文件名

INCLUDES:=. # 头文件目录

SRCDIR:= # 除了当前目录外,其他的源代码文件目录#

# # Now alter any implicit rules' variables if you like, e.g.:

CC:=g++

CFLAGS := -g -Wall -O3

CPPFLAGS := $(CFLAGS)

CPPFLAGS += $(addprefix -I,$(INCLUDES))

CPPFLAGS += -MMD

#

# # The next bit checks to see whether rm is in your djgpp bin

# # directory; if not it uses del instead, but this can cause (harmless)

# # `File not found' error messages. If you are not using DOS at all,

# # set the variable to something which will unquestioningly remove

# # files.

#

RM-F := rm -f

# # You shouldn't need to change anything below this point.

#

SRCS := $(wildcard *.cpp) $(wildcard $(addsuffix /*.cpp, $(SRCDIR))) OBJS := $(patsubst %.cpp,%.o,$(SRCS))

DEPS := $(patsubst %.o,%.d,$(OBJS))

MISSING_DEPS := $(filter-out $(wildcard $(DEPS)),$(DEPS))

MISSING_DEPS_SOURCES := $(wildcard $(patsubst %.d,%.cpp,$(MISSING_DEPS)))

.PHONY : all deps objs clean veryclean rebuild info

all: $(EXECUTABLE)

deps : $(DEPS)

objs : $(OBJS)

clean :

@$(RM-F) *.o

@$(RM-F) *.d

veryclean: clean

@$(RM-F) $(EXECUTABLE)

rebuild: veryclean all

ifneq ($(MISSING_DEPS),)

$(MISSING_DEPS) :

@$(RM-F) $(patsubst %.d,%.o,$@)

endif

-include $(DEPS)

$(EXECUTABLE) : $(OBJS)

$(CC) -o $(EXECUTABLE) $(OBJS) $(addprefix -L,$(LIBDIR)) $(addprefix -l,$(LIBS))

info:

@echo $(SRCS)

@echo $(OBJS)

@echo $(DEPS)

@echo $(MISSING_DEPS)

@echo $(MISSING_DEPS_SOURCES)

注:1)命令行前的空白符必须为一个制表符(Tab);如,@$(RM-F) *.o前不是空格,而是一个制表符;

内容解析

1.Makefile基本语法

target为要生成的目标文件;dependency为target的依赖文件;command为用于生成target 的命令行;

: ...

(tab)

(tab)

.

.

.

2.赋值符号:= 与=

:=与=的区别在于,符号:=表示立即展开变量值。例如:

A:=foo

B:=$(A)

A:=bar

这时,B的值仍为foo,因为它已被展开,不会再随A的值改变而改变。

3.符号#是Makefile的注释符号

4.wildcard函数

SRCS:=$(wildcard *.cpp) 表示列举当前目录中扩展名为.cpp的所有文件,然后赋值给变量SRCS。详细请google之。

5.patsubst函数

OBJS := $(patsubst %.cpp,%.o,$(SRCS))表示,将$(SRCS)中所有满足模式%.cpp的字符串替换为%.o。

6.filter-out函数

$(filter-out $(A),$(B))表示从B中过滤掉A中的内容,返回剩余内容;

7. “.PHONY”

用.PHONY修饰的target是“伪目标”,不需要生成真实的文件;make假定phony target是已经生成的,然后更新它后边的依赖文件和执行它下边的命令(command);

8.all deps objs clean veryclean rebuild info

这些都是“伪目标”。

all是第一个目标,所以输入make时它被默认执行;all生成或更新所有*.cpp文件对应的*.d 文件和*.o文件,并链接所有*.o文件生成可执行文件$(EXECUTABLE)。

deps仅仅生成*.d文件;.d文件是什么文件?它包含了代码文件的依赖信息。

objs仅仅生成*.o文件;.o文件是C++代码编译后的中间结果文件,废话!

clean用于删除*.d文件和*.o文件。

veryclean删除*.d文件、*.o文件,还有名为$(EXECUTABLE)的可执行文件。

rebuild先调用veryclean清除结果文件,再调用all重新编译和链接。

info查看某些信息。

使用方法:

make deps即可执行deps;

9.ifneq...else...endif

条件语句,ifneq表示如果不想等,则...;

10.include 语句

include表示把的内容包含进来;

$(DEPS)是包含依赖信息的文件,每个源文件对应一个.d文件;-include $(DEPS)表示把这些依赖信息包含进来;

11.链接*.o文件,生成可执行文件

主菜来了!

$(EXECUTABLE) : $(OBJS)

$(CC) -o $(EXECUTABLE) $(OBJS) $(addprefix -l,$(LIBS))

$(EXECUTABLE)为可执行文件名;$(OBJS)为所有.o文件名;$(CC)在这里是g++;$(addprefix -l,$(LIBS)添加引用库;

前面说好的*.d文件和*.o文件是怎么生成的呢?貌似没有命令指出要生成它们呀!请看隐含规则!

12. 隐含规则(Implicit rules)

$(EXECUTABLE)依赖于$(OBJS),但makefile中没有指明$(OBJS)依赖于谁,也没指明命令生成它们;

这时,make的隐含规则开始起作用;针对$(OBJS)中的每个目标,make自动调用:$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@

依次生成.o文件和.d文件;

$<表示依赖文件列表的第一个文件名;

$@表示目标文件名;

之所以会生成.d文件,是由于“-MMD”这一编译选项。为g++加上这一选项后,编译器会生成文件依赖信息,并存放至.d文件中。

每一个.cpp文件相应地生成一个.d文件和一个.o文件。

13.@符号

命令行前的@符号表示不回显命令行;

14.CFLAGS和CPPFLAGS

这两者包含编译选项,更详细内容请Google之。

-g 添加gdb调试信息;

-Wall 提示warning信息;

-O3 表示第3级优化;

4 通用Makefile——4

#############################################################

# Generic Makefile for C/C++ Program

#

# License: GPL (General Public License)

# Author: whyglinux

# Date: 2006/03/04 (version 0.1)

# 2007/03/24 (version 0.2)

# 2007/04/09 (version 0.3)

# 2007/06/26 (version 0.4)

# 2008/04/05 (version 0.5)

#

# Description:

# ------------

# This is an easily customizable makefile template. The purpose is to

# provide an instant building environment for C/C++ programs.

#

# It searches all the C/C++ source files in the specified directories,

# makes dependencies, compiles and links to form an executable.

#

# Besides its default ability to build C/C++ programs which use only

# standard C/C++ libraries, you can customize the Makefile to build

# those using other libraries. Once done, without any changes you can

# then build programs using the same or less libraries, even if source

# files are renamed, added or removed. Therefore, it is particularly

# convenient to use it to build codes for experimental or study use.

#

# GNU make is expected to use the Makefile. Other versions of makes

# may or may not work.

#

# Usage:

# ------

# 1. Copy the Makefile to your program directory.

# 2. Customize in the "Customizable Section" only if necessary:

# * to use non-standard C/C++ libraries, set pre-processor or compiler

# options to and linker ones to

# (See Makefile.gtk+-2.0 for an example)

# * to search sources in more directories, set to

# * to specify your favorite program name, set to

# 3. Type make to start building your program.

#

# Make Target:

# ------------

# The Makefile provides the following targets to make:

# $ make compile and link

# $ make NODEP=yes compile and link without generating dependencies

# $ make objs compile only (no linking)

# $ make tags create tags for Emacs editor

# $ make ctags create ctags for VI editor

# $ make clean clean objects and the executable file

# $ make distclean clean objects, the executable and dependencies

# $ make help get the usage of the makefile

#

#===================================================================== ======

## Customizable Section: adapt those variables to suit your program.

##==================================================================== ======

# The pre-processor and compiler options.

MY_CFLAGS =

# The linker options.

MY_LIBS =

# The pre-processor options used by the cpp (man cpp for more).

CPPFLAGS = -Wall

# The options used in linking as well as in any direct use of ld.

LDFLAGS =

# The directories in which source files reside.

# If not specified, only the current directory will be serached.

SRCDIRS =

# The executable file name.

# If not specified, current directory name or `a.out' will be used.

PROGRAM =

## Implicit Section: change the following only when necessary.

##==================================================================== ======

# The source file types (headers excluded).

# .c indicates C source files, and others C++ ones.

SRCEXTS = .c .C .cc .cpp .CPP .c++ .cxx .cp

# The header file types.

HDREXTS = .h .H .hh .hpp .HPP .h++ .hxx .hp

# The pre-processor and compiler options.

# Users can override those variables from the command line.

CFLAGS = -g -O2

CXXFLAGS= -g -O2

# The C program compiler.

#CC = gcc

# The C++ program compiler.

#CXX = g++

# Un-comment the following line to compile C programs as C++ ones.

#CC = $(CXX)

# The command used to delete file.

#RM = rm -f

ETAGS = etags

ETAGSFLAGS =

CTAGS = ctags

CTAGSFLAGS =

## Stable Section: usually no need to be changed. But you can add more.

##==================================================================== ======

SHELL = /bin/sh

EMPTY =

SPACE = $(EMPTY) $(EMPTY)

ifeq ($(PROGRAM),)

CUR_PATH_NAMES = $(subst /,$(SPACE),$(subst $(SPACE),_,$(CURDIR)))

PROGRAM = $(word $(words $(CUR_PATH_NAMES)),$(CUR_PA TH_NAMES))

ifeq ($(PROGRAM),)

PROGRAM = a.out

endif

endif

ifeq ($(SRCDIRS),)

SRCDIRS = .

endif

SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS)))) HEADERS = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(HDREXTS))))

SRC_CXX = $(filter-out %.c,$(SOURCES))

OBJS = $(addsuffix .o, $(basename $(SOURCES)))

DEPS = $(OBJS:.o=.d)

## Define some useful variables.

DEP_OPT = $(shell if `$(CC) --version | grep "GCC" >/dev/null`; then \

echo "-MM -MP"; else echo "-M"; fi )

DEPEND = $(CC) $(DEP_OPT) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS) DEPEND.d = $(subst -g ,,$(DEPEND))

COMPILE.c = $(CC) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS) -c

COMPILE.cxx = $(CXX) $(MY_CFLAGS) $(CXXFLAGS) $(CPPFLAGS) -c

LINK.c = $(CC) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)

LINK.cxx = $(CXX) $(MY_CFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)

.PHONY: all objs tags ctags clean distclean help show

# Delete the default suffixes

.SUFFIXES:

all: $(PROGRAM)

# Rules for creating dependency files (.d). #------------------------------------------

%.d:%.c

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

%.d:%.C

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

%.d:%.cc

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

%.d:%.cpp

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

%.d:%.CPP

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

%.d:%.c++

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

%.d:%.cp

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

%.d:%.cxx

@echo -n $(dir $<) > $@

@$(DEPEND.d) $< >> $@

# Rules for generating object files (.o).

#---------------------------------------- objs:$(OBJS)

%.o:%.c

$(COMPILE.c) $< -o $@

%.o:%.C

$(COMPILE.cxx) $< -o $@

%.o:%.cc

$(COMPILE.cxx) $< -o $@

%.o:%.cpp

$(COMPILE.cxx) $< -o $@

%.o:%.CPP

$(COMPILE.cxx) $< -o $@

%.o:%.c++

$(COMPILE.cxx) $< -o $@

%.o:%.cp

$(COMPILE.cxx) $< -o $@

%.o:%.cxx

$(COMPILE.cxx) $< -o $@

# Rules for generating the tags.

#-------------------------------------

tags: $(HEADERS) $(SOURCES)

$(ETAGS) $(ETAGSFLAGS) $(HEADERS) $(SOURCES)

ctags: $(HEADERS) $(SOURCES)

$(CTAGS) $(CTAGSFLAGS) $(HEADERS) $(SOURCES)

# Rules for generating the executable.

#-------------------------------------

$(PROGRAM):$(OBJS)

ifeq ($(SRC_CXX),) # C program

$(LINK.c) $(OBJS) $(MY_LIBS) -o $@

@echo Type ./$@ to execute the program.

else # C++ program

$(LINK.cxx) $(OBJS) $(MY_LIBS) -o $@

@echo Type ./$@ to execute the program.

endif

ifndef NODEP

ifneq ($(DEPS),)

sinclude $(DEPS)

endif

endif

clean:

$(RM) $(OBJS) $(PROGRAM) $(PROGRAM).exe

distclean: clean

$(RM) $(DEPS) TAGS

# Show help.

help:

@echo 'Generic Makefile for C/C++ Programs (gcmakefile) version 0.5' @echo 'Copyright (C) 2007, 2008 whyglinux ' @echo

@echo 'Usage: make [TARGET]'

@echo 'TARGETS:'

@echo ' all (=make) compile and link.'

@echo ' NODEP=yes make without generating dependencies.'

@echo ' objs compile only (no linking).'

@echo ' tags create tags for Emacs editor.'

@echo ' ctags create ctags for VI editor.'

@echo ' clean clean objects and the executable file.'

@echo ' distclean clean objects, the executable and dependencies.'

@echo ' show show variables (for debug use only).'

@echo ' help print this message.'

@echo

@echo 'Report bugs to .'

# Show variables (for debug use only.)

show:

@echo 'PROGRAM :' $(PROGRAM)

@echo 'SRCDIRS :' $(SRCDIRS)

@echo 'HEADERS :' $(HEADERS)

@echo 'SOURCES :' $(SOURCES)

@echo 'SRC_CXX :' $(SRC_CXX)

@echo 'OBJS :' $(OBJS)

@echo 'DEPS :' $(DEPS)

@echo 'DEPEND :' $(DEPEND)

@echo 'COMPILE.c :' $(COMPILE.c)

@echo 'COMPILE.cxx :' $(COMPILE.cxx)

@echo 'link.c :' $(LINK.c)

@echo 'link.cxx :' $(LINK.cxx)

## End of the Makefile ## Suggestions are welcome ## All rights reserved ## ############################################################## ############################################################# # Generic Makefile for C/C++ Program

#

# License: GPL (General Public License)

# Author: whyglinux

# Date: 2006/03/04 (version 0.1)

# 2007/03/24 (version 0.2)

# 2007/04/09 (version 0.3)

# 2007/06/26 (version 0.4)

# 2008/04/05 (version 0.5)

#

# Description:

# ------------

# This is an easily customizable makefile template. The purpose is to

# provide an instant building environment for C/C++ programs.

#

# It searches all the C/C++ source files in the specified directories,

# makes dependencies, compiles and links to form an executable.

#

# Besides its default ability to build C/C++ programs which use only

# standard C/C++ libraries, you can customize the Makefile to build

# those using other libraries. Once done, without any changes you can

# then build programs using the same or less libraries, even if source

# files are renamed, added or removed. Therefore, it is particularly

# convenient to use it to build codes for experimental or study use.

#

# GNU make is expected to use the Makefile. Other versions of makes

# may or may not work.

#

# Usage:

# ------

# 1. Copy the Makefile to your program directory.

# 2. Customize in the "Customizable Section" only if necessary:

# * to use non-standard C/C++ libraries, set pre-processor or compiler # options to and linker ones to

# (See Makefile.gtk+-2.0 for an example)

# * to search sources in more directories, set to

# * to specify your favorite program name, set to

# 3. Type make to start building your program.

#

# Make Target:

# ------------

# The Makefile provides the following targets to make:

# $ make compile and link

# $ make NODEP=yes compile and link without generating dependencies # $ make objs compile only (no linking)

# $ make tags create tags for Emacs editor

# $ make ctags create ctags for VI editor

# $ make clean clean objects and the executable file

# $ make distclean clean objects, the executable and dependencies

# $ make help get the usage of the makefile

#

#===================================================================== ======

## Customizable Section: adapt those variables to suit your program.

##==================================================================== ======

# The pre-processor and compiler options.

MY_CFLAGS =

# The linker options.

MY_LIBS =

# The pre-processor options used by the cpp (man cpp for more).

CPPFLAGS = -Wall

# The options used in linking as well as in any direct use of ld.

LDFLAGS =

# The directories in which source files reside.

# If not specified, only the current directory will be serached.

SRCDIRS =

# The executable file name.

# If not specified, current directory name or `a.out' will be used.

PROGRAM =

## Implicit Section: change the following only when necessary.

##==================================================================== ======

# The source file types (headers excluded).

# .c indicates C source files, and others C++ ones.

SRCEXTS = .c .C .cc .cpp .CPP .c++ .cxx .cp

# The header file types.

HDREXTS = .h .H .hh .hpp .HPP .h++ .hxx .hp

# The pre-processor and compiler options.

# Users can override those variables from the command line.

CFLAGS = -g -O2

CXXFLAGS= -g -O2

# The C program compiler.

#CC = gcc

# The C++ program compiler.

#CXX = g++

# Un-comment the following line to compile C programs as C++ ones.

#CC = $(CXX)

# The command used to delete file.

#RM = rm -f

ETAGS = etags

ETAGSFLAGS =

CTAGS = ctags

CTAGSFLAGS =

## Stable Section: usually no need to be changed. But you can add more.

##==================================================================== ======

SHELL = /bin/sh

EMPTY =

SPACE = $(EMPTY) $(EMPTY)

ifeq ($(PROGRAM),)

CUR_PATH_NAMES = $(subst /,$(SPACE),$(subst $(SPACE),_,$(CURDIR))) PROGRAM = $(word $(words $(CUR_PATH_NAMES)),$(CUR_PA TH_NAMES))

ifeq ($(PROGRAM),)

PROGRAM = a.out

endif

endif

ifeq ($(SRCDIRS),)

SRCDIRS = .

endif

SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS)))) HEADERS = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(HDREXTS))))

SRC_CXX = $(filter-out %.c,$(SOURCES))

OBJS = $(addsuffix .o, $(basename $(SOURCES)))

DEPS = $(OBJS:.o=.d)

手动建立makefile简单实例解析

手动建立makefile简单实例解析 假设我们有一个程序由5个文件组成,源代码如下:/*main.c*/ #include "mytool1.h" #include "mytool2.h" int main() { mytool1_print("hello mytool1!"); mytool2_print("hello mytool2!"); return 0; } /*mytool1.c*/ #include "mytool1.h" #include void mytool1_print(char *print_str) { printf("This is mytool1 print : %s ",print_str); } /*mytool1.h*/ #ifndef _MYTOOL_1_H #define _MYTOOL_1_H void mytool1_print(char *print_str); #endif /*mytool2.c*/ #include "mytool2.h" #include void mytool2_print(char *print_str) { printf("This is mytool2 print : %s ",print_str); }

/*mytool2.h*/ #ifndef _MYTOOL_2_H #define _MYTOOL_2_H void mytool2_print(char *print_str); #endif 首先了解一下make和Makefile。GNU make是一个工程管理器,它可以管理较多的文件。我所使用的RedHat 9.0的make版本为GNU Make version 3.79.1。使用make的最大好处就是实现了“自动化编译”。如果有一个上百个文件的代码构成的项目,其中一个或者几个文件进行了修改,make就能够自动识别更新了的文件代码,不需要输入冗长的命令行就可以完成最后的编译工作。make执行时,自动寻找Makefile(makefile)文件,然后执行编译工作。所以我们需要编写Makefile文件,这样可以提高实际项目的工作效率。 在一个Makefile中通常包含下面内容: 1、需要由make工具创建的目标体(target),通常是目标文件或可执行文件。 2、要创建的目标体所依赖的文件(dependency_file)。 3、创建每个目标体时需要运行的命令(command)。 格式如下: target:dependency_files command target:规则的目标。通常是程序中间或者最后需要生成的文件名,可以是.o文件、也可以是最后的可执行程序的文件名。另外,目标也可以是一个make执行的动作的名称,如目标“clean”,这样的目标称为“伪目标”。 dependency_files:规则的依赖。生成规则目标所需要的文件名列表。通常一个目标依赖于一个或者多个文件。 command:规则的命令行。是make程序所有执行的动作(任意的shell命令或者可在shell下执行的程序)。一个规则可以有多个命令行,每一条命令占一行。注意:每一个命令行必须以[Tab]字符开始,[Tab]字符告诉make此行是一个命令行。make按照命令完成相应的动作。这也是书写Makefile中容易产生,而且比较隐蔽的错误。命令就是在任何一个目标的依赖文件发生变化后重建目标的动作描述。一个目标可以没有依赖而只有动作(指定的命令)。比如Makefile中的目标“clean”,此目标没有依赖,只有命令。它所指定的命令用来删除make过程产生的中间文件(清理工作)。 在Makefile中“规则”就是描述在什么情况下、如何重建规则的目标文件,通常规则

跟我一起写Makefile

跟我一起写Makefile 陈皓 1 概述 什么是makefile?或许很多Winodws的程序员都不知道这个东西,因为那些Windows的IDE都为你做了这个工作,但我觉得要作一个好的和professional的程序员,makefile还是要懂。这就好像现在有这么多的HTML的编辑器,但如果你想成为一个专业人士,你还是要了解HTML的标识的含义。特别在Unix下的软件编译,你就不能不自己写makefile了,会不会写makefile,从一个侧面说明了一个人是否具备完成大型工程的能力。 因为,makefile关系到了整个工程的编译规则。一个工程中的源文件不计数,其按类型、功能、模块分别放在若干个目录中,makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复杂的功能操作,因为makefile就像一个Shell脚本一样,其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make命令,整个工程完全自动编译,极大的提高了软件开发的效率。make是一个命令工具,是一个解释makefile中指令的命令工具,一般来说,大多数的IDE都有这个命令,比如:Delphi的make,Visual C++的nmake,Linux下GNU的make。可见,makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少,这是我想写这篇文章的原因。当然,不同产商的make各不相同,也有不同的语法,但其本质都是在“文件依赖性”上做文章,这里,我仅对GNU的make进行讲述,我的环境是RedHat Linux 8.0,make的版本是3.80。必竟,这个make是应用最为广泛的,也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的(POSIX.2)。 在这篇文档中,将以C/C++的源码作为我们基础,所以必然涉及一些关于C/C++的编译的知识,相关于这方面的内容,还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。 2 关于程序的编译和链接 在此,我想多说关于程序编译的一些规范和方法,一般来说,无论是C、C++、还是pas,首先要把源文件编译成中间代码文件,在Windows下也就是.obj 文件,UNIX下是.o 文件,即Object File,这个动作叫做编译(compile)。然后再把大量的Object File合成执行文件,这个动作叫作链接(link)。 编译时,编译器需要的是语法的正确,函数与变量的声明的正确。对于后者,通常是你需要告诉编译器头文件的所在位置(头文件中应该只是声明,而定义应该放在C/C++文件中),只要所有的语法正确,编译器就可以编译出中间目标文件。一般来说,每个源文件都应该对应于一个中间目标文件(O文件或是OBJ 文件)。 链接时,主要是链接函数和全局变量,所以,我们可以使用这些中间目标文件(O文件或是OBJ文件)来链接我们的应用程序。链接器并不管函数所在的源文件,只管函数的中间目标文件(Object File),在大多数时候,由于源文件太多,编译生成的中间目标文件太多,而在链接时需要明显地指出中间目标文件名,这对于编译很不方便,所以,我们要给中间目标文件打个包,在Windows下这种包叫“库文件”(Library File),也就是.lib 文件,在UNIX下,是Archive File,也就是.a 文件。 总结一下,源文件首先会生成中间目标文件,再由中间目标文件生成执行文件。在编译时,编译器只检测程序语法,和函数、变量是否被声明。如果函数未被声明,编译器会给出一个警告,但可以生成Object File。而在链接程序时,链接器会在所有的Object File中找寻函数的实现,如果找不到,那到就会报链接错

linux驱动的Makefile分析

第6行,判断KERNELRELEASE是否为空,该变量是描述内核版本的字符串。只有执行make命令的当前目录为内核源代码目录时,该变量才不为空字符。 第7、8行定义了KERNELDIR和PWD变量。KERNELDIR是内核路径变量,PWD是由执行pwd命令得到的当前模块路径。 第11行make的语法是”Make –C 内核路径M=模块路径modules”,该语法会执行内核模块的编译 第13行是将模块安装到对应的路径中,当在命令执行make modules_install时,执行该命令,其他时候不执行 第24行,意思是将hello.o编译成hello.ko模块。如果要编译其他模块时,只要将hello.o中的hello改成模块的文件名就可以了 Makefile的执行过程: 执行make命令后,将进入Makefile文件。此时KERNELRELEASE变量为空,此时是第一次进入Makefile文件。当执行完变量赋值代码后,会根据make参数执行不同的逻辑。 如下: make modules_install 命令,将执行13、15行将模块安装到操作系统中。 make clean命令,会删除目录中的所有临时文件。 make命令,会执行10、11行编译模块。首先$(MAKE) -C $(KERNELDIR) M=$(PWD) modules 中的-C $(KERNELDIR)选项,会使编译器进入内核源码目录/home/zzc/linux-2.6.31,读取Makefile文件,从中得到一些信息,例如变量KERNELRELEASE将在这里赋值。当内核源码目录中的Makefile文件读取完成后,编译器会根据选项M=$(PWD)第二次进入模块所在的目录,并再一次执行Makefie文件。当第二次执行Makefile文件时,变量KERNELRELEASE

LINUX编程 Makefile中的变量详解应用

第六章:Makefile中的变量 -------------------------------------------------------------------------------- 在Makefile中,变量就是一个名字(像是C语言中的宏),代表一个文本字符串(变量的值)。在Makefile的目标、依赖、命令中引用一个变量的地方,变量会被它的值所取代(与C语言中宏引用的方式相同,因此其他版本的make也把变量称之为“宏”)。在Makefile中变量的特征有以下几点: 1. Makefile中变量和函数的展开(除规则的命令行以外),是在make读取makefile文件时进行的,这里的变量包括了使用“=”定义和使用指示符“define”定义的。 2. 变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列表、编译输出的目录列表和所有我们能够想到的事物。 3. 变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。需要注意的是,尽管在GNU make中没有对变量的命名有其它的限制,但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的,因为除字母、数字和下划线以外的其它字符可能会在以后的make版本中被赋予特殊含义,并且这样命名的变量对于一些shell来说不能作为环境变量使用。 4. 变量名是大小写敏感的。变量“foo”、“Foo”和“FOO”指的是三个不同的变量。Makefile 传统做法是变量名是全采用大写的方式。推荐的做法是在对于内部定义定义的一般变量(例如:目标文件列表objects)使用小写方式,而对于一些参数列表(例如:编译选项CFLAGS)采用大写方式,这并不是要求的。但需要强调一点:对于一个工程,所有Makefile中的变量命名应保持一种风格,否则会显得你是一个蹩脚的程序员(就像代码的变量命名风格一样)。 5. 另外有一些变量名只包含了一个或者很少的几个特殊的字符(符号)。称它们为自动化变量。像“$<”、“$@”、“$?”、“$*”等。 6.1 变量的引用 当我们定义了一个变量之后,就可以在Makefile的很多地方使用这个变量。变量的引用方式是:使用“$(VARIABLE_NAME)”或者“${ VARIABLE_NAME }”来引用一个变量的定义。例如:“$(foo) ”或者“${foo}”就是取变量“foo”的值。美元符号“$”在Makefile中有特殊的含义,所有在命令或者文件名中使用“$”时需要用两个美元符号“$$”来表示。对一个变量的引用可以在Makefile的任何上下文中,目标、依赖、命令、绝大多数指示符和新变量的赋值中。这里有一个例子,其中变量保存了所有.o文件的列表: objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects)

Makefile下编写Helloworld的例子

什么是makefile?或许很多Windows的程序员都不知道这个东西,因为那些Windows的IDE都为你做了这个工作,但我觉得 要作一个好的和professional的程序员,makefile还是要懂。这就好像现在有这么多的HTML的编辑器,但如果你想成为一个专 业人士,你还是要了解HTML的标识的含义。特别在Unix下的软件编译,你就不能不自己写makefile了,会不会写makefile, 从一个侧面说明了一个人是否具备完成大型工程的能力。 因为,makefile关系到了整个工程的编译规则。一个工程中的源文件不计数,其按类型、功能、模块分别放在若干个目录中, makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复 杂的功能操作,因为makefile就像一个Shell脚本一样,其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make 命令,整个工程完全自动编译,极大的提高了软件 开发的效率。make是一个命令工具,是一个解释makefile中指令的命令工具,一般来说,大多数的IDE都有这个命令,比如: Delphi的make,VisualC++的nmake,Linux下GNU的make。可见,makefile都成为了一种在工程方面的编译方法。 更新版本 hello.c程序 #include int main(){printf("Hello,World!\n");

return 0;}=== makefile开始=== Helloworld: hello.o gcc hello.o–o Helloworld Hello.o: hello.c hello.h gcc–MM hello.c gcc–c hello.c–o hello.o .PHONY: clean Clean: rm–rf*.o hellworld === makefile结束===

模块驱动笔记

驱动模块装载全纪录 模块驱动源代码demo.c如下: /* ************************************************************************* * *my first linux driver * ************************************************************************* */ //#ifndef_KERNEL_ //#define_KERNEL_/*缂..杩..??/ //#endif #ifdef MODULE/*浠ユā?..寮.?璇./ #include #ifdef CONFIG_DEVFS_FS #include/*璁惧??.欢绯荤?澶存.浠?/ #endif #include/*初始化相关头文件*/ #include/*与printk()等函数有关的头文件*/ #include/*与kmalloc()等函数有关的头文件*/ #include/*与文件系统有关的头文件*/ #include/*错误代码处理头文件error codes*/ #include/*数据类型头文件size_t*/ #include/*与进程调度相关的头文件*/ #include/*O_ACCMODE*/ #include/*COPY_TO_USER*/ #include/*cli(),*_flag*/ #define DEVICE_NAME"ZJD demo"/*该驱动的设备名*/ #define DEMORAW_MINOR1 #define DEMO_Devfs_path"demo/0"/*驱动目录*/ //#define demo_MAJOR254/*主设备号*/ //#define demo_MINOR0/*次设备号*/ static int demoMajor=0;

make_Makefile 结构分析

Makefile结构分析 -----uClinux (2.6.x内核)系统映像过程 刘江欧阳昭暐吕熙隆 1、源代码文件及目录构成 解压缩uClinux-dist-20070130.tar.gz压缩文件,在uClinux-dist原始子目录下主要有:config、Bin、linux-2.4.x、linux-2.6.x 、lib、tools、Include、user和vendors,以及文件Makefile。另外,在编译后生成子目录images和romfs,以及文件autoconfig.h、config.in和两个隐含文件:.config和.depend。 config子目录包含文件及下一级子目录,如 config.in、configure.help、Fixconfig、Makefile、 Mkconfig、Setconfig所有这些文件及子目录 Scripts均与系统配置有关; linux-2.6.x子目录是嵌入式操作系统 uClinux-2.6.x的核心目录,包括下一级子目录 arch、include、init、drivers、fs、ipc、kernel、 lib、Mm、scripts和关键文件Makefile、 rules.make,编译后还要生成新文件romfs.o、linux 和system.map;lib子目录为嵌入式操作系统提供 压缩和改进了的函数库支持;tools子目录包含 romfs-inst.sh文件,通过调用此文件,可以把目录 或文件加入到romfs子目录中;user子目录包含各 种驱动程序文件目录,根据用户的配置情况,不同的 驱动程序会被编译进最后形成的操作系统中; vendors子目录包括与特定硬件平台相关的分类目录 组。目录结构如图1所示。 Makefile的详细介绍情况在 uClinux-dist\linux-2.6.x\Documentation\kbuil d中,如图2所示。图1、目录结构即Linux 内核中的 Makefile 以及与 Makefile 直接相关的文件有:

Linux系统的Makefile和Kconfig及模块简介

Linux系统的Makefile、Kconfig和模块 1Makefile 1.1Makefile组织层次 Linux的Make体系由如下几部分组成: ?顶层Makefile 顶层Makefile通过读取配置文件,递归编译内核代码树的相关目录,从而产生两个重要的目标文件:vmlinux和模块。 ?内核相关Makefile 位于arch/$(ARCH) 目录下,为顶层Makefile提供与具体硬件体系结构相关的信息。?公共编译规则定义文件。 包括Makefile.build 、Makefile.clean、Makefile.lib、Makefile.host等文件组成。这些文件位于scripts目录中,定义了编译需要的公共的规则和定义。 ?内核配置文件 .config 通过调用make menuconfig或者make xconfig命令,用户可以选择需要的配置来生成期望的目标文件。 ?其他Makefile 主要为整个Makefile体系提供各自模块的目标文件定义,上层Makefile根据它所定义的目标来完成各自模块的编译。 1.2Makefile的使用 在编译内核之前,用户必须首先完成必要的配置。Linux内核提供了数不胜数的功能,支持众多的硬件体系结构,这就需要用户对将要生成的内核进行裁减。内核提供了多种不同的工具来简化内核的配置。 make config,字符界面下命令行工具,这个工具会依次遍历内核所有的配置项,要求用户进行逐项的选择配置。这个工具会耗费用户太多时间,除非万不得以(你的编译主机不支持其他配置工具)一般不建议使用。 make menuconfig,基于ncurse库编制的图形界面工具,一般台式机使用该工具。 make xconfig,基于X11的图形配置工具,一般用于工作站环境。

Linux如何写makefile文件

Linux如何写makefile文件 关于程序的编译和链接 —————————— 在此,我想多说关于程序编译的一些规范和方法,一般来说,无论是C、C++、还是pas,首先要把源文件编译成中间代码文件,在Windows下也就是 .obj 文件,UNIX下是 .o 文件,即 Object File,这个动作叫做编译(compile)。然后再把大量的Object File合成执行文件,这个动作叫作链接(link)。 编译时,编译器需要的是语法的正确,函数与变量的声明的正确。对于后者,通常是你需要告诉编译器头文件的所在位置(头文件中应该只是声明,而定义应该放在 C/C++文件中),只要所有的语法正确,编译器就可以编译出中间目标文件。一般来说,每个源文件都应该对应于一个中间目标文件(O文件或是OBJ文 件)。 链接时,主要是链接函数和全局变量,所以,我们可以使用这些中间目标文件(O文件或是OBJ文件)来链接我们的应用程序。链接器并不管函数所在的源文件, 只管函数的中间目标文件(Object File),在大多数时候,由于源文件太多,编译生成的中间目标文件太多,而在链接时需要明显地指出中间目标文件名,这对于编译很不方便,所以,我们要给 中间目标文件打个包,在Windows 下这种包叫“库文件”(Library File),也就是 .lib 文件,在UNIX下,是Archive File,也就是 .a 文件。 总结一下,源文件首先会生成中间目标文件,再由中间目标文件生成执行文件。在编译时,编译器只检测程序语法,和函数、变量是否被声明。如果函数未被声明, 编译器会给出一个警告,但可以生成Object File。而在链接程序时,链接器会在所有的Object File中找寻函数的实现,如果找不到,那到就会报链接错误码(Linker Error),在VC下,这种错误一般是:Link 2001错误,意思说是说,链接器未能找到函数的实现。你需要指定函数的Object File. 好,言归正传,GNU的make有许多的内容,闲言少叙,还是让我们开始吧。 Makefile 介绍 ——————— make命令执行时,需要一个 Makefile 文件,以告诉make命令需要怎么样的去编译和链接程序。 首先,我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例来源于GNU的make使用手册,在这个示例中,我们的工程有 8

Makefile 语法分析

Makefile 语法分析第一部分 VERSION = 2 # 给变量VERSION赋值 PATCHLEVEL = 6 # 给变量PATCHLEVEL赋值 SUBLEVEL = 22 # 给变量SUBLEVEL赋值 EXTRAVERSION = .6 # 给变量EXTRAVERSION赋值 NAME = Holy Dancing Manatees, Batman! # 给变量NAME赋值 # *DOCUMENTATION* # To see a list of typical targets execute "make help" # More info can be located in ./README # Comments in this file are targeted only to the developer, do not # expect to learn how to build the kernel reading this file. # Do not: # o use make's built-in rules and variables # (this increases performance and avoid hard-to-debug behavour); # o print "Entering directory ..."; MAKEFLAGS += -rR --no-print-directory # 操作符“+=”的作用是给变量(“+=”前面的MAKEFLAGS)追加值。 # 如果变量(“+=”前面的MAKEFLAGS)之前没有定义过,那么,“+=”会自动变成“=”; # 如果前面有变量(“+=”前面的MAKEFLAGS)定义,那么“+=”会继承于前次操作的赋值符;# 如果前一次的是“:=”,那么“+=”会以“:=”作为其赋值符 # 在执行make时的命令行选项参数被通过变量“MAKEFLAGS”传递给子目录下的make程序。# 对于这个变量除非使用指示符“unexport”对它们进行声明,它们在整个make的执行过程中始终被自动的传递给所有的子make。 # 还有个特殊变量SHELL与MAKEFLAGS一样,默认情况(没有用“unexport”声明)下在整个make的执行过程中被自动的传递给所有的子make。 # # -rR --no-print-directory # -r disable the built-in impilict rules. # -R disable the built-in variable setttings. # --no-print-directory。 # We are using a recursive build, so we need to do a little thinking # to get the ordering right. # # Most importantly: sub-Makefiles should only ever modify files in # their own directory. If in some directory we have a dependency on # a file in another dir (which doesn't happen often, but it's often # unavoidable when linking the built-in.o targets which finally # turn into vmlinux), we will call a sub make in that other dir, and

跟我一起写Makefile(可以注释版)

跟我一起写 Makefile 作者:陈皓 整理:祝冬华

第一部分、概述 (6) 第二部分、关于程序的编译和链接 (6) 第三部分、Makefile 介绍 (7) 一、Makefile的规则 (7) 二、一个示例 (8) 三、make是如何工作的 (9) 四、makefile中使用变量 (10) 五、让make自动推导 (11) 六、另类风格的makefile (12) 七、清空目标文件的规则 (13) 第四部分、Makefile 总述 (13) 一、Makefile里有什么? (13) 1、显式规则。 (14) 2、隐晦规则。 (14) 3、变量的定义。 (14) 4、文件指示。 (14) 5、注释。 (14) 二、Makefile的文件名 (15) 三、引用其它的Makefile (15) 四、环境变量 MAKEFILES (16) 五、make的工作方式 (16) 第五部分、书写规则 (17) 一、规则举例 (17) 二、规则的语法 (17) 三、在规则中使用通配符 (18) 四、文件搜寻 (19) 五、伪目标 (20) 六、多目标 (22) 七、静态模式 (22) 八、自动生成依赖性 (24) 第六部分书写命令 (25) 一、显示命令 (26) 二、命令执行 (26) 三、命令出错 (27) 四、嵌套执行make (28) 五、定义命令包 (30) 第七部分使用变量 (30) 一、变量的基础 (31) 二、变量中的变量 (32) 三、变量高级用法 (34) 四、追加变量值 (37) 五、override 指示符 (37) 六、多行变量 (38)

八、目标变量 (39) 九、模式变量 (40) 第八部分使用条件判断 (40) 一、示例 (40) 二、语法 (42) 第九部分使用函数 (43) 一、函数的调用语法 (44) 二、字符串处理函数 (44) 1、subst (44) 2、patsubst (45) 3、strip (45) 4、findstring (46) 5、filter (46) 6、filter-out (46) 7、sort (47) 8、word (47) 9、wordlist (47) 10、words (47) 11、firstword (48) 12、字符串函数实例 (48) 三、文件名操作函数 (48) 1、dir (48) 2、notdir (48) 3、suffix (49) 4、basename (49) 5、addsuffix (49) 6、addprefix (49) 7、join (50) 四、foreach 函数 (50) 五、if 函数 (50) 六、call函数 (51) 七、origin函数 (51) “undefined” (52) “default” (52) “file” (52) “command line” (52) “override” (52) “automatic” (52) 八、shell函数 (53) 九、控制make的函数 (53) 1、error (53) 2、warning (54) 第十部分 make 的运行 (54)

linux设备驱动程序的hello模块编译过程

linux设备驱动程序的hello模块编译过程 今天把linux设备驱动程序(第三版)的第一个模块hello模块编译通过了,这个东西卡了我好长时间了,期间我又花了很多时间去看linux程序设计(第二版),终于今天机械性地完成了这个试验。 编译环境:虚拟机linux2.6.18内核,(如果内核不是2.6的,可以参考我的内核升级过程,另外一篇文章有详细记录) 源程序hello.c: ///////////////////////////////////////////////////////////////////// /////// #include #include #include MODULE_LICENSE("Dual BSD/GPL"); static int hello_init(void) //有的上面定义的是init_modules(void)是通不过编译的 { printk(KERN_ALERT "Hello, world\n"); return 0; } static void hello_exit(void) { printk(KERN_ALERT "Goodbye, world\n"); } module_init(hello_init); module_exit(hello_exit); ///////////////////////////////////////////////////////////////////// /// Makefile的内容: ifneq ($(KERNELRELEASE),) obj-m := hello.o else KDIR:=/lib/modules/$(shell uname -r)/build PWD:=$(shell pwd)

makefile 中文手册 第六章 _ Makefile中的变量

第六章:Makefile中的变量 在Makefile中,变量是一个名字(像是C语言中的宏),代表一个文本字符串(变量的值)。在Makefile的目标、依赖、命令中引用变量的地方,变量会被它的值所取代(与C语言中宏引用的方式相同,因此其他版本的make也把变量称之为“宏”)。在Makefile中变量有以下几个特征: 1.Makefile中变量和函数的展开(除规则命令行中的变量和函数以外),是在make读取makefile文件时 进行的,这里的变量包括了使用“=”定义和使用指示符“define”定义的。 2.变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列 表、编译输出的目录列表和所有我们能够想到的事物。 3.变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。需要注意的是,尽管在GNU make中没有对变量的命名有其它的限制,但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的,因为除字母、数字和下划线以外的其它字符可能会在make的后续版本中被赋予特殊含义,并且这样命名的变量对于一些shell来说是不能被作为环境变量来使用的。 4.变量名是大小写敏感的。变量“foo”、“Foo”和“FOO”指的是三个不同的变量。Makefile传统做 法是变量名是全采用大写的方式。推荐的做法是在对于内部定义定义的一般变量(例如:目标文件列表objects)使用小写方式,而对于一些参数列表(例如:编译选项CFLAGS)采用大写方式,但这并不是要求的。但需要强调一点:对于一个工程,所有Makefile中的变量命名应保持一种风格,否则会显得你是一个蹩脚的程序员(就像代码的变量命名风格一样)。 5.另外有一些变量名只包含了一个或者很少的几个特殊的字符(符号)。称它们为自动化变量。 像“$<”、“$@”、“$?”、“$*”等。 6.1变量的引用 当我们定义了一个变量之后,就可以在Makefile的很多地方使用这个变量。变量的引用方式 是:“$(VARIABLE_NAME)”或者“${ VARIABLE_NAME }”来引用一个变量的定义。例如:“$(foo)”或者“${foo}”就是取变量“foo”的值。美元符号“$”在Makefile中有特殊的含义,所有在命令或者文件名中使用“$”时需要用两个美元符号“$$”来表示。对一个变量的引用可以在Makefile的任何上下文中,目标、依赖、命令、绝大多数指示符和新变量的赋值中。这里有一个例子,其中变量保存了所有.o文件的列表: objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects) $(objects) : defs.h 变量引用的展开过程是严格的文本替换过程,就是说变量值的字符串被精确的展开在变量被引用的地方。因此规则: foo = c prog.o : prog.$(foo) $(foo) $(foo) -$(foo) prog.$(foo) 被展开后就是:

makefile 中 $@ $^ % 使用

makefile 中$@ $^ %< 使用 https://www.sodocs.net/doc/20448113.html,/kesaihao862/article/details/7332528 这篇文章介绍在LINUX下进行C语言编程所需要的基础知识。在这篇文章当中,我们将会学到以下内容:源程序编译Makefile的编写程序库的链接程序的调试头文件和系统求助1.源程序的编译在Linux下面,如果要编译一个C语言源程序,我们要使用GNU的gcc编译器。下面我们以一个实例来说明如何使用gcc编译器。假设我们有下面一个非常简单的源程序(hello.c):int main(int argc,char **argv){printf("Hello Linux\n");}要编译这个程序,我们只要在命令行下执行:gcc -o hello hello.cgcc 编译器就会为我们生成一个hello的可执行文件。执行./hello就可以看到程序的输出结果了。命令行中gcc表示我们是用gcc来编译我们的源程序,-o 选项表示我们要求编译器给我们输出的可执行文件名为hello 而hello.c是我们的源程序文件。gcc编译器有许多选项,一般来说我们只要知道其中的几个就够了。-o 选项我们已经知道了,表示我们要求输出的可执行文件名。-c选项表示我们只要求编译器输出目标代码,而不必要输出可执行文件。-g选项表示我们要求编译器在编译的时候提供我们以后对程序进行调试的信息。知道了这三个选项,我

们就可以编译我们自己所写的简单的源程序了,如果你想要知道更多的选项,可以查看gcc的帮助文档,那里有着许多对其它选项的详细说明。2.Makefile的编写假设我们有下面这样的一个程序,源代码如下:/* main.c */#include "mytool1.h"#include "mytool2.h" int main(int argc,char **argv){mytool1_print("hello");mytool2_print("hello");}/* mytool1.h */ #ifndef _MYTOOL_1_H#define _MYTOOL_1_Hvoid mytool1_print(char *print_str);#endif/* mytool1.c */#include "mytool1.h"void mytool1_print(char *print_str){printf("This is mytool1 print %s\n",print_str);}/* mytool2.h */#ifndef _MYTOOL_2_H#define _MYTOOL_2_Hvoid mytool2_print(char *print_str);#endif/* mytool2.c */#include "mytool2.h"void mytool2_print(char *print_str){printf("This is mytool2 print %s\n",print_str);}当然由于这个程序是很短的我们可以这样来编译gcc -c main.cgcc -c mytool1.cgcc -c mytool2.cgcc -o main main.o mytool1.o mytool2.o这样的话我们也可以产生main程序,而且也不时很麻烦。但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)那么我们难道还要重新输入上面的命令?也许你会说,这个很容易解决啊,我写一个SHELL脚本,让她帮我去完成不就可以了。是的对于这个程序来说,是可

LN电机驱动模块详解

L298N电机驱动器使用说明书 注意:本说明书中添加超链接的按CTRL并点击连接,即可看到内容。

1.信号电源引入端 2.控制信号输入端 3.直流电机调速PWM脉宽信号输入 端。(控制步进电机或者控制直流电机 无需调速时,保持此状态) 4.控制信号指示灯 5. 光电隔离(抗干扰) 6.核心芯片(L298N) 7.二极管桥式续流保护8.电源滤波9.端子接线 实例一:步进电机的控制实例

步进电机是数字控制电机,它将脉冲信号转变成角位移,即给一个脉冲信号,步进电机就转动一个角度,因此非常适合于单片机控制。步进电机可分为反应式步进电机(简称VR)、永磁式步进电机(简称PM)和混合式步进电机(简称HB)。 一、步进电机最大特点是: 1、它是通过输入脉冲信号来进行控制的。 2、电机的总转动角度由输入脉冲数决定。 3、电机的转速由脉冲信号频率决定。 二、步进电机的驱动电路 根据控制信号工作,控制信号由单片机产生。(或者其他信号源) 三、基本原理作用如下: 两相四拍工作模式时序图:

(1)控制换相顺序 1、通电换相这一过程称为脉冲分配。 例如: 1、两相四线步进电机的四拍工作方式,其各相通电顺序为(A-B-A’ -B’)通电控制脉冲必须严格按照这一顺序分别控制A,B相的通断。) 2、两相四线步进电机的四拍工作方式,其各相通电顺序为: (A-AB-B-BA’-A’-A’B’-B’-B’ 依次循环。(出于对力矩、平稳、噪音及减少角度等方面考虑。往往采用八拍工作方式) (2)控制步进电机的转向 如果给定工作方式正序换相通电,步进电机正转,如果按反序通电换相,则电机就反转。如:正转通电顺序是:(A-B-A’-B’依次循环。)则反转的通电顺序是:(B‘-A’-B-A依次循环。) 参考下例:

openwrt顶层Makefile分析

openwrt 这里主要介绍openwrt的主Makefile,并未对各个目录下的Makefile和相关文件进行介绍。 在Makefile里是两个主要的分支,由if语句根据OPENWRT_BUILD的值进行不同的处理。第一个部分主要是执行编译前的准备,第二个部分是执行编译。 打开Makefile文件,可以看到默认的make目标world,这个目标没有依赖文件和执行命令。 执行make的时候,首先进入第一个部分,此时OPENWRT_BUILD的值为0,然后将OPENWRT_BUILD的值赋为1,在这里用到了override指示符,override指示符的作用的忽略make命令行的参数的赋值,可以对该变量进行赋值。 载入include下的相关文件,在toplevel.mk可以看到 %:: @+$(PREP_MK) $(NO_TRACE_MAKE) -r -s prereq @+$(SUBMAKE) -r $@ 默认的目标就会执行这里。 在toplevel.mk的顶部定义了PREP_MK= OPENWRT_BUILD= QUIET=0,将OPENWRT_BUILD的值赋为0。 在执行@+$(PREP_MK) $(NO_TRACE_MAKE) -r -s prereq命令的时候,在make命令行里有$(PREP_MK)变量,而由于OPENWRT_BUILD的值为0,在verbose.mk文件里NO_TRACE_MAKE := $(MAKE) V=99,所以会执行顶层 目录的Makefile第一个分支部分的目标prereq,即toplevel.mk文件中的目标prereq: prereq:: prepare-tmpinfo .config @+$(MAKE) -r -s tmp/.prereq-build $(PREP_MK) @+$(NO_TRACE_MAKE) -r -s $@ 这里会进行一些编译前的准备工作,然后执行@+$(NO_TRACE_MAKE) -r -s $@,再次去执行顶层Makefile,此时,并没有$(PREP_MK)变量,所以会执行顶层Makefile的第一个部分,载入include下的相关文件,和一些必要的Makefile文件,在顶层Makefile去寻找prereq目标, prereq: $(target/stamp-prereq) tmp/.prereq_packages 处理它的依赖文件。 然后再接着执行toplevel.mk %:: @+$(PREP_MK) $(NO_TRACE_MAKE) -r -s prereq @+$(SUBMAKE) -r $@ 在@+$(SUBMAKE) -r $@命令中也没有$(PREP_MK)变量,所以在顶层Makefile的第二个部分,寻找Makefile的默认目标,即world。 world: prepare $(target/stamp-compile) $(package/stamp-cleanup) $(package/stamp-compile) $(package/stamp-install) $(package/stamp-rootfs-prepare) $(target/stamp-install) FORCE $(_SINGLE)$(SUBMAKE) -r package/index 根据各个依赖文件进行相应的编译,最终完成编译。 在顶层Makefile里比较麻烦的是,将Makefile分为了两个主要分支,在每个分支里通过include载入相应的文件,在这些文件里包含相应的目标执行命令,在命令中多次用make + 目标+ 参数的方式,则会再次执行Makefile文件,就形成了Makefile的嵌套执行。

相关主题