makefile中findstring用法

合集下载

makefile中的特殊符号及关键字

makefile中的特殊符号及关键字1.常见⾃动变量和含义* ：表⽰⽬标⽂件的名称，不包含⽬标⽂件的扩展名。

+ ：表⽰所有的依赖⽂件，这些依赖⽂件之间以空格分开，按照出现的先后为顺序，其中可能包含重复的依赖⽂件。

< ：表⽰依赖项中第⼀个依赖⽂件的名称：依赖项中，所有⽬标⽂件时间戳晚的⽂件（表⽰修改过），依赖⽂件间以空格分开@ ：⽬标项中⽬标⽂件的名称^ ：依赖项中，所有不重复的依赖⽂件，以空格分开。

2.预定义变量Makefile中常⽤的变量及含义AR⽣成静态库库⽂件的程序名称arAS汇编编译器的名称asCC C语⾔编译器的名称ccCPP C语⾔预编译器的名称$(CC) -ECXX C++语⾔编译器的名称g++FC FORTRAN语⾔编译器的名称f77RM删除⽂件程序的名称rm -fARFLAGS⽣成静态库库⽂件程序的选项⽆默认值ASFLAGS汇编语⾔编译器的编译选项⽆默认值CFLAGS C语⾔编译器的编译选项⽆默认值CPPFLAGS C语⾔预编译器的编译选项⽆默认值CXXFLAGS C++语⾔编译器的编译选项⽆默认值FFLAGS FORTRAN语⾔编译器的编译选项⽆默认值3.设置搜索路径指定需要搜索的⽬录， make 会⾃动找到指定⽂件的⽬录并添加到⽂件上。

VPATH = path1:path2:...4.递归make对于规模⽐较⼤的程序，需要多个⼈在多个⽬录下进⾏开发。

如果只⽤⼀个 Makefile 来维护就会⽐较⿇烦，因此可以在每个⽬录下建⽴⾃⼰的 Makefile ，然后在总控 Makefile 中调⽤⼦⽬录的 Makefile ⽂件。

