SCons：下一代软件构建工具教程

需积分: 9 2 浏览量更新于2024-07-19 收藏 2.42MB PDF 举报

"Scons是一个开源的软件构建工具，它是一个新一代的构建工具，可以视为经典Make工具的增强版，并集成了类似于autoconf/automake的功能以及像ccache这样的编译器缓存。简而言之，SCons是一种更简单、更可靠、更快的构建软件的方法。" 在软件开发过程中，构建工具是非常关键的一环，它们负责管理和自动化源代码到可执行文件的转换过程。SCons就是这样一个工具，它的设计目标是提高构建效率，增强跨平台兼容性，并减少构建过程中的错误。 SCons与传统的Make工具相比，有以下几个显著优势： 1. **跨平台**：SCons是用Python编写的，因此它天生具有跨平台能力，可以在多种操作系统上运行，如Windows、Linux、Mac OS等。 2. **易用性**：SCons的配置文件是基于Python脚本的，这使得构建规则的编写更加直观和灵活，开发者可以利用Python的全部功能来定制构建过程。 3. **依赖性管理**：SCons自动跟踪源文件的依赖关系，确保每次只重新构建必要的部分，从而提高构建速度。 4. **集成功能**：SCons内置了类似autoconf/automake的功能，可以自动生成配置文件，适应不同环境下的编译需求。 5. **编译器缓存**：尽管SCons自身并不直接提供缓存机制，但它可以与ccache等编译器缓存工具配合使用，进一步提升重复编译的效率。在给定的部分内容中，我们看到了一系列的文件路径，这些通常是构建过程中产生的目标文件（.os和.o结尾）和库文件（如.libagg.a）。SCons会根据源文件、头文件和依赖关系来编译和链接这些目标文件，最终生成可执行程序或库。此外，还有一些特定于Mapnik（一个地图渲染库）的Python绑定文件，表明这个项目可能涉及到地理信息系统的开发。例如，`./src/font_engine_freetype.os`可能是Mapnik使用FreeType库处理字体的组件，而`./bindings/python/mapnik_map.os`则可能是Python接口中与地图对象相关的代码。`./plugins`目录下包含了输入插件，如`shape`和`raster`，这些可能用于读取和处理矢量或栅格数据。 SCons作为一个强大的构建工具，能够帮助开发者高效地管理和构建复杂项目，尤其是在涉及多平台和多语言的项目中，其优势更为明显。通过合理利用SCons，可以提高开发效率，减少手动配置带来的错误，让团队更加专注于软件本身的开发。

Building Object Files

C:\>scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cl /Fohello.obj /c hello.c /nologo

link /nologo /OUT:hello.exe hello.obj

embedManifestExeCheck(target, source, env)

scons: done building targets.

First, notice that you only need to specify the name of the source file, and that SCons correctly deduces the names of

the object and executable files to be built from the base of the source file name.

Second, notice that the same input SConstruct file, without any changes, generates the correct output file names

on both systems: hello.o and hello on POSIX systems, hello.obj and hello.exe on Windows systems.

This is a simple example of how SCons makes it extremely easy to write portable software builds.

(Note that we won't provide duplicate side-by-side POSIX and Windows output for all of the examples in this guide;

just keep in mind that, unless otherwise specified, any of the examples should work equally well on both types of

systems.)

2.2. Building Object Files

The Program builder method is only one of many builder methods that SCons provides to build different types of

files. Another is the Object builder method, which tells SCons to build an object file from the specified source file:

Object('hello.c')

Now when you run the scons command to build the program, it will build just the hello.o object file on a POSIX

system:

% scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cc -o hello.o -c hello.c

scons: done building targets.

And just the hello.obj object file on a Windows system (with the Microsoft Visual C++ compiler):

C:\>scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cl /Fohello.obj /c hello.c /nologo

scons: done building targets.

2.3. Simple Java Builds

SCons also makes building with Java extremely easy. Unlike the Program and Object builder methods, however,

the Java builder method requires that you specify the name of a destination directory in which you want the class

files placed, followed by the source directory in which the .java files live:

The SConstruct File

scons: done cleaning targets.

Notice that SCons changes its output to tell you that it is Cleaning targets ... and done cleaning

targets.

2.5. The SConstruct File

If you're used to build systems like Make you've already figured out that the SConstruct file is the SCons equivalent

