标签 make 下的文章

有一天,我试图在一个新的 Ubuntu 系统上编译一个程序,当我试图使用 make 命令时,它向我抛出一个错误:

The program 'make' is currently not installed. You can install it by typing:
sudo apt install make

这表明 make 命令还没有安装。你可以用这些命令在 Ubuntu 上逐步安装 make

sudo apt update
sudo apt install make

第一个命令是更新本地的软件包缓存。如果是一个新安装的 Ubuntu 系统,这是很有必要的。有了刷新的软件包缓存,你的系统就会知道应该从哪个仓库下载 make 包。

并验证 make 是否已经正确安装:

make --version

Checking make version

在 Ubuntu 上安装 make 的更好方法

安装 make 命令的一个更好的方法是使用 build-essential 包。这个包包含 makegccg++ 和其他一些编译器和开发工具。

sudo apt install build-essential

Installing Build Essential package

安装了这个 build-essential 包后,你就可以在 Linux 中轻松地运行 C/C++ 程序

如果 make 已经安装了,但它没有工作怎么办?

在一些罕见的情况下,可能会发生 make 已经安装了,但却无法工作的情况。

其原因是 make 命令不在 $PATH 变量中。你可以用这个命令重新安装 make

sudo apt install --reinstall make

如果这不起作用,你可以尝试 手动添加二进制文件到你的 PATH 中,但这应该不需要手动。

我希望这个快速提示能帮助你。仍然有问题或对相关主题有疑问?请随时在评论区留言。


via: https://itsfoss.com/make-command-not-found-ubuntu/

作者:Abhishek Prakash 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

CMake 是一个跨平台的编译、测试和打包软件,即使你以前从来没有使用过构建系统,也可以轻松上手。

 title=

在我以前的文章 Autotools 入门 一文中,我说明了如何使用 Autotools 来管理和打包代码。这是一个强大且通用的平台,可轻松集成到许多打包系统中,包括 RPM、APT、pkgsrc 等等。它的语法和结构可能会令人困惑,但幸运的是,我们还有其他选择,开源的 CMake 就是其中一个。

CMake 是一个用于构建、测试和打包软件的跨平台套件。它使用简单而清晰的语法,因此即使你以前从未使用过构建系统,也很容易开始使用。

安装 CMake

CMake 可能已经安装在你的 Linux 系统上。如果没有,你可以使用发行版的程序包管理器进行安装:

$ sudo dnf install cmake

在 Debian 或者其他相似的系统上:

$ sudo apt install cmake

在 Mac 上,你可以使用 MacPorts 或者 Homebrew 来安装:

$ sudo port install cmake

在 Windows 上,你可以使用 Chocolatey 或者直接从 CMake 网站 下载二进制来安装。

使用 CMake

对于想要从源代码构建软件的开发人员或用户来说,CMake 是一种快速简便的编译和安装方法。 CMake 分阶段工作:

  1. 首先,在 cmake 步骤中,CMake 扫描计算机查看一些默认设置。默认设置包括库的位置以及在系统上安装软件的位置。
  2. 接下来,使用系统上的 make 命令(在 Linux 上是 GUN Make,在 NetBSD 上是 NetBSD Make)来编译程序。这个过程通常是将人类可读的源代码转换成机器语言。
  3. 最后,在 make install 一步中,那些编译过的文件将被拷贝到(在 cmake 步骤中扫描出来的)计算机上合适的位置。

这看起来很简单,当你使用 CMake 时就是这样。

CMake 的可移植性

CMake 在设计时就考虑了可移植性。虽然它不能使你的项目在所有 POSIX 平台上都能正常工作(这取决于作为开发者的你),但它可以确保将标记为要安装的文件安装到已知平台上最合适的位置。而且由于有了 CMake 之类的工具,对于高级用户而言,根据其系统需求自定义和覆盖任何不合适的选项都很容易。

使用 CMake,你只需要知道将哪些文件安装到哪个常规位置即可。它会照顾其他一切。不再需要自定义安装脚本,它们有可能在任何未经测试的操作系统上失败。

打包

像 Autotools 一样,CMake 也得到了很好的打包支持。无论它们是打包成 RPM 还是 DEB 或 TGZ(或其他任何东西),将带有 CMake 的项目交给打包者,他们的工作既简单又直接。打包工具支持 CMake,因此可能不需要进行任何修补或者调整。在许多情况下,可以自动将 CMake 项目整合到工作流中。

如何使用 CMake

要在项目中使用 CMake,只需在项目目录中创建 CMakeLists.txt 文件。首先,声明最低要求的 CMake 版本以及项目名称和版本。CMake 会努力在尽可能长时间内保持兼容性,但是随着你使用的时间越长,并且关注它最新的开发动态,你就会知道哪些特性是你所依赖的。

cmake_minimum_required(VERSION 3.10)

project(Hello VERSION 1.0)

如你可能已经看到的那样,CMake 的语法是一个带有括号和参数的命令。大写的 VERSION 字符串不是任意的,也不只是格式。它们是 project 命令中的有效参数。