⽬录结构如下：.├── add│├── add_float.c│├── add.h│├── add_int.c│└── Makefile├── main.c├── Makefile└── sub├── Makefile├── sub_float.c├── sub.h└── sub_int.c1.递归调⽤的⽅式add：cd add && $(MAKE)它等价于add：$(MAKE) -C add2.总控MakefileCC = gccCFLAGS = -O2TARGET = cacuexport OBJSDIR = $(shell pwd)/objs$(TARGET):$(OBJSDIR) main.o$(MAKE) -C add$(MAKE) -C sub$(CC) -o $(TARGET) $(OBJSDIR)/*.o$(OBJSDIR):mkdir -p $@main.o:%.o:%.c$(CC) -c $< -o $(OBJSDIR)/$@ $(CFLAGS) -Iadd -Isubclean:-$(RM) $(TARGET)-$(RM) $(OBJSDIR)/*.o如果总控 Makefile 中的⼀些变量需要传递给下层的 Makefile，可以使⽤ export 命令。

Makefile 常用函数表

Makefile 常用函数表一、字符串处理函数1.$(subst FROM,TO,TEXT)函数名称：字符串替换函数—subst。

函数功能：把字串“TEXT”中的“FROM”字符替换为“TO”。

返回值：替换后的新字符串。

2.$(patsubst PATTERN,REPLACEMENT,TEXT)函数名称：模式替换函数—patsubst。

函数功能：搜索“TEXT”中以空格分开的单词，将否符合模式“TATTERN”替换为“REPLACEMENT”。

参数“PATTERN”中可以使用模式通配符“%”来代表一个单词中的若干字符。

如果参数“REPLACEMENT”中也包含一个“%”，那么“REPLACEMENT”中的“%”将是“TATTERN”中的那个“%”所代表的字符串。

在“TATTERN”和“REPLACEMENT”中，只有第一个“%”被作为模式字符来处理，后续的作为字符本上来处理。

在两个参数中当使用第一个“%”本是字符本身时，可使用反斜杠“\”对它进行转义处理。

返回值：替换后的新字符串。

函数说明：参数“TEXT”单词之间的多个空格在处理时被合并为一个空格，但前导和结尾空格忽略。

3.$(strip STRINT)函数名称：去空格函数—strip。

函数功能：去掉字串（若干单词，使用若干空字符分割）“STRINT”开头和结尾的空字符，并将其中多个连续空字符合并为一个空字符。

返回值：无前导和结尾空字符、使用单一空格分割的多单词字符串。

函数说明：空字符包括空格、[Tab]等不可显示字符。

4.$(findstring FIND,IN)函数名称：查找字符串函数—findstring。

函数功能：搜索字串“IN”，查找“FIND”字串。

返回值：如果在“IN”之中存在“FIND”，则返回“FIND”，否则返回空。

函数说明：字串“IN”之中可以包含空格、[Tab]。

搜索需要是严格的文本匹配。

5.$(filter PATTERN…,TEXT)函数名称：过滤函数—filter。

Makefile中的几个常见的符号及其含义

Makefile中的⼏个常见的符号及其含义= 是最基本的赋值:= 是覆盖之前的值= 是如果没有被赋值过就赋予等号后⾯的值+= 是添加等号后⾯的值“=”和“:=”的区别：1、“=”make会将整个makefile展开后，再决定变量的值。

也就是说，变量的值将会是整个makefile中最后被指定的值。

看例⼦： x = fooy = $(x) barx = xyz在上例中，y的值将会是 xyz bar ，⽽不是 foo bar 。

2、“:=”“:=”表⽰变量的值决定于它在makefile中的位置，⽽不是整个makefile展开后的最终值。

x := fooy := $(x) barx := xyz在上例中，y的值将会是 foo bar ，⽽不是 xyz bar 了。

'@' 符号的使⽤通常makefile会将其执⾏的命令⾏在执⾏前输出到屏幕上。

如果将‘@’添加到命令⾏前，这个命令将不被make回显出来。

例如：@echo --compiling module----; // 屏幕输出 --compiling module----echo --compiling module----; // 没有@ 屏幕输出echo --compiling module----' - ' 符号的使⽤通常删除，创建⽂件如果碰到⽂件不存在或者已经创建，那么希望忽略掉这个错误，继续执⾏，就可以在命令前⾯添加 -， -rm dir；-mkdir aaadir；ref:https:///u012989012/article/details/80572043。

makefile的用法

makefile的用法Makefile是一种用于自动化编译程序的工具，它可以根据源代码文件的依赖关系，自动编译出最终的可执行文件。

Makefile的使用可以大大提高程序的开发效率和可维护性，下面我们来详细了解一下Makefile的用法。

一、Makefile的基本语法Makefile的基本语法由一系列规则组成，每个规则由以下几部分组成：1. 目标(Target)：表示需要生成的文件名或者是一个伪目标，如clean。

2. 依赖(Prerequisites)：表示生成目标所依赖的文件或者是其他目标。

3. 命令(Command)：表示生成目标的具体命令。

例如，下面是一个简单的Makefile规则：```hello: main.o hello.ogcc -o hello main.o hello.omain.o: main.cgcc -c main.chello.o: hello.cgcc -c hello.c```这个Makefile规则表示需要生成一个名为hello的可执行文件，它依赖于main.o和hello.o两个目标文件。

生成hello文件的具体命令是gcc -o hello main.o hello.o。

同时，main.o和hello.o两个目标文件分别依赖于main.c和hello.c两个源代码文件，生成它们的具体命令是gcc -c main.c和gcc -c hello.c。

二、Makefile的常用命令1. make：执行Makefile文件，生成目标文件。

2. make clean：删除所有生成的目标文件。

3. make install：将生成的目标文件安装到指定的目录中。

4. make uninstall：卸载已经安装的目标文件。

5. make help：显示Makefile文件中定义的所有规则。

三、Makefile的高级用法1. 变量Makefile中可以定义变量，用于存储一些常用的参数或者路径。

makefile的语法规则

Makefile的语法规则Makefile是GNU构建系统（GNU Build System，简称GNU Make），GNU Make是一个自动化构建工具，用于构建编译程序。

Makefile由一系列语法规则构成，这些规则定义了如何从源文件生成可执行文件或其他目标文件。

基本语法目标：目标是makefile要达到的最终目的，可以是一个可执行程序、一个库文件、一个文档文件等。

依赖：依赖是目标文件所依赖的其他文件，当依赖文件发生变化时，目标文件也需要重新生成。

命令：命令是生成目标文件所需的具体操作，可以是编译、链接、拷贝等。

示例：目标：hello依赖：hello.c命令：gcc -o hello hello.c这条规则定义了如何从源文件hello.c生成可执行文件hello。

当hello.c发生变化时，make会自动执行gcc -o hello hello.c命令重新生成hello可执行文件。

变量变量用于存储信息，变量名以开头，例如：CFLAGS = -Wall -O2这条代码定义了一个名为CFLAGS的变量，值为"-Wall -O2"。

变量可以在命令中使用，例如：目标：hello依赖：hello.c命令：gcc CFLAGS -o hello hello.c这条规则中，CFLAGS变量的值被用在了gcc命令中。

函数函数用于执行特定的任务，函数名以(开头，例如：(info 目标文件是 (TARGET))这条代码定义了一个名为info的函数，当make执行这条代码时，会输出“目标文件是(TARGET)”的信息。

目標：hello依賴：hello.c命令：(CC) (CFLAGS) -o hello hello.cCC = gccCFLAGS = -Wall -O2这条规则重写了上面两个规则。

CC和CFLAGS被定义为变量，并且在命令中使用了这些变量。

当make执行这条规则时，会使用gcc编译器和-Wall -O2编译标志来编译hello.c文件，并将输出的可执行文件命名为hello。

整理后的makefile中文手册

本文比较完整的讲述GNU make工具，涵盖GNU make的用法、语法。

同时重点讨论如何为一个工程编写Makefile。

作为一个Linux程序员，make工具的使用以及编写Makefile是必需的。

系统、详细讲述make的中文资料比较少，出于对广大中文Linuxer 的支持，本人在工作之余，花了18个多月时间完成对‚info make‛的翻译整理，完成这个中文版手册。

本书不是一个纯粹的语言翻译版本，其中对GNU make的一些语法和用法根据我个人的工作经验进行了一些详细分析和说明，也加入了一些个人的观点和实践总结。

本书的所有的例子都可以在支持V3.8版本的GNU make的系统中正确执行。

由于个人水平限制，本文在一些地方存在描述不准确之处。

恳请大家在阅读过程中，提出您宝贵的意见，也是对我个人的帮助。

我的个人电子邮箱地址：xhbdahai@。

非常愿意和大家交流！共同学习。

阅读本书之前，读者应该对GNU的工具链和Linux的一些常用编程工具有一定的了解。

诸如：gcc、as、ar、ld、yacc等；同时在书写Makefile时，需要能够进行一些基本的shell编程。

这些工具是维护一个工程的基础。

如果大家对这些工具的用法不是很熟悉，可参考项目资料。

阅读本文的几点建议：1.如果之前你对GNU make没有了解、当前也不想深入的学习GNU make的读者。

可只阅读本文各章节前半部分的内容（作为各章节的基础知识）。

2.如果你已经对GNU make比较熟悉，你更需要关心此版本的新增特点、功能、和之前版本不兼容之处；也可以作为开发过程过程的参考手册。

3.之前你对GNU make没有概念、或者刚开始接触，本身又想成为一个Linux下的专业程序员，那么建议：完整学习本文的各个章节，包括了基础知识和高级用法、技巧。

Makefile经典教程（掌握这些足够）

Makefile经典教程（掌握这些⾜够）makefile很重要什么是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，下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++的编译的知识，相关于这⽅⾯的内容，还请各位查看相关的编译器的⽂档。

makefile文件语法

makefile文件语法Makefile是一种用于自动化构建过程的工具，它使用一种特定的语法来定义构建规则和依赖关系。

下面是一些Makefile的基本语法规则：1. 目标（Target）：目标是指要构建的程序或文件。

它通常以冒号（:）开头，后面跟着一个或多个依赖项（dependencies）。

```makefiletarget: dependenciescommands```2. 依赖项（Dependencies）：依赖项是指要构建目标所必需的文件或目标。

在Makefile中，依赖项以空格分隔。

3. 命令（Commands）：命令是指在构建目标时执行的命令行指令。

这些命令可以是编译、链接或其他任何必要的操作。

4. 变量（Variables）：Makefile允许使用变量来存储值，以便在构建过程中重复使用。

变量以符号开头，后面跟着变量名。

```makefileVAR = value```5. 模式规则（Pattern Rules）：模式规则允许根据文件模式匹配来构建目标。

它们使用通配符来匹配文件名，并在匹配的文件上执行相应的命令。

```makefiletargets : patterncommands```6. 条件语句（Conditionals）：Makefile支持条件语句，可以根据条件执行不同的命令或规则。

条件使用ifdef、ifndef、ifeq等关键字定义。

7. 注释（Comments）：Makefile使用井号（）作为注释标记，任何在该符号之后的内容都会被视为注释，并被忽略。

8. 自动变量（Automatic Variables）：Makefile提供了一些自动变量，可以在命令中使用，以获取有关目标、依赖项或文件名的信息。

例如，$表示当前目标，$<表示第一个依赖项等。

这些是Makefile的一些基本语法规则，但还有更多高级特性和用法，可以参考Make工具的文档或相关教程进行深入学习。

makefile 用法及搭配

Makefile 是一个用于自动编译和链接的配置文件，它通常用于管理大型项目的编译过程。

Makefile 定义了一系列的规则和依赖关系，用于指定如何生成目标文件。

Makefile 的基本用法如下：1. 定义目标文件：在Makefile 中，每个规则都有一个目标文件，这个目标文件是规则中所有命令的输出文件。

目标文件使用空格分隔，每个目标文件之间用tab 键进行缩进。

2. 定义依赖文件：规则中的依赖文件是生成目标文件所需的文件。

如果没有找到这些依赖文件，规则中的命令将不会被执行。

3. 定义命令：规则中的命令是用来生成目标文件的。

在命令前必须有一个tab 键进行缩进。

在Makefile 中，还可以使用伪目标（phony target）来指定特定的动作或命令，而不需要生成任何文件。

例如，可以使用“clean”作为伪目标，执行清理操作的命令。

下面是一个简单的Makefile 的例子：```makefile# 目标文件：main.omain.o: main.cgcc -c main.c -o main.o# 目标文件：mainmain: main.ogcc main.o -o main```这个Makefile 定义了两个规则：一个是生成main.o 目标文件，另一个是生成main 目标文件。

生成main.o 目标文件需要main.c 文件作为依赖文件，并执行gcc -c main.c -o main.o 命令。

生成main 目标文件需要main.o 文件作为依赖文件，并执行gcc main.o -o main 命令。

使用Makefile 时，需要注意以下几点：1. Makefile 的语法非常简单，但要编写高效的Makefile 需要对项目的结构和依赖关系有深入的了解。

2. Makefile 中的规则必须遵循一定的格式，否则无法正确执行。

3. 在Makefile 中使用变量和条件语句可以提高Makefile 的可读性和灵活性。

android的makefile里的常用宏定义

android的makefile⾥的常⽤宏定义在Android编译框架中，把许多固定的、反复⽤到的⽬录路径定义为宏变量，常⽤宏如下：out/target/product/xxx的宏即为:PRODUCT_OUTout/target/product/xxx/system的宏即为:TARGET_OUTout/target/product/xxx/root的宏即为：TARGET_ROOT_OUT，device/test05/BoardConfig.mk 红⾊部分即为：TARGET_PRODUCT宏，⼀般 TARGET_PRODUCT、 PRODUCT_DEVICE、TARGET_DEVICE，指的是同⼀个值。

⼤多数的宏变量定义位置：build/core/envsetup.mk+++++++++++++++++++++++++++++++++++++++++++++++++++# Variables we check:# HOST_BUILD_TYPE = { release debug }# TARGET_BUILD_TYPE = { release debug }# and we output a bunch of variables, see the case statement at# the bottom for the full list# OUT_DIR is also set to "out" if it's not already set.# this allows you to set it to somewhere else if you like# Set up version information.include $(BUILD_SYSTEM)/version_defaults.mk# ---------------------------------------------------------------# If you update the build system such that the environment setup# or buildspec.mk need to be updated, increment this number, and# people who haven't re-run those will have to do so before they# can build. Make sure to also update the corresponding value in# buildspec.mk.default and envsetup.sh.CORRECT_BUILD_ENV_SEQUENCE_NUMBER := 10# ---------------------------------------------------------------# The product defaults to generic on hardware# NOTE: This will be overridden in product_config.mk if make# was invoked with a PRODUCT-xxx-yyy goal.ifeq ($(TARGET_PRODUCT),)TARGET_PRODUCT := fullendif# the variant -- the set of files that are included for a buildifeq ($(strip $(TARGET_BUILD_VARIANT)),)TARGET_BUILD_VARIANT := engendif# ---------------------------------------------------------------# Set up configuration for host machine. We don't do cross-# compiles except for arm, so the HOST is whatever we are# running onUNAME := $(shell uname -sm)# HOST_OSifneq (,$(findstring Linux,$(UNAME)))HOST_OS := linuxendififneq (,$(findstring Darwin,$(UNAME)))HOST_OS := darwinendififneq (,$(findstring Macintosh,$(UNAME)))HOST_OS := darwinendififneq (,$(findstring CYGWIN,$(UNAME)))HOST_OS := windowsendif# BUILD_OS is the real host doing the build.BUILD_OS := $(HOST_OS)# Under Linux, if USE_MINGW is set, we change HOST_OS to Windows to build the# Windows SDK. Only a subset of tools and SDK will manage to build properly.ifeq ($(HOST_OS),linux)ifneq ($(USE_MINGW),)HOST_OS := windowsendifendififeq ($(HOST_OS),)$(error Unable to determine HOST_OS from uname -sm: $(UNAME)!)endif# HOST_ARCHifneq (,$(findstring 86,$(UNAME)))HOST_ARCH := x86endififneq (,$(findstring Power,$(UNAME)))HOST_ARCH := ppcendifBUILD_ARCH := $(HOST_ARCH)ifeq ($(HOST_ARCH),)$(error Unable to determine HOST_ARCH from uname -sm: $(UNAME)!)endif# the host build defaults to release, and it must be release or debugifeq ($(HOST_BUILD_TYPE),)HOST_BUILD_TYPE := releaseendififneq ($(HOST_BUILD_TYPE),release)ifneq ($(HOST_BUILD_TYPE),debug)$(error HOST_BUILD_TYPE must be either release or debug, not '$(HOST_BUILD_TYPE)') endifendif# This is the standard way to name a directory containing prebuilt host# objects. E.g., prebuilt/$(HOST_PREBUILT_TAG)/ccifeq ($(HOST_OS),windows)HOST_PREBUILT_TAG := windowselseHOST_PREBUILT_TAG := $(HOST_OS)-$(HOST_ARCH)endif# TARGET_COPY_OUT_* are all relative to the staging directory, ie PRODUCT_OUT.# Define them here so they can be used in product config files.TARGET_COPY_OUT_SYSTEM := systemTARGET_COPY_OUT_DATA := dataTARGET_COPY_OUT_VENDOR := system/vendorTARGET_COPY_OUT_ROOT := rootTARGET_COPY_OUT_RECOVERY := recovery# Read the product specs so we an get TARGET_DEVICE and other# variables that we need in order to locate the output files.include $(BUILD_SYSTEM)/product_config.mkbuild_variant := $(filter-out eng user userdebug tests,$(TARGET_BUILD_VARIANT))ifneq ($(build_variant)-$(words $(TARGET_BUILD_VARIANT)),-1)$(warning bad TARGET_BUILD_VARIANT: $(TARGET_BUILD_VARIANT))$(error must be empty or one of: eng user userdebug tests)endif# ---------------------------------------------------------------# Set up configuration for target machine.# The following must be set:# TARGET_OS = { linux }# TARGET_ARCH = { arm | x86 }ifeq ($(TARGET_ARCH),)TARGET_ARCH := armendifTARGET_OS := linux# the target build type defaults to releaseifneq ($(TARGET_BUILD_TYPE),debug)TARGET_BUILD_TYPE := releaseendif# ---------------------------------------------------------------# figure out the output directoriesifeq (,$(strip $(OUT_DIR)))ifeq (,$(strip $(OUT_DIR_COMMON_BASE)))OUT_DIR := $(TOPDIR)out #指定 OUT_DIR 为 out/elseOUT_DIR := $(OUT_DIR_COMMON_BASE)/$(notdir $(PWD))endifendifDEBUG_OUT_DIR := $(OUT_DIR)/debug# Move the host or target under the debug/ directory# if necessary.TARGET_OUT_ROOT_release := $(OUT_DIR)/targetTARGET_OUT_ROOT_debug := $(DEBUG_OUT_DIR)/targetTARGET_OUT_ROOT := $(TARGET_OUT_ROOT_$(TARGET_BUILD_TYPE)) #TARGET_BUILD_TYPE这个变量⼀般 lunch的时候指定HOST_OUT_ROOT_release := $(OUT_DIR)/hostHOST_OUT_ROOT_debug := $(DEBUG_OUT_DIR)/hostHOST_OUT_ROOT := $(HOST_OUT_ROOT_$(HOST_BUILD_TYPE))HOST_OUT_release := $(HOST_OUT_ROOT_release)/$(HOST_OS)-$(HOST_ARCH)HOST_OUT_debug := $(HOST_OUT_ROOT_debug)/$(HOST_OS)-$(HOST_ARCH)HOST_OUT := $(HOST_OUT_$(HOST_BUILD_TYPE))BUILD_OUT := $(OUT_DIR)/host/$(BUILD_OS)-$(BUILD_ARCH)TARGET_PRODUCT_OUT_ROOT := $(TARGET_OUT_ROOT)/productTARGET_COMMON_OUT_ROOT := $(TARGET_OUT_ROOT)/commonHOST_COMMON_OUT_ROOT := $(HOST_OUT_ROOT)/commonPRODUCT_OUT := $(TARGET_PRODUCT_OUT_ROOT)/$(TARGET_DEVICE) #TARGET_DEVICE 在 product_config.mk ⾥定义，最终由 PRODUCT_DEVICE决定，⽽这个变量是在具体 lunch 的时候指定；OUT_DOCS := $(TARGET_COMMON_OUT_ROOT)/docsBUILD_OUT_EXECUTABLES:= $(BUILD_OUT)/binHOST_OUT_EXECUTABLES:= $(HOST_OUT)/binHOST_OUT_SHARED_LIBRARIES:= $(HOST_OUT)/libHOST_OUT_JAVA_LIBRARIES:= $(HOST_OUT)/frameworkHOST_OUT_SDK_ADDON := $(HOST_OUT)/sdk_addonHOST_OUT_INTERMEDIATES := $(HOST_OUT)/objHOST_OUT_HEADERS:= $(HOST_OUT_INTERMEDIATES)/includeHOST_OUT_INTERMEDIATE_LIBRARIES := $(HOST_OUT_INTERMEDIATES)/libHOST_OUT_STATIC_LIBRARIES := $(HOST_OUT_INTERMEDIATE_LIBRARIES)HOST_OUT_NOTICE_FILES:=$(HOST_OUT_INTERMEDIATES)/NOTICE_FILESHOST_OUT_COMMON_INTERMEDIATES := $(HOST_COMMON_OUT_ROOT)/objTARGET_OUT_INTERMEDIATES := $(PRODUCT_OUT)/objTARGET_OUT_HEADERS:= $(TARGET_OUT_INTERMEDIATES)/includeTARGET_OUT_INTERMEDIATE_LIBRARIES := $(TARGET_OUT_INTERMEDIATES)/lib TARGET_OUT_COMMON_INTERMEDIATES := $(TARGET_COMMON_OUT_ROOT)/obj TARGET_OUT := $(PRODUCT_OUT)/$(TARGET_COPY_OUT_SYSTEM)TARGET_OUT_EXECUTABLES:= $(TARGET_OUT)/binTARGET_OUT_OPTIONAL_EXECUTABLES:= $(TARGET_OUT)/xbinTARGET_OUT_SHARED_LIBRARIES:= $(TARGET_OUT)/libTARGET_OUT_JAVA_LIBRARIES:= $(TARGET_OUT)/frameworkTARGET_OUT_APPS:= $(TARGET_OUT)/appTARGET_OUT_KEYLAYOUT := $(TARGET_OUT)/usr/keylayoutTARGET_OUT_KEYCHARS := $(TARGET_OUT)/usr/keycharsTARGET_OUT_ETC := $(TARGET_OUT)/etcTARGET_OUT_STATIC_LIBRARIES:= $(TARGET_OUT_INTERMEDIATES)/libTARGET_OUT_NOTICE_FILES:=$(TARGET_OUT_INTERMEDIATES)/NOTICE_FILESTARGET_OUT_FAKE := $(PRODUCT_OUT)/fake_packagesTARGET_OUT_DATA := $(PRODUCT_OUT)/$(TARGET_COPY_OUT_DATA)TARGET_OUT_DATA_EXECUTABLES:= $(TARGET_OUT_EXECUTABLES)TARGET_OUT_DATA_SHARED_LIBRARIES:= $(TARGET_OUT_SHARED_LIBRARIES) TARGET_OUT_DATA_JAVA_LIBRARIES:= $(TARGET_OUT_JAVA_LIBRARIES)TARGET_OUT_DATA_APPS:= $(TARGET_OUT_DATA)/appTARGET_OUT_DATA_KEYLAYOUT := $(TARGET_OUT_KEYLAYOUT)TARGET_OUT_DATA_KEYCHARS := $(TARGET_OUT_KEYCHARS)TARGET_OUT_DATA_ETC := $(TARGET_OUT_ETC)TARGET_OUT_DATA_STATIC_LIBRARIES:= $(TARGET_OUT_STATIC_LIBRARIES)TARGET_OUT_DATA_NATIVE_TESTS := $(TARGET_OUT_DATA)/nativetestTARGET_OUT_CACHE := $(PRODUCT_OUT)/cacheTARGET_OUT_VENDOR := $(PRODUCT_OUT)/$(TARGET_COPY_OUT_VENDOR)TARGET_OUT_VENDOR_EXECUTABLES:= $(TARGET_OUT_VENDOR)/binTARGET_OUT_VENDOR_OPTIONAL_EXECUTABLES:= $(TARGET_OUT_VENDOR)/xbin TARGET_OUT_VENDOR_SHARED_LIBRARIES:= $(TARGET_OUT_VENDOR)/libTARGET_OUT_VENDOR_JAVA_LIBRARIES:= $(TARGET_OUT_VENDOR)/frameworkTARGET_OUT_VENDOR_APPS:= $(TARGET_OUT_VENDOR)/appTARGET_OUT_VENDOR_ETC := $(TARGET_OUT_VENDOR)/etcTARGET_OUT_UNSTRIPPED := $(PRODUCT_OUT)/symbolsTARGET_OUT_EXECUTABLES_UNSTRIPPED := $(TARGET_OUT_UNSTRIPPED)/system/bin TARGET_OUT_SHARED_LIBRARIES_UNSTRIPPED := $(TARGET_OUT_UNSTRIPPED)/system/lib TARGET_ROOT_OUT_UNSTRIPPED := $(TARGET_OUT_UNSTRIPPED)TARGET_ROOT_OUT_SBIN_UNSTRIPPED := $(TARGET_OUT_UNSTRIPPED)/sbinTARGET_ROOT_OUT_BIN_UNSTRIPPED := $(TARGET_OUT_UNSTRIPPED)/binTARGET_ROOT_OUT := $(PRODUCT_OUT)/$(TARGET_COPY_OUT_ROOT)TARGET_ROOT_OUT_BIN := $(TARGET_ROOT_OUT)/binTARGET_ROOT_OUT_SBIN := $(TARGET_ROOT_OUT)/sbinTARGET_ROOT_OUT_ETC := $(TARGET_ROOT_OUT)/etcTARGET_ROOT_OUT_USR := $(TARGET_ROOT_OUT)/usrTARGET_RECOVERY_OUT := $(PRODUCT_OUT)/$(TARGET_COPY_OUT_RECOVERY) TARGET_RECOVERY_ROOT_OUT := $(TARGET_RECOVERY_OUT)/rootTARGET_SYSLOADER_OUT := $(PRODUCT_OUT)/sysloaderTARGET_SYSLOADER_ROOT_OUT := $(TARGET_SYSLOADER_OUT)/rootTARGET_SYSLOADER_SYSTEM_OUT := $(TARGET_SYSLOADER_OUT)/root/systemTARGET_INSTALLER_OUT := $(PRODUCT_OUT)/installerTARGET_INSTALLER_DATA_OUT := $(TARGET_INSTALLER_OUT)/dataTARGET_INSTALLER_ROOT_OUT := $(TARGET_INSTALLER_OUT)/rootTARGET_INSTALLER_SYSTEM_OUT := $(TARGET_INSTALLER_OUT)/root/systemTARGET_FACTORY_RAMDISK_OUT := $(PRODUCT_OUT)/factory_ramdiskCOMMON_MODULE_CLASSES := TARGET-NOTICE_FILES HOST-NOTICE_FILES HOST-JAVA_LIBRARIES ifeq (,$(strip $(DIST_DIR)))DIST_DIR := $(OUT_DIR)/distendififeq ($(PRINT_BUILD_CONFIG),)PRINT_BUILD_CONFIG := trueendif++++++++++++++++++++++++++++++++++++++。

makefile正则表达式

makefile正则表达式Makefile是一种自动化构建工具，它可以自动化编译程序并生成可执行文件。

在Makefile中，正则表达式是一个非常重要的工具，可以帮助我们更方便地编写规则和指令。

本文将介绍一些常用的Makefile正则表达式。

1. 通配符在Makefile中，通配符用于匹配文件名。

常用的通配符有：*：匹配任意字符（包括0个或多个字符）？：匹配任意单个字符例子：%.c：匹配所有以“.c”为后缀名的文件*.o：匹配以“.o”为后缀名的所有文件2. 替换符替换符用于替换文本中的内容。

常用的替换符有：$(VAR：OLD=NEW)：将VAR中的OLD替换为NEW$(VAR：OLD=)：将VAR中的OLD删除$(VAR：%OLD=NEW)：将VAR中以OLD结尾的部分替换成NEW 例子：$(SRCS：.c=.o)：将SRCS中以“.c”为后缀名的文件替换成以“.o”为后缀名的文件3. 匹配符匹配符用于判断字符串是否匹配某种规则。

常用的匹配符有：$(findstring STR, TEXT)：在TEXT中查找STR，返回匹配到的子串$(filter PATTERN..., TEXT)：从TEXT中选择与PATTERN匹配的子串$(wildcard PATTERN)：寻找与PATTERN匹配的所有文件例子：$(findstring abc,abcdefg)：返回“abc”$(filter %.c %.o, file.c file.o file.h)：返回“file.c file.o” $(wildcard *.c)：返回当前目录下所有以“.c”为后缀名的文件这些是常用的Makefile正则表达式，能够极大地简化我们的代码编写。

在实际使用中，可以根据需要灵活运用，提高自己的效率。

makefile四则运算

makefile四则运算标题：深入理解Makefile中的四则运算在软件开发过程中，Makefile是一个非常重要的工具，它主要用于自动化编译和链接程序。

而在Makefile中，我们可以使用一些特殊的语法进行数学运算，包括四则运算（加、减、乘、除）。

本文将详细解析Makefile 中的四则运算，帮助你更好地理解和使用这一功能。

一、Makefile中的变量与赋值在开始四则运算之前，我们首先需要了解Makefile中的变量和赋值。

在Makefile中，我们可以使用"="或者":="来为变量赋值。

其中"="表示延迟赋值，会在需要时才进行计算；而":="表示立即赋值，会在定义时就进行计算。

例如：VAR1 = 10VAR2 := 20在这段代码中，VAR1被赋值为10，VAR2被赋值为20。

二、Makefile中的四则运算在Makefile中，我们可以使用"(shell expr ...)"命令来进行四则运算。

这个命令会执行shell命令expr，并将结果返回。

以下是一些基本的四则运算示例：1. 加法：makefileSUM := (shell expr (VAR1) + (VAR2))在这个例子中，SUM会被赋值为VAR1和VAR2的和，即30。

2. 减法：makefileDIFF := (shell expr (VAR1) - (VAR2))在这个例子中，DIFF会被赋值为VAR1和VAR2的差，即-10。

3. 乘法：makefilePRODUCT := (shell expr (VAR1) \* (VAR2))注意，由于"*"在Makefile中有特殊含义，所以我们需要使用"\*"来表示乘法。

在这个例子中，PRODUCT会被赋值为VAR1和VAR2的乘积，即200。

Makefile中ifeqifneq等用法

Makefile中ifeqifneq等⽤法（1）ifeq的⽤法ifeq ($（变量名），变量值 )........else ifeq ($(..), ..).........else.........endif（2）最近在学习makefile的过程中遇到需要⽤ifeq进⾏逻辑与判断，但是ifeq并没有像其他编程语⾔那样有逻辑或（||）逻辑与（&&）的符号可⽤。

这时候需要变通⼀下。

1）逻辑与变通实现：举例说明：⽐如需要判断两个变量 VALUE1 和 VALUE2 的值都存在才执⾏某个动作，这需要逻辑与的判断C语⾔的逻辑： if ( VALUE1 && VALUE2){do something....}没有&&符号，我们可以这样变通：将两个变量链接起来再判断ifneq ($(VALUE1)$(VALUE2),)do something....endif如果变量 VALUE1 和 VALUE2 都有具体的值，⽐如需要进⾏这样的判断： VALUE1 == V1 && VALUE2 == V2, 可以按如下的写法;ifeq ($(VALUE1)_$(VALUE2), V1_V2) ### 当然中间的下划线 "_" 可以⽤其他字符代替do something....endif2）逻辑或变通实现，同样是上⾯的两个变量if( VALUE1 == V1 || VALUE2 == V2 ) {...} 可以⽤findstring函数做如下变通实现：#如果VALUE1或者VALUE2为V1或V2，则findstring 不会返回空。

ifneq ($(findstring $(VALUE1)$(VALUE2), V1 V2),)do something...endif。

makefile中的字符串操作

，则返回空字串。
示例：$(suffix src/foo.c src-1.0/bar.c hacks)返回值是“.c .c
”。
$(basename <names...>)
名称：取前缀函数——basename。
功能：从文件名序列<names>中取出各个文件名的前缀部分。
返回：返回文件名序列<names>的前缀序列，如果文件没有前缀
cts))”是一样的。
$(strip <string>)
名称：去空格函数——strip。
功能：去掉<string>字串中开头和结尾的空字符。
返回：返回被去掉空格的字符串值。
示例：
$(strip a b c )
把字串“a b c ”去到开头和结尾的空格，结果是“a b c”。
$(findstring <find>,<in>)
，表示任意长度的字串。如果<replacement>中也包含“%”，那么
，<replacement>中的这个“%”将是<pattern>中的那个“%
”所代表的字串。（可以用“\”来转义，以“\%”来表示真实含义的“%
”字符）
返回：函数返回被替换过后的字符串。
示例：
$(patsubst %.c,%.o,x.c.c bar.c)
把字串“x.c.c bar.c”符合模式[%.c]的单词替换成[%.o]，返回
结果是“x.c.o bar.o”
备注：
这和我们前面“变量章节”说过的相关知识有点相似。如：
“$(var:<pattern>=<replacement>)”

makefile的基本用法以及yolov3的makefile解析

makefile的基本用法以及yolov3的makefile解析Makefile的基本用法以及YOLOv3的Makefile解析Makefile是一种用于自动化构建的文件，它定义了一系列规则和依赖关系，用于编译、链接和生成可执行文件等操作。

Makefile通常用于C/C++项目中，但它也可以用于其他编程语言。

一、Makefile的基本用法1. 规则（Rule）Makefile中的规则定义了如何生成目标文件和如何根据依赖关系重新生成目标文件。

一个规则通常由以下几部分组成：target: prerequisites[tab] command- target：目标文件，即要生成的文件。

- prerequisites：目标文件的依赖文件。

- command：生成目标文件的命令。

2. 变量（Variable）Makefile中的变量用于存储值，可以在规则中引用。

常见的变量有以下几种：- CC：C/C++编译器。

- CFLAGS：编译选项。

- LDFLAGS：链接选项。

- RM：删除文件的命令。

可以通过在Makefile中定义变量来方便地修改编译和链接参数，使构建过程更加灵活。

3. 默认规则（Default Rule）Makefile中可以定义一个默认规则，当使用make命令时，会自动执行默认规则中定义的命令。

默认规则的语法如下：.PHONY: allall: target- .PHONY：伪目标，表示该规则是一个伪目标。

- all：默认规则的名字。

- target：默认规则要生成的目标文件。

4. 命令行变量在执行make命令时，可以通过命令行参数传递变量的值。

例如，make CC=gcc可以将CC变量的值设置为gcc。

5. clean规则clean规则用于删除生成的目标文件和其他中间文件，以便重新构建项目。

通常的写法是：clean:[tab] (RM) target这里的(RM)是一个预定义变量，表示删除文件的命令（通常为rm -f）。

Linux下Makefile简单教程

目录一：Makefile基本规则1.1示例1.2 隐式规则1.3 伪目标1.4 搜索源文件二：变量2.1使用变量定义变量值2.2追加变量三：条件判断四：函数Linux下Makefile总结——一步MakeFile可以看做是一种简单的编程语言，其诞生的本质目的是实现自动化编译。

以Linux下gcc-c编译器为例，编译一个c语言程序需要经过以下几个步骤：1.将c语言源程序预处理，生成.i文件；2.预处理后的.i语言编译成汇编语言，生成.s文件；3.汇编语言经过汇编，生成目标文件.o文件；4.将各个模块的.o文件链接起来，生成一个可执行程序文件。

我们知道，在Visual C++6.0中，可以新建一个工程，在一个工程当中能够包含若干个c语言文件，则编译的时候直接编译整个工程便可。

Linux下无法为多个c语言文件新建工程，但可以通过MakeFile实现它们的整合编译。

如上gcc-c编译步骤，如果使用Makefile则过程为：.C文件——>.o文件——>可执行文件当然，Makefile中也加入了自己的设置变量方法与集成了一些函数，能够更有效地方便用户使用。

/**************************分隔符********************************/ 一：Makefile基本规则1.1示例target ... : prerequisites ...command......target也就是一个目标文件，可以是Object File，也可以是执行文件。

