SCONS构建工具入门与应用

5星 · 超过95%的资源需积分: 14 159 浏览量更新于2024-07-16 收藏 2.42MB PDF 举报

"scons-user.pdf 是一份针对SCONS构建工具的入门文档，旨在帮助用户理解和使用SCONS进行软件编译。SCONS与CMAKE类似，是现代替代传统MAKE的流行工具，它们在软件构建自动化领域占据重要地位。文档中包含了各种源代码文件路径，如 agg_renderer.os、font_set.os 和 mapnik_symbolizer.os 等，这些文件路径暗示了SCONS可能被用于一个涉及图形渲染、字体处理和地图相关库的项目。此外，还提到了与Python绑定的接口，如mapnik_font_engine.os，表明SCONS也支持与其他编程语言的集成。文档还涉及到图像处理、几何形状处理（如agg_line_aa_basics.o和agg_arc.o）、字体引擎、数据源管理以及地图保存等相关功能的实现。" SCONS是一个开源的构建工具，基于Python编写，它提供了一种简单而强大的方式来管理软件项目的构建过程。SCONS的使用方法类似于Make，但它的语法更加简洁，且具有更好的跨平台兼容性。SCONS的核心理念是通过读取项目目录中的SConstruct文件来自动发现和构建源码，减少了手动配置的需求。在SCONS中，构建目标（如编译的`.os`对象文件）可以通过简单的Python表达式定义，这使得构建规则可以灵活地适应项目需求。例如，`./src/agg_renderer.os`可能是图形渲染库的一个部分，而`./src/arrow.os`可能涉及矢量图形的处理。文档中提到的`libagg.a`是一个静态库，可能包含了多个图形处理相关的函数集合。 SCONS支持与其他语言的集成，如Python。在文档中，我们看到`bindings/python`目录下有多个与Python相关的`.os`文件，如`mapnik_font_engine.os`，这表明SCONS可以用来构建Python绑定库，使得Python程序可以直接调用C/C++编译的底层库，提高性能。此外，文档还提到了输入插件，如`plugins/input/shape/`和`plugins/input/raster/`，这表明SCONS可以用于处理地理空间数据，如ESRI Shapefile和栅格数据，这在GIS软件开发中是非常常见的。 SCONS的优势在于其灵活性和可扩展性。通过Python的语法，用户可以轻松地添加自定义构建规则，处理复杂的依赖关系，并能够方便地与现有的Python生态系统整合。这使得SCONS成为大型、多模块项目理想的构建选择，尤其是在那些需要跨平台编译和复杂构建流程的项目中。

Cleaning Up After a Build

Java('classes', 'src')

If the src directory contains a single hello.java file, then the output from running the scons command would

look something like this (on a POSIX system):

% scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

javac -d classes -sourcepath src src/hello.java

scons: done building targets.

We'll cover Java builds in more detail, including building Java archive (.jar) and other types of file, in Chapter 26,

Java Builds.

2.4. Cleaning Up After a Build

When using SCons, it is unnecessary to add special commands or target names to clean up after a build. Instead, you

simply use the -c or --clean option when you invoke SCons, and SCons removes the appropriate built files. So if

we build our example above and then invoke scons -c afterwards, the output on POSIX looks like:

% scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cc -o hello.o -c hello.c

cc -o hello hello.o

scons: done building targets.

% scons -c

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Cleaning targets ...

Removed hello.o

Removed hello

scons: done cleaning targets.

And the output on Windows looks like:

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.

C:\>scons -c

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Cleaning targets ...

Removed hello.obj

Removed hello.exe

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.

Compiling Multiple Source Files

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

embedManifestExeCheck(target, source, env)

3.2. Compiling Multiple Source Files

You've just seen how to configure SCons to compile a program from a single source file. It's more common, of course,

that you'll need to build a program from many input source files, not just one. To do this, you need to put the source

files in a Python list (enclosed in square brackets), like so:

Program(['prog.c', 'file1.c', 'file2.c'])

A build of the above example would look like:

% scons -Q

cc -o file1.o -c file1.c

cc -o file2.o -c file2.c

cc -o prog.o -c prog.c

cc -o prog prog.o file1.o file2.o

Notice that SCons deduces the output program name from the first source file specified in the list--that is, because the

first source file was prog.c, SCons will name the resulting program prog (or prog.exe on a Windows system). If

you want to specify a different program name, then (as we've seen in the previous section) you slide the list of source

files over to the right to make room for the output program file name. (SCons puts the output file name to the left

of the source file names so that the order mimics that of an assignment statement: "program = source files".) This

makes our example:

Program('program', ['prog.c', 'file1.c', 'file2.c'])

On Linux, a build of this example would look like:

% scons -Q

cc -o file1.o -c file1.c

cc -o file2.o -c file2.c

cc -o prog.o -c prog.c

cc -o program prog.o file1.o file2.o

Or on Windows:

C:\>scons -Q

cl /Fofile1.obj /c file1.c /nologo

cl /Fofile2.obj /c file2.c /nologo

cl /Foprog.obj /c prog.c /nologo

link /nologo /OUT:program.exe prog.obj file1.obj file2.obj

embedManifestExeCheck(target, source, env)

3.3. Making a list of files with Glob

You can also use the Glob function to find all files matching a certain template, using the standard shell pattern

matching characters *, ? and [abc] to match any of a, b or c. [!abc] is also supported, to match any character

except a, b or c. This makes many multi-source-file builds quite easy:

剩余313页未读，继续阅读

weixin_40987531

粉丝: 0
资源: 4

SCONS构建工具入门与应用

SCons-4.0.0：Python库的安装与使用指南

基于Linux的hi3861开发环境安装scons-3.0.4教程

PyScons-1.0.57.tar.gz: 详细的Python库安装指南

scons-2.4.0.zip

scons-2.5.1.zip

scons-mdk.zip

scons-3.0.5.zip

scons-2.3.1.tar.gz

scons-4.0.0.tar.gz

scons-2.5.1.tar.gz

最新资源