在继续之前,先写一个简单的 C 或者 C++ 的 hello world 程序。为了简单,我就写了六行 C 代码,并把它保存在 hello.c 中(为了匹配我在 CMakeLists.txt 中可执行文件的名字)。

#include <stdio.h>

int main() {
   printf("Hello open source\n");
   return 0;
}

不过,不要搞错了,CMake 不仅适用于 C 和 C++。它可以处理任意文件,并且有许多可用的命令,因此它可以帮助你维护许多不同形式的项目。

CMake 网站中记录了所有有效的内置命令及其可用参数,因此无论你要做什么,都可以轻松发现所需的功能。不过,这是一个简单的示例,因此,你需要的下一个命令是必不可少的 —— 你必须为 CMake 定义要构建的代码:

add_executable(Hello hello.c)

这个命令指定了你编译后的二进制文件的名字为 Hello。因此,它与你在终端中执行带有 -o Hellogcc 命令是一样的。

在一些比较复杂的项目中,你可能还需要使用库文件,你可以使用 add library 命令来链接库文件。

在你设置了你想要构建和标记为安装的文件之后,你必须要告诉 CMake 一旦用户安装了程序,最终的应用程序应该在哪个位置。

在这个简单的例子里,你仅需要做的一件事就是在你的 CMakeLists.txt 文件里添加 install 命令。install 命令接受几个参数。但是在这个例子中,你仅需要使用 TARGET 命令来指定你要安装文件的名字。

install(TARGETS Hello)

向 CMake 工程添加一些文件

一个软件项目向用户交付的往往不仅仅只有代码,还有一些其他的文件数据,例如手册或者是信息页、示例项目,或者是配置文件。你可以使用与包含编译文件时类似的工作流程,将任意数据包含在 CMake 项目中:在 CMakelists.txt 文件中使用 file 命令,然后说明一下这些文件要安装在哪里。

例如,你可以在这个项目中包含一个 assets 目录,你可以使用 file 命令,后面跟上 COPYDESTINATION 参数来告诉 CMake 将这些额外的文件复制到你的分发包中。