of a Makefile. That is, the SConstruct file is the input file that SCons reads to control the build.

2.5.1. SConstruct Files Are Python Scripts

There is, however, an important difference between an SConstruct file and a Makefile: the SConstruct file

is actually a Python script. If you're not already familiar with Python, don't worry. This User's Guide will introduce

you step-by-step to the relatively small amount of Python you'll need to know to be able to use SCons effectively.

And Python is very easy to learn.

One aspect of using Python as the scripting language is that you can put comments in your SConstruct file using

Python's commenting convention; that is, everything between a '#' and the end of the line will be ignored:

# Arrange to build the "hello" program.

Program('hello.c') # "hello.c" is the source file.

You'll see throughout the remainder of this Guide that being able to use the power of a real scripting language can

greatly simplify the solutions to complex requirements of real-world builds.

2.5.2. SCons Functions Are Order-Independent

One important way in which the SConstruct file is not exactly like a normal Python script, and is more like a

Makefile, is that the order in which the SCons functions are called in the SConstruct file does not affect the

order in which SCons actually builds the programs and object files you want it to build.

In other words, when you

call the Program builder (or any other builder method), you're not telling SCons to build the program at the instant

the builder method is called. Instead, you're telling SCons to build the program that you want, for example, a program

built from a file named hello.c, and it's up to SCons to build that program (and any other files) whenever it's

necessary. (We'll learn more about how SCons decides when building or rebuilding a file is necessary in Chapter 6,

Dependencies, below.)

SCons reflects this distinction between calling a builder method like Program and actually building the program

by printing the status messages that indicate when it's "just reading" the SConstruct file, and when it's actually

building the target files. This is to make it clear when SCons is executing the Python statements that make up the

SConstruct file, and when SCons is actually executing the commands or other actions to build the necessary files.

Let's clarify this with an example. Python has a print statement that prints a string of characters to the screen. If we

put print statements around our calls to the Program builder method:

print("Calling Program('hello.c')")

Program('hello.c')

print("Calling Program('goodbye.c')")

In programming parlance, the SConstruct file is declarative, meaning you tell SCons what you want done and let it figure out the order in

which to do it, rather than strictly imperative, where you specify explicitly the order in which to do things.

Making the SCons Output Less Verbose

Program('goodbye.c')

print("Finished calling Program()")

Then when we execute SCons, we see the output from the print statements in between the messages about reading

the SConscript files, indicating that that is when the Python statements are being executed:

% scons

scons: Reading SConscript files ...

Calling Program('hello.c')

Calling Program('goodbye.c')

Finished calling Program()

scons: done reading SConscript files.

scons: Building targets ...

cc -o goodbye.o -c goodbye.c

cc -o goodbye goodbye.o

cc -o hello.o -c hello.c

cc -o hello hello.o

scons: done building targets.

Notice also that SCons built the goodbye program first, even though the "reading SConscript" output shows that

we called Program('hello.c') first in the SConstruct file.

2.6. Making the SCons Output Less Verbose

You've already seen how SCons prints some messages about what it's doing, surrounding the actual commands used

to build the software:

C:\>scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cl /Fohello.obj /c hello.c /nologo

link /nologo /OUT:hello.exe hello.obj

embedManifestExeCheck(target, source, env)

scons: done building targets.

These messages emphasize the order in which SCons does its work: all of the configuration files (generically referred

to as SConscript files) are read and executed first, and only then are the target files built. Among other benefits,

these messages help to distinguish between errors that occur while the configuration files are read, and errors that

occur while targets are being built.

One drawback, of course, is that these messages clutter the output. Fortunately, they're easily disabled by using the

-Q option when invoking SCons:

C:\>scons -Q

cl /Fohello.obj /c hello.c /nologo

link /nologo /OUT:hello.exe hello.obj

embedManifestExeCheck(target, source, env)

Because we want this User's Guide to focus on what SCons is actually doing, we're going to use the -Q option to

remove these messages from the output of all the remaining examples in this Guide.

剩余313页未读，继续阅读

crstnacy

粉丝: 0
资源: 1

SCons：下一代软件构建工具教程

scons 2.4.0 用户指南

SCons用户指南.pdf

scons3.0.1 scons-design

scons3.0.1 scons-api

scons3.0.1 scons-man

scons安装包

scons-test：测试SCons

scons:SCons-一种软件构建工具

Scons V3.0.5

scons-2.3.4

最新资源