SCons快速入门与应用指南

1星需积分: 50 13 浏览量更新于2024-07-22 收藏 2.38MB PDF 举报

"Scons是一个构建工具，类似于Makefile，但设计得更易于学习和使用。它用于自动化编译、链接和其他软件构建过程。SCons在Python基础上构建，提供了灵活的构建脚本，使得项目管理更加方便。" SCons是Software Construction Tool的缩写，它是一个开源的构建系统，用于替代传统的Makefile。SCons基于Python编程语言，因此具有Python的易读性和可扩展性。这使得编写构建脚本变得更加直观，对于新手来说，学习曲线比Makefile要平缓。在SCons中，构建过程通过脚本定义，这些脚本可以描述源文件、目标文件以及如何将源文件转换为目标文件的规则。SCons使用一种名为“构造函数”（Builder）的概念，这些构造函数知道如何处理特定类型的文件，例如编译C++源文件或链接对象文件。例如，`./src/agg_renderer.os`和`./agg/libagg.a`等文件可能分别代表了编译的Objective代码和最终的静态库。 SCons的一个关键优点是它的跨平台特性。由于SCons是用Python编写的，它可以在任何支持Python的操作系统上运行，包括Windows、Linux和Mac OS X。这意味着开发者可以使用相同的构建脚本在不同的平台上构建软件，无需进行大量的调整。 SCons的另一个强项是其自动依赖性检测。它会扫描源文件以确定它们依赖的头文件，从而自动更新构建命令，确保每次只重新构建必要的部分。这在处理大型项目时非常有用，可以显著提高构建效率。在给定的文件列表中，我们可以看到各种不同类型的文件，如`.os`（编译后的对象文件）、`.o`（同样为对象文件）、`.a`（静态库）和`.py`（Python模块）。这些文件反映了SCons在管理一个包含C++源码、Python绑定以及可能的库和插件的复杂项目。例如，`./bindings/python/*`目录下的文件表明该项目包含Python接口，允许Python程序与底层C++代码交互。 SCons提供了一种强大而灵活的方法来管理和构建软件项目，无论项目规模大小。通过使用SCons，开发者可以更专注于编写代码，而不是处理构建系统的细节。同时，由于SCons的Python基础，它可以轻松地与其他Python工具和库集成，增强了整体的开发环境。

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.

剩余305页未读，继续阅读

Geoflying

粉丝: 0
资源: 2

SCons快速入门与应用指南

scons用户手册

scons-2.5.1.tar.gz

scons使用设计手册

qt使用qnx的scons编译

rt-thread scons

python使用pip安装scons

Ubuntu下scons安装

scons 怎么指定python3

scons环境变量的配置

scons 与cmake

最新资源