file(COPY assets DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")

这个 ${CMAKE_CURRENT_BINARY_DIR} 变量是一个特殊的 CMake 内置变量,表示 CMake 正在处理的目录。换句话说,你的任何文件都会被复制到编译目录(在你运行 cmake 命令后,这个过程会更加清晰,到时候回过头来看一下)。

因为这些额外的数据文件有些杂乱不堪(如果你不信的话,可以看一下 /usr/share 这个目录)。对于你自己的项目创建一个子文件夹对谁都有好处。最好也带上版本名字。你可以通过在 CMAKE_CURRENT_BINARY_DIR 中指定一个新的目录,使用你选择的项目名称,后面跟一个为你的项目命名的特殊变量和你在项目声明中为它设置的 VERSION

file(COPY assets DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/Hello-${Hello_VERSION}")

定义安装位置

你已经定义你要编译的文件,因此现在你要告诉 CMake 你的程序要安装在哪个位置。比如你的主程序,这个要程使用 install 命令:

install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/Hello-${Hello_VERSION}" TYPE DATA)

这里有一些新的参数。DIRECTORY 参数指定了数据文件是一个目录,而不是一个文件(FILE)或者脚本(SCRIPT)。你使用的参数和复制一些额外文件到编译目录时是一样。另外,在 install 命令中 TYPE 或者 DESTINATION 必须要指定其一。TYPE 参数指定了通用的文件类型,这些文件通常将会被放到合适的位置。在 Linux 系统上,TYPE DATA 一般是 /usr/local/share 或者 /usr/share,除非用户定义了其他的位置。

这是诸如 CMake 之类的良好构建系统的强大功能之一。你不必担心文件的确切位置,因为你知道用户可以更改 CMake 的首选默认设置,并且 CMake 将构建代码以使其正常工作。

运行 CMake

CMake 有多种方式来让你执行命令,你可以在终端或者在一个可交互的程序上执行命令,或者你也可以使用它的图形界面(GUI)。我比较偏向于使用终端命令,但是我也喜欢使用一些其他的方式(相比与在 Makefile 中查找那些晦涩的变量然后去修改它们更胜一筹)。

对于编译过开源 C++ 项目的任何人,都熟悉的第一步是创建一个 build 目录,进入到该目录,然后运行 cmake .. 命令。 我是一个懒惰的打字员,所以我将构建目录命名为 b,但是你可以使用最合适的方式:

$ mkdir b
$ cd b
$ cmake ..
-- The C compiler identification is GNU 11.1.1
-- The CXX compiler identification is GNU 11.1.1
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working C compiler: /usr/bin/cc - skipped
-- Detecting C compile features
-- Detecting C compile features - done
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++ - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /var/home/seth/demo-hello/b
$

这或多或少相当于经典的 ./configure; make; make install 中的 ./configure。看一下你的构建目录,CMake 已经帮你生成了几个新的文件,来让你的项目更完整。这里生成了 CMake 的数据文件、一个常规的 Makefile 文件(这是一个免费提供的 247 行的文件,但对于越复杂的项目,行数要多得多),还有一个包含这个示例程序的任意非编译数据的 Hello-1.0 目录。

$ ls
CMakeCache.txt
CMakeFiles
Makefile
Hello-1.0
cmake_install.cmake

接下来,你可以进行构建。你可以使用 CMake 的 --build 选项来做这件事,使用当前的构建目录作为源目录。

$ cmake --build .
Scanning dependencies of target Hello
[ 50%] Building C object CMakeFiles/Hello.dir/hello.c.o
[100%] Linking C executable Hello
[100%] Built target Hello

或者你可以运行 make 命令。这将读取由 CMake 生成的 Makefile 文件。在这个例子中,make 默认的行为就是由源程序 hello.c 生成目标文件。

$ make
Scanning dependencies of target Hello
[ 50%] Building C object CMakeFiles/Hello.dir/hello.c.o
[100%] Linking C executable Hello
[100%] Built target Hello
$

如你所料,Hello 二进制可执行文件现在存在于当前的构建目录中。因为它是一个简单的自包含应用程序,所以你可以运行它进行测试:

$ ./Hello
Hello open source
$

最后,你可以用 --install 选项进行安装。因为我不希望我的简单的 “hello world” 应用程序真的被安装到我的系统上,我设置了 --prefix 选项,将 CMake 的目标从根目录(/)重定向到 /tmp 的一个子目录。

$ cmake --install . --prefix /tmp/hello/
-- Install configuration: ""
-- Installing: /tmp/dist-hello/usr/local/bin/Hello
-- Installing: /tmp/dist-hello/usr/local/share/Hello-1.0
-- Installing: /tmp/dist-hello/usr/local/share/Hello-1.0/assets/file0
-- Installing: /tmp/dist-hello/usr/local/share/Hello-1.0/assets/file1

另外,你也可以运行 make install 来调用 Makefile 的安装动作。同样,为了避免在我的系统上安装一个演示程序,我在这个例子中设置了 DESTDIR 变量,将安装目标重定向到 /tmp 的一个子目录:

$ mkdir /tmp/dist-hello
$ make install DESTDIR=/tmp/dist-hello
[100%] Built target Hello
Install the project...
-- Install configuration: ""
-- Installing: /tmp/dist-hello/usr/local/bin/Hello
-- Installing: /tmp/dist-hello/usr/local/share/Hello-1.0
-- Installing: /tmp/dist-hello/usr/local/share/Hello-1.0/assets/file0
-- Installing: /tmp/dist-hello/usr/local/share/Hello-1.0/assets/file1

看一下输出的内容,来确定它具体的安装位置,这个程序已经安装好了。

快速自定义

CMake 的安装前缀(由 CMAKE_INSTALL_PREFIX 变量指定)默认是在 /usr/local 这个位置,但是所有的 CMake 变量都可以在你运行 cmake 命令的时候,加一个 -D 选项来改变它。

$ cmake -DCMAKE_INSTALL_PREFIX=/usr ..
$ make install DESTDIR=/tmp/dist-hello
$ make install DESTDIR=/tmp/dist-hello
[100%] Built target Hello
Install the project...
-- Install configuration: ""
-- Installing: /tmp/dist-hello/usr/bin/Hello
-- Installing: /tmp/dist-hello/usr/share/Hello-1.0
-- Installing: /tmp/dist-hello/usr/share/Hello-1.0/assets/file0
-- Installing: /tmp/dist-hello/usr/share/Hello-1.0/assets/file1

所有由 CMake 使用的变量都可以通过这种方式来修改。

交互式的 CMake

CMake 的交互模式是一种用于配置安装环境的友好而有用的方法。要让用户知道该项目使用的所有可能的 CMake 变量是一件工作量很大的事,因此 CMake 交互式界面是他们无需查看 MakefileCMakeLists 即可发现自定义选项的简便方法。

为了调用这个交互式的 CMake,使用 ccmake 命令,在这个简单的项目里没有太多的东西。但是对于像 Rosegarden 这样的大型项目,这将非常有用。

 title=

CMake 的更多知识

还有很多很多的 CMake 知识需要去了解。作为一个开发者,我非常喜欢它简洁的语法、详尽的文档、可扩展性以及便捷性。作为一个用户我非常喜欢 CMake 友好且实用的错误提示信息还有它的用户界面,如果你的项目还未开始使用构建系统,请了解一下 CMake 吧。你以及以后尝试打包你应用程序的任何人都不会后悔。


via: https://opensource.com/article/21/5/cmake

作者:Seth Kenlon 选题:lujun9972 译者:amwps290 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

如果你仍未使用过 Autotools,那么这篇文章将改变你递交代码的方式。

你有没有下载过流行的软件项目的源代码,要求你输入几乎是仪式般的 ./configure; make && make install 命令序列来构建和安装它?如果是这样,你已经使用过 GNU Autotools 了。如果你曾经研究过这样的项目所附带的一些文件,你可能会对这种构建系统的显而易见的复杂性感到害怕。

好的消息是,GNU Autotools 的设置要比你想象的要简单得多,GNU Autotools 本身可以为你生成这些上千行的配置文件。是的,你可以编写 20 或 30 行安装代码,并免费获得其他 4,000 行。

Autotools 工作方式

如果你是初次使用 Linux 的用户,正在寻找有关如何安装应用程序的信息,那么你不必阅读本文!如果你想研究如何构建软件,欢迎阅读它;但如果你只是要安装一个新应用程序,请阅读我在在 Linux 上安装应用程序的文章。

对于开发人员来说,Autotools 是一种管理和打包源代码的快捷方式,以便用户可以编译和安装软件。 Autotools 也得到了主要打包格式(如 DEB 和 RPM)的良好支持,因此软件存储库的维护者可以轻松管理使用 Autotools 构建的项目。

Autotools 工作步骤:

  1. 首先,在 ./configure 步骤中,Autotools 扫描宿主机系统(即当前正在运行的计算机)以发现默认设置。默认设置包括支持库所在的位置,以及新软件应放在系统上的位置。
  2. 接下来,在 make 步骤中,Autotools 通常通过将人类可读的源代码转换为机器语言来构建应用程序。
  3. 最后,在 make install 步骤中,Autotools 将其构建好的文件复制到计算机上(在配置阶段检测到)的相应位置。

这个过程看起来很简单,和你使用 Autotools 的步骤一样。

Autotools 的优势

GNU Autotools 是我们大多数人认为理所当然的重要软件。与 GCC(GNU 编译器集合)一起,Autotools 是支持将自由软件构建和安装到正在运行的系统的脚手架。如果你正在运行 POSIX 系统,可以毫不保守地说,你的计算机上的操作系统里大多数可运行软件都是这些这样构建的。

即使是你的项目是个玩具项目不是操作系统,你可能会认为 Autotools 对你的需求来说太过分了。但是,尽管它的名气很大,Autotools 有许多可能对你有益的小功能,即使你的项目只是一个相对简单的应用程序或一系列脚本。

可移植性

首先,Autotools 考虑到了可移植性。虽然它无法使你的项目在所有 POSIX 平台上工作(这取决于你,编码的人),但 Autotools 可以确保你标记为要安装的文件安装到已知平台上最合理的位置。而且由于 Autotools,高级用户可以轻松地根据他们自己的系统情况定制和覆盖任何非最佳设定。

使用 Autotools,你只要知道需要将文件安装到哪个常规位置就行了。它会处理其他一切。不需要可能破坏未经测试的操作系统的定制安装脚本。

打包

Autotools 也得到了很好的支持。将一个带有 Autotools 的项目交给一个发行版打包者,无论他们是打包成 RPM、DEB、TGZ 还是其他任何东西,都很简单。打包工具知道 Autotools,因此可能不需要修补、魔改或调整。在许多情况下,将 Autotools 项目结合到流程中甚至可以实现自动化。

如何使用 Autotools

要使用 Autotools,必须先安装它。你的发行版可能提供一个单个的软件包来帮助开发人员构建项目,或者它可能为每个组件提供了单独的软件包,因此你可能需要在你的平台上进行一些研究以发现需要安装的软件包。

Autotools 的组件是:

  • automake
  • autoconf
  • automake
  • make

虽然你可能需要安装项目所需的编译器(例如 GCC),但 Autotools 可以很好地处理不需要编译的脚本或二进制文件。实际上,Autotools 对于此类项目非常有用,因为它提供了一个 make uninstall 脚本,以便于删除。

安装了所有组件之后,现在让我们了解一下你的项目文件的组成结构。

Autotools 项目结构

GNU Autotools 有非常具体的预期规范,如果你经常下载和构建源代码,可能大多数都很熟悉。首先,源代码本身应该位于一个名为 src 的子目录中。

你的项目不必遵循所有这些预期规范,但如果你将文件放在非标准位置(从 Autotools 的角度来看),那么你将不得不稍后在 Makefile 中对其进行调整。

此外,这些文件是必需的:

  • NEWS
  • README
  • AUTHORS
  • ChangeLog

你不必主动使用这些文件,它们可以是包含所有信息的单个汇总文档(如 README.md)的符号链接,但它们必须存在。

Autotools 配置

在你的项目根目录下创建一个名为 configure.ac 的文件。autoconf 使用此文件来创建用户在构建之前运行的 configure shell 脚本。该文件必须至少包含 AC_INITAC_OUTPUT M4 宏。你不需要了解有关 M4 语言的任何信息就可以使用这些宏;它们已经为你编写好了,并且所有与 Autotools 相关的内容都在该文档中定义好了。

在你喜欢的文本编辑器中打开该文件。AC_INIT 宏可以包括包名称、版本、报告错误的电子邮件地址、项目 URL 以及可选的源 TAR 文件名称等参数。

AC\_OUTPUT 宏更简单,不用任何参数。

AC_INIT([penguin], [2019.3.6], [[[email protected]][8]])
AC_OUTPUT

如果你此刻运行 autoconf,会依据你的 configure.ac 文件生成一个 configure 脚本,它是可以运行的。但是,也就是能运行而已,因为到目前为止你所做的就是定义项目的元数据,并要求创建一个配置脚本。

你必须在 configure.ac 文件中调用的下一个宏是创建 Makefile 的函数。 Makefile 会告诉 make 命令做什么(通常是如何编译和链接程序)。

创建 Makefile 的宏是 AM_INIT_AUTOMAKE,它不接受任何参数,而 AC_CONFIG_FILES 接受的参数是你要输出的文件的名称。

最后,你必须添加一个宏来考虑你的项目所需的编译器。你使用的宏显然取决于你的项目。如果你的项目是用 C++ 编写的,那么适当的宏是 AC_PROG_CXX,而用 C 编写的项目需要 AC_PROG_CC,依此类推,详见 Autoconf 文档中的 Building Programs and Libraries 部分。

例如,我可能会为我的 C++ 程序添加以下内容:

AC_INIT([penguin], [2019.3.6], [[[email protected]][8]])
AC_OUTPUT
AM_INIT_AUTOMAKE
AC_CONFIG_FILES([Makefile])
AC_PROG_CXX

保存该文件。现在让我们将目光转到 Makefile

生成 Autotools Makefile

Makefile 并不难手写,但 Autotools 可以为你编写一个,而它生成的那个将使用在 ./configure 步骤中检测到的配置选项,并且它将包含比你考虑要包括或想要自己写的还要多得多的选项。然而,Autotools 并不能检测你的项目构建所需的所有内容,因此你必须在文件 Makefile.am 中添加一些细节,然后在构造 Makefile 时由 automake 使用。

Makefile.am 使用与 Makefile 相同的语法,所以如果你曾经从头开始编写过 Makefile,那么这个过程将是熟悉和简单的。通常,Makefile.am 文件只需要几个变量定义来指示要构建的文件以及它们的安装位置即可。

_PROGRAMS 结尾的变量标识了要构建的代码(这通常被认为是 原语 primary 目标;这是 Makefile 存在的主要意义)。Automake 也会识别其他原语,如 _SCRIPTS_ DATA_LIBRARIES,以及构成软件项目的其他常见部分。

如果你的应用程序在构建过程中需要实际编译,那么你可以用 bin_PROGRAMS 变量将其标记为二进制程序,然后使用该程序名称作为变量前缀引用构建它所需的源代码的任何部分(这些部分可能是将被编译和链接在一起的一个或多个文件):

bin_PROGRAMS = penguin
penguin_SOURCES = penguin.cpp

bin_PROGRAMS 的目标被安装在 bindir 中,它在编译期间可由用户配置。

如果你的应用程序不需要实际编译,那么你的项目根本不需要 bin_PROGRAMS 变量。例如,如果你的项目是用 Bash、Perl 或类似的解释语言编写的脚本,那么定义一个 _SCRIPTS 变量来替代:

bin_SCRIPTS = bin/penguin

Automake 期望源代码位于名为 src 的目录中,因此如果你的项目使用替代目录结构进行布局,则必须告知 Automake 接受来自外部源的代码:

AUTOMAKE_OPTIONS = foreign subdir-objects

最后,你可以在 Makefile.am 中创建任何自定义的 Makefile 规则,它们将逐字复制到生成的 Makefile 中。例如,如果你知道一些源代码中的临时值需要在安装前替换,则可以为该过程创建自定义规则:

all-am: penguin
        touch bin/penguin.sh
       
penguin: bin/penguin.sh
        @sed "s|__datadir__|@datadir@|" $&lt; &gt;bin/$@

一个特别有用的技巧是扩展现有的 clean 目标,至少在开发期间是这样的。make clean 命令通常会删除除了 Automake 基础结构之外的所有生成的构建文件。它是这样设计的,因为大多数用户很少想要 make clean 来删除那些便于构建代码的文件。

但是,在开发期间,你可能需要一种方法可靠地将项目返回到相对不受 Autotools 影响的状态。在这种情况下,你可能想要添加:

clean-local:
        @rm config.status configure config.log
        @rm Makefile
        @rm -r autom4te.cache/
        @rm aclocal.m4
        @rm compile install-sh missing Makefile.in

这里有很多灵活性,如果你还不熟悉 Makefile,那么很难知道你的 Makefile.am 需要什么。最基本需要的是原语目标,无论是二进制程序还是脚本,以及源代码所在位置的指示(无论是通过 _SOURCES 变量还是使用 AUTOMAKE_OPTIONS 告诉 Automake 在哪里查找源代码)。

一旦定义了这些变量和设置,如下一节所示,你就可以尝试生成构建脚本,并调整缺少的任何内容。

生成 Autotools 构建脚本

你已经构建了基础结构,现在是时候让 Autotools 做它最擅长的事情:自动化你的项目工具。对于开发人员(你),Autotools 的接口与构建代码的用户的不同。

构建者通常使用这个众所周知的顺序:

$ ./configure
$ make
$ sudo make install

但是,要使这种咒语起作用,你作为开发人员必须引导构建这些基础结构。首先,运行 autoreconf 以生成用户在运行 make 之前调用的 configure 脚本。使用 -install 选项将辅助文件(例如符号链接)引入到 depcomp(这是在编译过程中生成依赖项的脚本),以及 compile 脚本的副本(一个编译器的包装器,用于说明语法,等等)。

$ autoreconf --install
configure.ac:3: installing './compile'
configure.ac:2: installing './install-sh'
configure.ac:2: installing './missing'

使用此开发构建环境,你可以创建源代码分发包:

$ make dist

dist 目标是从 Autotools “免费”获得的规则。这是一个内置于 Makefile 中的功能,它是通过简单的 Makefile.am 配置生成的。该目标可以生成一个 tar.gz 存档,其中包含了所有源代码和所有必要的 Autotools 基础设施,以便下载程序包的人员可以构建项目。

此时,你应该仔细查看存档文件的内容,以确保它包含你要发送给用户的所有内容。当然,你也应该尝试自己构建:

$ tar --extract --file penguin-0.0.1.tar.gz
$ cd penguin-0.0.1
$ ./configure
$ make
$ DESTDIR=/tmp/penguin-test-build make install

如果你的构建成功,你将找到由 DESTDIR 指定的已编译应用程序的本地副本(在此示例的情况下为 /tmp/penguin-test-build)。

$ /tmp/example-test-build/usr/local/bin/example
hello world from GNU Autotools

去使用 Autotools

Autotools 是一个很好的脚本集合,可用于可预测的自动发布过程。如果你习惯使用 Python 或 Bash 构建器,这个工具集对你来说可能是新的,但它为你的项目提供的结构和适应性可能值得学习。

而 Autotools 也不只是用于代码。Autotools 可用于构建 Docbook 项目,保持媒体有序(我使用 Autotools 进行音乐发布),文档项目以及其他任何可以从可自定义安装目标中受益的内容。


via: https://opensource.com/article/19/7/introduction-gnu-autotools

作者:Seth Kenlon 选题:lujun9972 译者:wxy 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

我过去认为 makefile 只是一种将一组组的 shell 命令列出来的简便方法;过了一段时间我了解到它们是有多么的强大、灵活以及功能齐全。这篇文章带你领略其中一些有关规则的特性。

备注:这些全是针对 GNU Makefile 的,如果你希望支持 BSD Makefile ,你会发现有些新的功能缺失。感谢 zge 指出这点。

规则

规则 rule 是指示 make 应该如何并且何时构建一个被称作为 目标 target 的文件的指令。目标可以依赖于其它被称作为 前提 prerequisite 的文件。

你会指示 make 如何按 步骤 recipe 构建目标,那就是一套按照出现顺序一次执行一个的 shell 命令。语法像这样:

target_name : prerequisites
    recipe

一但你定义好了规则,你就可以通过从命令行执行以下命令构建目标:

$ make target_name

目标一经构建,除非前提改变,否则 make 会足够聪明地不再去运行该步骤。

关于前提的更多信息

前提表明了两件事情:

  • 当目标应当被构建时:如果其中一个前提比目标更新,make 假定目的应当被构建。
  • 执行的顺序:鉴于前提可以反过来在 makefile 中由另一套规则所构建,它们同样暗示了一个执行规则的顺序。

如果你想要定义一个顺序但是你不想在前提改变的时候重新构建目标,你可以使用一种特别的叫做“ 唯顺序 order only ”的前提。这种前提可以被放在普通的前提之后,用管道符(|)进行分隔。

样式

为了便利,make 接受目标和前提的样式。通过包含 % 符号可以定义一种样式。这个符号是一个可以匹配任何长度的文字符号或者空隔的通配符。以下有一些示例:

  • %:匹配任何文件
  • %.md:匹配所有 .md 结尾的文件
  • prefix%.go:匹配所有以 prefix 开头以 .go 结尾的文件

特殊目标

有一系列目标名字,它们对于 make 来说有特殊的意义,被称作 特殊目标 special target

你可以在这个文档发现全套特殊目标。作为一种经验法则,特殊目标以点开始后面跟着大写字母。

以下是几个有用的特殊目标:

  • .PHONY:向 make 表明此目标的前提可以被当成伪目标。这意味着 make 将总是运行,无论有那个名字的文件是否存在或者上次被修改的时间是什么。
  • .DEFAULT:被用于任何没有指定规则的目标。
  • .IGNORE:如果你指定 .IGNORE 为前提,make 将忽略执行步骤中的错误。

替代

当你需要以你指定的改动方式改变一个变量的值, 替代 substitution 就十分有用了。

替代的格式是 $(var:a=b),它的意思是获取变量 var 的值,用值里面的 b 替代词末尾的每个 a 以代替最终的字符串。例如:

foo := a.o
bar : = $(foo:.o=.c) # sets bar to a.c

注意:特别感谢 Luis Lavena 让我们知道替代的存在。

档案文件

档案文件是用来一起将多个数据文档(类似于压缩文件的概念)收集成一个文件。它们由 ar Unix 工具所构建。ar 可以用于为任何目的创建档案,但除了静态库,它已经被 tar 大量替代。

make 中,你可以使用一个档案文件中的单独一个成员作为目标或者前提,就像这样:

archive(member) : prerequisite 
    recipe

最后的想法

关于 make 还有更多可探索的,但是至少这是一个起点,我强烈鼓励你去查看文档,创建一个笨拙的 makefile 然后就可以探索它了。


via: https://monades.roperzh.com/rediscovering-make-power-behind-rules/

作者:Roberto Dip 译者:tomjlw 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

用这个方便的工具来更有效的运行和编译你的程序。

当你需要在一些源文件改变后运行或更新一个任务时,通常会用到 make 工具。make 工具需要读取一个 Makefile(或 makefile)文件,在该文件中定义了一系列需要执行的任务。你可以使用 make 来将源代码编译为可执行程序。大部分开源项目会使用 make 来实现最终的二进制文件的编译,然后使用 make install 命令来执行安装。

本文将通过一些基础和进阶的示例来展示 makeMakefile 的使用方法。在开始前,请确保你的系统中安装了 make

基础示例

依然从打印 “Hello World” 开始。首先创建一个名字为 myproject 的目录,目录下新建 Makefile 文件,文件内容为:

say_hello:
        echo "Hello World"

myproject 目录下执行 make,会有如下输出:

$ make
echo "Hello World"
Hello World

在上面的例子中,“say\_hello” 类似于其他编程语言中的函数名。这被称之为 目标 target 。在该目标之后的是预置条件或依赖。为了简单起见,我们在这个示例中没有定义预置条件。echo ‘Hello World' 命令被称为 步骤 recipe 。这些步骤基于预置条件来实现目标。目标、预置条件和步骤共同构成一个规则。

总结一下,一个典型的规则的语法为:

目标: 预置条件
<TAB> 步骤

作为示例,目标可以是一个基于预置条件(源代码)的二进制文件。另一方面,预置条件也可以是依赖其他预置条件的目标。

final_target: sub_target final_target.c
        Recipe_to_create_final_target
        
sub_target: sub_target.c
        Recipe_to_create_sub_target

目标并不要求是一个文件,也可以只是步骤的名字,就如我们的例子中一样。我们称之为“伪目标”。

再回到上面的示例中,当 make 被执行时,整条指令 echo "Hello World" 都被显示出来,之后才是真正的执行结果。如果不希望指令本身被打印处理,需要在 echo 前添加 @

say_hello:
        @echo "Hello World"

重新运行 make,将会只有如下输出:

$ make
Hello World

接下来在 Makefile 中添加如下伪目标:generateclean

say_hello:
        @echo "Hello World"

generate:
        @echo "Creating empty text files..."
        touch file-{1..10}.txt

clean:
        @echo "Cleaning up..."
        rm *.txt

随后当我们运行 make 时,只有 say_hello 这个目标被执行。这是因为Makefile 中的第一个目标为默认目标。通常情况下会调用默认目标,这就是你在大多数项目中看到 all 作为第一个目标而出现。all 负责来调用它他的目标。我们可以通过 .DEFAULT_GOAL 这个特殊的伪目标来覆盖掉默认的行为。

Makefile 文件开头增加 .DEFAULT_GOAL

.DEFAULT_GOAL := generate

make 会将 generate 作为默认目标:

$ make
Creating empty text files...
touch file-{1..10}.txt

顾名思义,.DEFAULT_GOAL 伪目标仅能定义一个目标。这就是为什么很多 Makefile 会包括 all 这个目标,这样可以调用多个目标。

下面删除掉 .DEFAULT_GOAL,增加 all 目标:

all: say_hello generate

say_hello:
        @echo "Hello World"

generate:
        @echo "Creating empty text files..."
        touch file-{1..10}.txt

clean:
        @echo "Cleaning up..."
        rm *.txt

运行之前,我们再增加一些特殊的伪目标。.PHONY 用来定义这些不是文件的目标。make 会默认调用这些伪目标下的步骤,而不去检查文件名是否存在或最后修改日期。完整的 Makefile 如下:

.PHONY: all say_hello generate clean

all: say_hello generate

say_hello:
        @echo "Hello World"

generate:
        @echo "Creating empty text files..."
        touch file-{1..10}.txt

clean:
        @echo "Cleaning up..."
        rm *.txt

make 命令会调用 say_hellogenerate

$ make
Hello World
Creating empty text files...
touch file-{1..10}.txt

clean 不应该被放入 all 中,或者被放入第一个目标中。clean 应当在需要清理时手动调用,调用方法为 make clean

$ make clean
Cleaning up...
rm *.txt

现在你应该已经对 Makefile 有了基础的了解,接下来我们看一些进阶的示例。

进阶示例

变量

在之前的实例中,大部分目标和预置条件是已经固定了的,但在实际项目中,它们通常用变量和模式来代替。

定义变量最简单的方式是使用 = 操作符。例如,将命令 gcc 赋值给变量 CC

CC = gcc

这被称为递归扩展变量,用于如下所示的规则中:

hello: hello.c
    ${CC} hello.c -o hello

你可能已经想到了,这些步骤将会在传递给终端时展开为:

gcc hello.c -o hello

${CC}$(CC) 都能对 gcc 进行引用。但如果一个变量尝试将它本身赋值给自己,将会造成死循环。让我们验证一下:

CC = gcc
CC = ${CC}

all:
    @echo ${CC}

此时运行 make 会导致:

$ make
Makefile:8: *** Recursive variable 'CC' references itself (eventually).  Stop.

为了避免这种情况发生,可以使用 := 操作符(这被称为简单扩展变量)。以下代码不会造成上述问题:

CC := gcc
CC := ${CC}

all:
    @echo ${CC}

模式和函数

下面的 Makefile 使用了变量、模式和函数来实现所有 C 代码的编译。我们来逐行分析下:

# Usage:
# make        # compile all binary
# make clean  # remove ALL binaries and objects

.PHONY = all clean

CC = gcc                        # compiler to use

LINKERFLAG = -lm

SRCS := $(wildcard *.c)
BINS := $(SRCS:%.c=%)

all: ${BINS}

%: %.o
        @echo "Checking.."
        ${CC} ${LINKERFLAG} $< -o $@

%.o: %.c
        @echo "Creating object.."
        ${CC} -c $<

clean:
        @echo "Cleaning up..."
        rm -rvf *.o ${BINS}
  • # 开头的行是评论。
  • .PHONY = all clean 行定义了 allclean 两个伪目标。
  • 变量 LINKERFLAG 定义了在步骤中 gcc 命令需要用到的参数。
  • SRCS := $(wildcard *.c)$(wildcard pattern) 是与文件名相关的一个函数。在本示例中,所有 “.c”后缀的文件会被存入 SRCS 变量。
  • BINS := $(SRCS:%.c=%):这被称为替代引用。本例中,如果 SRCS 的值为 'foo.c bar.c',则 BINS的值为 'foo bar'
  • all: ${BINS} 行:伪目标 all 调用 ${BINS} 变量中的所有值作为子目标。
  • 规则:
%: %.o
  @echo "Checking.."
  ${CC} ${LINKERFLAG} $&lt; -o $@

下面通过一个示例来理解这条规则。假定 foo 是变量 ${BINS} 中的一个值。% 会匹配到 foo%匹配任意一个目标)。下面是规则展开后的内容:

foo: foo.o
  @echo "Checking.."
  gcc -lm foo.o -o foo

如上所示,%foo 替换掉了。$<foo.o 替换掉。$<用于匹配预置条件,$@ 匹配目标。对 ${BINS} 中的每个值,这条规则都会被调用一遍。

  • 规则:
%.o: %.c
  @echo "Creating object.."
  ${CC} -c $&lt;

之前规则中的每个预置条件在这条规则中都会都被作为一个目标。下面是展开后的内容:

foo.o: foo.c
  @echo "Creating object.."
  gcc -c foo.c
  • 最后,在 clean 目标中,所有的二进制文件和编译文件将被删除。

下面是重写后的 Makefile,该文件应该被放置在一个有 foo.c 文件的目录下:

# Usage:
# make        # compile all binary
# make clean  # remove ALL binaries and objects

.PHONY = all clean

CC = gcc                        # compiler to use

LINKERFLAG = -lm

SRCS := foo.c
BINS := foo

all: foo

foo: foo.o
        @echo "Checking.."
        gcc -lm foo.o -o foo

foo.o: foo.c
        @echo "Creating object.."
        gcc -c foo.c

clean:
        @echo "Cleaning up..."
        rm -rvf foo.o foo

关于 Makefile 的更多信息,GNU Make 手册提供了更完整的说明和实例。


via: https://opensource.com/article/18/8/what-how-makefile

作者:Sachin Patil 选题:lujun9972 译者:Zafiry 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

问题:我试着在Linux上构建一个程序,该程序的开发版本是使用“autogen.sh”脚本进行的。当我运行它来创建配置脚本时,却发生了下面的错误:

Can't exec "aclocal": No such file or directory at /usr/share/autoconf/Autom4te/FileUtils.pm line 326.
autoreconf: failed to run aclocal: No such file or directory

我怎样才能修复这个程序?

开发版本常常是通过autogen.sh使用程序源代码生成的,构建过程包括验证程序功能和生成配置脚本。autogen.sh脚本依赖于autoreconf来调用autoconf,automake,aclocal和其它相关工具。

丢失的aclocal是automake包的一部分,因此,要修复该错误,请安装以下包。

在Debian,Ubuntu或Linux Mint上:

$ sudo apt-get install automake

在CentOS,Fedora或RHEL上:

$ sudo yum install automake 

via: http://ask.xmodulo.com/fix-failed-to-run-aclocal.html

译者:GOLinux 校对:wxy

本文由 LCTT 原创翻译,Linux中国 荣誉推出