scons v3.0.4 完整用户指南（附英文书签）

需积分: 9 157 浏览量更新于2024-07-17 收藏 11.64MB PDF 举报

SCons v3.0.4 用户指南是一份详细的文档，针对Python编写的构建工具SCons的最新官方版本，发布日期为2019年2月27日。这份指南是英文原版，特别强调了内置的书签功能，与无书签的官方版本相比，它提供了更为方便的导航和学习体验。指南覆盖了SCons的核心模块和功能，包括： 1. **源代码目录结构**：指南列出了如`./src/agg_renderer.os`、`./agg/src`等源代码文件夹，这暗示了文档可能会详细介绍SCons如何处理和构建图形渲染相关的C++代码，以及Python绑定。 2. **Python绑定**：多个文件路径如`mapnik_symbolizer.os`、`mapnik_font_engine.os`等涉及Python接口，表明指南会介绍如何在Python中使用SCons来操作Mapnik（一个流行的地图渲染引擎），包括符号化、字体引擎等。 3. **输入插件**：`plugins/input/shape/dbffile.os` 和 `plugins/input/shape/shapefile.os` 展示了SCons如何集成不同的数据源处理，例如Shapefile格式的数据。 4. **图形处理**：`agg_line_aa_basics.o` 和 `agg_bezier_arc.o` 等文件可能涉及图形算法和抗锯齿技术，说明指南中会涉及图形渲染的细节。 5. **Python模块**：如`mapnik_view_transform.os` 和 `mapnik_rule.os`，说明文档会讲解如何通过Python控制地图视图变换和规则集的构建。 6. **内存管理**：`memory.os` 可能介绍了SCons在内存管理和优化方面的实践。 7. **输入/输出**：`save_map.os` 和 `raster_datasource.os` 提供了关于保存地图和处理栅格数据的信息。 8. **库和依赖**：`agg/libagg.a` 和 `font_engine_freetype.os` 显示SCons如何处理外部库和字体引擎（如FreeType）。 9. **字体和矢量图形**：`font_set.os` 和 `agg_arc.o` 可能涉及字体处理和矢量图形绘制。 10. **其他**：`unicode.os` 可能讨论Unicode字符支持，`ogcserver` 可能介绍Open Geospatial Consortium (OGC)兼容性，而`mapnik_map.os` 和 `arrow.os` 可能涵盖了地图对象和箭头绘制。总体而言，这份用户指南为开发者提供了全面的SCons v3.0.4 使用方法，不仅涵盖了基础配置和构建流程，还深入探讨了特定领域的集成应用，适合那些希望深入了解并利用SCons进行项目构建的Python和图形开发人员。

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页未读，继续阅读

WZW_GYC

粉丝: 0
资源: 2

scons v3.0.4 完整用户指南（附英文书签）

scons-3.0.4.tar.gz

SCons用户指南.pdf

scons 2.4.0 用户指南

SCons 2.3.6用户指南 英文

Scons V3.0.5

SCons v4.1.0 版本

Scons用户手册V4.3.0

快速掌握SCons：2.3.6用户指南

SCons 1.3.0用户指南：快速安装与基本构建

SCons 2.5.1用户指南：无需Makefile的跨平台编译工具

最新资源

SCons 2.3.6用户指南英文