prerequisites就是，要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。

（任意的Shell命令）为了方便理解，我们来看一个示例：/*Makefile示例*/edit : main.o kbd.o command.o display.o /insert.o search.o files.o utils.ogcc -o edit main.o kbd.o command.o display.o /insert.o search.o files.o utils.omain.o : main.c defs.h #生成main.ogcc -c main.ckbd.o : kbd.c defs.h command.h #生成kdb.ogcc -c kbd.ccommand.o : command.c defs.h command.h #生成command.ogcc -c command.cdisplay.o : display.c defs.h buffer.h #生成display.ogcc -c display.cinsert.o : insert.c defs.h buffer.h #生成insert.ogcc -c insert.csearch.o : search.c defs.h buffer.h #生成search.ogcc -c search.cfiles.o : files.c defs.h buffer.h command.h #生成files.ogcc -c files.cutils.o : utils.c defs.h #生成utils.ogcc -c utils.cclean :rm edit main.o kbd.o command.o display.o /insert.o search.o files.o utils.o/*END*/执行输入：make -s edit反斜杠（/）是换行符的意思。

makefile 常用符号

makefile 常用符号Makefile是一种用于自动化构建和部署软件的工具，它使用规则和宏来描述项目的结构和编译过程。

以下是一些常用的Makefile符号：1. 目标（Targets）：Makefile中的命令执行目标。

