【Unix环境编程】一些乱七八糟的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.

    make命令几个标记：
    -k 在make遇到错误时继续执行
    -n 让make命令在没有实际执行的情况下列出将会执行的操作步骤
    -f <filebname> 作用是make命令使用指定的制作文件，默认当前子目录第一个名为makefile的文件再获Makefile的文件。
    我们可以把目标文件的名字做参数传给make命令，不指定的话make将创建制作文件里的第一个目标。
   
    make依赖关系和规则：
    make命令博大精深但是还不知道如何建立我们的软件，需要我们提供一个文件告诉make软件如何构造，即制作文件。一般和项目源文件放一个目录，同时可以制作多个制作文件。
    制作文件由一组依赖关系和规则构成。每个依赖关系有一个目标文件和所依赖的源文件组成，规则则藐视怎样从被依赖文件创建出目标文件来。
    依赖关系定义了最终应用程序中每个文件和源文件关系。例如：依赖关系定义为最终应用程序依赖于main.o 2.o 3.o也就是依赖于main.o的下级依赖main.c和a.h, 2.o的下级依赖和3.o的下级依赖。main.受main.c和a.h文件中修改的影响，如果两个文件发生变化需要重新编译main.c文件来重建main.o。规则需要一个制表符tab开始而不能用空格。make并不管命令是怎么工作的，他只管执行所定义的命令。make 会比较目标文件和依赖文件的修改日期，如果依赖文件的日期要比目标文件的日期要新，或者目标文件不存在的话，那么，make就会执行后续定义的命令。
    在制作文件中写法是：
    目标名：空格/tab 文件清单1 文件清单2 ...
    myapp： main.o 2.o 3.o
 gcc -o myapp main.o 2.o 3.o
    main.o: main.c a.h
     gcc -c main.c
    2.o:  2.c a.h b.h
 gcc -c 2.c
    3.o:  3.c b.h c.h
 gcc -c 3.c
    表示main.o 依赖于main.c和a.h。
    当我们执行make -f Makefile后:
    gcc -c main.c
    gcc -c 2.c
    gcc -c 3.c
    gcc -o myapp main.o 2.o 3.o

    rm 2.o
    make -f Makefile
    gcc -c 2.c
    gcc -o myapp main.o 2.o 3.o

    规则中的几个通配符：
    * ：*.c表示所有后缀为c的文件
    ~ ：应该是当前用户的home下目录，和ssh中一样
    ？：

    make工作流程
    在默认的方式下，也就是我们只输入make命令。那么，
    1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
    2、如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到myapp这个文件，并把这个文件作为最终的目标文件。
    3、如果myapp文件不存在，或是myapp所依赖的后面的 .o 文件的文件修改时间要比myapp这个文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。
    4、如果edit所依赖的.o文件也存在，那么make会在当前文件中找目标为.o文件的依赖性，如果找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程）
    5、当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用 .o 文件生命make的终极任务，也就是执行文件myapp。
    make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的 文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只管文件的依赖性。我们可以在make文件最后加一个clean命令：
    ......
    main.o: main.c a.h
     $(CC) -I$(INCLUDE) $(CPLAGS) -c main.c
    clean:
    rm myapp main.o 2.o 3.o
    这里clean没有被第一个目标文件myapp直接或在间接关联，后面的命令不会自动执行，在我们执行make clean后才会清除所有目标文件。

   
    #which compiler
    CC = gcc

    #where to install
    INSTDIR = /usr/local/bin   

    TARGET = myapp
    #SOURCE := $(wildcard *.c) $(wildcard *.h)   

    #where are include files kept
    INCLUDE = .
    #-I/usr/include/mysql  -I./
   
    #Options for development
    CFLAGS = -g -Wall -ansi
 
    #Options for release
    #CFLAGS = -O -Wall -ansi
   
    ALL:$(TARGET)

    $(TARGET): main.o 2.o 3.o
     $(CC) -o myapp main.o 2.o 3.o
    main.o: main.c a.h
     $(CC) -I$(INCLUDE) $(CPLAGS) -c main.c
    2.o: 2.c a.h b.h
        $(CC) -I$(INCLUDE) $(CPLAGS) -c 2.c
    3.o: 3.c b.h c.h
        $(CC) -I$(INCLUDE) $(CPLAGS) -c 3.c
   
    .PHONY:clean
    clean:
        -rm main.o 2.o 3.o
    install:myapp
        @if [ -d $(INSTDIR) ];/
            then /
            cp myapp $(INSTDIR);/
            chmod a+x $(INSTDIR)/myapp;/
            chmod og-w $(INSTDIR)/myapp;/
            echo "Installed in $(INSTDIR)";/
        else /
            echo "Sorry, $(INSTDIR) does not exist";/
        fi

    makefile中使用变量
    上面例子中我们2.0被我们重复出现了几次，如果项目很大，makefile很复杂时，我们想加一个.o文件可能需要修改的地方就很多，为了makefile便于维护我们可以在makefile中使用变量，也就是一个字符串，相当于C中的宏。下面例子：
    #表示注释
    宏定义 MACRONAME=value 应用办法是$MACRONAME，$(MACRONAME)或${MACRONAME}。宏定义可以用做编译器命令选项。另外对gcc/cc/c89等区别，定义为宏修改方便。例如
    这里make会将$(CC),$(CFLAGS)都替换为相应定义，和C中#define相似。
    @ 表示make在执行一条命令之前不把命令本身输出到标准输出中。使用到echo时候会用到。
    - 表示不管任何错误。@告诉make在执行一条命令之前不把命令本身输入到标准输出中。
    clean删除不再需要的目标代码文件，install把应用移动到另一个子目录中。
    .PHONY表示clean是一个伪目标。伪目标不是一个文件，只是一个标签，make无法生成它的依赖关系和决定是否执行它，。PHONY就特表示不管有没有文件，clean就是一个伪目标。伪目标同样也可成为依赖。看下面的例子：
    .PHONY: cleanall cleanobj cleandiff
    cleanall : cleanobj cleandiff
    rm program
    cleanobj :
    rm *.o
    cleandiff :
    rm *.diff
    make clean将清除所有要被清除的文件。cleanobj和cleandiff这两个伪目标有点像“子程序”的意思。我们可以输入make cleanall和make cleanobj和make cleandiff命令来达到清除不同种类文件的目的。
    目标install依赖于myapp，make会知道执行制作install的其他命令之前要创建出myapp。make会启动shell来执行install的规则。并且每一条规则都会启动一个新shell，所以我们必须在代码后面加/，让这些shell脚本程序命令在逻辑上成为一个完整的命令行。传递到一个启动的shell中执行。@就是执行规则前不要在标准输出上显示命令本身。同样需要make install执行
    include关键字可以把别的Makefile包含进来，
    make的自动推导
    GNU的make可以自动推导文件以及文件依赖关系后面的命令，所以我们不需要每个.o文件后面都写上类似命令，make可以自动识别并推导命令。必然make找到一个2.o那么2.c就会是2.o的依赖文件，比起cc -c 2.c也会推导出来。
    上面例子中可修改为：
    ...
    main.o: a.h
    2.o: a.h b.h
    3.o: b.h c.h
    .PHONY:clean
    ...
    我们也可以利用make提供的自动推导和文件功能修改成：
    main.o 2.o: a.h
    2.o 3.o: b.h
    3.o: c.h
    推导规则也叫内建规则，可以通过make -p命令将内建规则打印出来。例如：
    OUTPUT_OPTION = -o $@
    COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
    .c .o:
        $(COMPILE.c) $< $(OUTPUT_OPTION)
       
    静态模式：
    静态模式可以使规则更加有弹性和灵活，语法为：
    <targets ...>: <target-pattern>: <prereq-patterns ...>
    <commands>
    ...
    targets定义一系列目标文件，可有通配符，是目标的一个集合
    target-parrtern是指明targets模式，也就是目标集模式
    prereq-parrterns是目标的依赖模式。对target-parrtern形成的模式再进行一次依赖目标的的定义
    例如：
    files = foo.elc bar.o lose.o
    $(filter %.o,$(files)): %.o: %.c
    $(CC) -c $(CFLAGS) $< -o $@
    $(filter %.elc,$(files)): %.elc: %.el
    emacs -f batch-byte-compile $<
    我们将target-parrtern定义为%.o意思是target集合都是以.o结尾的，prereq-parrterns定义成%.c意思是对target-parrtern形成的目标集二次定义，形成的新集合去掉.o加上.c。文件名中遇到的%我们可以用反斜杠转义。
    首先我们$(filter %.o $(files))表示调用Makefile的filter函数过滤只要其中的%.o内容。
    $<和$@都是自动化变量，$<表示所有的依赖目标集（bar.c lose.c / foo.el），$@表示目标集(bar.o lose.o) 
    上面
    $(filter %.o,$(files)): %.o: %.c
    $(CC) -c $(CFLAGS) $< -o $@可以解析为：
    bar.o : bar.c
    $(CC) -c $(CFLAGS) bar.c -o bar.o
    lose.o : lose.c
    $(CC) -c $(CFLAGS) lose.c -o lose.o
    当我们%.o有几百个的时候 我们只用这种简单的静态模式规则就可以写一堆规则，很有效率
 
    总结Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。
    1、显式规则。显式规则说明了，如何生成一个或多的的目标文件。这是由Makefile的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。
    2、隐晦规则。由于我们的make有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书写Makefile，这是由make所支持的。
    3、变量的定义。在Makefile中我们要定义一系列的变量，变量一般都是字符串，这个有点你C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。
    4、 文件指示。其包括了三个部分，一个是在一个Makefile中引用另一个Makefile，就像C语言中的include一样；另一个是指根据某些情况指 定Makefile中的有效部分，就像C语言中的预编译#if一样；还有就是定义一个多行的命令。有关这一部分的内容，我会在后续的部分中讲述。
    5、注释。Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用“#”字符，这个就像C/C++中的“//”一样。如果你要在你的Makefile中使用“#”字符，可以用反斜框进行转义，如：“#”。
最后，还值得一提的是，在Makefile中的命令，必须要以[Tab]键开始。