例如，`all`、`clean`、`build`等。

2. 依赖（Dependencies）：目标所需的文件或目标。

可以使用`依赖目标`来表示一个目标依赖于另一个目标。

3. 命令（Commands）：用于生成或构建目标的命令。

可以包含多个命令，用分号分隔。

4. 通配符（Patterns）：用于匹配文件或目录的名称。

例如，`src/*.c`表示所有以`.c`结尾的文件位于`src`目录。

5. 函数（Functions）：Makefile中的自定义功能。

可以通过`定义函数名`来定义一个函数，并在需要时调用它。

6. 变量（Variables）：Makefile中的数据存储单元。

可以使用`变量名=值`的方式来定义变量，并在需要时引用它们。

7. 规则（Rules）：用于描述如何生成目标的规则。

规则由左边的目标、冒号、右边的命令和可选的`phony：`组成。

8. phony目标（Phony targets）：虚拟目标，用于绕过Makefile中的正常构建过程。

可以在phony目标后跟一个冒号，然后是实际的命令。

9. 自动变量（Automatic variables）：在构建过程中自动计算的变量。

常见的自动变量有`$@`（所有目标）、`$^`（所有依赖文件）、`$?`（已改变的依赖文件）等。

10. 模式变量（Pattern variables）：用于根据文件名匹配值来设置变量。

例如，`OBJS := obj/*.o`，这将把所有以`.o`结尾的文件编译为目标。

11. 隐含规则（Implicit rules）：Makefile中用于自动生成目标的一种机制。

当一个目标没有显式规则时，Makefile会尝试使用隐含规则来生成它。

makefile中findstring用法

makefile中findstring用法摘要：1.Findstring的定义和作用2.Findstring的语法3.Findstring的实例与应用4.Findstring的扩展与进阶用法正文：Makefile是一种常用的构建工具，用于自动化编译、测试和部署等任务。

在Makefile中，findstring指令用于在文件系统中查找匹配特定模式的文件。

本文将详细介绍findstring的用法，包括其定义、语法、实例与应用，以及扩展与进阶用法。

1.Findstring的定义和作用Findstring是Makefile中一个强大的文件查找指令，它可以让你根据指定的模式在文件系统中查找文件。

findstring指令的作用是将找到的文件添加到Makefile的待处理文件列表中，以便在后续的编译、链接等过程中使用。

2.Findstring的语法findstring指令的语法如下：```findstring pattern [-type] [-name] [-not] [-path] [-exec] [-ok] [-print] [-quit] [-Err] [-out] [-zip] [-XXX] […]```其中，pattern是文件匹配的模式，可以包含通配符（如*、?、[]等）；其余选项用于限定查找范围和结果输出。

3.Findstring的实例与应用以下是一个简单的findstring实例：```makefindstring := $(wildcard *.c)```这个例子中，findstring指令将在当前目录下查找所有以.c结尾的文件，并将找到的文件列表赋值给变量findstring。

在后续的编译过程中，可以使用这个变量来指定待编译的C源文件。

4.Findstring的扩展与进阶用法findstring指令还支持一些扩展和进阶用法，如结合其他指令使用。

例如，可以使用`-exec`选项在找到的文件上执行指定的命令：```makefindstring := $(wildcard *.c)all:for ((i=1; i<=$(findstring); i++)); doecho "Compiling $i..."$(CC) $i -o $(BASENAME/$(i).o)done```在这个例子中，findstring指令找到所有以.c结尾的文件，然后使用for循环依次编译它们。

makefile中findstring用法

makefile中findstring用法
在Makefile 中，`findstring` 函数用于查找一个字符串是否包含在另一个字符串中。

它的基本语法如下：
```makefile
$(findstring find, in)
```
其中，`find` 是要查找的字符串，而`in` 是要搜索的字符串。

如果`find` 存在于`in` 中，`findstring` 返回`find`，否则返回空字符串。

以下是一个简单的示例：
```makefile
# 定义一个字符串
mystring := This is a sample string.
# 使用findstring查找子字符串
ifeq ($(findstring sample, $(mystring)), sample)
result := Substring found!
else
result := Substring not found.
endif
# 打印结果
all:
@echo $(result)
```
在这个例子中，`findstring` 被用于检查`mystring` 是否包含子字符串"sample"。

根据结果，Makefile 将输出相应的消息。

请注意，`findstring` 是大小写敏感的，所以在搜索时要注意大小写匹配。