scons - 云端在线

程序：

您的姓名

scons - 一个软件构建工具

概要

烤饼 [选项...] [名称=值...] [目标...]

商品描述

这个 烤饼 实用程序通过确定哪些组件来构建软件（或其他文件）
必须重建并执行必要的命令来重建它们。

默认情况下， 烤饼 搜索名为的文件 构造, 构造或 构建 （在那里面
order) 并从找到的第一个文件中读取其配置。一个
备用文件名可以通过 -f 选项。

这个 构造 file 可以使用指定的辅助配置文件 新兵()
功能。 按照惯例，这些附属文件被命名为 新兵，虽然任何名字
可能用过了。 （由于这种命名约定，术语“SConscript 文件”有时是
用于泛指所有 烤饼 配置文件，不管实际文件
名称。）

配置文件指定要构建的目标文件，以及（可选）规则
建立这些目标。 构建通用软件存在合理的默认规则
组件（可执行程序、目标文件、库），因此对于大多数软件
项目，只需要指定目标和输入文件。

在阅读之前 构造 文件， 烤饼 查找名为的目录 站点_scons in
各种系统目录（见下文）和包含 构造 文件;
对于每个存在的目录， 站点_scons 预先添加到 sys.path，文件
site_scons/site_init.py, 评估它是否存在，并且目录
site_scons/site_tools 如果存在，则附加到默认刀具路径。 见
--无站点目录 和 --站点目录 选项了解更多详情。

烤饼 将 SConscript 文件作为 Python 脚本读取和执行，因此您可以正常使用
Python 脚本功能（例如流控制、数据操作和导入
Python 库）来处理复杂的构建情况。 烤饼但是，读取和
执行所有 SConscript 文件 before 它开始构建任何目标。 为了使这个
明显， 烤饼 打印关于它正在做什么的以下消息：

$ scons foo.out
scons：读取 SConscript 文件...
scons：完成读取 SConscript 文件。
scons：建立目标......
cp foo.in foo.out
scons：完成构建目标。
$

状态消息（除了读取“cp foo.in foo.out”的行之外的所有内容）可能是
使用 -Q 选项。

烤饼 不会自动传播用于执行的外部环境 烤饼 至
用于构建目标文件的命令。 这是为了保证构建
无论当时设置的环境变量如何，都是可重复的 烤饼 被调用。这
也意味着如果编译器或您想用来构建您的其他命令
目标文件不在标准系统位置， 烤饼 不会找到他们，除非你
显式设置 PATH 以包含这些位置。 每当您创建一个 烤饼
构建环境，您可以从外部传播 PATH 的值
环境如下：

导入操作系统
env = Environment(ENV = {'PATH' : os.environ['PATH']})

同样，如果命令使用外部环境变量，如 $PATH、$HOME、
$JAVA_HOME、$LANG、$SHELL、$TERM 等，这些变量也可以显式传播：

导入操作系统
env = Environment(ENV = {'PATH' : os.environ['PATH'],
'家' : os.environ['HOME']})

或者您可以显式地传播调用用户的完整外部环境：

导入操作系统
env = 环境（ENV = os.environ）

这是以让您的构建依赖于用户的环境为代价的
正确设置，但对于许多配置可能更方便。

烤饼 可以自动扫描已知的输入文件以获取依赖信息（例如，
C 或 C++ 文件中的 #include 语句）并将适当地重建依赖文件
每当任何“包含”的输入文件发生变化时。 烤饼 支持定义新的能力
未知输入文件类型的扫描仪。

烤饼 知道如何使用 SCCS 从 SCCS 或 RCS 子目录自动获取文件，
RCS 或 BitKeeper。

烤饼 通常在包含一个顶级目录的顶级目录中执行 构造 文件，
可选地将要构建的目标文件或文件指定为命令行参数。

默认情况下，命令

烤饼

将构建当前目录中或以下的所有目标文件。 明确的默认目标
（在命令行上没有指定目标时构建）可以定义
SConscript 文件使用 默认（） 功能，如下所述。

即便 默认（） 目标在 SConscript 文件中指定，所有目标文件在
或低于当前目录可以通过显式指定当前目录来构建
(.) 作为命令行目标：

烤饼。

构建所有目标文件，包括当前目录之外的任何文件，可能是
通过提供根目录的命令行目标来指定（在 POSIX 系统上）：

烤饼 /

或应在其中构建所有目标的卷的路径名（在 Windows 上）
系统）：

scons C:\ D:\

要仅构建特定目标，请将它们作为命令行参数提供：

scons foo 酒吧

在这种情况下，只会构建指定的目标（以及任何派生文件）
他们所依赖的）。

通常不需要在 SConscript 文件中指定“清理”目标。 这 -c 旗
删除构建指定目标所需的所有文件：

scons -c 。

删除所有目标文件，或：

scons -c 构建导出

删除构建和导出下的目标文件。 要删除的其他文件或目录
可以使用 干净的（） 功能。 相反，目标通常是
被删除 -c 通过使用可以防止调用被删除 不清洁()
功能。

可以通过保留在顶级目录中来构建层次树的子集
（其中 构造 文件存在）并指定子目录作为目标
构建：

scons src/子目录

或者通过更改目录并使用 -u 选项，它遍历
目录层次结构，直到找到 构造 文件，然后相对构建目标
到当前子目录：

cd src/子目录
scons -u 。

烤饼 支持通过一个并行构建多个目标 -j 选项，作为其
参数，可能产生的并发任务数：

scons -j 4

例如，并行构建四个目标。

烤饼 可以维护可以在多个目标（派生）文件之间共享的缓存
建立。 在 SConscript 文件中启用缓存时，任何由 烤饼 将
被复制到缓存中。 如果在缓存中找到最新的目标文件，它将是
从缓存中检索而不是在本地重建。 缓存行为可能是
以其他方式禁用和控制 --缓存力, --缓存禁用,
--缓存只读和 --缓存显示 命令行选项。 这 - 随机的 选项对
防止多个构建尝试同时更新缓存。

可以在命令中指定要传递给 SConscript 文件的变量值
线：

scons 调试=1。

这些变量通过 ARGUMENTS 字典在 SConscript 文件中可用，并且
可以在 SConscript 文件中使用以任何方式修改构建：

如果 ARGUMENTS.get('debug', 0):
环境 = 环境（CCFLAGS = '-g'）
其他：
环境 = 环境（）

命令行变量参数在 ARGLIST 列表中也可用，索引为
他们在命令行上的顺序。 这允许您按顺序而不是按顺序处理它们
名称，如有必要。 ARGLIST[0] 返回一个包含 (argname, argvalue) 的元组。 一个蟒蛇
如果您尝试访问不存在的列表成员，则会引发异常。

烤饼 需要 Python 2.7 或更高版本。 不应该有其他依赖项或
运行要求 司康。

默认情况下， 烤饼 知道如何在各种系统上搜索可用的编程工具。
在 Windows 系统上， 烤饼 搜索 Microsoft Visual C++ 工具 MinGW
工具链、英特尔编译器工具和 PharLap ETS 编译器。 在 OS/2 系统上， 烤饼
搜索 OS/2 编译器、GCC 工具链和 Microsoft Visual C++
工具，在 SGI IRIX、IBM AIX、Hewlett Packard HP-UX 和 Sun Solaris 系统上， 烤饼
搜索本机编译器工具（MIPSpro、Visual Age、aCC 和 Forte 工具）
分别）和 GCC 工具链。 在所有其他平台上，包括 POSIX（Linux 和
UNIX）平台， 烤饼 搜索 GCC 工具链 Microsoft Visual C++
工具，以及英特尔编译器工具。 当然，您可以通过以下方式覆盖这些默认值
适当配置环境构造变量。

配置

一般情况下， 烤饼 支持与 GNU 相同的命令行选项 使，其中许多
通过支持 缺点.

-b
忽略与非 GNU 版本的兼容性 使。

-c，--清洁，--删除
通过删除指定了构造命令的所有目标文件进行清理。
还可以使用以下命令删除与构造命令关联的任何文件或目录
清洁（） 功能。 不会删除指定的任何目标 不清洁（） 功能。

--缓存调试=文件
打印调试信息 缓存目录() 派生文件缓存到指定的
文件。 如果 文件 is - （连字符），调试信息打印到标准
输出。 打印的消息描述了正在查找的签名文件名
在、检索或写入 缓存目录() 目录树。

--缓存禁用，--无缓存
禁用由指定的派生文件缓存 缓存目录（）。 烤饼 既不会检索
缓存中的文件，也不会将文件复制到缓存中。

--cache-force，--cache-populate
使用时 缓存目录()，通过复制任何已经存在的、最新的来填充缓存
除了由此调用构建的文件外，派生文件也将被缓存到缓存中。 这是
用于使用所有当前派生文件填充新缓存，或添加到
缓存最近通过禁用缓存构建的任何派生文件 --缓存禁用
选项。

--缓存只读
使用缓存（如果已启用）进行读取，但不要使用已更改的内容更新缓存
文件。

--缓存显示
使用时 缓存目录() 并从缓存中检索派生文件，显示命令
将被执行以构建文件，而不是通常的报告，
“从缓存中检索到‘文件’。”这将为构建日志产生一致的输出，
无论目标文件是重建的还是从缓存中检索的。

--配置=模式
这指定了如何 配置 调用应该使用或生成结果
配置测试。 该选项应从以下选项中指定：

--config=自动
scons 将使用其正常的依赖机制来决定是否必须重新构建测试或
不是。 这样可以通过在每次调用时不运行相同的配置测试来节省时间
scons，但会忽略系统头文件或外部命令（例如
编译器），如果您没有明确指定这些依赖项。 这是默认的
行为。

--config=强制
如果指定了此选项，则所有配置测试都将重新运行，而不管
缓存的结果是否过时。 这可用于显式强制
配置测试更新以响应其他未配置的更改
系统头文件或编译器。

--config=缓存
如果指定了此选项，则不会重新运行任何配置测试，并且所有结果都将
从缓存中取出。 请注意，如果 --config=cache，scons 仍然会认为它是一个错误
被指定并且一个必要的测试在缓存中还没有任何结果。

-C 目录, --目录=目录
更改为指定 目录 在搜索之前 构造, 构造或
构建 文件，或做任何其他事情。 多种的 -C 选项是相对解释的
到上一个，最右边的 -C 选项获胜。 （这个选项几乎
相当于 -f 目录/SConstruct, 除了它会搜索 构造,
构造或 构建 在指定的目录中。）

-D
工作方式与 -u 除了默认目标的方式之外的选项
处理。 当使用此选项且命令行上未指定目标时，
构建所有默认目标，无论它们是否在当前目录下。

--调试=类型
调试构建过程。 类型[,类型...] 指定什么类型的调试。 多种的
可以指定类型，用逗号分隔。 以下类型有效：

--调试=计数
打印 SCons 内部使用的各种类创建了多少对象
在读取 SConscript 文件之前和之后以及构建目标之前和之后。
使用 Python 执行 SCons 时不支持此操作 -O （优化）选项或
当 SCons 模块经过优化编译时（即，当执行
， *.pyo 文件）。

--debug=重复
为变体文件从其源文件的每个取消链接/重新链接（或副本）打印一行。
包括用于取消链接陈旧变体文件以及取消链接旧文件的调试信息
在构建目标之前。

--调试=dtree
新的同义词 --tree=派生 选项。 这将在未来被弃用
释放并最终删除。

--debug=解释
打印准确原因的解释 烤饼 正在决定（重新）构建任何目标。
（注意：这不会打印任何目标 而不去 重建。）

--debug=查找库
指示搜索库的扫描器打印关于每个库的消息
它正在搜索的潜在库名称，以及它找到的实际库。

--debug=包含
在构建每个顶级目标后打印包含树。 这一般用于
找出给定派生文件的来源包含哪些文件：

$ scons --debug=包括 foo.o

--调试=记忆器
使用 Memoizer 打印命中和未命中的摘要，这是一个内部子系统
计算 SCons 在内存中使用缓存值而不是每次重新计算它们的频率
需要他们的时候。

--调试=内存
打印在读取 SConscript 文件之前和之后 SCons 使用的内存量和
在构建目标之前和之后。

--debug=nomemoizer
为向后兼容而保留的弃用选项。

--debug=对象
打印 SCons 内部使用的各种类的各种对象的列表。

--调试=pdb
在 pdb Python 调试器的控制下重新运行 SCons。

--调试=准备
每次准备构建任何目标（内部或外部）时打印一行。
烤饼 为它考虑的每个目标打印此内容，即使该目标是最新的（请参阅
还有--debug=explain）。 这可以帮助调试目标不存在的问题
建成; 它显示是否 烤饼 至少正在考虑它们。

--debug=预子
在构建之前打印用于构建每个目标的原始命令行
环境变量被替换。 还显示正在构建哪些目标
这个命令。 输出看起来像这样：

$ scons --debug=presub
使用操作构建 myprog.o：
$SHCC $SHCFLAGS $SHCCFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES
...

--debug=堆栈跟踪
遇到无法解释的异常时打印内部 Python 堆栈跟踪
错误。

--调试=街
新的同义词 --tree=全部，状态 选项。 这将在某些情况下被弃用
未来发布并最终删除。

--调试=时间
打印各种时间分析信息：执行每个人所花费的时间
构建命令； 总构建时间（SCons 从开始到结束运行的时间）； 总数
读取和执行 SConscript 文件所花费的时间； SCons 本身花费的总时间
花费在运行上（即不计算读取和执行 SConscript 文件）；和两者
执行所有构建命令所花费的总时间和挂钟时间
花费在执行这些构建命令上。 （什么时候 烤饼 没有执行 -j 选项，
经过的挂钟时间通常会比总时间略长
由于发生了 SCons 处理，因此花费了执行所有构建命令的时间
在执行每个命令之间。 什么时候 烤饼 被执行 - 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 -j 选项，以及您的
构建配置允许良好的并行化，经过的挂钟时间应该是
明显小于执行所有构建命令所花费的总时间，
因为多个构建命令和干预 SCons 处理应该发生在
平行线。）

--调试=树
新的同义词 --tree=全部 选项。 这将在未来被弃用
释放并最终删除。

--磁盘检查=类型
启用特定检查以检查磁盘上是否存在 SCons 所在的文件
配置需要一个目录（反之亦然），无论是 RCS 还是 SCCS
搜索源和包含文件时存在源。 这 类型 论证可以是
设置： 所有, 显式启用所有检查（默认行为）； 没有, 禁用
所有此类检查； 匹配, 检查磁盘上的文件和目录是否与 SCons 匹配
预期配置； RCS, 检查是否存在任何 RCS 源
缺少源文件或包含文件； 装箱, 检查 SCCS 源是否存在
对于任何丢失的源文件或包含文件。 可以指定多个检查分隔
逗号； 例如， --diskcheck=sccs,rcs 仍会检查 SCCS 和 RCS 来源，
但禁用检查文件和目录的磁盘匹配。 禁用某些或
所有这些检查都可以为大型配置提供性能提升，或者当
配置将检查跨网络或共享的文件和/或目录
文件系统，错误构建或不处理的风险略有增加
优雅地错误（如果确实应该在 SCCS 或 RCS 中找到包含文件，对于
例如，或者如果文件确实存在，其中 SCons 配置需要一个
目录）。

--重复=订单
在构建树中有三种复制文件的方法：硬链接、软（符号）
链接和副本。 SCons 的默认行为是更喜欢硬链接而不是软链接
到副本。 您可以使用此选项指定不同的行为。 订单 必须是一个
of 硬拷贝 （默认）， 软硬拷贝, 硬拷贝, 电子版 or 复制. SCCons
将尝试使用指定顺序的机制复制文件。

-f 文件, --文件=文件, --生成文件=文件, --构造=文件
使用 VHDL 语言编写 文件 作为初始 SConscript 文件。 多种的 -f 可以指定选项，在
这种情况下 烤饼 将读取所有指定的文件。

-h，--帮助
如果在 SConscript 中定义了此构建的本地帮助消息，则打印一条本地帮助消息
文件，加上一行描述 -H 命令行选项帮助的选项。 如果不
定义本地帮助消息，打印有关命令行的标准帮助消息
选项。 显示相应消息后退出。

-H，--帮助选项
打印有关命令行选项的标准帮助消息并退出。

-i，--忽略错误
忽略为重建文件而执行的命令中的所有错误。

-I 目录, --include-目录=目录
指定一个 目录 搜索导入的 Python 模块。 如果几个 -I 选项是
使用时，将按照指定的顺序搜索目录。

--隐式缓存
缓存隐式依赖。 这导致 烤饼 使用隐式（扫描）
上次运行的依赖项，而不是扫描文件中的隐式
依赖关系。 这可以显着加快 SCons，但具有以下特点
限制：

烤饼 不会检测到隐式依赖搜索路径的变化（例如 路径, 路径)
这通常会导致使用不同版本的同名文件。

烤饼 在新的隐式依赖项的情况下将错过隐式依赖项的更改
在隐式依赖搜索路径中更早地添加了依赖（例如 路径,
路径) 而不是具有相同名称的当前隐式依赖项。

--隐式依赖项更改
强制 SCons 忽略缓存的隐式依赖项。 这导致隐式
要重新扫描和重新缓存的依赖项。 这意味着 --隐式缓存.

--implicit-deps-未更改
强制 SCons 忽略隐式依赖项中的更改。 这导致缓存
始终使用隐式依赖项。这意味着 --隐式缓存.

- 交互的
以交互模式启动 SCons。 SConscript 文件被读取一次和一个 烤饼>>>
打印提示。 现在可以通过在交互式提示符下键入命令来重建目标
无需重新读取 SConscript 文件并重新初始化依赖关系图
从头开始。

SCons 交互模式支持以下命令：

建立[选项] [目标] ...
构建指定的 目标 （及其依赖项）具有指定的 SCons
命令行 配置. b 和 烤饼 是同义词。

以下 SCons 命令行选项会影响 建立 命令：

--cache-debug=文件
--缓存禁用，--无缓存
--cache-force，--cache-populate
--缓存只读
--缓存显示
--调试=类型
-i，--忽略错误
-j N, --jobs=N
-k, --继续
-n、--no-exec、--just-print、--dry-run、--recon
-Q
-s，--静音，--安静
--taskmastertrace=文件
--tree=选项

指定的任何其他 SCons 命令行选项不会导致错误，但具有
对 建立 命令（主要是因为它们会影响 SConscript 文件
被读取，这只会在交互模式开始时发生一次）。

清洁[选项] [目标] ...
清理指定的 目标 （及其依赖项）与指定的选项。
c 是同义词。 这个命令本身就是 建立 - 干净的

出口
退出 SCons 交互模式。 您也可以通过终止输入（CTRL+D on
UNIX 或 Linux 系统，Windows 系统上的 CTRL+Z）。

帮助[命令]
提供有关 SCons 交互模式中可用命令的帮助消息。 如果
指挥 被指定， h 和 ? 是同义词。

壳[命令行]
执行指定的 命令行 在一个子外壳中。 如果不 命令行 被指定，
执行指定的交互式命令解释器 SHELL 环境
变量（在 UNIX 和 Linux 系统上）或 康斯佩克 环境变量（在
Windows 系统）。 sh 和 ! 是同义词。

版本
打印 SCons 版本信息。

空行重复最后输入的命令。 可以使用命令行编辑，如果
的ReadLine 模块可用。

$ scons --交互式
scons：读取 SConscript 文件...
scons：完成读取 SConscript 文件。
scons>>> build -n prog
scons>>> 退出

-j N, --工作=N
指定要同时运行的作业（命令）数。 如果有超过
一种 -j 选项，最后一个有效。

-k, --继续
出错后尽可能继续。 失败的目标和那些
依赖它不会被重新制作，但在命令行中指定的其他目标将
还是要处理。

-m
忽略与非 GNU 版本的兼容性 使.

--最大漂移=SECONDS
将文件修改时间的最大预期漂移设置为 SECONDS。 这
value 确定文件在其缓存内容之前必须保持不变的时间
将使用签名而不是计算新的内容签名（MD5 校验和）
文件的内容。 默认值为 2 天，这意味着文件必须具有
至少两天前的修改时间，以便拥有其缓存的内容
使用的签名。 负值意味着从不缓存内容签名并
如果已经存在缓存值，则忽略缓存值。 值 0 表示始终使用
缓存签名，无论文件多旧。

--md5-块大小=千字节
将用于计算 MD5 签名的块大小设置为 千字节. 这个值决定
计算 MD5 签名时一次读入的块的大小。 文件
在执行签名计算之前，低于该大小将完全存储在内存中
而更大的文件是逐块读取的。 巨大的块大小导致高内存
消耗而非常小的块大小会大大减慢构建速度。

默认值是使用 64 KB 的块大小，这应该是合适的
对于大多数用途。

-n、--just-print、--dry-run、--recon
没有执行。 打印将被执行以构建任何过时目标的命令
文件，但不执行命令。

--无站点目录
防止自动添加标准 站点_scons 指向 系统路径。 也
防止加载 site_scons/site_init.py 模块（如果存在），并防止
添加他们的 site_scons/site_tools dirs 到刀具路径。

--个人资料=文件
在 Python profiler 下运行 SCons 并将结果保存在指定的 文件。 该
可以使用 Python pstats 模块分析结果。

-q, --问题
不要运行任何命令，也不要打印任何东西。 只需返回一个为零的退出状态，如果
指定的目标已经是最新的，否则为非零。

-Q
静默有关读取 SConscript 文件、构建目标和
进入目录。 执行重建目标文件的命令仍然是
打印。

- 随机的
以随机顺序构建依赖项。 这在构建多棵树时很有用
同时启用缓存，以防止同时进行多个构建
尝试构建或检索相同的目标文件。

-s，--静音，--安静
沉默的。不要打印为重建目标文件而执行的命令。还
抑制 SCons 状态消息。

-S，--不继续，--停止
忽略与 GNU 的兼容性 使.

--站点目录=DIR
使用命名目录作为站点目录而不是默认目录 站点_scons 目录。 这个目录
将被前置 系统路径，模块 DIR/site_init.py 将被加载，如果它
存在，并且 DIR/site_tools 将被添加到默认工具路径中。

默认设置的 站点_scons 目录何时使用 --站点目录 未指定取决于
系统平台，如下。 请注意，目录是按顺序检查的
给定，从最通用到最具体，所以最后执行的 site_init.py 文件是
最具体的一个（这使它有机会覆盖其他所有内容），以及
dirs 被添加到路径中，所以最后检查的目录首先出现在路径中
结果路径。

Windows上：

%ALLUSERSPROFILE/应用程序数据/scons/site_scons
%USERPROFILE%/本地设置/应用程序数据/scons/site_scons
%APPDATA%/scons/site_scons
%HOME%/.scons/site_scons
./site_scons

Mac OS X的：

/图书馆/应用程序支持/SCons/site_scons
/opt/local/share/scons/site_scons（对于 MacPorts）
/sw/share/scons/site_scons（对于 Fink）
$HOME/图书馆/应用程序支持/SCons/site_scons
$HOME/.scons/site_scons
./site_scons

Solaris：

/opt/sfw/scons/site_scons
/usr/share/scons/site_scons
$HOME/.scons/site_scons
./site_scons

Linux、HPUX 和其他类似 Posix 的系统：

/usr/share/scons/site_scons
$HOME/.scons/site_scons
./site_scons

--堆栈大小=千字节
将用于运行线程的大小堆栈设置为 千字节. 这个值决定了堆栈
用于运行作业的线程的大小。 这些是执行操作的线程
过时的节点的构建器。 注意这个选项没有
效果，除非 工作数量 对应于 -j 和 --jobs 的选项大于
一。 使用太小的堆栈大小可能会导致堆栈溢出错误。 这
通常显示为导致 scon 在构建之前中止的分段错误
任何事物。 使用太大的堆栈大小会导致 scons 使用更多内存
超出要求，可能会减慢整个构建过程。

默认值是使用 256 KB 的堆栈大小，这应该是合适的
对于大多数用途。 除非遇到堆栈，否则不需要增加此值
溢出错误。

-t，--触摸
忽略与 GNU 的兼容性 使. （触摸文件以使其显示为最新
使用时不需要 烤饼.)

--taskmastertrace=文件
将跟踪信息打印到指定的 文件 关于内部Taskmaster如何
object 评估和控制节点的构建顺序。 一个文件名 - 五月
用于指定标准输出。

-树=选项
在构建每个顶级目标后打印依赖关系树。 这打印
以各种格式取出部分或全部树，具体取决于 选项 指定的：

--tree=全部
在构建每个顶级目标后打印整个依赖树。这打印出来
完整的依赖树，包括隐式依赖和忽略
依赖性。

--tree=派生
将树输出限制为仅派生（目标）文件，而不是源文件。

--tree=状态
打印每个显示节点的状态信息。

--tree=修剪
修剪树以避免重复已经存在的节点的依赖信息
被显示。 任何已显示的节点都将打印其名称
[正方形 括号]，作为可以找到该节点的依赖项的指示
通过在树中搜索更高的相关输出。

可以指定多个选项，以逗号分隔：

# 仅打印派生文件，以及状态信息：
scons --tree=派生，状态

# 打印目标的所有依赖，以及状态信息
# 并修剪已访问节点的依赖项：
scons --tree=all,prune,status 目标

-u，--向上，--搜索-向上
向上走目录结构，直到 构造 , 构造 or 构建 文件
找到，并将其用作目录树的顶部。 如果没有指定目标
在命令行上，只会构建位于或低于当前目录的目标。

-U
工作方式与 -u 除了默认目标的方式之外的选项
处理。 当使用此选项且命令行上未指定目标时，
当前目录的 SConscript(s) 中定义的所有默认目标都是
构建，无论结果目标最终位于哪个目录。

-v，--版本
打印 烤饼 版本、版权信息、作者列表和任何其他
相关信息。 然后退出。

-w，--打印目录
在其他处理之前和之后打印包含工作目录的消息。

--无打印目录
关闭 -w，即使它是隐式开启的。

--警告=类型, --警告=否-类型
启用或禁用警告。 类型 指定要启用的警告类型或
禁用：

--warn=全部, --warn=全部
启用或禁用所有警告。

--warn=cache-write-error，--warn=no-cache-write-error
启用或禁用有关尝试将构建文件的副本写入到
指定 缓存目录(). 默认情况下禁用这些警告。

--warn=corrupt-sconsign，--warn=no-corrupt-sconsign
启用或禁用有关不熟悉的签名数据的警告 .sconsign 文件。 这些
默认情况下启用警告。

--warn=依赖，--warn=无依赖
启用或禁用有关依赖项的警告。 这些警告被禁用
默认。

--warn=不推荐使用，--warn=不推荐使用
启用或禁用有关使用当前已弃用功能的所有警告。 这些
默认情况下启用警告。 请注意， --warn=不弃用 选项不
禁用有关绝对所有已弃用功能的警告。 对某些人的警告
已弃用多个版本的已弃用功能
在正式不再发布之前，警告可能是强制性的
由 SCons 支持。 某些特定弃用功能的警告可能已启用或
单独禁用； 见下文。

--warn=deprecated-copy，--warn=no-deprecated-copy
启用或禁用有关使用已弃用的警告 环境复制（） 方法。

--warn=deprecated-source-signatures，--warn=no-deprecated-source-signatures
启用或禁用有关使用已弃用的警告 源签名()
功能或 env.SourceSignatures() 方法。

--warn=deprecated-target-signatures，--warn=no-deprecated-target-signatures
启用或禁用有关使用已弃用的警告 目标签名()
功能或 env.TargetSignatures() 方法。

--warn=重复环境，--warn=无重复环境
启用或禁用有关尝试指定具有两个目标的构建的警告
使用相同动作的不同构造环境。 这些警告是
默认启用。

--warn=fortran-cxx-mix，--warn=no-fortran-cxx-mix
启用或禁用有关链接 Fortran 和 C++ 对象文件的特定警告
单个可执行文件，这可能会导致某些编译器出现不可预测的行为。

--warn=未来不推荐使用，--warn=未来不推荐使用
启用或禁用有关将来不推荐使用的功能的警告。
默认情况下禁用这些警告。 启用此警告特别是
推荐用于为其他用户重新分发 SCons 配置的项目
构建，以便可以尽快警告项目即将弃用
可能需要更改配置的功能。

--warn=链接，--warn=无链接
启用或禁用有关链接步骤的警告。

--warn=误导性关键字，--warn=no-misleading-keywords
启用或禁用有关使用拼写错误的关键字的警告 目标 和 来源
调用 Builders 时。 （注意最后 s 字符，正确的拼写是 目标
和 来源。） 默认情况下启用这些警告。

--warn=missing-sconscript，--warn=no-missing-sconscript
启用或禁用有关丢失 SConscript 文件的警告。 这些警告是
默认启用。

--warn=no-md5-module，--warn=no-no-md5-module
启用或禁用有关没有 MD5 校验和的 Python 版本的警告
模块可用。 默认情况下启用这些警告。

--warn=no-metaclass-support，--warn=no-no-metaclass-support
启用或禁用有关不支持元类的 Python 版本的警告
当 --调试=记忆器 选项被使用。 默认情况下启用这些警告。

--warn=无对象计数, --warn=无对象计数
启用或禁用有关 --调试=对象 功能不工作时 烤饼
与 python 一起运行 -O 选项或来自优化的 Python (.pyo) 模块。

--warn=无并行支持, --warn=无并行支持
启用或禁用有关无法支持的 Python 版本的警告
并行构建时 -j 选项被使用。 默认情况下启用这些警告。

--warn=python 版本，--warn=no-python 版本
启用或禁用有关使用不推荐使用的版本运行 SCons 的警告
Python。 默认情况下启用这些警告。

--warn=保留变量，--warn=无保留变量
启用或禁用有关尝试设置保留构造变量的警告
名称 已更改来源, CHANGED_TARGETS 目标, TARGET, 目标, 源, 来源,
未更改_来源 or UNCHANGED_TARGETS 目标. 默认情况下禁用这些警告。

--warn=堆栈大小，--warn=无堆栈大小
启用或禁用有关无法设置堆栈大小的请求的警告
荣幸。 默认情况下启用这些警告。

--warn=target_not_build，--warn=no-target_not_built
启用或禁用有关未构建预期目标的构建规则的警告。
默认情况下，当前未启用这些警告。

-Y 知识库, --存储库=知识库, --源目录=知识库
在指定的存储库中搜索本地未找到的任何输入和目标文件
目录层次结构。 多种的 -Y 可以指定选项，在这种情况下
存储库按指定的顺序搜索。

配置 文件 参考

建筑业 环境
构建环境是 SConscript 文件通信的基本方式
建立信息 烤饼. 一个新的施工环境是使用
环境 功能：

环境 = 环境（）

变量，称为 结构 变量, 也可以在构建环境中设置
通过在创建对象时将它们指定为关键字或为它们分配一个值
创建对象后：

环境 = 环境（FOO = 'foo'）
env['BAR'] = 'bar'

为方便起见，构造变量也可以由 解析标志
关键字参数，适用于 解析标志 方法（如下所述）到参数
所有其他处理完成后的值。 如果确切的内容，这很有用
标志的数量未知（例如，从控制文件中读取）或者标志是否为
分布到多个构造变量。

env = Environment(parse_flags = '-Iinclude -DEBUG -lm')

此示例将“包含”添加到 路径, 'EBUG' 到 CPP定义, 和 'm' 到 LIBS.

默认情况下，使用一组构建器方法初始化新的构建环境
和适合当前平台的构造变量。 一个可选的
平台关键字参数可用于指定应初始化环境
对于不同的平台：

环境 = 环境（平台 = 'cygwin'）
env = 环境（平台 = 'os2'）
环境 = 环境（平台 = 'posix'）
env = 环境（平台 = 'win32'）

指定平台会在
使用和生成带有前缀和后缀的文件名的环境
平台。

请注意 win32 平台添加了 系统驱动 和 系统根 来自用户的变量
外部环境对施工环境的影响 ENV 字典。 这是为了使任何
执行使用套接字与其他系统连接的命令（例如获取源
来自外部 CVS 存储库规范的文件，例如
：服务器：[email protected]：/cvsroot/scons) 将适用于 Windows 系统。

平台参数可以是函数或可调用对象，在这种情况下 Environment()
方法将调用指定的参数来更新新的构建环境：

定义我的平台（环境）：
env['VAR'] = 'xyzzy'

env = 环境（平台 = my_platform）

此外，可以使用一组特定的工具来初始化环境
指定为可选关键字参数：

env = 环境（工具 = ['msvc', 'lex']）

可以使用 toolpath 参数指定非内置工具：

env = Environment(tools = ['default', 'foo'], toolpath = ['tools'])

这将在 tools/foo.py 中查找工具规范（以及使用普通默认值
平台的工具）。 foo.py 应该有两个函数： generate(env, **kw) 和
存在（环境）。 这 产生（） 函数修改传入的环境来设置
变量，以便可以执行该工具； 它可以使用用户认为的任何关键字参数
供应（见下文）以改变其初始化。 这 存在（） 函数应该返回一个
如果工具可用，则为真值。 刀具路径中的刀具在任何
内置的。 例如，将 gcc.py 添加到工具路径将覆盖内置的 gcc
工具。 另请注意，刀具路径存储在环境中供以后调用使用
克隆（）和 工具（） 方法：

基础 = 环境（工具路径 = ['custom_path']）
派生 = base.Clone(tools=['custom_tool'])
派生.CustomBuilder()

工具列表的元素也可能是函数或可调用对象，在这种情况下
Environment() 方法将调用指定的元素来更新新的构造
环境：

def my_tool（环境）：
env['XYZZY'] = 'xyzzy'

env = 环境（工具 = [my_tool]）

工具列表的各个元素本身也可以是两个元素的列表
表格（工具名, kw_字典）。 SCons 搜索 工具名 描述的规范文件
以上，并通过 kw_字典，它必须是一个字典，作为工具的关键字参数
生成 功能。 的 生成 函数可以使用参数来修改工具的
通过以不同方式设置环境或以其他方式改变其行为
初始化。

# 在工具/my_tool.py 中：
定义生成（环境，**kw）：
# 将 MY_TOOL 设置为关键字参数 'arg1' 或 1 的值。
env['MY_TOOL'] = kw.get('arg1', '1')
定义存在（环境）：
返回1

# 在 SConstruct 中：
env = Environment(tools = ['default', ('my_tool', {'arg1': 'abc'})],
工具路径=['工具'])

工具定义（即 my_tool()）可以使用它所在环境的 PLATFORM 变量
接收为不同平台定制工具。

如果未指定工具列表，则 SCons 将使用
ENV构建变量中的PATH变量和Environment时的平台名称
被构建。 构建环境后更改 PATH 变量不会
导致工具被重新检测。

SCons 支持以下开箱即用的工具规范：

386asm
为嵌入 Phar Lap ETS 的 386ASM 汇编器设置构造变量
操作系统。

集： $AS, $ASCOM, $ASFLAGS, $ASPPCOM, $ASPPFLAGS.

用途： $抄送, $CPPFLAGS, $_CPPDEFFLAGS, $_CPPINCFLAGS.

aixc++
为 IMB xlc / Visual Age C++ 编译器设置构造变量。

集： $CXX, $CXX版本, $SHCXX, $SHOBJ后缀.

艾克斯
为 IBM xlc / Visual Age C 编译器设置构造变量。

集： $抄送, $CC版本, $SHCC.

爱克斯夫77
为 IBM Visual Age f77 Fortran 编译器设置构造变量。

集： $77, 77 美元.

艾克斯链接
为 IBM Visual Age 链接器设置构造变量。

集： $LINKFLAGS, $SHLIB后缀, $SHLINKFLAGS.

苹果链接
设置 Apple 链接器的构造变量（类似于 GNU 链接器）。

集： $框架路径前缀, $LDMODULECOM, $LD 模块标志, $LDMODULE前缀,
$LD模块后缀, $LINKCOM, $上海联通, $SHLINKFLAGS, $_FRAMEWORKPATH, $_框架.

用途： $FRAMEWORKFLAGS.

ar
为 ar 库归档器设置构造变量。

集： $AR, $阿康, $ARFLAGS, $LIBPREFIX, $LIBSFFIX, $RANLIB, $RANLIBCOM,
$RANLIBF标志.

as
为 as 汇编程序设置构造变量。

集： $AS, $ASCOM, $ASFLAGS, $ASPPCOM, $ASPPFLAGS.

用途： $抄送, $CPPFLAGS, $_CPPDEFFLAGS, $_CPPINCFLAGS.

密件抄送32
为 bcc32 编译器设置构造变量。

集： $抄送, $CCCOM, $CCFLAGS, $C文件后缀, $CFLAGS, $CPPDEFPREFIX, $CPPDEF后缀,
$INC前缀, $INC后缀, $SHCC, $上海商会, $SHCCFLAGS, $SHCFLAGS, $SHOBJ后缀.

用途： $_CPPDEFFLAGS, $_CPPINCFLAGS.

BitKeeper的
为 BitKeeper 源代码控制系统设置构造变量。

集： $比特币, $BIKEEPERCOM, $BitKEEPERGET, $BitKeePERGETFLAGS.

用途： $BitKeeperCOMSTR.

cc
为通用 POSIX C copmilers 设置构造变量。

集： $抄送, $CCCOM, $CCFLAGS, $C文件后缀, $CFLAGS, $CPPDEFPREFIX, $CPPDEF后缀,
$框架路径, $框架, $INC前缀, $INC后缀, $SHCC, $上海商会, $SHCCFLAGS,
$SHCFLAGS, $SHOBJ后缀.

用途： $平台.

心肺功能
为 Compaq Visual Fortran 编译器设置构造变量。

集： $FORTRAN 语言, $Fortrancom, $FORTRANMODDIR, $FORTRANMODDIR前缀,
$FORTRANMOD目录后缀, $FORTRANPPCOM, $OBJ后缀, $SHFORTRANCOM, $SHFORTRANPPCOM.

用途： $CPPFLAGS, $FORTRAFLAGS, $SHFORTRAFLAGS, $_CPPDEFFLAGS, $_FORTRANINCFLAGS,
$_FORTRANMODFLAG.

CVS
为 CVS 源代码管理系统设置构造变量。

集： $ CVS, $CVSCOFLAGS, $CVSCOM, $CVSFLAGS.

用途： $CVSCOMSTR.

XX
为通用 POSIX C++ 编译器设置构造变量。

集： $CPPDEFPREFIX, $CPPDEF后缀, $CXX, $CXXCOM, $CXX 文件后缀, $CXXFLAGS,
$INC前缀, $INC后缀, $OBJ后缀, $SHCXX, $SHCXXCOM, $SHCXXFLAGS, $SHOBJ后缀.

用途： $CXXCOMSTR.

链接
为 cygwin 链接器/加载器设置构造变量。

集： $IMPLIBPREFIX, $IMPLIB后缀, $LDMODULERIONFLAGS, $LINKFLAGS, $RPATH前缀,
$RPATH后缀, $SHLIBPREFIX, $SHLIB后缀, $SHLIB版本标志, $上海联通,
$SHLINKFLAGS, $_LDMODULEVERSIONFLAGS, $_SHLIBVERSIONFLAGS.

默认
通过调用平台的默认工具模块列表来设置变量
SCons 正在运行。

DMD
为 D 语言编译器 DMD 设置构造变量。

集： $DC, $DCOM, $DDBUG, $DDEBGPREFIX, $DDBUGSUFFIX, $D文件后缀, $DFLAGPREFIX,
$DFLAGS, $DFLAG后缀, $DINC前缀, $DINCSFFIX, $DLIB, $DLIBCOM, $DLIBDIR前缀,
$DLIB目录后缀, $DLIBFLAGPREFIX, $DLIBFLAG后缀, $DLIBLINK前缀, $DLIB链接后缀,
$DLINK, $DLINKCOM, $DLINKFLAGS, $路径, $DVER前缀, $版本, $DVER后缀,
$RPATH前缀, $RPATH后缀, $SHDC, $SHDCOM, $SHDLINK, $SHDLINKCOM, $SHDLINKFLAGS,
$_DDEBUGFLAGS, $_DFLAGS, $_DINCFLAGS, $_DLIBDIRFLAGS, $_DLIBFLAGS, $_DLIBFLAGS,
$_DVERFLAGS, $_RPATH.

文档书
这个工具试图让在 SCons 中使用 Docbook 更容易一些。它提供
用于创建不同输出格式的几个工具链，如 HTML 或 PDF。 包含
包中是 1.76.1 版 Docbook XSL 样式表的分发版。
只要不指定自定义样式表，这些官方
版本被选择为默认......这应该减少不可避免的设置麻烦
你。

如果您遇到以下情况，将自动检测对图像和 XIncludes 的隐式依赖
HTML 要求。 Paul DuBois 的附加样式表 utils/xmldepend.xsl 是
用于此目的。

请注意，不提供对 XML 目录解析的支持！ 该工具调用
XSLT 处理器和带有您指定的样式表的 PDF 渲染器，就是这样。 这
休息在你的手中，你在解决的时候仍然需要知道你在做什么
通过目录命名。

要激活工具“docbook”，您必须将其名称添加到环境中
构造函数，像这样

env = 环境（工具=['docbook']）

在启动时，Docbook 工具会尝试查找所需的 xsltproc 处理器，以及一个
PDF 渲染器，例如 fop。 因此，请确保将这些添加到您的系统的
环境 PATH 可以直接调用，无需指定其完整路径。

对于Docbook转HTML最基本的处理，你需要已经安装

· Python lxml 绑定到 libxml2，或

· libxml2/libxslt 的直接 Python 绑定，或

· 一个独立的 XSLT 处理器，目前检测到的有 xsltproc、saxon、saxon-xslt
和夏兰。

渲染为 PDF 要求您安装 fop 或 xep 应用程序之一。

创建 HTML 或 PDF 文档非常简单明了。 说

env = 环境（工具=['docbook']）
env.DocbookHtml('manual.html', 'manual.xml')
env.DocbookPdf('manual.pdf', 'manual.xml')

从您的 XML 源 manual.xml 中获取两个输出。 作为快捷方式，您可以将
仅文件名的词干，如下所示：

env = 环境（工具=['docbook']）
env.DocbookHtml('手册')
env.DocbookPdf('手册')

并得到相同的结果。 还支持目标和源列表：

env = 环境（工具=['docbook']）
env.DocbookHtml(['manual.html','reference.html'], ['manual.xml','reference.xml'])

甚至

env = 环境（工具=['docbook']）
env.DocbookHtml(['manual','reference'])

重要提示
每当您遗漏源列表时，您可能不会指定文件扩展名！
该工具使用给定的名称作为文件词干，并为目标和
相应的源文件。
以上规则对建设者有效 文档Html, Docbook.pdf, 文档电子书,
Docbook幻灯片Pdf 和 DocbookX包含。 对于 文档人 转型你可以
指定一个目标名称，但实际的输出名称是从
XML 源中的 refname 条目。

建筑商 DocbookHtml分块, DocbookHtml帮助 和 文档幻灯片Html 很特别，在
说：

1. 他们创建了大量文件，其中确切的名称和数量取决于
源文件的内容，以及

2.主要目标总是命名为index.html，即XSL的输出名称
样式表不会选择转换。

因此，指定目标 HTML 名称根本没有用。 所以基本的
这些构建器的语法始终是：

env = 环境（工具=['docbook']）
env.DocbookHtmlhelp('手册')

如果要使用特定的 XSL 文件，可以将附加的 xsl 参数设置为
您的 Builder 调用如下：

env.DocbookHtml('other.html', 'manual.xml', xsl='html.xsl')

因为如果您总是为您的自定义命名使用相同的本地命名，这可能会变得乏味
XSL 文件，例如用于 HTML 的 html.xsl 和用于 PDF 输出的 pdf.xsl，一组变量用于
提供了设置默认 XSL 名称。 这些是：

DOCBOOK_DEFAULT_XSL_HTML
DOCBOOK_DEFAULT_XSL_HTMLCHUNKED
DOCBOOK_DEFAULT_XSL_HTMLHELP
DOCBOOK_DEFAULT_XSL_PDF
DOCBOOK_DEFAULT_XSL_EPUB
DOCBOOK_DEFAULT_XSL_MAN
DOCBOOK_DEFAULT_XSL_幻灯片PDF
DOCBOOK_DEFAULT_XSL_SLIDESHTML

您可以在构建环境时设置它们：

env = Environment(工具=['docbook'],
DOCBOOK_DEFAULT_XSL_HTML='html.xsl',
DOCBOOK_DEFAULT_XSL_PDF='pdf.xsl')
env.DocbookHtml('manual') # 现在使用 html.xsl

集： $DOCBOOK_DEFAULT_XSL_EPUB, $DOCBOOK_DEFAULT_XSL_HTML,
$DOCBOOK_DEFAULT_XSL_HTMLCHUNKED, $DOCBOOK_DEFAULT_XSL_HTMLHELP,
$DOCBOOK_DEFAULT_XSL_MAN, $DOCBOOK_DEFAULT_XSL_PDF, $DOCBOOK_DEFAULT_XSL_SLIDESHTML,
$DOCBOOK_DEFAULT_XSL_SLIDESPDF, $DOCBOOK_FOP, $DOCBOOK_FOPCOM, $DOCBOOK_FOPFLAGS,
$DOCBOOK_XMLLINT, $DOCBOOK_XMLLINTCOM, $DOCBOOK_XMLLINTFLAGS, $DOCBOOK_XSLTPROC,
$DOCBOOK_XSLTPROCCOM, $DOCBOOK_XSLTPROCFLAGS, $DOCBOOK_XSLTPROCPARAMS.

用途： $DOCBOOK_FOPCOMSTR, $DOCBOOK_XMLLINTCOMSTR, $DOCBOOK_XSLTPROCCOMSTR.

DVI
附上 DVI接口 builder 到施工环境。

DVIPDF
为 dvipdf 实用程序设置构造变量。

集： $DVIPDF, $DVIPDFCOM, $DVIPDFFLAGS.

用途： $DVIPDFCOMSTR.

会员
为 dvips 实用程序设置构造变量。

集： $DVIPS, $DVIPSFLAGS, $PSCOM, $PS前缀, $PS后缀.

用途： $PSCOMSTR.

f03
为通用 POSIX Fortran 03 编译器设置构造变量。

集： $03, $F03COM, $F03标志, $F03PPCOM, 03 美元, $SHF03COM, $SHF03标志,
$SHF03PPCOM, $_F03INCFLAGS.

用途： $F03COMSTR, $F03PPCOMSTR, $SHF03COMSTR, $SHF03PPCOMSTR.

f08
为通用 POSIX Fortran 08 编译器设置构造变量。

集： $08, $F08COM, $F08标志, $F08PPCOM, 08 美元, $SHF08COM, $SHF08标志,
$SHF08PPCOM, $_F08INCFLAGS.

用途： $F08COMSTR, $F08PPCOMSTR, $SHF08COMSTR, $SHF08PPCOMSTR.

f77
为通用 POSIX Fortran 77 编译器设置构造变量。

集： $77, $F77COM, $F77文件后缀, $F77标志, $F77PPCOM, $F77PP文件后缀,
$FORTRAN 语言, $Fortrancom, $FORTRAFLAGS, 77 美元, $SHF77COM, $SHF77标志, $SHF77PPCOM,
$SHFORTRAN, $SHFORTRANCOM, $SHFORTRAFLAGS, $SHFORTRANPPCOM, $_F77INCFLAGS.

用途： $F77COMSTR, $F77PPCOMSTR, $FORTRANCOMSTR, $FORTRANPPCOMSTR, $SHF77COMSTR,
$SHF77PPCOMSTR, $SHFORTRANCOMSTR, $SHFORTRANPPCOMSTR.

f90
为通用 POSIX Fortran 90 编译器设置构造变量。

集： $90, $F90COM, $F90标志, $F90PPCOM, 90 美元, $SHF90COM, $SHF90标志,
$SHF90PPCOM, $_F90INCFLAGS.

用途： $F90COMSTR, $F90PPCOMSTR, $SHF90COMSTR, $SHF90PPCOMSTR.

f95
为通用 POSIX Fortran 95 编译器设置构造变量。

集： $95, $F95COM, $F95标志, $F95PPCOM, 95 美元, $SHF95COM, $SHF95标志,
$SHF95PPCOM, $_F95INCFLAGS.

用途： $F95COMSTR, $F95PPCOMSTR, $SHF95COMSTR, $SHF95PPCOMSTR.

FORTRAN
为通用 POSIX Fortran 编译器设置构造变量。

集： $FORTRAN 语言, $Fortrancom, $FORTRAFLAGS, $SHFORTRAN, $SHFORTRANCOM,
$SHFORTRAFLAGS, $SHFORTRANPPCOM.

用途： $FORTRANCOMSTR, $FORTRANPPCOMSTR, $SHFORTRANCOMSTR, $SHFORTRANPPCOMSTR.

克++
为 gXX C++ 编译器设置构造变量。

集： $CXX, $CXX版本, $SHCXXFLAGS, $SHOBJ后缀.

g77
为 g77 Fortran 编译器设置构造变量。 调用 f77 工具模块
设置变量。

气
设置气体组装器的构造变量。 调用 as 模块。

集： $AS.

GCC
为 gcc C 编译器设置构造变量。

集： $抄送, $CC版本, $SHCCFLAGS.

GDC
为 D 语言编译器 GDC 设置构造变量。

集： $DC, $DCOM, $DDBUG, $DDEBGPREFIX, $DDBUGSUFFIX, $D文件后缀, $DFLAGPREFIX,
$DFLAGS, $DFLAG后缀, $DINC前缀, $DINCSFFIX, $DLIB, $DLIBCOM, $DLIBFLAGPREFIX,
$DLIBFLAG后缀, $DLINK, $DLINKCOM, $DLINKFLAGPREFIX, $DLINKFLAGS, $DLINK标志后缀,
$路径, $DVER前缀, $版本, $DVER后缀, $RPATH前缀, $RPATH后缀, $SHDC,
$SHDCOM, $SHDLINK, $SHDLINKCOM, $SHDLINKFLAGS, $_DDEBUGFLAGS, $_DFLAGS, $_DINCFLAGS,
$_DLIBFLAGS, $_DVERFLAGS, $_RPATH.

gettext的
这实际上是一个工具集，支持国际化和本地化
使用 SCons 构建的软件。 该工具集加载以下工具：

· xgettext - 从源代码中提取国际化消息到 POT 文件，

· msginit - 可以选择性地用于初始化 PO 文件，

· msgmerge - 更新已包含翻译消息的 PO 文件，

· msgfmt - 将文本 PO 文件编译为二进制可安装 MO 文件。

当您启用 gettext 时，它会在内部加载所有上述工具，因此您
鼓励查看他们的个人文档。

上述每个工具都提供了自己的构建器，可用于执行
与软件国际化相关的特定活动。 然而你可能
兴趣 顶级 建设者 翻译 稍后描述几段。

要使用 gettext 工具，请将“gettext”工具添加到您的环境中：

env = 环境（工具 = ['默认'，'gettext']）

gfortran
为 GNU F95/F2003 GNU 编译器设置构造变量。

集： $77, $90, $95, $FORTRAN 语言, 77 美元, $SHF77标志, 90 美元, $SHF90标志, 95 美元,
$SHF95标志, $SHFORTRAN, $SHFORTRAFLAGS.

链接
为 GNU 链接器/加载器设置构造变量。

集： $LDMODULERIONFLAGS, $RPATH前缀, $RPATH后缀, $SHLIB版本标志,
$SHLINKFLAGS, $_LDMODULESONAME, $_SHLIBSONAME.

gs
此工具设置使用 Ghostscript 所需的构造变量
命令。 它还向 PDF Builder (PDF），这样
对于 TeX/LaTeX 工具链，从 PS/EPS 到 PDF 的转换会自动发生。
最后，它添加了一个显式的 Ghostscript Builder (Gs) 环境。

集： GS $, $GSCOM, $GSFLAGS.

用途： $GSCOMSTR.

高性能计算++
为 HP/UX 系统上的编译器 aCC 设置构造变量。

高压电
为 HP/UX 系统上的 aCC 设置构造变量。 调用 cXX 工具
附加变量。

集： $CXX, $CXX版本, $SHCXXFLAGS.

链接
为 HP/UX 系统上的链接器设置构造变量。

集： $LINKFLAGS, $SHLIB后缀, $SHLINKFLAGS.

ICC
为 OS/2 系统上的 icc 编译器设置构造变量。

集： $抄送, $CCCOM, $C文件后缀, $CPPDEFPREFIX, $CPPDEF后缀, $CXXCOM,
$CXX 文件后缀, $INC前缀, $INC后缀.

用途： $CCFLAGS, $CFLAGS, $CPPFLAGS, $_CPPDEFFLAGS, $_CPPINCFLAGS.

ICL
为英特尔 C/C++ 编译器设置构造变量。 调用 intelc Tool 模块
设置其变量。

国际金融联盟
为英特尔 Fortran 编译器设置构造变量。

集： $FORTRAN 语言, $Fortrancom, $FORTRANPPCOM, $SHFORTRANCOM, $SHFORTRANPPCOM.

用途： $CPPFLAGS, $FORTRAFLAGS, $_CPPDEFFLAGS, $_FORTRANINCFLAGS.

堡垒
为较新版本的 Intel Fortran 编译器设置构造变量
Linux操作系统。

集： $77, $90, $95, $FORTRAN 语言, 77 美元, $SHF77标志, 90 美元, $SHF90标志, 95 美元,
$SHF95标志, $SHFORTRAN, $SHFORTRAFLAGS.

ILINK
为 OS/2 系统上的 ilink 链接器设置构造变量。

集： $LIBDIRP前缀, $库目录后缀, $LIBLINK前缀, $LIBLINK后缀, $ LINK, $LINKCOM,
$LINKFLAGS.

链接32
为 Borland ilink32 链接器设置构造变量。

集： $LIBDIRP前缀, $库目录后缀, $LIBLINK前缀, $LIBLINK后缀, $ LINK, $LINKCOM,
$LINKFLAGS.

安装
为文件和目录安装设置构造变量。

集： $安装, $安装字符串.

智能
为英特尔 C/C++ 编译器（Linux 和 Windows，版本 7）设置构造变量
然后）。 调用 gcc 或 msvc（分别在 Linux 和 Windows 上）来设置
基础变量。

集： $AR, $抄送, $CXX, $INTEL_C_COMPILER_VERSION, $ LINK.

罐
为 jar 实用程序设置构造变量。

集： $罐子, $JARCOM, $罐子旗, $JAR后缀.

用途： $JARCOMSTR.

Java语言
为 javac 编译器设置构造变量。

集： $Java引导类路径, $JAVAC, $JAVACCOM, $JavaCFLAGS, $JAVACCLASSPATH,
$JAVACLASS后缀, $Java源路径, $Java后缀.

用途： $JAVACCOMSTR.

爪哇
为 javah 工具设置构造变量。

集： $JAVACLASS后缀, $JAVAH, $JAVAHCOM, $JAVAHF标志.

用途： $JAVACCLASSPATH, $JavaHCOMSTR.

胶乳
为 Latex 实用程序设置构造变量。

集： $乳胶, $LATEXCOM, $LATEXFLAGS.

用途： $LATEXCOMSTR.

最不发达国家
为 D 语言编译器 LDC2 设置构造变量。

集： $DC, $DCOM, $DDBUG, $DDEBGPREFIX, $DDBUGSUFFIX, $D文件后缀, $DFLAGPREFIX,
$DFLAGS, $DFLAG后缀, $DINC前缀, $DINCSFFIX, $DLIB, $DLIBCOM, $DLIBDIR前缀,
$DLIB目录后缀, $DLIBFLAGPREFIX, $DLIBFLAG后缀, $DLIBLINK前缀, $DLIB链接后缀,
$DLINK, $DLINKCOM, $DLINKFLAGPREFIX, $DLINKFLAGS, $DLINK标志后缀, $路径,
$DVER前缀, $版本, $DVER后缀, $RPATH前缀, $RPATH后缀, $SHDC, $SHDCOM,
$SHDLINK, $SHDLINKCOM, $SHDLINKFLAGS, $_DDEBUGFLAGS, $_DFLAGS, $_DINCFLAGS,
$_DLIBDIRFLAGS, $_DLIBFLAGS, $_DLIBFLAGS, $_DVERFLAGS, $_RPATH.

法
为 lex 词法分析器设置构造变量。

集： $LEX, $莱克斯康, $LEXFLAGS.

用途： $莱克斯康斯特.

链接
为通用 POSIX 链接器设置构造变量。

集： $LD模块, $LDMODULECOM, $LD 模块标志, $LD模块转换符号链接,
$LDMODULE前缀, $LD模块后缀, $LDMODULEVERSION, $LDMODULERIONFLAGS,
$LIBDIRP前缀, $库目录后缀, $LIBLINK前缀, $LIBLINK后缀, $ LINK, $LINKCOM,
$LINKFLAGS, $SHLIB后缀, $SHLINK, $上海联通, $SHLINKFLAGS, $__LDMODULVERSIONFLAGS,
$__SHLIB版本标志.

用途： $LDMODULECOMSTR, $LINKCOMSTR, $SHLINKCOMSTR.

链接位置
为嵌入的 Phar Lap ETS 的 LinkLoc 链接器设置构造变量
操作系统。

集： $LIBDIRP前缀, $库目录后缀, $LIBLINK前缀, $LIBLINK后缀, $ LINK, $LINKCOM,
$LINKFLAGS, $SHLINK, $上海联通, $SHLINKFLAGS.

用途： $LINKCOMSTR, $SHLINKCOMSTR.

m4
为 m4 宏处理器设置构造变量。

集： 4 美元, $M4COM, $M4FLAGS.

用途： $M4COMSTR.

MASM
为 Microsoft 汇编程序设置构造变量。

集： $AS, $ASCOM, $ASFLAGS, $ASPPCOM, $ASPPFLAGS.

用途： $ASCOMSTR, $ASPPCOMSTR, $CPPFLAGS, $_CPPDEFFLAGS, $_CPPINCFLAGS.

中
为 Microsoft IDL 编译器设置构造变量。

集： $MIDL, $MIDLCOM, $中旗.

用途： $MIDLCOMSTR.

明威
为 MinGW（Windows 上的最小 Gnu）设置构造变量。

集： $AS, $抄送, $CXX, $LDMODULECOM, $LIBPREFIX, $LIBSFFIX, $OBJ后缀, $RC, $RCCOM,
$RCFLAGS, $RCINCFLAGS, $RCINCPREFIX, $RCINC后缀, $SHCCFLAGS, $SHCXXFLAGS,
$上海联通, $SHLINKFLAGS, $SHOBJ后缀, $WINDOWSDEFPREFIX, $WINDOWSDEF后缀.

用途： $RCCOMSTR, $SHLINKCOMSTR.

消息文件
这个 scons 工具是 scons gettext 工具集的一部分。 它提供了 scons 接口
消息文件(1) 命令，它从文本生成二进制消息目录 (MO)
翻译说明 (PO)。

集： $MOS后缀, $MSGFMT, $MSGFMTCOM, $MSGFMTCOMSTR, $MSGFMTFLAGS, $后缀.

用途： $LINGUAS_FILE.

消息初始化
这个 scons 工具是 scons gettext 工具集的一部分。 它提供了 scons 接口
消息初始化(1) 程序，它创建新的 PO 文件，用
来自用户环境（或选项）的值。

集： $MSGINIT, $MSGINITCOM, $MSGINITCOMSTR, $MSGINITFLAGS, $POAUTOINIT,
$POCREATE_ALIAS, $后缀, $锅后缀, $_MSGINITLOCAL.

用途： $LINGUAS_FILE, $POAUTOINIT, $POTOMAIN.

消息合并
这个 scons 工具是 scons gettext 工具集的一部分。 它提供了 scons 接口
消息合并(1) 命令，将两个统一样式的 .po 文件合并在一起。

集： $MSGMERGE, $MSGMERGECOM, $MSGMERGECOMSTR, $MSGMERGEFLAGS, $后缀, $锅后缀,
$POUPDATE_ALIAS.

用途： $LINGUAS_FILE, $POAUTOINIT, $POTOMAIN.

微软库
为 Microsoft mslib 库归档程序设置构造变量。

集： $AR, $阿康, $ARFLAGS, $LIBPREFIX, $LIBSFFIX.

用途： $ARCOMSTR.

mslink
为 Microsoft 链接器设置构造变量。

集： $LD模块, $LDMODULECOM, $LD 模块标志, $LDMODULE前缀, $LD模块后缀,
$LIBDIRP前缀, $库目录后缀, $LIBLINK前缀, $LIBLINK后缀, $ LINK, $LINKCOM,
$LINKFLAGS, $REGSVR, $REGSVRCOM, $REGSVFLAGS, $SHLINK, $上海联通, $SHLINKFLAGS,
$WIN32DEFPREFIX, $WIN32DEF后缀, $WIN32EXPREFIX, $WIN32EXP后缀, $WINDOWSDEFPREFIX,
$WINDOWSDEF后缀, $WINDOWSEXPREFIX, $WINDOWSEXP后缀, $WINDOWSPROGMANIFEST前缀,
$WINDOWSPROGMANIFEST后缀, $WINDOWSSHLIBMANIFEST前缀, $WINDOWSSHIBMANIFESTSUFFIX,
$WINDOWS_INSERT_DEF.

用途： $LDMODULECOMSTR, $LINKCOMSTR, $REGSVRCOMSTR, $SHLINKCOMSTR.

微软SDK
为 Microsoft Platform SDK 和/或 Windows SDK 设置变量。 请注意，与大多数
其他工具模块，mssdk 不设置构造变量，而是设置
环境 变量 在 SCons 用来执行 Microsoft
工具链：%INCLUDE%、%LIB%、%LIBPATH% 和 %PATH%。

用途： $MSSDK_DIR, $MSSDK_VERSION, $MSVS_VERSION.

微信
为 Microsoft Visual C/C++ 编译器设置构造变量。

集： $建造者, $抄送, $CCCOM, $CCFLAGS, $CCPCHFLAGS, $CCPDBFLAGS, $C文件后缀,
$CFLAGS, $CPPDEFPREFIX, $CPPDEF后缀, $CXX, $CXXCOM, $CXX 文件后缀, $CXXFLAGS,
$INC前缀, $INC后缀, $OBJ前缀, $OBJ后缀, $PCHCOM, $PCHPDBFLAGS, $RC, $RCCOM,
$RCFLAGS, $SHCC, $上海商会, $SHCCFLAGS, $SHCFLAGS, $SHCXX, $SHCXXCOM, $SHCXXFLAGS,
$SHOBJ前缀, $SHOBJ后缀.

用途： $CCCOMSTR, $CXXCOMSTR, $PCH, $PCH停止, $PDB, $SHCCCOMSTR, $SHCXXCOMSTR.

微博
为 Microsoft Visual Studio 设置构造变量。

集： $MSVSBUILDCOM, $MSVSCleanCOM, $MSVS编码, $MSVSPROJECTCOM, $MSVSREBUILDCOM,
$MSVSSCONS, $MSVSSCONSCOM, $MSVSS 征兵, $MSVSSCONFLAGS, $MSVSSOLUTIONCOM.

MWCC
为 Metrowerks CodeWarrior 编译器设置构造变量。

集： $抄送, $CCCOM, $C文件后缀, $CPPDEFPREFIX, $CPPDEF后缀, $CXX, $CXXCOM,
$CXX 文件后缀, $INC前缀, $INC后缀, $MWCW_VERSION, $MWCW_VERSIONS, $SHCC,
$上海商会, $SHCCFLAGS, $SHCFLAGS, $SHCXX, $SHCXXCOM, $SHCXXFLAGS.

用途： $CCCOMSTR, $CXXCOMSTR, $SHCCCOMSTR, $SHCXXCOMSTR.

世界末日
为 Metrowerks CodeWarrior 链接器设置构造变量。

集： $AR, $阿康, $LIBDIRP前缀, $库目录后缀, $LIBLINK前缀, $LIBLINK后缀,
$ LINK, $LINKCOM, $SHLINK, $上海联通, $SHLINKFLAGS.

NASM
为 nasm Netwide Assembler 设置构造变量。

集： $AS, $ASCOM, $ASFLAGS, $ASPPCOM, $ASPPFLAGS.

用途： $ASCOMSTR, $ASPPCOMSTR.

包装
设置构造变量 小包装 建造者。

包装
用于构建二进制和源包的框架。

PDF格式
为便携式文档格式构建器设置构造变量。

集： $PDF前缀, $PDF后缀.

胶乳
为 pdflatex 实用程序设置构造变量。

集： $LATEX重试, $PDFLATEX, $PDFLATEXCOM, $PDFLATEXFLAGS.

用途： $PDFLATEXCOMSTR.

pdf文件
为 pdftex 实用程序设置构造变量。

集： $LATEX重试, $PDFLATEX, $PDFLATEXCOM, $PDFLATEXFLAGS, $PDFEX, $PDFEXCOM,
$PDFEXFLAGS.

用途： $PDFLATEXCOMSTR, $PDFEXCOMSTR.

强制执行
设置与 Perforce 源代码管理交互的构造变量
系统。

集： $P4, $P4COM, $P4标志.

用途： $P4COMSTR.

qt
为构建 Qt 应用程序设置构建变量。

集： $QTDIR, $QT_AUTOSCAN, $QT_BINPATH, $QT_CPPPATH, $QT_LIB, $QT_LIBPATH, $QT_MOC,
$QT_MOCCXXPREFIX, $QT_MOCCXXSUFFIX, $QT_MOCFROMCXXCOM, $QT_MOCFROMCXXFLAGS,
$QT_MOCFROMHCOM, $QT_MOCFROMHFLAGS, $QT_MOCHPREFIX, $QT_MOCHSUFFIX, $QT_UIC,
$QT_UICCOM, $QT_UICDECFLAGS, $QT_UICDECLPREFIX, $QT_UICDECLSUFFIX, $QT_UICIMPLFLAGS,
$QT_UICIMPLPREFIX, $QT_UICIMPLSUFIX, $QT_UISUFFIX.

RCS
设置与修订控制系统交互的构造变量。

集： $RCS, $RCS_CO, $RCS_COCOM, $RCS_COFLAGS.

用途： $RCS_COCOMSTR.

米克
为 rmic 实用程序设置构造变量。

集： $JAVACLASS后缀, $RMIC, $RMICCOM, $RMIC标志.

用途： $RMICCOMSTR.

rpcgen
设置用于使用 RPCGEN 构建的构建变量。

集： $RPCGEN, $RPCGENClientFLAGS, $RPCGENFLAGS, $RPCGENHEADERFLAGS,
$RPCGenSERVICEFLAGS, $RPCGENXDRFLAGS.

供应链服务中心
设置与源代码控制系统交互的构造变量。

集： $SCCS, $SCCSCOM, $SCCSFLAGS, $SCCSGETFLAGS.

用途： $SCCSCOMSTR.

夏尔
为 SGI 库归档器设置构造变量。

集： $AR, $ARCOMSTR, $ARFLAGS, $LIBPREFIX, $LIBSFFIX, $SHLINK, $SHLINKFLAGS.

用途： $ARCOMSTR, $SHLINKCOMSTR.

魔法++
为 SGI C++ 编译器设置构造变量。

集： $CXX, $CXXFLAGS, $SHCXX, $SHOBJ后缀.

上海国际会议中心
为 SGI C 编译器设置构造变量。

集： $CXX, $SHOBJ后缀.

链接
为 SGI 链接器设置构造变量。

集： $ LINK, $RPATH前缀, $RPATH后缀, $SHLINKFLAGS.

sunar
为 Sun 库归档程序设置构造变量。

集： $AR, $阿康, $ARFLAGS, $LIBPREFIX, $LIBSFFIX.

用途： $ARCOMSTR.

阳光++
为 Sun C++ 编译器设置构造变量。

集： $CXX, $CXX版本, $SHCXX, $SHCXXFLAGS, $SHOBJ前缀, $SHOBJ后缀.

太阳城
为 Sun C 编译器设置构造变量。

集： $CXX, $SHCCFLAGS, $SHOBJ前缀, $SHOBJ后缀.

太阳F77
为 Sun f77 Fortran 编译器设置构造变量。

集： $77, $FORTRAN 语言, 77 美元, $SHF77标志, $SHFORTRAN, $SHFORTRAFLAGS.

太阳F90
为 Sun f90 Fortran 编译器设置构造变量。

集： $90, $FORTRAN 语言, 90 美元, $SHF90标志, $SHFORTRAN, $SHFORTRAFLAGS.

太阳F95
为 Sun f95 Fortran 编译器设置构造变量。

集： $95, $FORTRAN 语言, 95 美元, $SHF95标志, $SHFORTRAN, $SHFORTRAFLAGS.

阳光联通
为 Sun 链接器设置构造变量。

集： $RPATH前缀, $RPATH后缀, $SHLINKFLAGS.

wig
为 SWIG 接口生成器设置构造变量。

集： $痛饮, $SWIGC文件后缀, $SWIGCOM, $SWIGCXX文件后缀, $SWIGDIRECTORSuffix,
$SWIGFLAGS, $SWIGIN前缀, $SWIGINC后缀, $SWIGPATH, $Swig版本, $_SWIGINCFLAGS.

用途： $SWIGCOMSTR.

焦油
为 tar 归档程序设置构造变量。

集： $焦油, $目标通信, $tarflags, $tarsuffix.

用途： $TARCOMSTR.

TEX
为 TeX 格式化程序和排版程序设置构造变量。

集： $BIBTEX, $BIBTEXCOM, $BIBTEXFLAGS, $乳胶, $LATEXCOM, $LATEXFLAGS, $MAKE指数,
$MAKEINDEXCOM, $MAKEINDEXFLAGS, $特克斯, $德康, $文本标志.

用途： $BIBTEXCOMSTR, $LATEXCOMSTR, $MAKEINDEXCOMSTR, $TEXCOMSTR.

文本文件
设置构造变量 文本文件 和 子文件 建设者。

集： $行分隔符, $SUBSTFILE前缀, $SUBST文件后缀, $文本文件前缀,
$文本文件后缀.

用途： $SUBST_DICT.

库
为 Borlan tib 库归档器设置构造变量。

集： $AR, $阿康, $ARFLAGS, $LIBPREFIX, $LIBSFFIX.

用途： $ARCOMSTR.

获取文本
这个 scons 工具是 scons gettext 工具集的一部分。 它提供了 scons 接口
获取文本(1) 程序，它从源代码中提取国际化消息。 这
工具提供 POT更新 生成器生成 PO 版型 文件。

集： $锅后缀, $POTUPDATE_ALIAS, $XGETTEXTCOM, $XGETTEXTCOMSTR, $XGETTEXFLAGS,
$XGETTEXTROM, $XGETTEXTFROM前缀, $XGETTEXTFROMSUFFIX, $XGETTEXTPATH,
$XGETTEXTPATH前缀, $XGETTEXTPATH后缀, $_XGETTEXTDOMAIN, $_XGETTEXTFROMFLAGS,
$_XGETTEXTPATHFLAGS.

用途： $POTOMAIN.

雅克
为 yacc 解析生成器设置构造变量。

集： $YACC, $YACCCOM, $YACCFLAGS, $YACCH文件后缀, $YACCHXX文件后缀,
$YACCVCG文件后缀.

用途： $YACCCOMSTR.

拉链
设置 zip 存档器的构造变量。

集： $邮编, $邮编, $ZIP压缩, $邮编, $邮编.

用途： $邮编.

此外，还有一个名为“工具” 默认 它用一个配置环境
当前平台的默认工具集。

在 posix 和 cygwin 平台上，SCons 首选 GNU 工具（例如 gcc），在 Windows 上
SCons 首选 Microsoft 工具（例如 msvc），然后是 MinGW，并且在 OS/2 中
IBM 工具（例如 icc）是 SCons 的首选。

生成器 方法
构建规则是通过调用构建环境的构建器方法来指定的。 这
构建器方法的参数是 目标 （要构建的目标列表，通常是文件
姓名）和 资源 （要构建的源列表，通常是文件名）。

因为一长串文件名会导致大量引用， 烤饼 供应一个 分裂（）
全局函数和同名环境方法将单个字符串拆分为一个
列表，以空白字符的字符串分隔。 （这些类似于 split()
Python 字符串的成员函数，但即使输入不是字符串也能工作。）

像所有 Python 参数一样，构建器方法的目标和源参数可以是
指定有或没有“目标”和“源”关键字。 当关键字是
省略，目标是第一个，然后是源。 以下是等价的
调用程序生成器方法的示例：

env.Program('bar', ['bar.c', 'foo.c'])
env.Program('bar', Split('bar.c foo.c'))
env.Program('bar', env.Split('bar.c foo.c'))
env.Program(source = ['bar.c', 'foo.c'], target = 'bar')
env.Program(target = 'bar', Split('bar.c foo.c'))
env.Program(target = 'bar', env.Split('bar.c foo.c'))
env.Program('bar', source = 'bar.c foo.c'.split())

不是绝对路径名的目标文件名和源文件名（即不以
/ 在 POSIX 系统上或 \fR on Windows 系统， - or 也完全不需要 an 可选 驾驶 信件）
旨在 解读 相对的 至 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 目录 包含 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 新兵 正在读取的文件。 一个
初始 # 路径名上的（哈希标记）表示文件名的其余部分被解释
相对于包含顶级的目录 构造 文件，即使 # is
后跟目录分隔符（斜杠或反斜杠）。

例子：

# 描述将要构建的目标的注释
# 假设这些调用位于
# 一个名为“subdir”的子目录。

# 从“subdir/foo.c”构建程序“subdir/foo”：
env.Program('foo', 'foo.c')

# 从“subdir/bar.c”构建程序“/tmp/bar”：
env.Program('/tmp/bar', 'bar.c')

# 开头的 '#' 或 '#/' 是等价的； 下列
# 调用构建程序“foo”和“bar”（在
# 顶级 SConstruct 目录）来自“subdir/foo.c”和
# "subdir/bar.c"，分别为：
env.Program('#foo', 'foo.c')
env.Program('#/bar', 'bar.c')

# 构建程序“other/foo”（相对于顶层
# SConstruct 目录）来自“subdir/foo.c”：
env.Program('#other/foo', 'foo.c')

当目标与源共享相同的基本名称并且只有后缀不同时，并且如果
builder 方法有一个为目标文件类型定义的后缀，然后是目标参数
可以完全省略，并且 烤饼 将从源文件中推导出目标文件名
名称。 下面的例子都构建了可执行程序 酒吧 （在 POSIX 系统上）或
工具栏 （在 Windows 系统上）来自 bar.c 源文件：

env.Program(target = 'bar', source = 'bar.c')
env.Program('bar', source = 'bar.c')
env.Program(source = 'bar.c')
env.Program('bar.c')

为方便起见，一个 源目录 调用 Builder 时可以指定关键字参数。 什么时候
指定，所有不是绝对路径的源文件字符串都将被解释
相对于指定的 源目录. 以下示例将构建 构建/程序 （或
构建/prog.exe 在 Windows 上）文件中的程序 源代码/f1.c 和 源代码/f2.c:

env.Program('build/prog', ['f1.c', 'f2.c'], srcdir='src')

通过以下方式调用构建器方法时，可以覆盖或添加构造变量
传递额外的关键字参数。 这些覆盖或添加的变量只会在
在构建目标时生效，因此它们不会影响构建的其他部分。 为了
例如，如果您只想为一个程序添加额外的库：

env.Program('hello', 'hello.c', LIBS=['gl', 'glut'])

或者生成一个带有非标准后缀的共享库：

env.SharedLibrary('word', 'word.cpp',
SHLIBSUFIX='.ocx',
LIBSUFIXES=['.ocx'])

（请注意，如果您想要 SCons，则必须同时设置 $SHLIBSUFFIX 和 $LIBSUFFIXES 变量
自动搜索对非标准库名称的依赖； 见
这些变量的描述，请参见下文，以获取更多信息。）

也可以使用 解析标志 覆盖中的关键字参数：

env = Program('hello', 'hello.c', parse_flags = '-Iinclude -DEBUG -lm')

此示例将“包含”添加到 路径, 'EBUG' 到 CPP定义, 和 'm' 到 LIBS.

虽然由定义的构建器方法 烤饼 实际上是构造方法
环境对象，它们也可以在没有显式环境的情况下被调用：

程序('你好', 'hello.c')
SharedLibrary('word', 'word.cpp')

在这种情况下，使用默认构造环境在内部调用方法
由工具和价值观组成 烤饼 已确定适合
本地系统。

可以在没有显式环境的情况下调用的构建器方法可以从
通过将以下内容添加到 SConscript 文件中的自定义 Python 模块
Python模块：

从 SCons.Script 导入 *

所有构建器方法都返回一个类似列表的对象，其中包含代表目标的节点
或将要构建的目标。 一个 Node 是代表构建的内部 SCons 对象
目标或来源。

返回的节点列表对象可以作为源或
传递给通常接受文件名的任何 SCons 函数或方法。 为了
例如，如果有必要添加一个特定的 -D 编译一个特定对象时的标志
文件：

bar_obj_list = env.StaticObject('bar.c', CPPDEFINES='-DBAR')
env.Program(source = ['foo.c', bar_obj_list, 'main.c'])

通过避免必须指定一个节点，以这种方式使用节点可以实现更便携的构建
调用 Program() 构建器方法时特定于平台的对象后缀。

请注意，Builder 调用将自动“扁平化”源文件和目标文件列表，因此
在中间通过 StaticObject() 调用返回 bar_obj 列表是可以的
源文件列表。 如果您需要操作 Builders 返回的列表列表
直接使用 Python，您可以手动构建列表：

foo = Object('foo.c')
bar = Object('bar.c')
objects = ['begin.o'] + foo + ['middle.o'] + bar + ['end.o']
对于对象中的对象：
打印 str（对象）

或者您可以使用 展平() 由 scons 提供的函数来创建一个只包含
节点，这可能更方便：

foo = Object('foo.c')
bar = Object('bar.c')
objects = Flatten(['begin.o', foo, 'middle.o', bar, 'end.o'])
对于对象中的对象：
打印 str（对象）

还要注意，因为 Builder 调用返回一个类似列表的对象，而不是实际的 Python 列表，
你应该 而不去 使用 Python += 将 Builder 结果附加到 Python 列表的运算符。
因为列表和对象是不同的类型，Python不会更新原来的
list 到位，但会创建一个包含串联的新 Node-list 对象
列表元素和 Builder 结果。 这将导致任何其他问题
SCons 配置中的 Python 变量仍然保留对
原始清单。 相反，使用 Python 。延长（） 确保列表更新的方法
到位。 例子：

对象文件 = []

# 不要使用 += 如下：
#
# object_files += Object('bar.c')
#
# 它不会就地更新 object_files 列表。
#
# 相反，使用 .extend() 方法：
object_files.extend(Object('bar.c'))

可以通过将 Node 传递给 Python-builtin 来使用 Node 文件的路径名
字符串（） 功能：

bar_obj_list = env.StaticObject('bar.c', CPPDEFINES='-DBAR')
print "bar_obj 的路径是：", str(bar_obj_list[0])

再次注意，因为 Builder 调用返回一个列表，我们必须访问第一个
列表中的元素 (bar_obj_list[0]) 到达实际代表的节点
目标文件。

构建器调用支持 目录 指定 Builder 的操作的关键字参数
应在更改目录后执行。 如果 目录 参数是一个字符串或一个
directory 节点，scons 会切换到指定的目录。 如果 目录 不是字符串
或 Node 且非零，则 scons 将更改为目标文件的目录。

# scons 将更改为“sub”子目录
# 在执行“cp”命令之前。
env.Command('sub/dir/foo.out', 'sub/dir/foo.in',
"cp dir/foo.in dir/foo.out",
chdir='sub')

# 因为 chdir 不是字符串，所以 scons 会变成
# 执行前的目标目录（“sub/dir”）
# "cp" 命令。
env.Command('sub/dir/foo.out', 'sub/dir/foo.in',
"cp foo.in foo.out",
目录=1)

请注意，scons 将 而不去 自动修改其构造变量的扩展，如
$目标 和 $源 使用 chdir 关键字参数时——即展开的文件
名称仍将相对于顶级 SConstruct 目录，因此
相对于 chdir 目录不正确。 如果您使用 chdir 关键字参数，您将
通常需要使用扩展提供不同的命令行，例如 ${目标.文件} 和
${SOURCE.文件} 仅使用目标和源的文件名部分。

烤饼 提供以下构建器方法：

C文件(), env.CFile()
在给定 lex (.l) 或 yacc (.y) 输入文件的情况下构建 C 源文件。 指定的后缀
由 $C文件后缀 构造变量（默认为 .c）被自动添加到
如果目标尚不存在，则为目标。 例子：

# 构建 foo.c
env.CFile(target = 'foo.c', source = 'foo.l')
# 构建 bar.c
env.CFile(target = 'bar', source = 'bar.y')

命令（）, 环境命令（）
这个 命令 “Builder”实际上是作为一个看起来像Builder的函数来实现的，
但实际上对 Builder 应该采取的行动采取了额外的论据
被制作。 见 命令 调用语法和详细信息的函数说明。

CXX文件(), env.CXXFile()
在给定 lex (.ll) 或 yacc (.yy) 输入文件的情况下构建 C++ 源文件。 后缀
由指定 $CXX 文件后缀 构造变量（默认为 .cc）是
如果目标不存在，则自动添加到目标中。 例子：

# 构建 foo.cc
env.CXXFile(target = 'foo.cc', source = 'foo.ll')
# 构建 bar.cc
env.CXXFile(target = 'bar', source = 'bar.yy')

DocbookEpub(), env.DocbookEpub()
一个伪生成器，为 EPUB 输出提供 Docbook 工具链。

env = 环境（工具=['docbook']）
env.DocbookEpub('manual.epub', 'manual.xml')

或者干脆

env = 环境（工具=['docbook']）
env.DocbookEpub('手册')

DocbookHtml(), env.DocbookHtml()
一个伪生成器，为 HTML 输出提供 Docbook 工具链。

env = 环境（工具=['docbook']）
env.DocbookHtml('manual.html', 'manual.xml')

或者干脆

env = 环境（工具=['docbook']）
env.DocbookHtml('手册')

DocbookHtmlChunked(), env.DocbookHtmlChunked()
一个伪构建器，为分块的 HTML 输出提供 Docbook 工具链。 它支持
base.dir 参数。 chunkfast.xsl 文件（需要“EXSLT”）用作
默认样式表。 基本语法：

env = 环境（工具=['docbook']）
env.DocbookHtmlChunked('手册')

其中 manual.xml 是输入文件。

如果您在自己的样式表中使用 root.filename 参数，则必须指定
新目标名称。 这确保了依赖关系是正确的，尤其是对于
通过“scons -c”清理：

env = 环境（工具=['docbook']）
env.DocbookHtmlChunked('mymanual.html', 'manual', xsl='htmlchunk.xsl')

提供了对 base.dir 的一些基本支持。 您可以将 base_dir 关键字添加到
您的 Builder 调用，并且给定的前缀被添加到所有创建的文件名中：

env = 环境（工具=['docbook']）
env.DocbookHtmlChunked('manual', xsl='htmlchunk.xsl', base_dir='output/')

确保您不要忘记基本文件夹的尾部斜杠，否则您的
文件只会重命名！

DocbookHtmlhelp(), env.DocbookHtmlhelp()
一个伪生成器，为 HTMLHELP 输出提供 Docbook 工具链。 它的基本语法
是：

env = 环境（工具=['docbook']）
env.DocbookHtmlhelp('手册')

其中 manual.xml 是输入文件。

如果您在自己的样式表中使用 root.filename 参数，则必须指定
新目标名称。 这确保了依赖关系是正确的，尤其是对于
通过“scons -c”清理：

env = 环境（工具=['docbook']）
env.DocbookHtmlhelp('mymanual.html', 'manual', xsl='htmlhelp.xsl')

提供了对 base.dir 参数的一些基本支持。 您可以添加 base_dir
关键字到您的 Builder 调用，并且给定的前缀被添加到所有创建的
文件名：

env = 环境（工具=['docbook']）
env.DocbookHtmlhelp('manual', xsl='htmlhelp.xsl', base_dir='output/')

确保您不要忘记基本文件夹的尾部斜杠，否则您的
文件只会重命名！

文档管理器(), env.DocbookMan()
一个伪构建器，为手册页输出提供 Docbook 工具链。 它的基本语法
是：

env = 环境（工具=['docbook']）
env.DocbookMan('手册')

其中 manual.xml 是输入文件。 请注意，您可以指定目标名称，但
实际输出名称是从 XML 源中的 refname 条目自动设置的。

文档书PDF(), env.DocbookPdf()
一个伪生成器，为 PDF 输出提供 Docbook 工具链。

env = 环境（工具=['docbook']）
env.DocbookPdf('manual.pdf', 'manual.xml')

或者干脆

env = 环境（工具=['docbook']）
env.DocbookPdf('手册')

DocbookSlidesHtml(), env.DocbookSlidesHtml()
一个伪生成器，为 HTML 幻灯片输出提供 Docbook 工具链。

env = 环境（工具=['docbook']）
env.DocbookSlidesHtml('手册')

如果您在自己的样式表中使用 titlefoil.html 参数，则必须提供
新目标名称。 这确保了依赖关系是正确的，尤其是对于
通过“scons -c”清理：

env = 环境（工具=['docbook']）
env.DocbookSlidesHtml('mymanual.html','manual', xsl='slideshtml.xsl')

提供了对 base.dir 参数的一些基本支持。 您可以添加 base_dir
关键字到您的 Builder 调用，并且给定的前缀被添加到所有创建的
文件名：

env = 环境（工具=['docbook']）
env.DocbookSlidesHtml('manual', xsl='slideshtml.xsl', base_dir='output/')

确保您不要忘记基本文件夹的尾部斜杠，否则您的
文件只会重命名！

DocbookSlidesPdf(), env.DocbookSlidesPdf()
一个伪生成器，为 PDF 幻灯片输出提供 Docbook 工具链。

env = 环境（工具=['docbook']）
env.DocbookSlidesPdf('manual.pdf', 'manual.xml')

或者干脆

env = 环境（工具=['docbook']）
env.DocbookSlidesPdf('手册')

DocbookXInclude(), env.DocbookXInclude()
一个伪生成器，用于在单独的处理步骤中解析 XIncludes。

env = 环境（工具=['docbook']）
env.DocbookXInclude('manual_xincluded.xml', 'manual.xml')

DocbookXslt(), env.DocbookXslt()
一个伪构建器，将给定的 XSL 转换应用到输入文件。

env = 环境（工具=['docbook']）
env.DocbookXslt('manual_transformed.xml', 'manual.xml', xsl='transform.xslt')

请注意，此构建器需要设置 xsl 参数。

视频接口(), 环境.DVI()
从 .tex、.ltx 或 .latex 输入文件构建 .dvi 文件。 如果源文件后缀
是 .tex，scons 会检查文件的内容； 如果字符串 \documentclass 或
\documentstyle 被发现，该文件被假定为一个 LaTeX 文件，目标是
通过调用构建 $LATEXCOM 命令行; 否则， $德康 命令行是
用过的。 如果文件是 LaTeX 文件，则 DVI接口 builder 方法还将检查
.aux 文件的内容并调用 $BIBTEX 命令行 如果字符串 bibdata 是
找到，开始 $MAKE指数 如果找到 .ind 文件，则生成索引并将检查
内容 .log 文件并重新运行 $LATEXCOM 命令，如果日志文件说它是
必要。

后缀 .dvi（在 TeX 本身内硬编码）会自动添加到目标，如果
它尚未存在。 例子：

# 从 aaa.tex 构建
env.DVI(目标 = 'aaa.dvi', 源 = 'aaa.tex')
# 构建 bbb.dvi
env.DVI(目标 = 'bbb', 源 = 'bbb.ltx')
# 从 ccc.latex 构建
env.DVI(目标 = 'ccc.dvi', 源 = 'ccc.latex')

GS(), 环境.Gs()
用于显式调用 gs 可执行文件的构建器。 根据底层操作系统，
尝试了不同的名称 gs、gsos2 和 gswin32c。

env = 环境（工具=['gs']）
env.Gs('cover.jpg','scons-scons.pdf',
GSFLAGS='-dNOPAUSE -dBATCH -sDEVICE=jpeg -dFirstPage=1 -dLastPage=1 -q')
)

安装（）, 环境安装（）
在指定的目标中安装一个或多个源文件或目录，这些文件或目录必须
成为一个目录。 指定的源文件或目录的名称保持不变
在目标目录中。 源可以作为字符串或节点给出
由建筑商退回。

env.Install('在/ usr / local / bin目录', source = ['foo', 'bar'])

安装方式（）, env.InstallAs()
将一个或多个源文件或目录安装到特定名称，允许更改
作为安装的一部分的文件或目录名称。 如果目标和
源参数列出不同数量的文件或目录。

env.InstallAs(target = '/usr/local/bin/foo',
源 = 'foo_debug')
env.InstallAs(target = ['../lib/libfoo.a', '../lib/libbar.a'],
源 = ['libFOO.a', 'libBAR.a'])

安装VersionedLib(), env.InstallVersionedLib()
安装版本化共享库。 适合架构的符号链接将
基于源库的符号链接生成。

env.InstallVersionedLib(target = '/usr/local/bin/foo',
源 = 'libxyz.1.5.2.so')

罐（）, 环境.Jar()
从指定的源列表构建 Java 归档 (.jar) 文件。 任何目录
将在源列表中搜索 .class 文件）。 源中的任何 .java 文件
列表将通过调用编译为 .class 文件 爪哇岛 建造者。

如果 $JARCHDIR 值被设置，jar命令会切换到指定目录
使用 -C 选项。 如果 $JARCHDIR 未明确设置，SCons 将使用任何顶部
Java .class 在其中构建的子目录树 爪哇岛 建造者。

如果任何源文件的内容以字符串 Manifest-Version 开头，则
文件被假定为一个清单，并通过以下命令传递给 jar 命令 m 选项
设置。

env.Jar(target = 'foo.jar', source = 'classes')

env.Jar(target = 'bar.jar',
源 = ['bar1.java', 'bar2.java'])

爪哇(), 环境.Java()
构建一个或多个 Java 类文件。 来源可以是显式的任意组合
.java 文件，或将扫描 .java 文件的目录树。

SCons 将解析每个源 .java 文件以查找类（包括内部类）
在该文件中定义，并从中找出目标 .class 文件
被创建。 类文件将放置在指定的目标目录下。

SCons 还将在每个 Java 文件中搜索 Java 包名称，它假定可以
在第一列中以字符串包开头的行中找到； 这
生成的 .class 文件将放置在反映指定包的目录中
名称。 例如，文件 Foo.java 定义了一个公共 Foo 类并包含
sub.dir 的包名会生成对应的 sub/dir/Foo.class 类文件。

例子：

env.Java(target = 'classes', source = 'src')
env.Java(target = 'classes', source = ['src1', 'src2'])
env.Java(target = 'classes', source = ['File1.java', 'File2.java'])

Java 源文件可以使用底层操作系统的本机编码。 由于 SCons
默认情况下以简单 ASCII 模式编译，编译器将生成有关以下内容的警告
不可映射的字符，这可能会在进一步处理文件时导致错误。 在
这种情况下，用户必须指定 LANG 环境变量来告诉编译器
使用什么编码。 为了可移植性，最好编码是硬编码的
如果编译在具有不同编码的系统上完成，则编译将起作用。

环境 = 环境（）
env['ENV']['LANG'] = 'en_GB.UTF-8'

JavaH(), 环境.JavaH()
构建用于实现 Java 本机方法的 C 头文件和源文件。 目标可以
要么是头文件将被写入的目录，要么是头文件名
它将包含所有定义。 来源可以是 .class 的名称
文件，通过调用编译成.class文件的.java文件的名称 爪哇岛
builder 方法，或从 爪哇岛 建造者方法。

如果构造变量 $JavaCLASSDIR 设置，无论是在环境中还是在
打电话给 爪哇 builder 方法本身，那么变量的值将是
从任何 .class 文件名的开头删除。

例子：

# 构建 java_native.h
classes = env.Java(target = 'classdir', source = 'src')
env.JavaH（目标 = 'java_native.h'，源 = 类）

# 构建 include/package_foo.h 和 include/package_bar.h
env.JavaH(target = 'include',
source = ['package/foo.class', 'package/bar.class'])

# 构建 export/foo.h 和 export/bar.h
env.JavaH（目标='出口'，
源 = ['classes/foo.class', 'classes/bar.class'],
JAVACLASSDIR = '类')

图书馆（）, 环境库（）
的同义词 静态库 建造者方法。

可加载模块（）, env.LoadableModule()
在大多数系统上，这与 共享库. 在 Mac OS X (Darwin) 平台上，
这将创建一个可加载的模块包。

M4(), 环境.M4()
从 M4 输入文件构建输出文件。 这使用默认值 $M4FLAGS 价值 -E,
它认为所有警告都是致命的，并在使用时停止第一个警告
m4 的 GNU 版本。 例子：

env.M4（目标 = 'foo.c'，源 = 'foo.c.m4'）

莫克（）, 环境.Moc()
从 moc 输入文件构建输出文件。 Moc 输入文件是头文件
或 cxx 文件。 此构建器仅在使用工具“qt”后可用。 见 $QTDIR
变量以获取更多信息。 例子：

env.Moc('foo.h') # 生成 moc_foo.cc
env.Moc('foo.cpp') # 生成 foo.moc

MO文件(), env.MOFiles()
该构建器属于 msgfmt 工具。 构建器将 PO 文件编译为 MO 文件。

例如： 1. 通过编译 pl.po 和 en.po 创建 pl.mo 和 en.mo：

#...
env.MOFiles(['pl', 'en'])

例如： 2. 为 LINGUAS 文件中定义的语言编译文件：

#...
env.MOFiles（LINGUAS_FILE = 1）

例如： 3. 通过编译 pl.po 和 en.po plus 文件来创建 pl.mo 和 en.mo
LINGUAS 文件中定义的语言：

#...
env.MOFiles(['pl', 'en'], LINGUAS_FILE = 1)

例如： 4. 为 LINGUAS 文件中定义的语言编译文件（另一个版本）：

#...
环境['LINGUAS_FILE'] = 1
env.MOFiles()

MSVS项目（）, env.MSVSProject()
构建 Microsoft Visual Studio 项目文件，并默认构建解决方案文件
以及。

这将基于 Visual Studio 的版本构建一个 Visual Studio 项目文件
已配置（最新安装的版本，或指定的版本
$MSVS_VERSION 在环境构造函数中）。 对于 Visual Studio 6，它将生成一个
.dsp 文件。 对于 Visual Studio 7 (.NET) 和更高版本，它将生成一个 .vcproj
文件中。

默认情况下，这也会为指定的项目生成一个解决方案文件，一个 .dsw 文件
Visual Studio 6 或 Visual Studio 7 (.NET) 的 .sln 文件。 这种行为可能是
调用时通过指定 auto_build_solution=0 禁用 MSVS项目，在这种情况下
您可能想通过调用 MSVS解决方案 生成器
（见下文）。

这个 MSVS项目 builder 将几个文件名列表放入项目中
文件。 这些目前仅限于 srcs、incs、localincs、resources 和 misc。 这些
是非常不言自明的，但应该注意的是，这些列表被添加到
$来源 构造变量作为字符串，而不是 SCons 文件节点。 这是因为
它们代表要添加到项目文件中的文件名，而不是使用的源文件
构建项目文件。

上述文件名列表都是可选的，但至少必须为
生成的项目文件为非空。

除了上述值列表之外，还可以指定以下值：

目标
目标 .dsp 或 .vcproj 文件的名称。 版本的正确后缀
必须使用 Visual Studio，但 $MSVSPROJECTSUFFIX 构造变量 will
被定义为正确的值（见下面的例子）。

变种
此特定变体的名称。 对于 Visual Studio 7 项目，这也可以
是变体名称的列表。 这些通常是“调试”或“发布”之类的东西，
但真的可以是你想要的任何东西。 对于 Visual Studio 7 项目，它们还可以
指定一个目标平台，用 | 与变体名称分隔。 （竖管）
字符：调试|Xbox。 默认目标平台是 Win32。 多次调用
MSVS项目 允许使用不同的变体； 所有变体都将添加到
项目文件及其适当的构建目标和源。

命令参数
不同变体的附加命令行参数。 的数量
cmdargs 条目必须与变体条目的数量匹配，或者为空（不是
指定的）。 如果你只给一个，它会自动传播给所有
变种。

构建目标
可选的字符串、节点或字符串或节点列表（每个构建变体一个），用于
告诉 Visual Studio 调试器在什么构建变体中使用什么输出目标。
buildtarget 条目的数量必须与变体条目的数量相匹配。

运行文件
Visual Studio 7 及更高版本将运行和调试的文件的名称。 这
在生成的 Visual Studio 项目中显示为输出字段的值
文件。 如果不指定，则默认与指定的相同
构建目标值。

请注意，因为 SCons 总是从所在目录执行其构建命令
SConstruct 文件所在的位置，如果您在不同的环境中生成项目文件
目录比 SConstruct 目录，用户将无法双击
Visual Studio 控制台输出中显示的编译错误消息中的文件名
窗户。 这可以通过将 Visual C/C++ /FC 编译器选项添加到
$CCFLAGS 变量，以便编译器将打印任何文件的完整路径名
导致编译错误。

用法示例：

barrcs = ['bar.cpp'],
barincs = ['bar.h'],
barlocalincs = ['StdAfx.h']
barresources = ['bar.rc','resource.h']
barmisc = ['bar_readme.txt']

dll = env.SharedLibrary(目标 = 'bar.dll',
来源 = barrcs)

env.MSVSProject(目标 = 'Bar' + env['MSVSPROJECTSUFFIX'],
srcs = barrcs,
incs = barincs，
localincs = barlocalincs,
资源 = barresources，
杂项=巴杂项，
构建目标 = dll，
变体='发布'）

从 SCons 2.4 版开始，还可以指定可选参数
调试设置，它会在 Visual Studio 下创建用于调试的文件：

调试设置
写入 .vcproj.user 或
.vcxproj.user 文件，具体取决于安装的版本。 正如对 cmdargs 所做的那样
（见上文），您可以指定一个 调试设置 每个变体的字典。 如果你给
只有一个，它将传播到所有变体。

目前，仅实现了 Visual Studio v9.0 和 Visual Studio v11 版本，对于
其他版本不生成文件。 要生成用户文件，您只需要添加一个
调试设置 为您的 MSVS 提供正确参数的环境字典
版本。 如果字典为空，或不包含任何好的值，则没有文件将
被生成。

以下是一个更人为的示例，涉及为变体设置项目
和调试设置：

# 假设您将默认值存储在文件中
vars = 变量（'variables.py'）
msvcver = vars.args.get('vc', '9')

# 检查命令 args 以强制使用一个 Microsoft Visual Studio 版本
如果 msvcver == '9' 或 msvcver == '11'：
env = 环境（MSVC_VERSION=msvcver+'.0', MSVC_BATCH=False）
其他：
环境 = 环境（）

AddOption('--userfile', action='store_true', dest='userfile', default=False,
help="创建 Visual Studio 项目用户文件")

#
# 1. 使用列表中所需的选项配置调试设置字典
# 允许的选项，例如，如果你想创建一个用户文件来启动
# 使用 Microsoft Visual Studio 2008 (v9) 测试您的 dll 的特定应用程序：
#
V9调试设置 = {
'命令':'c:\\myapp\\using\\thisdll.exe',
'工作目录': 'c:\\myapp\\using\\',
'CommandArguments': '-p 密码',
# '附加':'假',
# 'DebuggerType':'3',
# '远程':'1',
# 'RemoteMachine'：无，
#“远程命令”：无，
# 'HttpUrl': 无，
#'PDBPath'：无，
# 'SQLDebugging': 无，
＃ '环境'： ''，
# 'EnvironmentMerge':'true',
# 'DebuggerFlavor': 无，
#'MPIRunCommand'：无，
#'MPIRunArguments'：无，
#'MPIRunWorkingDirectory'：无，
# 'ApplicationCommand'：无，
# 'ApplicationArguments'：无，
# 'ShimCommand'：无，
#'MPIAcceptMode'：无，
# 'MPIAcceptFilter'：无，
}

#
# 2. 因为有很多不同的选项取决于 Microsoft
# Visual Studio 版本，如果你使用多个版本，你必须
# 为每个版本定义一个字典，例如如果你想创建一个用户
# 文件以启动特定应用程序以使用 Microsoft 测试您的 dll
# Visual Studio 2012 (v11)：
#
V10调试设置 = {
'LocalDebuggerCommand': 'c:\\myapp\\using\\thisdll.exe',
'LocalDebuggerWorkingDirectory': 'c:\\myapp\\using\\',
'LocalDebuggerCommandArguments': '-p 密码',
# 'LocalDebuggerEnvironment': 无，
# 'DebuggerFlavor': 'WindowsLocalDebugger',
# 'LocalDebuggerAttach'：无，
# 'LocalDebuggerDebuggerType': 无,
#'LocalDebuggerMergeEnvironment'：无，
# 'LocalDebuggerSQLDebugging': 无,
# 'RemoteDebuggerCommand'：无，
# 'RemoteDebuggerCommandArguments'：无，
# 'RemoteDebuggerWorkingDirectory'：无，
# 'RemoteDebuggerServerName'：无，
# 'RemoteDebuggerConnection'：无，
# 'RemoteDebuggerDebuggerType'：无，
# 'RemoteDebuggerAttach'：无，
# 'RemoteDebuggerSQLDebugging'：无，
# '部署目录'：无，
# 'AdditionalFiles'：无，
# 'RemoteDebuggerDeployDebugCppRuntime'：无，
# 'WebBrowserDebuggerHttpUrl'：无，
# 'WebBrowserDebuggerDebuggerType'：无，
# 'WebServiceDebuggerHttpUrl'：无，
# 'WebServiceDebuggerDebuggerType'：无，
# 'WebServiceDebuggerSQLDebugging'：无，
}

#
# 3. 根据Visual Studio的版本选择你想要的字典
# 要生成的文件。
#
如果不是 env.GetOption('userfile')：
dbgSettings = 无
elif env.get('MSVC_VERSION', None) == '9.0':
dbgSettings = V9调试设置
elif env.get('MSVC_VERSION', None) == '11.0':
dbgSettings = V10调试设置
其他：
dbgSettings = 无

#
# 4. 将字典添加到 DebugSettings 关键字中。
#
barrcs = ['bar.cpp', 'dllmain.cpp', 'stdafx.cpp']
barincs = ['targetver.h']
barlocalincs = ['StdAfx.h']
barresources = ['bar.rc','resource.h']
barmisc = ['ReadMe.txt']

dll = env.SharedLibrary(目标 = 'bar.dll',
来源 = barrcs)

env.MSVSProject(目标 = 'Bar' + env['MSVSPROJECTSUFFIX'],
srcs = barrcs,
incs = barincs，
localincs = barlocalincs,
资源 = barresources，
杂项=巴杂项，
构建目标 = [dll[0]] * 2，
变体 = ('Debug|Win32', 'Release|Win32'),
cmdargs = 'vc=%s' % msvcver,
调试设置 = (dbgSettings, {}))

MSVS解决方案（）, 环境.MSVSSolution()
构建 Microsoft Visual Studio 解决方案文件。

这将基于 Visual Studio 的版本构建一个 Visual Studio 解决方案文件
已配置（最新安装的版本，或指定的版本
$MSVS_VERSION 在施工环境中）。 对于 Visual Studio 6，它将生成
.dsw 文件。 对于 Visual Studio 7 (.NET)，它将生成一个 .sln 文件。

必须指定以下值：

目标
目标 .dsw 或 .sln 文件的名称。 版本的正确后缀
必须使用 Visual Studio，但值 $MSVS解决方案后缀 将被定义为
正确的值（见下面的例子）。

变种
此特定变体的名称，或变体名称列表（后者是
仅支持 MSVS 7 解决方案）。 这些通常是“调试”或
“释放”，但真的可以是你想要的任何东西。 对于 MSVS 7，他们还可以指定
目标平台，例如“Debug|Xbox”。 默认平台是 Win32。

工程
项目文件名列表，或调用返回的项目节点
MSVS项目 生成器，要放置到解决方案文件中。 应该注意的是
这些文件名不会以以下形式添加到 $SOURCES 环境变量中
文件，而是作为字符串。 这是因为它们代表的文件名是
添加到解决方案文件，而不是用于构建解决方案文件的源文件。

示例用法：

env.MSVSSolution（目标 = 'Bar' + env['MSVSSOLUTIONSUFFIX']，项目 = ['bar'
+ env['MSVSPROJECTSUFFIX']]，变体 = '发布')

目的（）, 环境对象（）
的同义词 静态对象 建造者方法。

包裹（）, 环境包（）
构建给定源文件的二进制包。

env.Package（来源= FindInstalledFiles（））

构建软件分发包。 包由要安装的文件和
包装信息。 前者可以用 资源 参数和可能
被排除在外，在这种情况下 查找已安装文件 函数将收集所有文件
有 安装 or 安装方式 附加的生成器。 如果 目标 未指定它将
从提供给此 Builder 的附加信息中推断出来。

包装信息是在构造变量的帮助下指定的
记录如下。 此信息称为标签，以强调其中一些可以
也可以附加到文件中 标签 功能。 强制性的会抱怨，如果
他们没有具体说明。 它们因选择的目标打包程序而异。

可以使用“PACKAGETYPE”命令行选项或使用
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $包类型 构造变量。 目前提供以下打包程序：

* msi - Microsoft 安装程序 * rpm - Redhat 包管理器 * ipkg - Itsy 包
管理系统 * tarbz2 - 压缩 tar * targz - 压缩 tar * zip - 压缩文件
* src_tarbz2 - 压缩的 tar 源 * src_targz - 压缩的 tar 源 * src_zip -
压缩文件源

运行时，“package_type”选项下始终提供更新的列表
已激活打包的项目上的“scons --help”。

env = Environment(tools=['default', 'packaging'])
env.Install('/箱/', '我的程序')
env.Package( NAME = 'foo',
版本 = '1.2.3',
包版本 = 0，
PACKAGETYPE = 'rpm',
许可证 = 'gpl',
摘要 = 'balalalalal',
DESCRIPTION = '这应该真的很长',
X_RPM_GROUP = '应用程序/fu',
SOURCE_URL = 'http://foo.org/foo-1.2.3.tar.gz'
)

PCH(), 环境.PCH()
构建 Microsoft Visual C++ 预编译头文件。 调用此构建器方法返回
两个目标的列表：PCH 作为第一个元素，目标文件作为第二个元素
元素。 通常会忽略目标文件。 仅提供此构建器方法
当 Microsoft Visual C++ 被用作编译器时。 PCH 构建器方法是
通常与 PCH 构造变量结合使用以强制目标文件
使用预编译头文件：

env['PCH'] = env.PCH('StdAfx.cpp')[0]

PDF(), 环境.PDF()
从 .dvi 输入文件（或扩展名为 .tex、.ltx 或 .latex）构建 .pdf 文件
输入文件）。 指定的后缀 $PDF后缀 构造变量（.pdf by
default) 会自动添加到目标中，如果它不存在的话。 例子：

# 从 aaa.tex 构建
env.PDF（目标 = 'aaa.pdf'，源 = 'aaa.tex'）
# 从 bbb.dvi 构建 bbb.pdf
env.PDF（目标 = 'bbb'，源 = 'bbb.dvi'）

POInit(), env.POInit()
该构建器属于 msginit 工具。 构建器初始化丢失的 PO 文件，如果
$POAUTOINIT 设置。 如果 $POAUTOINIT 未设置（默认）， 初始化 打印指令
用户（应该是翻译），告诉 PO 文件应该如何
初始化。 在正常项目中 应该 而不去 使用 初始化 和 使用 PO更新 代替.
PO更新 明智地选择 消息合并(1) 和 消息初始化(1). 初始化 总是使用
消息初始化(1) 并应视为特殊用途或临时使用的建筑商
（例如，用于快速、一次性初始化一堆 PO 文件）或用于测试。

通过定义的目标节点 初始化 默认情况下不构建（它们被“。”忽略）
节点），但添加到特殊别名（默认情况下为“po-create”）。 别名可能是
通过改变 $POCREATE_ALIAS 构造变量。 定义的所有 PO 文件
通过 初始化 可以很容易地初始化 烤饼 创造.

例如： 1. 从 messages.pot 初始化 en.po 和 pl.po：

#...
env.POInit(['en', 'pl']) #messages.pot --> [en.po, pl.po]

例如： 2. 从 foo.pot 初始化 en.po 和 pl.po：

#...
env.POInit(['en', 'pl'], ['foo']) # foo.pot --> [en.po, pl.po]

例如： 3. 从 foo.pot 初始化 en.po 和 pl.po 但使用 $POTOMAIN 结构
变量：

#...
env.POInit(['en', 'pl'], POTDOMAIN='foo') # foo.pot --> [en.po, pl.po]

例如： 4. 为 LINGUAS 文件中定义的语言初始化 PO 文件。 这些文件将
从模板messages.pot初始化：

#...
env.POInit(LINGUAS_FILE = 1) # 需要 'LINGUAS' 文件

例如： 5. 初始化 en.po 和 pl.pl PO 文件以及在
语言文件。 这些文件将从模板messages.pot初始化：

#...
env.POInit(['en', 'pl'], LINGUAS_FILE = 1)

例如： 6. 您可以先预配置您的环境，然后初始化 PO 文件：

#...
环境['POAUTOINIT'] = 1
环境['LINGUAS_FILE'] = 1
env['POTDOMAIN'] = 'foo'
env.POInit()

与以下效果相同：

#...
env.POInit（POAUTOINIT = 1，LINGUAS_FILE = 1，POTDOMAIN = 'foo'）

后记（）, env.PostScript()
从 .dvi 输入文件（或扩展名为 .tex、.ltx 或 .latex）构建 .ps 文件
输入文件）。 指定的后缀 $PS后缀 构造变量（.ps by
default) 会自动添加到目标中，如果它不存在的话。 例子：

# 从 aaa.tex 构建
env.PostScript（目标 = 'aaa.ps'，源 = 'aaa.tex'）
# 从 bbb.dvi 构建 bbb.ps
env.PostScript（目标 = 'bbb'，源 = 'bbb.dvi'）

POT更新(), env.POTUpdate()
该构建器属于 xgettext 工具。 构建器更新目标 POT 文件（如果存在或
如果没有，则创建一个。 默认情况下不构建节点（即它被忽略
'.'），但仅在需要时（即需要给定 POT 文件或特殊别名时）
被调用）。 此构建器将其目标节点（例如，messages.pot）添加到特殊别名
（pot-update 默认情况下，请参阅 $POTUPDATE_ALIAS) 所以您可以轻松更新/创建它们
- 烤饼 锅更新. 在没有真正的变化之前不会写入文件
国际化消息（或在进入 POT 文件的注释中）。

备注
你可能会看到 获取文本(1) 被 xgettext 工具调用，即使没有
国际化消息的真正变化（因此 POT 文件没有被更新）。
每次源文件更改时都会发生这种情况。 在这种情况下，我们调用
获取文本(1) 并将其输出与 POT 文件的内容进行比较，以决定是否
该文件是否应该更新。

例如： 1. 让我们创建 po/ 目录并在其中放置以下 SConstruct 脚本：

# SConstruct in 'po/' 子目录
env = 环境（工具 = ['default', 'xgettext'] ）
env.POTUpdate(['foo'], ['../a.cpp', '../b.cpp'])
env.POTUpdate(['bar'], ['../c.cpp', '../d.cpp'])

然后调用 scons 几次：

user@host:$ scons # 不创建 foo.pot 和 bar.pot
user@host:$ scons foo.pot # 更新或创建 foo.pot
user@host:$ scons pot-update # 更新或创建 foo.pot 和 bar.pot
user@host:$ scons -c # 不清理 foo.pot 和 bar.pot。

结果应如上面的评论所说。

例如： 2. 这个 POT更新 builder 可以在没有指定目标的情况下使用，在这种情况下
将使用默认目标messages.pot。 默认目标也可以被覆盖
设置 $POTOMAIN 构造变量或将其作为覆盖提供给 POT更新
建造者：

# SConstruct 脚本
env = 环境（工具 = ['default', 'xgettext'] ）
env['POTDOMAIN'] = "foo"
env.POTUpdate(source = ["a.cpp", "b.cpp"]) # 创建 foo.pot ...
env.POTUpdate(POTDOMAIN = "bar", source = ["c.cpp", "d.cpp"]) # 和 bar.pot

例如： 3. 可以在单独的文件中指定源，例如
POTFILES.in:

# POTFILES.in 在 'po/' 子目录中
../a.cpp
../b.cpp
# 文件结束

包含源列表的文件 (POTFILES.in) 的名称通过以下方式提供
$XGETTEXTROM:

# 在 'po/' 子目录中构造文件
env = 环境（工具 = ['default', 'xgettext'] ）
env.POTUpdate(XGETTEXTFROM = 'POTFILES.in')

例如： 4. 您可以使用 $XGETTEXTPATH 定义源搜索路径。 假设，对于
例如，您有文件 a.cpp、b.cpp、po/SConstruct、po/POTFILES.in。 然后你的
POT 相关文件如下所示：

# POTFILES.in 在 'po/' 子目录中
一个.cpp
b.cpp
# 文件结束

# 在 'po/' 子目录中构造文件
env = 环境（工具 = ['default', 'xgettext'] ）
env.POTUpdate(XGETTEXTFROM = 'POTFILES.in', XGETTEXTPATH='../')

例如： 5. 可以在一个列表中定义多个搜索目录，即
XGETTEXTPATH = ['dir1', 'dir2', ...]。 列表中的顺序决定搜索
源文件的顺序。 使用找到的第一个文件的路径。

让我们创建 0/1/po/SConstruct 脚本：

# S在'0/1/po/'子目录中构造文件
env = 环境（工具 = ['default', 'xgettext'] ）
env.POTUpdate(XGETTEXTFROM = 'POTFILES.in', XGETTEXTPATH=['../', '../../'])

和 0/1/po/POTFILES.in：

# POTFILES.in 在 '0/1/po/' 子目录中
一个.cpp
# 文件结束

写两个*.cpp文件，第一个是0/a.cpp：

/* 0/a.cpp */
gettext("来自 ../../a.cpp 的你好")

第二个是 0/1/a.cpp：

/* 0/1/a.cpp */
gettext("你好，来自 ../a.cpp")

然后运行 ​​scons。 您将获得 0/1/po/messages.pot 并显示消息“Hello from
../a.cpp"。当您在 $XGETTEXTFOM，即当您将 SConscript 编写为

# S在'0/1/po/'子目录中构造文件
env = 环境（工具 = ['default', 'xgettext'] ）
env.POTUpdate(XGETTEXTFROM = 'POTFILES.in', XGETTEXTPATH=['../../', '../'])

那么 messages.pot 将包含 msgid "Hello from ../../a.cpp" 行而不是 msgid
“来自../a.cpp的你好”。

PO更新(), env.PO更新()
该构建器属于 msgmerge 工具。 构建器使用以下内容更新 PO 文件 消息合并(1),
或按照 msginit 工具文档中的说明初始化丢失的 PO 文件，以及
初始化 建造者（另见 $POAUTOINIT）。 注意 PO更新 不 而不去 加 它的 目标 至
创造 别号 as 初始化 一样。

通过定义的目标节点 PO更新 默认情况下不构建（它们被忽略
'。' 节点）。 相反，它们会自动添加到特殊别名（'po-update'
默认）。 别名可以通过 $POUPDATE_ALIAS 结构
多变的。 您可以通过以下方式轻松更新项目中的 PO 文件 烤饼 更新.

例如： 1. 从 messages.pot 模板更新 en.po 和 pl.po（另见 $POTOMAIN),
假设后一个存在或有规则来构建它（见 POT更新):

#...
env.POUpdate(['en','pl']) #messages.pot --> [en.po, pl.po]

例如： 2. 从 foo.pot 模板更新 en.po 和 pl.po：

#...
env.POUpdate(['en', 'pl'], ['foo']) # foo.pot --> [en.po, pl.pl]

例如： 3. 从 foo.pot 更新 en.po 和 pl.po（另一个版本）：

#...
env.POUpdate(['en', 'pl'], POTDOMAIN='foo') # foo.pot --> [en.po, pl.pl]

例如： 4. 更新在 LINGUAS 文件中定义的语言文件。 文件已更新
来自 messages.pot 模板：

#...
env.POUpdate(LINGUAS_FILE = 1) # 需要 'LINGUAS' 文件

例如： 5. 同上，但从 foo.pot 模板更新：

#...
env.POUpdate（LINGUAS_FILE = 1，源 = ['foo']）

例如： 6. 为 LINGUAS 文件中定义的语言更新 en.po 和 pl.po plus 文件。
这些文件是从 messages.pot 模板更新的：

# 生成 'en.po'、'pl.po' + 'LINGUAS' 中定义的文件：
env.POUpdate(['en', 'pl'], LINGUAS_FILE = 1)

例如： 7. 使用 VHDL 语言编写 $POAUTOINIT 如果 PO 文件不存在，则自动初始化它：

#...
env.POUpdate(LINGUAS_FILE = 1, POAUTOINIT = 1)

例如： 8. 更新 LINGUAS 文件中定义的语言的 PO 文件。 这些文件是
从 foo.pot 模板更新。 所有必要的设置都通过预配置
环境。

#...
环境['POAUTOINIT'] = 1
环境['LINGUAS_FILE'] = 1
env['POTDOMAIN'] = 'foo'
env.PO更新()

程序（）, 环境程序（）
在给定一个或多个目标文件或 C、C++、D 或 Fortran 源代码的情况下构建可执行文件
文件。 如果指定了任何 C、C++、D 或 Fortran 源文件，则它们将是
使用自动编译为目标文件 摆件 建造者方法； 看到那个
生成器方法对合法源文件后缀列表的描述及其方式
解释。 目标可执行文件前缀（由 $PROGP前缀
构造变量； 默认情况下没有）和后缀（由 $程序后缀
构造变量； 默认情况下，.exe 在 Windows 系统上，在 POSIX 系统上没有）
如果不存在，则会自动添加到目标中。 例子：

env.Program(target = 'foo', source = ['foo.o', 'bar.c', 'baz.f'])

资源（）, 环境.RES()
构建 Microsoft Visual C++ 资源文件。 此构建器方法仅在以下情况下提供
Microsoft Visual C++ 或 MinGW 被用作编译器。 .res（或 .o 表示
如果没有给出其他后缀，则将 MinGW) 后缀添加到目标名称中。 源文件
扫描隐式依赖项，就好像它是一个 C 文件一样。 例子：

env.RES('resource.rc')

RMIC(), 环境.RMIC()
从 Java .class 文件为远程对象构建存根和骨架类文件。 这
target 是一个相对于存根和骨架类文件的目录
书面。 源可以是 .class 文件的名称，也可以是从
爪哇岛 建造者方法。

如果构造变量 $JavaCLASSDIR 设置，无论是在环境中还是在
打电话给 RMIC builder 方法本身，那么变量的值将是
从任何 .class 文件名的开头删除。

classes = env.Java(target = 'classdir', source = 'src')
env.RMIC（目标 = 'outdir1'，源 = 类）

env.RMIC（目标='outdir2'，
source = ['package/foo.class', 'package/bar.class'])

env.RMIC（目标='outdir3'，
源 = ['classes/foo.class', 'classes/bar.class'],
JAVACLASSDIR = '类')

RPCGenClient(), env.RPCGenClient()
从指定的 RPC (.x) 源文件生成 RPC 客户端存根 (_clnt.c) 文件。
因为 rpcgen 只在本地目录中构建输出文件，所以命令将是
默认在源文件的目录中执行。

# 构建 src/rpcif_clnt.c
env.RPCGenClient('src/rpcif.x')

RPCGenHeader(), env.RPCGenHeader()
从指定的 RPC (.x) 源文件生成 RPC 头 (.h) 文件。 因为
rpcgen 只在本地目录中构建输出文件，该命令将被执行
默认在源文件的目录中。

# 构建 src/rpcif.h
env.RPCGenHeader('src/rpcif.x')

RPCGenService(), env.RPCGenService()
从指定的 RPC (.x) 源文件生成 RPC 服务器骨架 (_svc.c) 文件。
因为 rpcgen 只在本地目录中构建输出文件，所以命令将是
默认在源文件的目录中执行。

# 构建 src/rpcif_svc.c
env.RPCGenClient('src/rpcif.x')

RPCGenXDR(), env.RPCGenXDR()
从指定的 RPC (.x) 源文件生成 RPC XDR 例程 (_xdr.c) 文件。
因为 rpcgen 只在本地目录中构建输出文件，所以命令将是
默认在源文件的目录中执行。

# 构建 src/rpcif_xdr.c
env.RPCGenClient('src/rpcif.x')

共享库（）, env.SharedLibrary()
给定一个或多个共享库（POSIX 系统上的 .so，Windows 上的 .dll）
目标文件或 C、C++、D 或 Fortran 源文件。 如果给出任何源文件，则
它们将被自动编译为目标文件。 静态库前缀和
后缀（如果有）会自动添加到目标中。 目标库文件前缀
（由指定 $SHLIBPREFIX 构造变量； 默认情况下，POSIX 上的 lib
系统，在 Windows 系统上没有）和后缀（由 $SHLIB后缀
构造变量； 默认情况下，Windows 系统上的 .dll，POSIX 系统上的 .so）是
如果不存在，则自动添加到目标。 例子：

env.SharedLibrary（目标 = 'bar'，源 = ['bar.c'，'foo.o']）

在 Windows 系统上， 共享库 builder 方法将始终构建导入
(.lib) 库除了共享 (.dll) 库之外，还添加了一个 .lib 库
如果没有明确列出的.lib 文件，则使用相同的基本名称
的目标。

在 Cygwin 系统上， 共享库 builder 方法将始终构建导入
(.dll.a) 库除了共享 (.dll) 库之外，还添加了一个 .dll.a 库
如果在 .dll.a 文件中还没有明确列出
的目标。

源中列出的任何目标文件都必须是为共享库构建的（即
是，使用 共享对象 建造者方法）。 如果有任何错误，scons 将引发错误
不匹配。

在某些平台上，共享库（加载
系统自动解析外部引用）和可加载模块
（由用户操作显式加载）。 为了获得最大的便携性，请使用 可加载模块
后者的建设者。

当。。。的时候 $SHLIB版本 构造变量被定义为版本化共享库
创建的。 这修改了 $SHLINKFLAGS 根据需要，将版本号添加到
库名称，并创建所需的符号链接。

env.SharedLibrary（目标 = 'bar'，源 = ['bar.c'，'foo.o']，SHLIBVERSION='1.5.2'）

在 POSIX 系统上，具有单个标记的版本只创建一个符号链接：
libbar.so.6 只有符号链接 libbar.so。 在 POSIX 系统上，具有两个
或更多标记恰好创建两个符号链接：libbar.so.2.3.1 将具有符号链接
libbar.so 和 libbar.so.2； 在 Darwin (OSX) 系统上，该库将是
libbar.2.3.1.dylib，链接是 libbar.dylib。

在 Windows 系统上，指定 register=1 将导致 .dll 在之后注册
它是使用 REGSVR32 构建的。 运行的命令（默认为“regsvr32”）是
取决于 $REGSVR 构造变量，传递的标志由
$REGSVFLAGS。 默认， $REGSVFLAGS 包括 /s 选项，以防止对话框
运行时弹出并要求用户注意。 如果你改变 $REGSVFLAGS，同
一定要包括 /s 选项。 例如，

env.SharedLibrary(target = 'bar',
源 = ['bar.cxx', 'foo.obj'],
寄存器=1)

完成链接后会将 bar.dll 注册为 COM 对象。

共享对象（）, env.SharedObject()
构建目标文件以包含在共享库中。 源文件必须具有以下之一
上面为 静态对象 建造者方法。 在
某些构建共享对象的平台需要额外的编译器选项（例如
-fPIC 对于 gcc) 除了构建普通（静态）对象所需的那些之外，但在
在某些平台上，共享对象和普通（静态）没有区别
一。 当存在差异时，SCons 将只允许链接共享对象
到共享库中，并且将为共享对象使用不同的后缀。 在
在没有区别的平台上，SCons 将允许正常（静态）和
要链接到共享库的共享对象，并且将使用相同的后缀
共享和普通（静态）对象。 目标对象文件前缀（由
$SHOBJ前缀 构造变量； 默认情况下，与 $OBJ前缀) 和后缀
（由指定 $SHOBJ后缀 构造变量）被自动添加到
目标（如果不存在）。 例子：

env.SharedObject（目标 = 'ddd'，源 = 'ddd.c'）
env.SharedObject（目标 = 'eee.o'，源 = 'eee.cpp'）
env.SharedObject（目标 = 'fff.obj'，源 = 'fff.for'）

请注意，源文件将根据后缀映射进行扫描
SourceFileScanner 对象。 有关更多信息，请参阅下面的“扫描仪对象”部分
信息。

静态库（）, env.StaticLibrary()
在给定一个或多个目标文件或 C、C++、D 或 Fortran 源代码的情况下构建静态库
文件。 如果给出了任何源文件，那么它们将被自动编译为
目标文件。 静态库前缀和后缀（如果有）会自动添加到
目标。 目标库文件前缀（由 $LIBPREFIX 结构
多变的; 默认情况下，POSIX 系统上的 lib，Windows 系统上没有）和后缀
（由指定 $LIBSFFIX 构造变量； 默认情况下，.lib 在 Windows 上
系统，POSIX 系统上的 .a ）会自动添加到目标中（如果尚未添加）
展示。 例子：

env.StaticLibrary（目标 = 'bar'，源 = ['bar.c'，'foo.o']）

源代码中列出的任何目标文件都必须是为静态库构建的（即
是，使用 静态对象 建造者方法）。 如果有任何错误，scons 将引发错误
不匹配。

静态对象（）, env.StaticObject()
从一个或多个 C、C++、D 或 Fortran 源文件构建静态对象文件。
源文件必须具有以下扩展名之一：

.asm 汇编语言文件
.ASM 汇编语言文件
.c C 文件
.C Windows：C 文件
POSIX：C++ 文件
.cc C++ 文件
.cpp C++ 文件
.cxx C++ 文件
.cxx C++ 文件
.c++ C++ 文件
.C++ C++ 文件
.d D 文件
.f Fortran 文件
.F Windows：Fortran 文件
POSIX：Fortran 文件 + C 预处理器
.for Fortran 文件
.FOR Fortran 文件
.fpp Fortran 文件 + C 预处理器
.FPP Fortran 文件 + C 预处理器
.m 对象 C 文件
.mm 对象 C++ 文件
.s 汇编语言文件
.S Windows：汇编语言文件
ARM：CodeSourcery Sourcery Lite
.sx 汇编语言文件 + C 预处理器
POSIX：汇编语言文件 + C 预处理器
.spp 汇编语言文件 + C 预处理器
.SPP 汇编语言文件 + C 预处理器

目标对象文件前缀（由 $OBJ前缀 构造变量；
默认情况下没有）和后缀（由 $OBJ后缀 构造变量；
.obj 在 Windows 系统上，.o 在 POSIX 系统上）自动添加到目标，如果
尚未出现。 例子：

env.StaticObject（目标 = 'aaa'，源 = 'aaa.c'）
env.StaticObject（目标='bbb.o'，源='bbb.c++'）
env.StaticObject（目标 = 'ccc.obj'，源 = 'ccc.f'）

注意源文件会根据后缀映射进行扫描
SourceFileScanner 对象。 有关更多信息，请参阅下面的“扫描仪对象”部分
信息。

子文件（）, env.Substfile()
这个 子文件 builder 通过从另一个文件或一组文件创建单个文本文件
将它们与 $行分隔符 并使用替换文本 $SUBST_DICT
构造变量。 源文件的嵌套列表被展平。 也可以看看 文本文件.

如果存在带有 .in 后缀的单个源文件，则去除后缀并
余数用作默认目标名称。

指定的前缀和后缀 $SUBSTFILE前缀 和 $SUBST文件后缀
构造变量（在这两种情况下默认为空字符串）是自动
如果它们不存在，则添加到目标。

如果一个名为的构造变量 $SUBST_DICT 存在，它可能是 Python
字典或一系列（键，值）元组。 如果是字典，它会被转换
以任意顺序进入元组列表，因此如果一个键是另一个键的前缀
或者如果一个替换可以被另一个替换进一步扩展，它是
无法预测是否会发生膨胀。

源中出现的任何键都将替换为相应的值，即
可能是 Python 可调用函数或字符串。 如果该值是可调用的，则它是
不带参数调用以获取字符串。 字符串是 SUBST-扩展和结果
代替钥匙。

env = 环境（工具 = ['默认'，'文本文件']）

env['前缀'] = '/ usr / bin'
script_dict = {'@prefix@':'/箱', @exec_prefix@: '$prefix'}
env.Substfile('script.in', SUBST_DICT = script_dict)

conf_dict = {'%VERSION%': '1.2.3', '%BASE%': 'MyProg'}
env.Substfile('config.h.in', conf_dict, SUBST_DICT = conf_dict)

# UNPREDICTABLE - 一个键是另一个键的前缀
bad_foo = {'$foo': '$foo', '$foobar': '$foobar'}
env.Substfile('foo.in', SUBST_DICT = bad_foo)

# PREDICTABLE - 首先应用最长的键
good_foo = [('$foobar', '$foobar'), ('$foo', '$foo')]
env.Substfile('foo.in', SUBST_DICT = good_foo)

# UNPREDICTABLE - 一个替换可以进一步扩展
bad_bar = {'@bar@': '@soap@', '@soap@': '碱液'}
env.Substfile('bar.in', SUBST_DICT = bad_bar)

# PREDICTABLE - 替换按顺序展开
good_bar = (('@bar@', '@soap@'), ('@soap@', '碱液'))
env.Substfile('bar.in', SUBST_DICT = good_bar)

# SUBST_DICT 可能是共同的（而不是覆盖）
替代 = {}
subst = 环境（工具 = ['textfile']，SUBST_DICT = 替换）
替换['@foo@'] = 'foo'
subst['SUBST_DICT']['@bar@'] = 'bar'
subst.Substfile('pgm1.c', [Value('#include "@[email protected]“'），
值（'#include“@[email protected]“'），
"common.in",
“pgm1.in”
])
subst.Substfile('pgm2.c', [Value('#include "@[email protected]“'），
值（'#include“@[email protected]“'），
"common.in",
“pgm2.in”
])

柏油（）, 环境焦油（）
构建指定文件和/或目录的 tar 存档。 不像大多数建筑商
方法， 焦油 对于给定的目标，可以多次调用 builder 方法； 每个
附加调用会添加到将被构建到存档中的条目列表中。 任何
将扫描源目录以查找对任何磁盘文件的更改，无论
scons 是否从其他 Builder 或函数调用中知道它们。

env.Tar('src.tar', 'src')

# 创建 stuff.tar 文件。
env.Tar('stuff', ['subdir1', 'subdir2'])
# 还要在 stuff.tar 文件中添加“另一个”。
env.Tar('东西', '另一个')

# 设置 TARFLAGS 以创建经过 gzip 过滤的存档。
env = 环境（TARFLAGS = '-c -z'）
env.Tar('foo.tar.gz', 'foo')

# 同时将后缀设置为 .tgz。
env = 环境（TARFLAGS = '-c -z'，
TARSUFFIX = '.tgz')
env.Tar('foo')

文本文件（）, 环境文本文件()
这个 文本文件 builder 生成单个文本文件。 源字符串构成
线条； 嵌套的源列表被展平。 $行分隔符 用于分隔
字符串。

如果存在，则 $SUBST_DICT 构造变量用于修改之前的字符串
它们是写的； 见 子文件 详细说明。

指定的前缀和后缀 $文本文件前缀 和 $文本文件后缀
构造变量（默认情况下分别为空字符串和 .txt）是
如果它们不存在，则自动添加到目标。 例子：

# 构建/写入 foo.txt
env.Textfile(target = 'foo.txt', source = ['Goethe', 42, 'Schiller'])

# 构建/写入 bar.txt
env.Textfile(target = 'bar',
来源 = ['lalala', 'tanteratei'],
LINESEPARATOR='|*')

# 嵌套列表会自动展平
env.Textfile(目标 = 'blob',
来源 = ['lalala', ['Goethe', 42 'Schiller'], 'tanteratei'])

# 文件可以通过将它们包装在 File() 中用作输入
env.Textfile(target = 'concat', # 用标记连接文件
源 = [文件（'concat1'），文件（'concat2'）]，
LINESEPARATOR = '=====================\n')

结果是：
文件.txt
....8<----
歌德
42
席勒
....8<---- （最后没有换行）

bar.txt：
....8<----
拉拉拉|*坦坦拉泰
....8<---- （最后没有换行）

斑点.txt
....8<----
LALALA
歌德
42
席勒
坦特拉泰
....8<---- （最后没有换行）

翻译（）, 环境翻译（）
这个伪生成器属于 gettext 工具集。 构建器提取国际化
来自源文件的消息，更新 POT 模板（如有必要），然后更新 PO
翻译（如有必要）。 如果 $POAUTOINIT 已设置，丢失的 PO 文件将
自动创建（即无需翻译人员干预）。 变量
$LINGUAS_FILE 和 $POTOMAIN 也被考虑在内。 所有其他建筑
使用的变量 POT更新和 PO更新 也在这里工作。

例如： 1. 最简单的方法是在一个
调用时的 SCons 脚本 翻译

# 'po/' 目录中的 SConscript
env = 环境（工具 = [“默认”，“gettext”]）
环境['POAUTOINIT'] = 1
env.Translate(['en','pl'], ['../a.cpp','../b.cpp'])

例如： 2. 如果您愿意，您也可以坚持使用 autotools 中已知的传统样式，
即使用 POTFILES.in 和 LINGUAS 文件

# 语言
输入
＃结束

#POTFILES.in
一个.cpp
b.cpp
＃ 结尾

# 征兵
env = 环境（工具 = [“默认”，“gettext”]）
环境['POAUTOINIT'] = 1
env['XGETTEXTPATH'] = ['../']
env.Translate(LINGUAS_FILE = 1, XGETTEXTFROM = 'POTFILES.in')

最后一种方法可能是推荐的方法。 它允许轻松拆分
国际化/本地化到单独的 SCons 脚本，其中一个脚本
源树负责翻译（从源到 PO 文件）和脚本
变体目录下负责将 PO 编译为 MO 文件
MO文件的安装。 同步这两个脚本的“粘合因素”是
LINGUAS 文件的内容。 请注意，更新的 POT 和 PO 文件通常会
提交回存储库，因此它们必须在源中更新
目录（而不是在变体目录中）。 此外，po/ 的文件列表
目录包含 LINGUAS 文件，因此源代码树看起来对翻译者来说很熟悉，并且
他们可以以他们通常的方式处理该项目。

例如： 3. 让我们准备一个开发树，如下所示

项目/
+ S构造
+构建/
+源/
+ 宝/
+ 征兵
+ SConscript.i18n
+ POTFILES.in
+ 语言

构建是变体目录。 编写顶层 SConstruct 脚本如下

# S构造
env = 环境（工具 = [“默认”，“gettext”]）
VariantDir('build', 'src', 重复 = 0)
环境['POAUTOINIT'] = 1
SConscript('src/po/SConscript.i18n', 出口 = 'env')
SConscript('build/po/SConscript', 出口 = 'env')

src/po/SConscript.i18n 为

# src/po/SConscript.i18n
导入（'env'）
env.Translate(LINGUAS_FILE=1, XGETTEXTFROM='POTFILES.in', XGETTEXTPATH=['../'])

和 src/po/SConscript

# src/po/SConscript
导入（'env'）
env.MOFiles（LINGUAS_FILE = 1）

这样的设置在 src/po/ 和二进制 MO 文件的源树下生成 POT 和 PO 文件
在 build/po/ 中的变体树下。 这样 POT 和 PO 文件就可以从
其他输出文件，不得提交回源存储库（例如 MO
文件）。

备注
在上面的示例中，PO 文件不会更新，也不会在您自动创建
问题 烤饼 '。' 命令。 文件必须通过手动更新（创建） 烤饼
更新 然后可以通过运行编译 MO 文件 烤饼 '。'.

类型库（）, 环境类型库()
从输入 IDL 文件 (.idl) 构建 Windows 类型库 (.tlb) 文件。 此外，
它将构建相关的接口存根和代理源文件，命名它们
根据 .idl 文件的基本名称。 例如，

env.TypeLibrary(source="foo.idl")

将创建 foo.tlb、foo.h、foo_i.c、foo_p.c 和 foo_data.c 文件。

uic(), 环境.Uic()
从 ui 文件构建头文件、实现文件和 moc 文件。 和
按上述顺序返回对应的节点。 此构建器仅可用
使用工具“qt”后。 注意：您可以直接将 .ui 文件指定为源文件
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 教学计划, 自学资料库 和 共享库 不使用此构建器的构建器。 使用这个
builder 允许您覆盖标准命名约定（注意：前缀是
总是附加在构建文件的名称之前； 如果你不想要前缀，你可以设置它们
到``）。 见 $QTDIR 变量以获取更多信息。 例子：

env.Uic('foo.ui') # -> ['foo.h', 'uic_foo.cc', 'moc_foo.cc']
env.Uic(target = Split('include/foo.h gen/uicfoo.cc gen/mocfoo.cc'),
source = 'foo.ui') # -> ['include/foo.h', 'gen/uicfoo.cc', 'gen/mocfoo.cc']

压缩（）, 环境.Zip()
构建指定文件和/或目录的 zip 存档。 不像大多数建筑商
方法， 压缩 对于给定的目标，可以多次调用 builder 方法； 每个
附加调用会添加到将被构建到存档中的条目列表中。 任何
将扫描源目录以查找对任何磁盘文件的更改，无论
scons 是否从其他 Builder 或函数调用中知道它们。

env.Zip('src.zip', 'src')

# 创建 stuff.zip 文件。
env.Zip('stuff', ['subdir1', 'subdir2'])
# 还要在 stuff.tar 文件中添加“另一个”。
env.Zip('东西', '另一个')

构建器方法的所有目标都自动依赖于它们的源。 显式
可以使用指定的依赖项 取决于 施工环境的方法（见
下文）。

此外， 烤饼 自动扫描各种编程语言的源文件，所以
不需要明确指定依赖项。 默认情况下，SCons 可以 C 源
文件、C++ 源文件、Fortran 源文件 .F （仅限 POSIX 系统）， .fpp, or .FPP
文件扩展名和汇编语言文件 .S （仅限 POSIX 系统）， .spp, or .SPP
C 预处理器依赖项的文件扩展名。 SCons 还默认支持
扫描 D 源文件，您也可以编写自己的 Scanner 来添加对
其他源文件类型。 这些可以添加到由
摆件（） 静态对象（）， 和 共享对象() 构建器通过将它们添加到
源文件扫描器 目的。 有关详细信息，请参阅下面的“扫描仪对象”部分
关于定义自己的 Scanner 对象和使用 源文件扫描器 目的。

方法 和 功能 至 Do 事情
除了 Builder 方法， 烤饼 提供多种其他施工环境
方法和全局函数来操作构建配置。

通常，同名的构造环境方法和全局函数
存在，这样您就不必记住某个特定的功能是否必须
在有或没有构建环境的情况下调用。 在以下列表中，如果您调用
作为一个全局函数，它看起来像：

功能（参数)

如果您通过构造环境调用某些东西，它看起来像：

环境函数（参数)

如果您可以通过两种方式调用该功能，那么会列出两种形式。

全局函数可以从您导入的自定义 Python 模块中调用
通过将以下内容添加到 Python 模块来创建 SConscript 文件：

从 SCons.Script 导入 *

除非另有说明，同名构建环境方法和全局
功能提供完全相同的功能。 唯一的区别是，在哪里
适当，通过构造环境调用功能将替代
构造变量到任何提供的字符串中。 例如：

环境 = 环境（FOO = 'foo'）
默认（'$FOO'）
env.Default('$FOO')

在上面的例子中，第一次调用全局 默认（） 函数实际上会添加一个
目标命名 $FOO 到默认目标列表，而第二次调用
env.Default() 构造环境方法将扩展值并添加一个名为
FOO 到默认目标列表。 有关构造变量扩展的更多信息，请参阅
下一节将介绍构造变量。

支持的构建环境方法和全局函数 烤饼 包括：

Action(action, [cmd/str/fun, [var, ...]] [option=value, ...]), env.Action(action,
[cmd/str/fun, [var, ...]] [选项=值, ...])
为指定的创建一个 Action 对象 行动. 请参阅“动作对象”部分
下面，对论点和行为的完整解释。

请注意 环境动作() 形式的调用将扩展构造变量
在任何参数字符串中，包括 行动 参数，当时它被称为 using
中的构造变量 ENV 施工环境
环境动作（） 被称为。 这 操作() 形式延迟所有变量扩展，直到
实际使用了 Action 对象。

AddMethod(对象, 函数, [名称]), env.AddMethod(函数, [名称])
当用 添加方法() 形式，添加指定 function 到指定的
对象 作为指定的方法 姓名. 当调用 env.Add方法() 形式，添加
指定的 function 对施工环境 ENV 作为指定的方法
姓名. 在这两种情况下，如果 姓名 省略或None，指定的名称 function
本身用于方法名称。

例子：

# 注意函数的第一个参数
# 被附加为方法必须是对象通过
# 将调用哪个方法； 蟒蛇
# 约定是称它为“自我”。
def my_method（自我，arg）：
print "my_method() got", arg

# 使用全局 AddMethod() 函数添加方法
# 到环境类。 这
AddMethod（环境，my_method）
环境 = 环境（）
env.my_method('arg')

# 添加函数作为方法，使用函数
# 方法调用的名称。
环境 = 环境（）
env.AddMethod(my_method, 'other_method_name')
env.other_method_name('另一个参数')

添加选项（参数）
此函数添加了一个新的命令行选项以进行识别。 指定的 参数
与标准 Python 支持的相同 optparse.add_option() 方法（带有
下面提到的一些附加功能）； 请参阅 optparse 的文档
对其期权处理能力的全面讨论。

除了支持的参数和值 optparse.add_option（） 方法，
SCons 添加选项 函数允许您将 nargs 关键字值设置为“？” （一种
仅带问号的字符串）以指示指定的长选项
采取（S）一个 可选 争论。 当 nargs = '?' 被传递给 添加选项 功能，
const 关键字参数可用于提供应为的“默认”值
当在命令行上指定选项而没有显式参数时使用。

如果调用时没有提供 default= 关键字参数 添加选项，该选项将
默认值为无。

一旦添加了新的命令行选项 添加选项, 期权价值可能是
使用访问 获取选项 or env.GetOption 选项()。 该值也可以设置，使用
设置选项 or 环境设置选项()，如果 SConscript 中的条件需要覆盖任何
默认值。 但是请注意，在命令行中指定的值将 时刻
覆盖任何 SConscript 文件设置的值。

任何为新选项指定的 help= 字符串都将由 -H or -h
选项（仅当 SConscript 文件中未指定其他帮助文本时才使用后者）。
由指定的本地选项的帮助文本 添加选项 将出现在 SCons 下方
选项本身，在单独的本地选项标题下。 选项将出现在
帮助文本的顺序 添加选项 通话发生。

计费示例：

AddOption('--前缀',
dest='前缀',
nargs=1，类型='字符串'，
动作='商店'，
元变量='目录'，
help='安装前缀')
env = Environment(PREFIX = GetOption('prefix'))

AddPostAction(目标, 行动), env.AddPostAction(目标, 行动)
安排指定 行动 在指定之后执行 目标 一直
建成。 指定的动作可以是一个动作对象，或者任何可以是
转换为 Action 对象（见下文）。

当提供多个目标时，动作可能会被调用多次，一次
在每个生成列表中的一个或多个目标的操作之后。

AddPreAction(目标, 动作), env.AddPreAction(目标, 动作)
安排指定 行动 在指定之前执行 目标 is
建成。 指定的动作可以是一个动作对象，或者任何可以是
转换为 Action 对象（见下文）。

当指定多个目标时，动作可能会被调用多次，一次
在生成列表中的一个或多个目标的每个操作之前。

请注意，如果任何目标是在多个步骤中构建的，则操作将是
在专门生成指定的“最终”操作之前调用
目标。 例如，从指定的源 .c 构建可执行程序时
通过中间目标文件文件：

foo = 程序（'foo.c'）
AddPreAction(foo, 'pre_action')

指定的 pre_action 将在 scons 调用链接命令之前执行
实际生成可执行程序二进制 foo，而不是在编译 foo.c 之前
文件转换为目标文件。

别名（别名，[targets，[action]]），env.Alias（别名，[targets，[action]]）
创建一个或多个虚假目标，并扩展到一个或多个其他目标。 一个
可选 行动 （命令）或可以指定将要执行的动作列表
每当任何别名目标过期时。 返回节点对象
表示存在于任何文件系统之外的别名。 此 Node 对象，或
别名，可以用作任何其他目标的依赖项，包括另一个
别名。 别名 可以多次调用同一个别名来添加额外的
别名的目标，或此别名列表的附加操作。

例子：

别名（'安装'）
别名（'安装'，'/ usr / bin')
别名（['install', 'install-lib'], '在/ usr / local / lib目录')

env.Alias('安装', ['在/ usr / local / bin目录'，'在/ usr / local / lib目录'])
env.Alias('安装', ['/ usr /本地/ man'])

env.Alias('update', ['file1', 'file2'], "update_database $SOURCES")

AllowSubstExceptions([异常，...])
指定扩展构造变量时允许的异常。
默认情况下，任何生成 NameError 或
IndexError 异常将扩展为 ''（空字符串）并且不会导致 scons 失败。
不在指定列表中的所有异常都将生成错误消息并终止
处理。

If 允许子异常 被多次调用，每次调用都会完全覆盖
先前允许的例外列表。

计费示例：

# 要求所有构造变量名称都存在。
# （如果你想严格执行，你可能希望这样做
# 所有构造变量必须在使用前定义。）
允许SubstExceptions()

# 也允许包含零除扩展的字符串
# like '${1 / 0}' 评估为 ''。
AllowSubstExceptions（IndexError、NameError、ZeroDivisionError）

AlwaysBuild(目标, ...), env.AlwaysBuild(目标, ...)
每个给定的标记 目标 所以它总是被认为是过时的，并且会
如果需要，总是重建。 但是请注意， 始终构建 不添加其
target(s) 到默认目标列表，因此只有在它们是
在命令行中指定，或者依赖于在命令中指定的目标
线——但他们会 时刻 如果指定，则建造。 可以传入多个目标
打一次电话 始终构建.

env.Append(key=val, [...])
将指定的关键字参数附加到构造变量的末尾
环境。 如果 Environment 没有指定的构造变量，它
只是简单地添加到环境中。 如果构造变量的值和
关键字参数是相同的类型，那么这两个值将简单地相加。
否则，构造变量和关键字参数的值都是
强制到列表，并且列表被添加到一起。 （另见 Prepend 方法，
下面。）

计费示例：

env.Append(CCFLAGS = '-g', FOO = ['foo.yyy'])

env.AppendENVPath（名称，新路径，[envname，sep，delete_existing]）
这会将新路径元素附加到指定外部环境中的给定路径
（默认为 ENV）。 这只会添加任何特定路径一次（留下最后一个
遇到并忽略其余部分，以保持路径顺序），并帮助确保这一点，
将规范化所有路径（使用 操作系统路径规范路径 和 os.path.normcase）。 这也可以
处理给定的旧路径变量是列表而不是字符串的情况，在
在这种情况下，将返回一个列表而不是一个字符串。

If 删除现有的 为0，则添加已存在的路径不会将其移动到
结束; 它将保持在列表中的位置。

计费示例：

打印'之前：'，env['ENV']['INCLUDE']
include_path = '/foo/bar:/foo'
env.AppendENVPath('INCLUDE', include_path)
打印'之后：'，env['ENV']['INCLUDE']

产量：
之前：/foo:/biz
之后：/biz:/foo/bar:/foo

env.AppendUnique(key=val, [...], delete_existing=0)
将指定的关键字参数附加到构造变量的末尾
环境。 如果 Environment 没有指定的构造变量，它
只是简单地添加到环境中。 如果附加到的构造变量是
一个列表，那么构造变量中已经存在的任何值将 而不去 be
再次添加到列表中。 但是，如果 delete_existing 为 1，则现有匹配值
首先删除，因此 arg 列表中的现有值移动到列表的末尾。

计费示例：

env.AppendUnique(CCFLAGS = '-g', FOO = ['foo.yyy'])

env.BitKeeper()
一个工厂函数，它返回一个用于获取源文件的 Builder 对象
使用 BitKeeper。 返回的 Builder 旨在传递给 源代码
功能。

此功能已弃用。 有关详细信息，请参阅条目 源代码 功能。

计费示例：

env.SourceCode('.', env.BitKeeper())

BuildDir（build_dir，src_dir，[重复]），env.BuildDir（build_dir，src_dir，[重复]）
弃用的同义词 变体目录 和 环境变量目录(). 这 构建目录 论点
变成了 变体目录 的论点 变体目录 or 环境变量目录（）。

生成器（动作，[参数]），env.Builder（动作，[参数]）
为指定的创建 Builder 对象 行动. 请参阅“构建器对象”部分
下面，对论点和行为的完整解释。

请注意 环境生成器() 形式的调用将扩展构造变量
在任何参数字符串中，包括 行动 论据，当时它被称为
使用构造变量 ENV 施工环境
环境生成器（） 被称为。 这 生成器 表单将所有变量扩展延迟到之后
实际上调用了 Builder 对象。

CacheDir(缓存目录), env.CacheDir(缓存目录)
指定 scons 将在 缓存目录. 派生的
缓存中的文件将在所有使用相同的构建之间共享 缓存目录 呼叫。
指定一个 缓存目录 of None 禁用派生文件缓存。

调用 环境缓存目录() 只会影响通过指定构建的目标
施工环境。 打电话 缓存目录 设置将被使用的全局默认值
通过构建环境构建的所有目标 而不去 有 环境缓存目录()
指定的。

当 缓存目录() 正在使用，scons 找到了需要的派生文件
重建后，它会首先在缓存中查看派生文件是否已经被
从相同的输入文件和相同的构建操作构建（如合并到
MD5 构建签名）。 如果是这样，scons 将从缓存中检索文件。 如果
派生文件不在缓存中，scons 将重建它然后放置一个副本
缓存中的构建文件（由其 MD5 构建签名标识），以便它可以
由其他需要从相同的派生文件构建相同派生文件的构建检索
投入。

使用指定的 缓存目录 可以通过使用禁用任何调用
--缓存禁用 选项。

如果 --缓存力 使用选项，scons 将放置一个副本 所有 派生文件在
缓存，即使它们已经存在并且不是通过此调用构建的。 这是
第一次填充缓存很有用 缓存目录 被添加到构建中，或者在使用之后
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 --缓存禁用 选项。

使用时 缓存目录, scons 将报告，“Retrieved `file' from cache”，除非
--缓存显示 正在使用选项。 当。。。的时候 --缓存显示 使用选项，scons 将
打印动作 将 已用于构建文件，没有任何指示
该文件实际上是从缓存中检索到的。 这对于生成构建很有用
无论是否构建了给定的派生文件，日志都是等效的
就地或从缓存中检索。

这个 无缓存 方法可用于禁用特定文件的缓存。 这可以是
如果某些工具的输入和/或输出无法预测或
大得令人望而却步。

清洁（目标，files_or_dirs），env.Clean（目标，files_or_dirs）
这指定了一个文件或目录列表，只要
目标是用指定的 -c 命令行选项。 指定的目标可能是
列表或单个目标。 多次调用 清洁 是合法的，并创造新的
目标或将文件和目录添加到指定目标的清理列表中。

多个文件或目录应指定为单独的参数
清洁 方法，或作为列表。 清洁 也将接受任何的返回值
构建环境Builder方法。 例子：

相关的 不清洁 函数覆盖调用 清洁 对于相同的目标，任何
传递给这两个函数的目标将 而不去 被删除 -c 选项。

例子：

清洁（'foo'，['bar'，'baz']）
Clean('dist', env.Program('hello', 'hello.c'))
清洁（['foo'，'bar']，'something_else_to_clean'）

在此示例中，安装项目会为文档创建一个子目录。
如果项目被卸载，此语句会导致子目录被删除。

清洁（docdir，os.path.join（docdir，项目名称））

env.Clone([key=val, ...])
返回构造环境的单独副本。 如果有关键字
指定的参数，它们被添加到返回的副本中，覆盖任何现有的
关键字的值。

计费示例：

env2 = env.Clone()
env3 = env.Clone(CCFLAGS = '-g')

此外，可以指定工具列表和工具路径，如在环境中
构造函数：

def MyTool(env): env['FOO'] = 'bar'
env4 = env.Clone(工具 = ['msvc', MyTool])

这个 解析标志 关键字参数也被识别：

# 为编译使用 wxWidgets 的程序创建环境
wx_env = env.Clone(parse_flags = '!wx-config --cflags --cxxflags')

命令（目标，源，动作，[key=val，...]），env.Command（目标，源，动作，
[键=val，...]）
执行特定操作（或操作列表）以构建一个或多个目标文件。 这
比为单个特殊情况定义单独的 Builder 对象更方便
建立。

作为一种特殊情况， 来源扫描仪 关键字参数可用于指定一个
将用于扫描源的扫描仪对象。 （全局 DirScanner 对象
如果任何源将是必须在磁盘上扫描的目录，则可以使用
对其他函数调用的 Builder 中尚未指定的文件的更改。）

指定的任何其他关键字参数覆盖任何同名的现有构造
变量。

动作可以是外部命令，指定为字符串，也可以是可调用的 Python
目的; 有关更完整的信息，请参阅下面的“操作对象”。 另请注意，一个
指定外部命令的字符串前面可能有一个 @（at 符号）以抑制
打印有问题的命令，或通过 - （连字符）忽略退出状态
外部命令。

例子：

env.Command('foo.out', 'foo.in',
"$FOO_BUILD < $SOURCES > $TARGET")

env.Command('bar.out', 'bar.in',
["rm -f $目标",
"$BAR_BUILD < $SOURCES > $TARGET"],
ENV = {'路径'：'/ usr /本地/ bin /'})

def 重命名（环境，目标，源）：
导入操作系统
os.rename('.tmp', str(目标[0]))

env.Command('baz.out', 'baz.in',
["$BAZ_BUILD < $SOURCES > .tmp",
改名 ]）

请注意 命令 默认情况下，函数通常会假定指定的
如果配置的其他部分没有标识，则目标和/或源是文件
它是什么类型的条目。 如有必要，您可以明确指定目标或
源节点应被视为目录，使用 你 or 环境目录()
功能。

例子：

env.Command('ddd.list', Dir('ddd'), 'ls -l $SOURCE > $TARGET')

env['DISTDIR'] = '目标/目录'
env.Command(env.Dir('$DISTDIR'))，无，make_distdir)

（另请注意，SCons 通常会自动创建所需的任何目录
保存一个目标文件，因此您通常不需要手动创建目录。）

配置（env，[custom_tests，conf_dir，log_file，config_h]），env.Configure（[custom_tests，
conf_dir、log_file、config_h])
为类似于 GNU autoconf 的集成功能创建一个配置对象。 看
下面的“配置上下文”部分，以获得对参数的完整解释
和行为。

env.Copy([key=val, ...])
现已弃用的同义词 环境克隆（）。

env.CVS（存储库，模块）
一个工厂函数，它返回一个 Builder 对象，用于从中获取源文件
指定的 CVS 知识库. 返回的 Builder 旨在传递给
源代码 功能。

此功能已弃用。 有关详细信息，请参阅条目 源代码 功能。

指定的可选 模块 将添加到所有存储库路径的开头
姓名； 本质上，这可以用来从
存储库路径名，因此您只需复制部分存储库
本地构建目录中的目录层次结构。

例子：

# 将获取 foo/bar/src.c
# 来自 /usr/local/CVSROOT/foo/bar/src.c。
env.SourceCode('.', env.CVS('/usr/local/CVSROOT'))

# 将获取 bar/src.c
# 来自 /usr/local/CVSROOT/foo/bar/src.c。
env.SourceCode('.', env.CVS('/usr/local/CVSROOT', 'foo'))

# 将获取 src.c
# 来自 /usr/local/CVSROOT/foo/bar/src.c。
env.SourceCode('.', env.CVS('/usr/local/CVSROOT', 'foo/bar'))

决策者（函数），环境决策者（函数）
指定通过此构造构建的目标的所有最新决策
环境将由指定的处理 function。 该 function 可以是其中之一
以下字符串指定要执行的决策函数的类型：

时间戳更新
指定目标应被视为过期并重建，如果
依赖项的时间戳比目标文件的时间戳更新。 这是
经典 Make 实用程序的行为，并且 make 可以用作同义词
时间戳更新。

时间戳匹配
指定目标应被视为过期并重建，如果
依赖的时间戳与上次记录的时间戳不同
目标已建立。 这提供了与经典 Make 实用程序非常相似的行为
（特别是，文件没有被打开，所以它们的内容可以被校验和）
除了如果依赖文件已经恢复，目标也将被重建
到一个版本 早期 时间戳，例如在恢复文件时可能发生
从备份档案。

MD5
指定目标应被视为过期并重建，如果
依赖项的内容在上次构建目标时发生了变化，如
确定对依赖项的内容执行 MD5 校验和
将其与上次构建目标时记录的校验和进行比较。 内容
可以用作 MD5 的同义词。

MD5-时间戳
指定目标应被视为过期并重建，如果
依赖项的内容在上次构建目标时发生了变化，除了
具有与目标上次匹配的时间戳的依赖项
重建将被认为是最新的，并且 而不去 重建。 这提供了行为
与始终校验和文件内容的 MD5 行为非常相似，具有
优化不检查时间戳没有的文件的内容
改变了。 缺点是 SCons 会 而不去 检测文件的内容是否有
改变了，但它的时间戳是一样的，就像在一个自动化脚本中可能发生的那样
运行构建、更新文件并再次运行构建，所有这些都在一个单一的
第二。

例子：

# 默认使用精确的时间戳匹配。
决定者（'时间戳匹配'）

# 对构建的任何目标使用 MD5 内容签名
#附上施工环境。
env.Decider('内容')

除了上述已有的功能外， function 争论可能是一个
采用以下三个参数的实际 Python 函数：

依赖
应该导致的节点（文件） 目标 如果它“改变”了就重建
自上次以来 目标 被建。

目标
正在构建的节点（文件）。 在正常情况下，这是应该重建的
如果 依赖 已经改变。”

上一页
存储的状态信息 依赖 最后一次 目标 是
建成。 可以参考它来匹配各种文件特征，例如
时间戳、大小或内容签名。

这个 function 如果 依赖 已经改变”
自上次以来 目标 已建成（表明目标 应该 be
重建），否则为 False（零）（表示目标应该 而不去 be
重建）。 请注意，可以使用任何适当的标准来做出决定。
忽略部分或全部函数参数是完全正常的。

计费示例：

def my_decider（依赖，目标，prev_ni）：
返回不是 os.path.exists(str(target))

环境决定者（我的决定者）

默认（目标），env.Default（目标）
这指定了一个默认目标列表，如果没有明确的，它将由 scons 构建
目标在命令行上给出。 多次调用 默认 是合法的，并添加到
默认目标列表。

应将多个目标指定为单独的参数 默认 方法，或
作为列表。 默认 还将接受任何构造返回的节点
环境的构建器方法。

例子：

默认（'foo'，'bar'，'baz'）
env.Default(['a', 'b', 'c'])
你好 = env.Program('hello', 'hello.c')
env.Default（你好）

一个论据 默认 of None 将清除所有默认目标。 后来打电话给 默认
将像往常一样添加到（现在为空的）默认目标列表中。

使用添加的当前目标列表 默认 函数或方法可用于
DEFAULT_TARGETS 列表； 见下文。

默认环境（[参数]）
创建并返回一个默认的构造环境对象。 这种建设
SCons 在内部使用环境来执行许多全局
此列表中的函数，并从源代码中透明地获取源文件
管理系统。

依赖（目标，依赖），env.Depends（目标，依赖）
指定显式依赖； 这 目标 将在任何时候重建 依赖
已经改变。 既指定 目标 和 依赖 可以是一个字符串（通常是
文件或目录的路径名）或 Node 对象，或字符串列表或 Node
对象（例如由 Builder 调用返回）。 这应该只对案例是必要的
文件的扫描程序未捕获依赖项。

计费示例：

env.Depends('foo', 'other-input-file-for-foo')

mylib = env.Library('mylib.c')
installed_lib = env.Install('lib', mylib)
bar = env.Program('bar.c')

# 安排将库复制到安装中
# 尝试构建“bar”程序之前的目录。
# （请注意，这只是示例。一个“真正的”库
# 依赖项通常通过 $LIBS 配置
# 和 $LIBPATH 变量，不使用 env.Depends() 调用。）

env.Depends（栏，installed_lib）

env.Dictionary([vars])
返回一个字典对象，其中包含所有构造变量的副本
环境。 如果指定了任何变量名，则只有指定的
构造变量在字典中返回。

计费示例：

dict = env.Dictionary()
cc_dict = env.Dictionary('CC', 'CCFLAGS', 'CCCOM')

目录（名称，[目录]），env.Dir（名称，[目录]）
这将返回一个目录节点，一个表示指定目录的对象 姓名.
姓名 可以是相对路径或绝对路径。 目录 是一个可选目录，它将
用作父目录。 如果不 目录 指定，当前脚本的
目录用作父目录。

If 姓名 是一个列表，SCons 返回一个 Dir 节点列表。 构造变量是
扩大在 姓名.

目录节点可用于任何您可以提供字符串作为目录名称的地方
Builder 方法或函数。 目录节点的属性和方法是
在许多情况下有用； 请参阅下面的“文件和目录节点”。

环境转储（[键]）
返回环境的可打印表示。 键，如果不是无，
应该是一个包含感兴趣变量名称的字符串。

这个 SConstruct：

env=环境（）
打印 env.Dump('CCCOM')

将打印：

'$CC -c -o $TARGET $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS $SOURCES'

虽然这个 SConstruct：

env=环境（）
打印 env.Dump()

将打印：

{'AR'：'ar'，
'ARCOM': '$AR $ARFLAGS $TARGET $SOURCES\n$RANLIB $RANLIBFLAGS $TARGET',
'ARFLAGS'：['r']，
'作为'：'作为'，
'ASCOM': '$AS $ASFLAGS -o $TARGET $SOURCES',
'ASFLAGS'：[]，
...

EnsurePythonVersion（主要，次要），env.EnsurePythonVersion（主要，次要）
确保 Python 版本至少为 主要.未成年人. 这个函数会打印出来
如果实际的 Python 版本是错误消息并以非零退出代码退出 SCons
还不够晚。

计费示例：

确保Python版本（2,2）

EnsureSConsVersion（主要，次要，[修订]），env.EnsureSConsVersion（主要，次要，
[修订]）
确保 SCons 版本至少为 主要次要或 主要.次要.修订。 如果
调整 被指定。 这个函数会打印出错误信息并退出 SCons
如果实际 SCons 版本不够晚，则使用非零退出代码。

例子：

确保SConsVersion(0,14)

确保SConsVersion(0,96,90)

环境([key=value, ...]), env.Environment([key=value, ...])
返回使用指定初始化的新构造环境 键=折扣值 对。

执行（动作，[strfunction，varlist]），env.Execute（动作，[strfunction，varlist]）
执行一个动作对象。 指定的 行动 可能是一个 Action 对象（参见
下面的“动作对象”部分，以获得对参数的完整解释和
行为），或者它可能是命令行字符串、命令列表或可执行 Python
函数，每一个都会被转换成一个Action对象然后执行。 这
将返回命令的退出值或 Python 函数的返回值。

请注意，如果执行 scons 将打印一条错误消息 行动 失败——也就是说，
退出或返回非零值。 斯康会 而不去，然而，自动
如果指定，则终止构建 行动 失败。 如果您希望构建停止
对失败的回应 执行 调用，您必须明确检查非零返回
值：

执行（复制（'file.out'，'file.in'））

如果执行（“mkdir sub/dir/ectory”）：
# mkdir 失败，不要尝试构建。
Exit 退出(1)

退出（[值]），环境。退出（[值]）
这告诉 scons 立即退出指定的 折扣值. 默认退出值为
如果未指定值，则使用 0（零）。

出口（变量），环境。出口（变量）
这告诉 scons 将当前 SConscript 文件中的变量列表导出到所有
其他 SConscript 文件。 导出的变量保存在全局集合中，因此
随后调用 导出模板 将覆盖以前具有相同名称的导出。
可以将多个变量名传递给 导出模板 作为单独的参数或列表。
关键字参数可用于提供名称及其值。 字典可以
用于在导出时将变量映射到不同的名称。 局部变量和
可以导出全局变量。

例子：

环境 = 环境（）
# 使 env 可用于 Import() 的所有 SConscript 文件。
出口（“环境”）

包 = '我的名字'
# 使所有 SConscript 文件都可以使用 env 和 package:.
导出（“环境”，“包”）

# 使 env 和 package 可用于所有 SConscript 文件：
导出（[“环境”，“包”]）

# 使用名称 debug 使 env 可用：
导出（调试 = 环境）

# 使用名称 debug 使 env 可用：
导出（{“调试”：env}）

请注意 新兵 功能支持 出口 更容易理解的论点
将一个变量或一组变量导出到单个 SConscript 文件。 见
的描述 新兵 功能，下。

文件（名称，[目录]），env.File（名称，[目录]）
这将返回一个文件节点，一个代表指定文件的对象 姓名. 姓名 能够
是相对路径或绝对路径。 目录 是一个可选目录，将被使用
作为父目录。

If 姓名 是一个列表，SCons 返回一个 File 节点列表。 构造变量是
扩大在 姓名.

文件节点可用于任何您可以将字符串作为文件名提供给 Builder
方法或功能。 文件节点具有许多有用的属性和方法
情况； 请参阅下面的“文件和目录节点”。

FindFile（文件，目录），env.FindFile（文件，目录）
寻找 文件 在指定的路径中 迪尔斯. 迪尔斯 可能是目录名称列表
或单个目录名称。 除了搜索存在于
文件系统，这个函数也搜索尚未被派生的文件
内置的。

计费示例：

foo = env.FindFile('foo', ['dir1', 'dir2'])

FindInstalledFiles(), env.FindInstalledFiles()
返回由设置的目标列表 安装 or 安装方式 建设者。

该函数作为一种方便的方法来选择二进制文件的内容
包。

计费示例：

安装（ '/箱', ['executable_a', 'executable_b'])

# 将返回文件节点列表
# [ '/bin/executable_a', '/bin/executable_b' ]
查找安装文件()

安装（ '/ lib目录', ['some_library'])

# 将返回文件节点列表
# [ '/bin/executable_a', '/bin/executable_b', '/lib/some_library' ]
查找安装文件()

FindPathDirs（变量）
返回一个函数（实际上是一个可调用的 Python 对象），旨在用作
路径函数 扫描仪对象。 返回的对象将查找指定的
变量 在构造环境中，并将构造变量的值视为
应搜索的目录路径列表（如 $CPP路径, $库路径等）。

请注意，使用 查找路径目录 通常比自己编写更好
路径函数 原因如下： 1) 返回的列表将包含所有
在源代码树中找到适当的目录（当 变体目录 被使用）或在代码中
存储库（当 存储库 或者 -Y 使用选项）。 2) scons 将识别
的扩展 变量 评估到与实际上相同的目录列表
相同的列表，并尽可能避免重新扫描目录中的文件。

计费示例：

def my_scan（节点，环境，路径，arg）：
# 扫描文件内容的代码在这里...
返回包含文件

扫描仪=扫描仪（名称='myscanner'，
功能=我的扫描，
path_function = FindPathDirs('MYPATH'))

FindSourceFiles(node='"."'), env.FindSourceFiles(node='"."')
返回用作构建文件源的节点列表。 它通过
检查从可选参数开始的依赖关系树 节点 默认情况下
到 '"."' 节点。 然后它将返回所有叶子 节点. 这些都是孩子
没有更多的孩子。

此功能是选择 Source Package 内容的便捷方法。

计费示例：

程序（'src/main_a.c'）
程序（'src/main_b.c'）
程序（'main_c.c'）

# 返回 ['main_c.c', 'src/main_a.c', 'SConstruct', 'src/main_b.c']
查找源文件（）

# 返回 ['src/main_b.c', 'src/main_a.c' ]
FindSourceFiles('src')

如您所见，构建支持文件（上例中的 SConstruct）也将是
由该函数返回。

展平（序列），env.展平（序列）
接受一个可能包含嵌套序列的序列（即 Python 列表或元组）
并返回一个扁平列表，其中包含任何
顺序。 这有助于收集调用 Builders 返回的列表；
其他 Builders 将自动展平指定为输入的列表，但直接使用 Python
不操纵这些列表。

例子：

foo = Object('foo.c')
bar = Object('bar.c')

# 因为 `foo' 和 `bar' 是 Object() Builder 返回的列表，
# `objects' 将是一个包含嵌套列表的列表：
对象 = ['f1.o', foo, 'f2.o', bar, 'f3.o']

# 将这样的列表传递给另一个 Builder 是可以的，因为
# Builder 将自动展平列表：
程序（源 = 对象）

# 如果需要直接使用 Python 操作列表，则需要
# 自己调用 Flatten()，或者以其他方式处理嵌套列表：
对于 Flatten(objects) 中的对象：
打印 str（对象）

获取构建失败（）
返回尝试构建时失败的操作的异常列表
目标。 返回列表中的每个元素都是一个 BuildError 对象，具有以下内容
记录构建失败各个方面的属性：

.node 发生构建失败时正在构建的节点。

.status 失败的命令或 Python 函数返回的数字退出状态
尝试构建指定的节点时。

.errstr 描述构建失败的 SCons 错误字符串。 （这通常是通用的
类似“错误 2”的消息，表示已执行的命令以状态退出
2）。

.filename 实际导致失败的文件或目录的名称。 这可能
不同于 .node 属性。 例如，如果尝试构建目标
命名 sub/dir/target 失败，因为无法创建 sub/dir 目录，然后
.node 属性将是 sub/dir/target 但 .filename 属性将是
子/目录。

.executor 正在构建的目标节点的 SCons Executor 对象。 这个可以用
检索用于失败操作的构造环境。

.action 失败的实际 SCons Action 对象。 这将是一项具体行动
为构建目标而执行的可能的操作列表中。

.command 扩展后执行并失败的实际扩展命令
$目标, $源, 和其他构造变量。

请注意 获取构建失败 函数将始终返回一个空列表，直到任何
发生构建失败，这意味着 获取构建失败 总是会返回一个
读取 SConscript 文件时为空列表。 其主要用途是
将在 SCons 退出之前通过将它们传递给标准来执行的函数
Python 退出.注册（） 功能。 例子：

进口 atexit

def print_build_failures():
从 SCons.Script 导入 GetBuildFailures
对于 GetBuildFailures() 中的 bf：
print "%s failed: %s" % (bf.node, bf.errstr)

atexit.register（print_build_failures）

GetBuildPath（文件，[...]），env.GetBuildPath（文件，[...]）
返回指定的 scons 路径名（或名称） 文件 （或文件）。 这
指定 文件 或文件可能是 scons 节点或表示路径名的字符串。

GetLaunchDir(), 环境.GetLaunchDir()
返回 scons 最初所在目录的绝对路径名
调用。 这在使用 -u, -U or -D 选项，它在内部
切换到 SConstruct 文件所在的目录。

GetOption(名称), env.GetOption(名称)
该函数提供了一种查询 scons 命令上设置的 SCons 选项值的方法
线（或使用设置 设置选项 功能）。 支持的选项有：

缓存调试
对应于--cache-debug；

缓存禁用
对应于--cache-disable；

缓存力
对应于--cache-force；

缓存显示
对应于--cache-show；

清洁
对应于-c、--clean 和--remove；

配置
对应于--config；

目录
对应于-C和--directory；

磁盘检查
对应于 --diskcheck

复制
对应于--duplicate；

文件
对应于-f、--file、--makefile和--sconstruct；

帮助
对应于 -h 和 --help；

忽略错误
对应于--ignore-errors；

隐式缓存
对应于--implicit-cache；

隐式_deps_changed
对应于--implicit-deps-changed；

隐式_deps_unchanged
对应于--implicit-deps-unchanged；

互动
对应于--interact和--interactive；

继续
对应于 -k 和 --keep-going；

最大漂移
对应于--max-drift；

没有执行
对应于-n、--no-exec、--just-print、--dry-run 和--recon；

无站点目录
对应于--no-site-dir；

工作数量
对应于 -j 和 --jobs；

配置文件_文件
对应于--profile；

题
对应于 -q 和 --question；

随机
对应于--random；

知识库
对应于-Y、--repository 和--srcdir；

无声
对应于-s、--silent和--quiet；

站点目录
对应于--site-dir；

堆栈大小
对应于--stack-size；

监工跟踪文件
对应于--taskmastertrace； 和

警告
对应于--warn 和--warning。

有关以下信息，请参阅相应命令行对象的文档
每个特定选项。

Glob（模式，[磁盘上，源，字符串，排除]），env.Glob（模式，[磁盘上，源，
字符串，排除])
返回与指定匹配的节点（或字符串） 模式, 相对于目录
当前的 SConscript 文件。 这 环境变量Glob() 形式执行字符串替换
模式 并返回与生成的扩展模式匹配的任何内容。

指定的 模式 使用 Unix shell 样式的元字符进行匹配：

* 匹配一切
? 匹配任何单个字符
[seq] 匹配 seq 中的任何字符
[!seq] 匹配任何不在 seq 中的字符

如果文件名的第一个字符是点，则必须显式匹配。
字符匹配 而不去 跨目录分隔符。

这个 水珠 了解存储库（请参阅 存储库 函数）和源目录
（见 变体目录 函数）并在
本地（SConscript）目录，如果在相应的任何地方找到匹配的节点
存储库或源目录。

这个 磁盘 参数可以设置为 False（或任何其他非真值）以禁用
在磁盘上搜索匹配项，从而仅返回已配置的匹配项
文件或目录节点。 默认行为是为任何返回相应的节点
找到磁盘上的匹配项。

这个 资源 参数可以设置为 True （或任何等效值）以指定，当
本地目录是 变体目录，返回的节点应该来自
对应的源目录，而不是本地目录。

这个 字符串 参数可以设置为 True （或任何等效值）以具有 水珠
函数返回代表匹配文件或目录的字符串，而不是节点。
返回的字符串将相对于本地 (SConscript) 目录。 （注意
这可能更容易对文件名进行任意操作，但如果
返回的字符串被传递到不同的 SConscript 文件，任何节点翻译都会
相对于其他 SConscript 目录，而不是原始 SConscript 目录。）

这个 排除 参数可以设置为模式或模式列表（遵循相同的
Unix shell 语义），必须从返回的元素中过滤掉。 元素
匹配此列表的至少一个模式将被排除。

例子：

程序('foo', Glob('*.c'))
Zip('/tmp/everything', Glob('.??*') + Glob('*'))
来源 = Glob('*.cpp', exclude=['os_*_specific_*.cpp']) + Glob('os_%s_specific_*.cpp'%currentOS)

帮助（文本，附加=假），env.Help（文本，附加=假）
这指定要打印的帮助文本，如果 -h 参数是给 scons 的。 如果 帮助
被多次调用，文本按顺序附加在一起 帮助 is
叫。 将 append 设置为 False，任何 帮助 生成的文本 添加选项 被破坏了。
如果 append 为 True，则 AddOption 帮助将附加到帮助字符串中，从而保留
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 -h 信息。

忽略（目标，依赖），env.Ignore（目标，依赖）
在确定目标文件是否存在时，将忽略指定的依赖文件
需要重建。

您还可以使用 忽略 从默认构建中删除目标。 为此
您必须指定将构建目标的目录作为目标，以及文件
您想跳过构建作为依赖项。

请注意，这只会删除从构建的文件中列出的依赖项
默认。 如果另一个对象需要该依赖项，它仍然会被构建
建成。 请参阅下面的第三个和第四个示例。

例子：

env.Ignore('foo', 'foo.c')
env.Ignore('bar', ['bar1.h', 'bar2.h'])
env.Ignore('.','foobar.obj')
env.Ignore('bar','bar/foobar.obj')

导入（变量），环境。导入（变量）
这告诉 scons 将变量列表导入当前的 SConscript 文件。 这个
将导入与导出的变量 导出模板 或在 出口 争论
新兵. 导出的变量 新兵 有优先权。 多个变量名
可以传递给 导入模板 作为单独的参数或列表。 变量“*”可以是
用于导入所有变量。

例子：

导入（“环境”）
导入（“环境”，“变量”）
导入（[“环境”，“变量”]）
进口（”*”）

文字（字符串），env.Literal（字符串）
指定的 绳子 将按原样保留并且没有构造变量
扩大了。

本地（目标），env.Local（目标）
指定的 目标 将在本地树中制作副本，即使已经
存储库中存在最新副本。 返回一个或多个目标节点的列表。

env.MergeFlags(arg, [唯一])
合并指定的 ARG 对施工环境建设的价值
变量。 如果 ARG 参数不是字典，它通过调用转换为字典
env.ParseFlags 在合并值之前的参数上。 注意 ARG 必须是一个
单个值，因此必须将多个字符串作为列表传递，而不是单独传递
参数 env.MergeFlags.

默认情况下，重复值被消除； 但是，您可以指定 unique=0 到
允许添加重复值。 消除重复值时，任何
以字符串 PATH 结尾的构造变量保留最左边的唯一值。
所有其他构造变量都保留最右边的唯一值。

例子：

# 添加优化标志到$CCFLAGS。
env.MergeFlags('-O3')

# 将运行 pkg-config 返回的标志与优化相结合
# 标记并将结果合并到构造变量中。
env.MergeFlags(['!pkg-config gtk+-2.0 --cflags', '-O3'])

# 将优化标志与运行 pkg-config 返回的标志结合起来
# 两次并将结果合并到构造变量中。
env.MergeFlags(['-O3',
'!pkg-config gtk+-2.0 --cflags --libs',
'!pkg-config libpng12 --cflags --libs'])

NoCache(目标, ...), env.NoCache(目标, ...)
指定应该的文件列表 而不去 每当 缓存目录 方法有
被激活。 指定的目标可以是列表或单个目标。

多个文件应指定为单独的参数 无缓存 方法，
或作为列表。 无缓存 还将接受任何构造的返回值
环境生成器方法。

调用 无缓存 对目录和其他非文件节点类型没有影响，因为
只有文件节点被缓存。

例子：

NoCache('foo.elf')
NoCache(env.Program('hello', 'hello.c'))

NoClean(目标, ...), env.NoClean(目标, ...)
指定文件或目录的列表，应该 而不去 每当
目标（或它们的依赖项）用 -c 命令行选项。 这
指定的目标可以是列表或单个目标。 多次调用 不清洁 旨在
合法，并防止通过调用 -c 选项。

多个文件或目录应指定为单独的参数
不清洁 方法，或作为列表。 不清洁 也将接受任何的返回值
构建环境Builder方法。

调用 不清洁 对于目标覆盖调用 清洁 对于相同的目标，任何
传递给这两个函数的目标将 而不去 被删除 -c 选项。

例子：

NoClean('foo.elf')
NoClean(env.Program('hello', 'hello.c'))

env.ParseConfig（命令，[函数，唯一]）
调用指定的 function 修改由输出指定的环境
命令。 默认值 function is env.MergeFlags，它期望一个典型的输出
*-config 命令（例如，gtk-config）并将选项添加到适当的
构造变量。 默认情况下，不会将重复值添加到任何构造中
变量； 您可以指定 unique=0 以允许添加重复值。

解释的选项和它们影响的构造变量是为
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 env.ParseFlags 方法（此方法调用）。 请参阅该方法的说明，
下面是选项和构造变量的表。

ParseDepends（文件名，[must_exist，only_one]），env.ParseDepends（文件名，[must_exist，
只有一个]）
解析指定内容 文件名 作为样式中的依赖项列表
的 Make 或 mkdep，并显式建立所有列出的依赖项。

默认情况下，如果指定 文件名 不存在。 可选的
必须存在 参数可以设置为非零值以使 scons 抛出异常
如果文件不存在或无法访问，则生成错误。

可选的 只有一个 参数可以设置为非零值以使 scons 抛出
如果文件包含更多依赖信息，则异常并生成错误
不止一个目标。 这可以为打算成为的文件提供一个小的健全性检查
例如，由 gcc -M 标志生成，它通常应该只写
一个输出文件的依赖信息到相应的 .d 文件中。

这个 文件名 并且其中列出的所有文件都将相对于
SConscript 文件的目录，它调用 解析依赖 功能。

env.ParseFlags（标志，...）
解析一个或多个包含 GCC 工具链的典型命令行标志的字符串
并返回一个字典，其中标志值分隔成适当的 SCons
构造变量。 这是为了作为伴侣 env.MergeFlags 方法，
但允许在必要时修改返回字典中的值，
在将它们合并到构建环境之前。 （注意 env.MergeFlags 将
如果其参数不是字典，则调用此方法，因此通常不需要
打电话 env.ParseFlags 除非您想直接操作这些值。）

如果任何字符串中的第一个字符是感叹号 (!)，则其余的
string 作为命令执行，命令的输出被解析为 GCC 工具
链命令行标志并添加到结果字典中。

标志值根据找到的前缀进行翻译，并添加到以下内容
构造变量：

-arch CCFLAGS，LINKFLAGS
-D CPP定义
-框架框架
-frameworkdir=框架路径
-包括 CCFLAGS
-isysroot CCFLAGS、LINKFLAGS
-I CPP路径
-l 库
-L 库路径
-mno-cygwin CCFLAGS、LINKFLAGS
-mwindows 链接标志
-pthread CCFLAGS，LINKFLAGS
-std=CFLAGS
-Wa，ASFLAGS，CCFLAGS
-Wl,-rpath=RPATH
-Wl，-R，RPATH
-Wl,-R 路径
-Wl，链接标志
-Wp，CPPFLAGS
-CCFLAGS
+ CCFLAGS、LINKFLAGS

与选项无关的任何其他字符串都被假定为库的名称
并添加到 $图书馆 构造变量。

示例（所有这些都产生相同的结果）：

dict = env.ParseFlags('-O2 -Dfoo -Dbar=1')
dict = env.ParseFlags('-O2', '-Dfoo', '-Dbar=1')
dict = env.ParseFlags(['-O2', '-Dfoo -Dbar=1'])
dict = env.ParseFlags('-O2', '!echo -Dfoo -Dbar=1')

环境.Perforce()
一个工厂函数，它返回一个 Builder 对象，用于从中获取源文件
Perforce 源代码管理系统。 返回的 Builder 旨在
传递给 源代码 功能。

此功能已弃用。 有关详细信息，请参阅条目 源代码 功能。

计费示例：

env.SourceCode('.', env.Perforce())

Perforce 使用许多外部环境变量进行操作。
因此，此函数从用户的外部添加以下变量
环境到构建环境的ENV字典：P4CHARSET，P4CLIENT，
P4LANGUAGE、P4PASSWD、P4PORT、P4USER、SystemRoot、USER 和 USERNAME。

平台（字符串）
这个 平台 表单返回一个可调用对象，该对象可用于初始化
使用平台关键字构建环境 环境 功能。

计费示例：

env = 环境（平台 = 平台（'win32'））

这个 环境平台 表单应用指定平台的可调用对象 绳子 至
调用方法的环境。

env.Platform('posix')

请注意，win32 平台将 SystemDrive 和 SystemRoot 变量从
用户的外部环境到施工环境的 $环境变量 字典。 这是
以便任何使用套接字与其他系统连接的执行命令（例如
从外部 CVS 存储库规范中获取源文件，例如
：服务器：[email protected]:/cvsroot/scons) 将在 Windows 系统上工作。

Precious(目标, ...), env.Precious(目标, ...)
每个给定的标记 目标 珍贵，因此在重建之前不会被删除。
通常 scons 在构建目标之前会删除它。 可以传入多个目标
打一次电话 珍贵.

env.Prepend(key=val, [...])
将指定的关键字参数附加到构造变量的开头
环境。 如果 Environment 没有指定的构造变量，
它只是添加到环境中。 如果构造变量的值和
关键字参数是相同的类型，那么这两个值将被简单地相加
一起。 否则，构造变量和关键字参数的值
都被强制为列表，并且列表被添加在一起。 （另见附录
方法，同上。）

计费示例：

env.Prepend(CCFLAGS = '-g', FOO = ['foo.yyy'])

env.PrependENVPath（名称，新路径，[envname，sep，delete_existing]）
这会将新路径元素附加到指定外部环境中的给定路径
($环境变量 默认）。 这只会添加任何特定路径一次（留下第一个
它遇到并忽略其余部分，以保持路径顺序），并帮助确保这一点，
将规范化所有路径（使用 os.path.normpath 和 os.path.normcase）。 这也可以
处理给定的旧路径变量是列表而不是字符串的情况，在
在这种情况下，将返回一个列表而不是一个字符串。

If 删除现有的 为0，则添加已存在的路径不会将其移动到
开始； 它将保持在列表中的位置。

计费示例：

打印'之前：'，env['ENV']['INCLUDE']
include_path = '/foo/bar:/foo'
env.PrependENVPath('INCLUDE', include_path)
打印'之后：'，env['ENV']['INCLUDE']

上面的示例将打印：

之前：/biz:/foo
之后：/foo/bar:/foo:/biz

env.PrependUnique(key=val,delete_existing=0,[...])
将指定的关键字参数附加到构造变量的开头
环境。 如果 Environment 没有指定的构造变量，
它只是添加到环境中。 如果构造变量被附加到
是一个列表，那么构造变量中已经存在的任何值都将 而不去
再次添加到列表中。 但是，如果 delete_existing 为 1，则现有匹配值
首先删除，因此 arg 列表中的现有值移动到列表的前面。

计费示例：

env.PrependUnique(CCFLAGS = '-g', FOO = ['foo.yyy'])

进度（可调用，[间隔]），进度（字符串，[间隔，文件，覆盖]），
进度（list_of_strings，[间隔，文件，覆盖]）
允许 SCons 通过显示字符串或调用来显示构建过程中取得的进展
评估节点（例如文件）时的函数。

如果第一个指定参数是 Python 可调用的（函数或对象具有
a __称呼__() 方法），该函数将被调用一次 间隔 次节点是
评估。 可调用对象将被评估的节点作为其唯一参数传递。 （为了
未来的兼容性，最好将 *args 和 **kw 作为参数添加到您的
功能或方法。 如果 SCons 更改了
接口以在将来调用带有附加参数的函数。）

一个简单的自定义进度函数示例，它打印一个包含
每 10 个节点的节点名称：

def my_progress_function（节点，*args，**kw）：
print '评估节点 %s!' % 节点
进度（my_progress_function，间隔=10）

打印字符串的自定义进度显示对象的更复杂示例
包含每 100 个评估节点的计数。 注意使用 \r （回车）
最后，以便字符串将在显示器上覆盖自身：

导入系统
类进度计数器（对象）：
计数 = 0
def __call__(self, 节点, *args, **kw):
自我计数 += 100
sys.stderr.write('评估的 %s 个节点\r' % self.count)
进度（ProgressCounter（），间隔= 100）

如果第一个参数 进展 是一个字符串，该字符串将在每个
间隔 评估节点。 默认是在标准输出上打印字符串； 一个
可以使用 file= 参数指定备用输出流。 以下将
在错误输出上打印一系列点，每 100 个评估节点一个点：

导入系统
进度（'.'，间隔=100，文件=sys.stderr）

如果字符串包含逐字子串 $目标，它将被替换为
节点。 请注意，出于性能原因，这是 而不去 一个常规的 SCons 变量
替换，因此您不能使用其他变量或使用花括号。 以下
示例将打印每个评估节点的名称，使用 \r （回车）
导致每一行被下一行覆盖，并且 overwrite= 关键字参数
确保先前打印的文件名被空格覆盖：

导入系统
进度（'$TARGET\r'，覆盖=真）

如果第一个参数为 进展 是一个字符串列表，然后是列表中的每个字符串
每隔一段时间就会以旋转的方式显示 间隔 评估节点。 这个可以用
在用户屏幕上实现“微调器”，如下所示：

进度（['-\r', '\\\r', '|\r', '/\r'], 间隔=5）

伪（目标，...），env.Pseudo（目标，...）
这表明每个给定的 目标 不应该由构建规则创建，如果
创建目标时，将产生错误。 这类似于 gnu make
.PHONY 目标。 然而，在绝大多数情况下，一个 别名 比较合适。
可以将多个目标传递给单个调用 昵称.

环境.RCS()
一个工厂函数，它返回一个 Builder 对象，用于从中获取源文件
RCS。 返回的 Builder 旨在传递给 源代码 功能：

此功能已弃用。 有关详细信息，请参阅条目 源代码 功能。

例子：

env.SourceCode('.', env.RCS())

请注意，scons 会自动从 RCS 子目录中获取源文件，所以
如上例所示配置 RCS 仅当您需要
正在从与源文件相同目录中的 RCS,v 文件中获取，或者如果您
需要为特定子目录显式指定 RCS。

env.Replace(key=val, [...])
用指定的关键字替换环境中的构造变量
参数。

计费示例：

env.Replace(CCFLAGS = '-g', FOO = 'foo.xxx')

Repository(目录), env.Repository(目录)
规定 目录 是要搜索文件的存储库。 多次调用
存储库 是合法的，并且每个都添加到将要使用的存储库列表中
搜索。

对 scons 来说，存储库是源代码树的副本，来自顶层目录
down，其中可能包含可用于构建的源文件和派生文件
本地源代码树中的目标。 典型示例将是官方来源
树由积分器维护。 如果存储库包含派生文件，则
应该使用 scons 构建派生文件，以便存储库包含
必要的签名信息，以便让 scons 找出何时适合
使用派生文件的存储库副本，而不是在本地构建一个。

请注意，如果存储库中已经存在最新的派生文件，scons 将 而不去
在本地目录树中复制。 为了保证本地副本将
制作，使用 本地 方法。

要求（目标，先决条件），env.Requires（目标，先决条件）
指定指定目标文件和目标文件之间的仅顺序关系
指定的先决条件文件。 将（重新）构建先决条件文件，如果
必要， before 目标文件，但目标文件实际上并不依赖于
先决条件，并且不会仅仅因为先决条件文件而重建
改变。

计费示例：

env.Requires('foo', 'file-that-must-be-built-before-foo')

返回（[变量...，停止=]）
默认情况下，这会停止处理当前的 SConscript 文件并返回到
调用 SConscript 文件中命名的变量的值 瓦尔 绳子
论据。 可以将包含变量名称的多个字符串传递给 回程。 任何
包含空格的字符串

可选的 stop= 关键字参数可以设置为 false 值以继续处理
之后的 SConscript 文件的其余部分 回程 称呼。 这是默认行为
在 SCons 0.98 之前。 但是，返回的值仍然是
命名变量 瓦尔 在这一点上 回程 叫做。

例子：

# 不返回值返回。
返回（）

# 返回 'foo' Python 变量的值。
返回（“富”）

# 返回 Python 变量 'foo' 和 'bar' 的值。
返回（“富”，“酒吧”）

# 返回 Python 变量 'val1' 和 'val2' 的值。
返回（'val1 val2'）

扫描仪（函数，[参数，键，path_function，node_class，node_factory，scan_check，
递归]), env.Scanner(函数, [参数, 键, path_function, node_class,
node_factory，scan_check，递归]）
为指定的创建一个 Scanner 对象 function. 请参阅“扫描仪”部分
对象”，以获取对论点和行为的完整解释。

环境.SCCS()
一个工厂函数，它返回一个 Builder 对象，用于从中获取源文件
SCCS。 返回的 Builder 旨在传递给 源代码 功能。

计费示例：

env.SourceCode('.', env.SCCS())

请注意，scons 会自动从 SCCS 子目录中获取源文件，因此
如上例所示配置 SCCS 只有在您
正在从与源文件位于同一目录中的 s.SCCS 文件中获取，或者如果您
需要为特定子目录显式指定 SCCS。

SConscript（脚本，[导出，variant_dir，重复]），env.SConscript（脚本，[导出，
变体目录，重复]），SConscript（目录=子目录，[名称=脚本，出口，变体目录，
重复]），env.SConscript（dirs=subdirs，[name=script，exports，variant_dir，duplicate]）
这告诉 scons 执行一个或多个附属的 SConscript（配置）文件。
调用脚本返回的任何变量使用 回程 将通过调用返回
新兵. 有两种调用方式 新兵 功能。

您可以调用的第一种方式 新兵 是明确指定一个或多个 脚本 as
第一个论点。 单个脚本可以指定为字符串； 多个脚本
必须指定为列表（显式或由类似的函数创建
分裂）。 例子：

SConscript('SConscript') # 在当前目录运行 SConscript
SConscript('src/SConscript') # 运行src目录下的SConscript
SConscript(['src/SConscript', 'doc/SConscript'])
config = SConscript('MyConfig.py')

第二种调用方式 新兵 是将（子）目录名称列表指定为
一个目录=子目录 关键字参数。 在这种情况下，scons 默认会执行一个
每个指定目录中名为 SConscript 的辅助配置文件。
您可以通过提供可选名称来指定 SConscript 以外的名称=脚本
关键字参数。 下面前三个例子和第一个效果一样
上面三个例子：

SConscript(dirs='.') # 在当前目录运行 SConscript
SConscript(dirs='src') # 运行src目录下的SConscript
SConscript(dirs=['src', 'doc'])
SConscript(dirs=['sub1', 'sub2'], name='MySConscript')

可选的 出口 参数提供变量名列表或字典
要导出到的命名值 脚本. 这些变量仅在本地导出到
指定的 脚本，并且不影响使用的全局变量池
导出模板 功能。 子公司 脚本 必须使用 导入模板 导入函数
变量。 例子：

foo = SConscript('sub/SConscript', 出口='env')
SConscript('dir/SConscript', 出口=['env', '变量'])
SConscript(dirs='subdir', exports='env 变量')
SConscript(dirs=['one', 'two', 'three'], exports='shared_info')

如果可选 变体目录 参数存在，它会导致等效于
变体目录 方法如下所述。 （如果 变体目录 不存在，则

复制 参数被忽略。） 变体目录 参数被解释为相对于
调用 SConscript 文件的目录。 见说明 变体目录
下面的功能以获取更多详细信息和限制。

If 变体目录 存在时，源目录是在其中的目录
SConscript 文件驻留并且 SConscript 文件被评估，就好像它在
变体目录 目录：

SConscript('src/SConscript', variant_dir = 'build')

相当于

VariantDir('build', 'src')
SConscript('构建/SConscript')

当源代码与
S构造：

SConscript('SConscript', variant_dir = 'build')

相当于

VariantDir('build', '.')
SConscript('构建/SConscript')

以下是一些复合示例：

# 收集配置信息并使用它来构建 src 和 doc
shared_info = SConscript('MyConfig.py')
SConscript('src/SConscript', 出口='shared_info')
SConscript('doc/SConscript', 出口='shared_info')

# 构建调试和生产版本。 征兵
# 可以使用 Dir('.').path 来确定变体。
SConscript('SConscript', variant_dir='debug', duplicate=0)
SConscript（'SConscript'，variant_dir='prod'，重复=0）

# 构建调试和生产版本。 征兵
# 传递要使用的标志。
opts = {'CPPDEFINES'：['DEBUG']，'CCFLAGS'：'-pgdb'}
SConscript（'SConscript'，variant_dir='debug'，duplicate=0，exports=opts）
选择= {'CPPDEFINES'：['NODEBUG']，'CCFLAGS'：'-O'}
SConscript（'SConscript'，variant_dir='prod'，duplicate=0，exports=opts）

# 构建通用文档并针对不同的架构进行编译
SConscript('doc/SConscript', variant_dir='build/doc', duplicate=0)
SConscript('src/SConscript', variant_dir='build/x86', duplicate=0)
SConscript('src/SConscript', variant_dir='build/ppc', duplicate=0)

SConscriptChdir(值), env.SConscriptChdir(值)
默认情况下，scons 将其工作目录更改为每个
附属 SConscript 文件存在。 可以通过指定以下任一项来禁用此行为：

SConscript目录(0)
env.SConscriptChdir(0)

在这种情况下，scons 将在读取所有 SConscript 时保留在顶级目录中
文件。 （这在从存储库构建时可能是必要的，当所有
可以在其中找到 SConscript 文件的目录不一定存在于本地。）
您可以通过多次调用 SConscriptChdir() 来启用和禁用此功能。

计费示例：

环境 = 环境（）
SConscript目录(0)
SConscript('foo/SConscript') # 不会 chdir 到 foo
env.SConscriptChdir(1)
SConscript('bar/SConscript') # 将 chdir 转换为 bar

SConsignFile([文件, dbm_module]), env.SConsignFile([文件, dbm_module])
这告诉 scons 将所有文件签名存储在指定的数据库中 文件。 如果
文件 name 被省略，默认使用 .sconsign。 （实际文件名存储在
磁盘可能有一个适当的后缀，由
数据库模块.) 如果 文件 不是绝对路径名，文件放在同一个
目录作为顶级 SConstruct 文件。

If 文件 为 None，则 scons 会将文件签名存储在单独的 .sconsign 文件中
每个目录，而不是在一个全局数据库文件中。 （这是之前的默认行为
到 SCons 0.96.91 和 0.97。）

可选的 数据库模块 参数可用于指定哪个 Python 数据库模块
默认是使用使用腌制 Python 数据的自定义 SCons.dblite 模块
结构，并且适用于所有 Python 版本。

例子：

# 将签名显式存储在“.sconsign.dblite”中
# 在顶级 SConstruct 目录中（
# 默认行为）。
S委托文件()

# 将签名存储在文件“etc/scons-signatures”中
# 相对于顶级 SConstruct 目录。
SConsignFile("etc/scons-signatures")

# 将签名存储在指定的绝对文件名中。
SConsignFile("/home/me/SCons/signatures")

# 将签名存储在单独的 .sconsign 文件中
# 在每个目录中。
SConsignFile(无)

env.SetDefault(key=val, [...])
将构造变量设置为使用关键字参数指定的默认值，如果
（且仅当）变量尚未设置。 以下陈述是
当量：

env.SetDefault(FOO = 'foo')

如果 'FOO' 不在 env 中： env['FOO'] = 'foo'

SetOption(名称, 值), env.SetOption(名称, 值)
此函数提供了一种设置 scons 命令行选项的选择子集的方法
来自 SConscript 文件。 支持的选项有：

清洁
对应于-c、--clean 和--remove；

复制
对应于--duplicate；

帮助
对应于 -h 和 --help；

隐式缓存
对应于--implicit-cache；

最大漂移
对应于--max-drift；

没有执行
对应于-n、--no-exec、--just-print、--dry-run 和--recon；

工作数量
对应于 -j 和 --jobs；

随机
对应于--random； 和

堆栈大小
对应于--stack-size。

有关以下信息，请参阅相应命令行对象的文档
每个特定选项。

计费示例：

SetOption('max_drift', 1)

SideEffect（side_effect，target），env.SideEffect（side_effect，target）
声明 副作用 作为建筑的副作用 目标。 两 副作用 和 目标
可以是列表、文件名或节点。 副作用是创建的目标文件
或更新为构建其他目标的副作用。 例如，Windows PDB 文件
是作为为静态库构建 .obj 文件的副作用而创建的，并且
各种日志文件被创建为各种 TeX 命令的副作用。 如果一个
target 是多个构建命令的副作用，scons 将确保只有一个
一组命令一次执行。 因此，您只需要使用此方法
对于由于多个构建命令而构建的副作用目标。

因为多个构建命令可能会更新同一个副作用文件，默认情况下
副作用 目标是 而不去 时自动删除 目标 被删除 -c
选项。 （但请注意， 副作用 作为清洁的一部分，可能会被移除
它所在的目录。）如果你想确保 副作用 被清洗
每当一个特定的 目标 已清理，您必须使用 清洁
or 环境清洁 功能。

SourceCode（条目，构建器），env.SourceCode（条目，构建器）
此函数及其关联的工厂函数已被弃用。 没有
替代品。 预期用途是使本地树与存档保持同步，但在
实际上，该函数仅导致在第一次运行时获取存档。
与存档同步最好在 SCons 外部完成。

安排从源代码管理中获取不存在的源文件
系统使用指定 建设者。 指定的 项 可以是节点、字符串或
两者的列表，并且可以代表单独的源文件或目录，其中
可以找到源文件。

对于任何不存在的源文件，scons 将搜索目录树并使用
第一 源代码 它找到的生成器。 指定的 建设者 可能是无，在这种情况下
scons 不会使用构建器来获取指定的源文件 项， 即使
a 源代码 builder 已被指定为树上更高的目录。

默认情况下，scons 会从 SCCS 或 RCS 子目录中获取文件，而无需显式
配置。 这需要一些额外的处理时间来搜索必要的
磁盘上的源代码管理文件。 您可以避免这些额外的搜索并加快速度
您可以通过禁用这些搜索来稍微构建一下，如下所示：

env.SourceCode('.', 无)

请注意，如果指定 建设者 是您手工创建的，它必须有一个
获取源文件时要使用的关联构造环境。

scons 提供了一组固定的工厂函数，它们返回适当的 Builders
各种流行的源代码管理系统。 调用的规范示例
包括：

env.SourceCode('.', env.BitKeeper('/usr/local/BKsources'))
env.SourceCode('src', env.CVS('/usr/local/CVSROOT'))
env.SourceCode('/', env.RCS())
env.SourceCode(['f1.c', 'f2.c'], env.SCCS())
env.SourceCode('no_source.c', 无)

SourceSignatures（类型），env.SourceSignatures（类型）
注意：虽然它还没有被官方弃用，但是这个功能的使用是
灰心。 见 决胜局 功能更灵活和直接的方式
配置 SCons 的决策。

这个 源签名 函数告诉 scons 如何判断一个源文件（一个
不是从任何其他文件构建的）自上次用于
构建一个特定的目标文件。 合法值为 MD5 或时间戳。

如果使用环境方法，则只使用指定类型的源签名
在决定使用该环境构建的目标是最新的还是必须是最新的时
重建。 如果使用全局函数，指定类型的源签名
成为所有关于目标是否是最新的决策的默认值。

MD5 表示 scons 确定源文件已更改，如果其 MD5 校验和
自上次用于重建特定目标以来，内容已更改
文件中。

时间戳表示 scons 确定源文件已更改，如果其时间戳
（修改时间）自上次用于重建
特定的目标文件。 （请注意，虽然这类似于 Make 的行为，
默认情况下，如果依赖项是 老年人 比上次
用于重建目标文件。）

Python 的两种行为没有区别 价值观 节点对象。

MD5 签名的计算时间更长，但比时间戳更准确
签名。 默认值为 MD5。

注意默认 目标签名 设置（见下文）是使用这个
源签名 用于构建其他目标的任何目标文件的设置
文件。 因此，改变 源签名 默认情况下会影响
构建中所有文件的最新决策（或使用特定构建的所有文件
施工环境时 env.SourceSignatures 用来）。

拆分（arg），env.Split（arg）
返回文件名或其他对象的列表。 如果 arg 是一个字符串，它将被拆分
字符串中的空白字符字符串，更容易写长
文件名列表。 如果 arg 已经是一个列表，则该列表将原封不动地返回。 如果
arg 是任何其他类型的对象，它将作为仅包含
目的。

计费示例：

文件 = 拆分（“f1.c f2.c f3.c”）
文件 = env.Split("f4.c f5.c f6.c")
文件 = 拆分（“”“
f7.c
f8.c
f9.c
""")

env.subst（输入，[原始，目标，源，转换]）
对指定的字符串或序列执行构造变量插值
论点 输入.

默认情况下，将从结果中删除前导或尾随空格。 和所有
空白序列将被压缩为单个空格字符。 此外，
任何 $( 和 $) 字符序列都将从返回的字符串中删除，
可选 原 如果要保留空格和 $(-$)，参数可以设置为 1
序列。 这 原 如果要删除所有字符，参数可以设置为 2
在任何 $( 和 $) 对之间（就像签名计算所做的那样）。

如果输入是序列（列表或元组），则序列的各个元素
将展开，结果将作为列表返回。

可选的 目标 和 资源 关键字参数必须设置为目标列表和
源节点，分别，如果你想要 $目标, $目标, $源 和 $来源 至
可用于扩展。 如果您打电话，这通常是必要的 环境变量
从用作 SCons 操作的 Python 函数中。

返回的字符串值或序列元素被转换为它们的字符串
默认情况下表示。 可选的 CONV 参数可以指定转换
将用于代替默认值的函数。 例如，如果你想要 Python
要作为 Python 对象返回的对象（包括 SCons 节点），您可以使用
Python Λ 成语传递一个未命名的函数，该函数只返回其未转换的
论据。

计费示例：

print env.subst("C 编译器是：$CC")

def 编译（目标，源，环境）：
sourceDir = env.subst("${SOURCE.srcdir}",
目标=目标，
来源=来源）

source_nodes = env.subst('$EXPAND_TO_NODELIST',
转换 = λ x: x)

标签（节点，标签）
使用有关如何 小包装 生成器
应该打包那些文件或目录。 所有标签都是可选的。

例子：

# 确保构建的库将与 0644 文件一起安装
#访问方式
标记（库（'lib.c'），UNIX_ATTR="0644"）

# 将 file2.txt 标记为文档文件
标签（'file2.txt'，文档）

TargetSignatures（类型），env.TargetSignatures（类型）
注意：虽然它还没有被官方弃用，但是这个功能的使用是
灰心。 见 决胜局 功能更灵活和直接的方式
配置 SCons 的决策。

这个 目标签名 函数告诉 scons 如何判断一个目标文件（一个
is 从任何其他文件构建）自上次用于构建以来已更改
其他一些目标文件。 法律价值是“建立”； “内容”（或其同义词“MD5”）；
“时间戳”； 或“来源”。

如果使用环境方法，则只使用指定类型的目标签名
对于使用该环境构建的目标。 如果使用全局函数，则指定
签名类型成为所有没有签名的目标文件的默认值
为其环境指定的显式目标签名类型。

“内容”（或其同义词“MD5”）表示 scons 确定目标文件已更改，如果
其内容的 MD5 校验和自上次用于
重建一些其他目标文件。 这意味着 scons 将打开 MD5 sum 的内容
构建后的目标文件，并可能决定不需要重新构建
“下游”目标文件，如果一个文件被重建，其内容与
上次。

"timestamp" 表示 scons 确定目标文件已更改，如果其时间戳
（修改时间）自上次用于重建其他一些
目标文件。 （请注意，虽然这类似于 Make 的行为，但默认情况下
如果依赖项是，它也会重建 老年人 比上次习惯
重建目标文件。）

“源”表示 scons 确定目标文件已按照
相应 源签名 设置（“MD5”或“时间戳”）。 这意味着 scons
将以相同的方式对待目标的所有输入文件，无论它们是否
源文件或已从其他文件构建。

"build" 表示 scons 确定目标文件已更改，如果它已被重建
此调用或其内容或时间戳是否已按照
相应 源签名 环境。 这“传播”了重建文件的状态
这样其他“下游”目标文件将始终被重建，即使内容
或者时间戳没有改变。

“构建”签名最快，因为“内容”（或“MD5”）签名需要更长的时间
计算，但比“时间戳”签名更准确，并且可以防止
当目标文件重建为完全相同时，不必要的“下游”重建
内容与之前的版本相同。 “源”设置提供了最一致的
当其他目标文件可以从源和目标输入重建时的行为
文件。 默认值为“源”。

因为默认设置是“源”，使用 源签名 通常
优于 目标签名，因此最新的决定将是一致的
所有文件（或使用特定构建环境构建的所有文件）。 用于
目标签名 为构建的目标文件如何影响其提供特定的控制
“下游”依赖项。

工具（字符串，[工具路径，**kw]），env.Tool（字符串，[工具路径，**kw]）
这个 工具 函数的形式返回一个可用于初始化的可调用对象
使用 Environment() 方法的 tools 关键字的构造环境。 这
可以使用构造环境作为参数调用对象，在这种情况下
对象会添加必要的变量到构造环境和名称
该工具将被添加到 $工具 构造变量。

额外的关键字参数被传递给工具的 生成（） 方法。

例子：

env = 环境（工具 = [ 工具（'msvc'） ]）

环境 = 环境（）
t = 工具（'msvc'）
t(env) # 将 'msvc' 添加到 TOOLS 变量
u = 工具（'opengl'，工具路径 = ['工具']）
u(env) # 将 'opengl' 添加到 TOOLS 变量

这个 环境工具 函数的形式应用指定工具的可调用对象
绳子 到调用该方法的环境。

额外的关键字参数被传递给工具的 生成（） 方法。

env.Tool('gcc')
env.Tool('opengl', toolpath = ['build/tools'])

值（值，[built_value]），env.Value（值，[built_value]）
返回表示指定 Python 值的 Node 对象。 可以使用值节点
作为目标的依赖。 如果调用结果 STR(折扣值) SCons 之间的变化
运行，任何目标取决于 价值观(折扣值) 将被重建。 （即使当
使用时间戳来确定文件是否是最新的。）使用时间戳源时
签名，值节点的时间戳等于该节点时的系统时间
创建。

返回的值节点对象有一个 写() 方法，可用于“构建”
值节点通过设置一个新值。 可选的 内置值 可以指定参数
何时创建值节点以指示应已考虑该节点
“建成。” 有对应的 读() 方法将返回的构建值
节点。

例子：

环境 = 环境（）

def 创建（目标，源，环境）：
# 一个将写入 'prefix=$SOURCE' 的函数
# 将字符串转换为指定为文件名的文件
# $目标。
f = open(str(target[0]), 'wb')
f.write('prefix=' + source[0].get_contents())

# 从命令中获取 prefix= 参数，如果有的话
# 行，并使用 在/ usr /本地 作为默认值。
前缀 = ARGUMENTS.get('前缀', '在/ usr /本地')

# 为上述函数操作附加一个 .Config() 构建器
#到施工环境。
env['BUILDERS']['Config'] = Builder(action = create)
env.Config(target = 'package-config', source = Value(prefix))

def build_value（目标，源，环境）：
# 通过更新“构建” Python 值的函数
# 包含文件内容的 Python 值
# 指定为生成器调用的源 ($SOURCE)。
目标[0].write(源[0].get_contents())

输出 = env.Value('之前')
输入 = env.Value('之后')

# 为上述函数附加一个 .UpdateValue() 构建器
# 对构建环境的操作。
env['BUILDERS']['UpdateValue'] = Builder(action = build_value)
env.UpdateValue（目标 = 值（输出），源 = 值（输入））

VariantDir(variant_dir, src_dir, [重复]), env.VariantDir(variant_dir, src_dir,
[复制]）
使用 变体目录 在另一个位置创建源的副本的功能：如果
名下 变体目录 未找到但存在于 源目录, 文件或目录是
复制到 变体目录. 目标文件可以构建在与目标文件不同的目录中
原始来源通过简单地引用变体中的来源（和目标）
树。

变体目录 可以多次调用同一个 源目录 设置多个
使用不同的选项构建（变种）。 该 源目录 位置必须在或
在 SConstruct 文件的目录下，以及 变体目录 可能不在下面
源目录.

默认行为是让 scons 在物理上复制源文件
变体树。 因此，保证在变体树中执行的构建是
与在源代码树中执行的构建相同，即使中间源文件
在构建过程中生成，或者预处理器或其他扫描仪搜索包含
相对于源文件的文件，或者单独的编译器或其他调用的工具是
硬编码以将派生文件与源文件放在同一目录中。

如果可能在平台上，复制是通过链接而不是
复制； 另见 - 复制 命令行选项。 此外，只有需要的文件
因为构建是重复的； 未使用的文件和目录不存在
in 变体目录.

可以通过将重复参数设置为 0 来禁用复制源树
（零）。 这将导致 scons 使用源文件的路径名调用 Builders
in 源目录 以及其中的派生文件的路径名 变体目录. 这总是更多
比重复 = 1 更有效，并且对于大多数构建通常是安全的（但请参见上文
可能导致问题的情况）。

需要注意的是 变体目录 最自然地与附属的 SConscript 文件一起工作。 然而，
然后，您将不在源目录中调用附属 SConscript 文件，而是在
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 变体目录，无论重复的值如何。 这就是你告诉scons的方式
要构建的源树的哪个变体：

# 在两个变体目录中运行 src/SConscript
VariantDir('build/variant1', 'src')
SConscript('build/variant1/SConscript')
VariantDir('build/variant2', 'src')
SConscript('build/variant2/SConscript')

另见 新兵 函数，如上所述，另一种方式来指定
变体目录连同调用一个附属的 SConscript 文件。

例子：

# 使用构建目录中的名称，而不是源目录
VariantDir('build', 'src', duplicate=0)
程序（'build/prog', 'build/source.c'）

# 这会在单独的子树中构建源代码和文档
VariantDir('build', '.', duplicate=0)
SConscript(dirs=['build/src','build/doc'])

# 和前面的例子一样，但是只使用了 SConscript
SConscript(dirs='src', variant_dir='build/src', duplicate=0)
SConscript(dirs='doc', variant_dir='build/doc', duplicate=0)

WhereIs(程序, [路径, pathext, 拒绝]), env.WhereIs(程序, [路径, pathext, 拒绝])
搜索指定的可执行文件 程序，将完整路径名返回到
如果找到则程序，如果没有则返回 None。 搜索指定的 径，
调用环境的 PATH (env['ENV']['PATH']) 的值，或者用户的当前
默认情况下，外部 PATH (os.environ['PATH'])。 在 Windows 系统上，搜索
具有指定文件中列出的任何文件扩展名的可执行程序 路径文本,
调用环境的 PATHEXT (env['ENV']['PATHEXT']) 或用户的当前
PATHEXT (os.environ['PATHEXT']) 默认情况下。 不会选择任何路径名或名称
指定的 拒绝 清单，如果有的话。

新兵 变量
除了全局函数和方法， 烤饼 支持多种 Python
可以在 SConscript 文件中使用的变量来影响您希望构建的方式
执行。 这些变量可以从您导入的自定义 Python 模块中访问
通过将以下内容添加到 Python 模块来创建 SConscript 文件：

从 SCons.Script 导入 *

格表
一个列表 关键词=折扣值 命令行中指定的参数。 列表中的每个元素
是一个包含 (关键词,折扣值) 的论点。 分开的 关键词 和
折扣值 元组的元素可以通过下标元素访问 [0] 和 [1] of
元组，分别。

计费示例：

print "第一个关键字，值="，ARGLIST[0][0]，ARGLIST[0][1]
print "第二个关键字，值="，ARGLIST[1][0]，ARGLIST[1][1]
第三元组 = ARGLIST[2]
print "第三个关键字，值="，third_tuple[0]，third_tuple[1]
对于 ARGLIST 中的键、值：
# 处理键和值

争论
所有的字典 关键词=折扣值 命令行中指定的参数。 这
字典不按顺序排列，并且如果给定关键字分配了多个值
它在命令行上，最后一个（最右边的）值是 争论
字典。

计费示例：

如果 ARGUMENTS.get('debug', 0):
环境 = 环境（CCFLAGS = '-g'）
其他：
环境 = 环境（）

BUILD_TARGETS
目标列表 烤饼 实际上会尝试构建，无论是否
它们是在命令行上或通过 默认() 函数或方法。 这
此列表的元素可能是字符串 or 节点，所以你应该通过
Python STR 函数以确保任何节点路径名称都转换为字符串。

因为这个列表可能取自使用指定的目标列表 默认()
函数或方法，列表的内容可能会在每次连续调用时更改
默认()。 见 默认目标 列表，下面，以获取更多信息。

计费示例：

如果BUILD_TARGETS中的'foo'：
print "别忘了测试 `foo' 程序！"
如果BUILD_TARGETS中的“特殊/程序”：
SConscript('特殊')

请注意 BUILD_TARGETS 列表仅包含命令行上列出的预期目标
或通过调用 默认() 函数或方法。 它确实 而不去 包含所有依赖
由于确保明确指定的目标而构建的目标
是最新的。

COMMAND_LINE_TARGETS
在命令行上明确指定的目标列表。 如果没有
在命令行上指定的目标，列表为空。 这可以用于
例如，仅在明确指定某个或多个目标时才采取具体行动
正在建设。

计费示例：

如果 COMMAND_LINE_TARGETS 中的“foo”：
print "别忘了测试 `foo' 程序！"
如果 COMMAND_LINE_TARGETS 中的“特殊/程序”：
SConscript('特殊')

默认目标
目标清单 节点 已使用指定的 默认() 函数或
方法。 列表的元素是节点，所以你需要通过 Python 运行它们
STR 函数获取每个节点的路径名。

计费示例：

打印 str(DEFAULT_TARGETS[0])
如果地图中的'foo'（str，DEFAULT_TARGETS）：
print "别忘了测试 `foo' 程序！"

的内容 默认目标 每次连续调用
默认（） 功能：

print map(str, DEFAULT_TARGETS) # 原来是 []
默认（'foo'）
print map(str, DEFAULT_TARGETS) # 现在是一个节点 ['foo']
默认（'栏'）
print map(str, DEFAULT_TARGETS) # 现在是一个节点 ['foo', 'bar']
默认（无）
print map(str, DEFAULT_TARGETS) # 返回 []

因此，请务必使用 默认目标 只有在你完成了所有的 默认()
调用，否则只需注意 SConscript 文件中这些语句的顺序
这样您就不会在实际添加到特定的默认目标之前寻找它
列表。

建筑业 变量
一个构建环境有一个相关的字典 结构 变量 ，
由内置或用户提供的构建规则使用。 构造变量必须遵循相同的
Python 标识符规则：首字母必须是下划线或字母，
后跟任意数量的下划线、字母或数字。

scons 为每个变量自动定义了许多有用的构造变量
支持的平台，用户可以定义额外的构造变量。 这
以下是自动定义的构造变量的列表：

__LDMODULEVERSIONFLAGS
这个构造变量自动引入 $_LDMODULEVERSIONFLAGS if
$LDMODULEVERSION 已设置。 否则它评估为一个空字符串。

__SHLIB版本标志
这个构造变量自动引入 $_SHLIBVERSIONFLAGS if
$SHLIB版本 已设置。 否则它评估为一个空字符串。

AR
静态库归档器。

ARCHITECTURE
指定为其构建包的系统架构。 默认是
运行 SCons 的机器的系统架构。 这是用来填充的
在 Ipkg 控制文件中的 Architecture: 字段中，并作为名称的一部分
生成的 RPM 文件。

ARCOM
用于从目标文件生成静态库的命令行。

阿康斯特
从汇编语言源生成目标文件时显示的字符串
文件。 如果没有设置，那么 $阿康 （命令行）显示。

env = Environment(ARCOMSTR = "归档 $TARGET")

标志
传递给静态库归档器的常规选项。

AS
装配工。

亚斯康
用于从汇编语言源生成目标文件的命令行
文件中。

阿斯康斯特
从汇编语言源生成目标文件时显示的字符串
文件。 如果没有设置，那么 $ASCOM （命令行）显示。

env = Environment(ASCOMSTR = "组装 $TARGET")

阿斯旗
传递给汇编器的常规选项。

阿斯普康
用于将汇编语言源文件组装成目标文件的命令行
在首先通过 C 预处理器运行文件之后。 中指定的任何选项
$ASFLAGS 和 $CPPFLAGS 构造变量包含在此命令行中。

ASPCOMSTR
从汇编语言源生成目标文件时显示的字符串
第一次通过 C 预处理器运行文件后的文件。 如果没有设置，那么
$ASPPCOM （命令行）显示。

env = Environment(ASPPCOMSTR = "组装 $TARGET")

ASPPF标志
将汇编语言源文件组装成对象时的常规选项
第一次通过 C 预处理器运行文件后的文件。 默认是使用
的值 $ASFLAGS.

国际博览馆
TeX 格式化程序和排版程序以及 LaTeX 的参考书目生成器
结构化格式化程序和排版程序。

BIBTEXCOM
用于调用 TeX 格式化程序的参考书目生成器的命令行和
排版器和 LaTeX 结构化格式化程序和排版器。

BIBTEXCOMSTR
为 TeX 或 LaTeX 生成参考书目时显示的字符串。 如果这不是
设置，然后 $BIBTEXCOM （命令行）显示。

env = Environment(BIBTEXCOMSTR = "生成参考书目 $TARGET")

中文标志
传递给 TeX 格式化程序的参考书目生成器的常规选项和
排版器和 LaTeX 结构化格式化程序和排版器。

守门员
BitKeeper 可执行文件。

比特守护者通讯
使用 BitKeeper 获取源文件的命令行。

比特币管理员
使用 BitKeeper 获取源文件时显示的字符串。 如果没有设置，
然后 $BIKEEPERCOM （命令行）显示。

比特守护者
命令 （$比特币) 和使用 BitKeeper 获取源文件的子命令。

比特币持有者获取标志
传递给 BitKeeper 的选项 得到 子命令。

BUILDERS
一个字典，将通过此环境可用的构建器的名称映射到
底层 Builder 对象。 生成器命名为 Alias、CFile、CXXFile、DVI、Library、
默认情况下可以使用对象、PDF、PostScript 和程序。 如果你初始化这个
创建环境时的变量：

env = Environment(BUILDERS = {'NewBuilder' : foo})

默认的 Builders 将不再可用。 在中使用新的 Builder 对象
除了默认的 Builders，添加新的 Builder 对象，如下所示：

环境 = 环境（）
env.Append(BUILDERS = {'NewBuilder' : foo})

或这个：

环境 = 环境（）
env['BUILDERS]['NewBuilder'] = foo

CC
C 编译器。

中央通信委员会
用于将 C 源文件编译为（静态）目标文件的命令行。 任何
中指定的选项 $CFLAGS, $CCFLAGS 和 $CPPFLAGS 构造变量是
包含在此命令行中。

CCCOMSTR
当 C 源文件编译为（静态）目标文件时显示的字符串。 如果
这没有设置，那么 $CCCOM （命令行）显示。

env = Environment(CCCOMSTR = "编译静态对象 $TARGET")

旗帜标志
传递给 C 和 C++ 编译器的常规选项。

中共党旗
添加到编译器命令行以支持使用预编译构建的选项
标题。 默认值 expand 扩展为相应的 Microsoft Visual C++
命令行选项时 $PCH 构造变量已设置。

CCPDBF标志
添加到编译器命令行的选项以支持将调试信息存储在
Microsoft Visual C++ PDB 文件。 默认值 expand 扩展为适当
Microsoft Visual C++ 命令行选项 $PDB 构造变量已设置。

SCons 默认使用的 Visual C++ 编译器选项来生成 PDB 信息
is /Z7. 这适用于并行（-j) 构建，因为它嵌入了调试
中间对象文件中的信息，而不是共享单个 PDB 文件
多个目标文件之间。 这也是获取调试信息的唯一方法
嵌入到静态库中。 使用 /子 相反，可能会产生改进的链接时间
性能，尽管并行构建将不再起作用。

您可以使用以下命令生成 PDB 文件 /子 通过覆盖默认值进行切换 $CCPDBFLAGS
变量如下：

env['CCPDBFLAGS'] = ['${(PDB and "/Zi /Fd%s" % File(PDB)) 或 ""}']

另一种方法是使用 /子 将调试信息放在单独的
通过覆盖每个目标文件的 .pdb 文件 $CCPDBFLAGS 变量如下：

env['CCPDBFLAGS'] = '/Zi /Fd${TARGET}.pdb'

版本
C 编译器的版本号。 这可能会或可能不会设置，具体取决于
正在使用的特定 C 编译器。

C文件后缀
C 源文件的后缀。 这由内部 CFile 构建器使用，当
从 Lex (.l) 或 YACC (.y) 输入文件生成 C 文件。 默认后缀为
当然，是 .c（小写）。 在不区分大小写的系统（如 Windows）上，SCons 也
将 .C（大写）文件视为 C 文件。

标志
传递给 C 编译器的常规选项（仅限 C；不是 C++）。

更改规范文件
用于修改控制打包构建的文件的挂钩（RPM 的 .spec，
Ipkg 的控件，MSI 的 .wxs）。 如果设置，函数将在
该文件的 SCons 模板已编写完毕。 XXX

已更改来源
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

CHANGED_TARGETS 目标
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

CHANGELOG
包含要包含在包中的更改日志文本的文件的名称。 这个
包含在 RPM .spec 文件的 %changelog 部分中。

_concat
用于产生变量的函数，例如 $_CPPINCFLAGS. 需要四五个
参数：连接到每个元素的前缀，元素列表，后缀
连接到每个元素、变量插值的环境和
在连接之前将调用以转换列表的可选函数。

env['_CPPINCFLAGS'] = '$( ${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs)} $)',

配置目录
写入配置上下文测试文件的目录的名称。 这
默认为包含 SConstruct 文件的顶级目录中的 .sconf_temp。

配置日志
配置上下文日志文件的名称。 默认是顶层的 config.log
包含 SConstruct 文件的目录。

_CPPDEFFLAGS
包含 C 预处理器的自动生成的构造变量
用于定义值的命令行选项。 的价值 $_CPPDEFFLAGS 由...创建
附加 $CPPDEFPREFIX 和 $CPPDEF后缀 到每个定义的开头和结尾
in $CPPD定义.

CPP定义
C 预处理器定义的独立于平台的规范。 定义
将通过自动生成的添加到命令行 $_CPPDEFFLAGS
构造变量（见上），根据值的类型构造
of $CPPD定义:

If $CPPD定义 是一个字符串，的值 $CPPDEFPREFIX 和 $CPPDEF后缀
构造变量将被添加到开头和结尾。

# 将 -Dxyz 添加到 POSIX 编译器命令行，
# 和 /Dxyz 到 Microsoft Visual C++ 命令行。
env = 环境（CPPDEFINES='xyz'）

If $CPPD定义 是一个列表，的值 $CPPDEFPREFIX 和 $CPPDEF后缀
构造变量将附加到每个元素的开头和结尾
名单。 如果任何元素是列表或元组，则第一项是名称
已定义，第二项是它的值：

# 将 -DB=2 -DA 添加到 POSIX 编译器命令行，
# 和 /DB=2 /DA 到 Microsoft Visual C++ 命令行。
env = 环境（CPPDEFINES=[('B', 2), 'A'])

If $CPPD定义 是一个字典，的值 $CPPDEFPREFIX 和 $CPPDEF后缀
构造变量将附加到每个项目的开头和结尾
字典。 每个字典项的键是定义到字典的名称
item的对应值； 如果值为 None，则定义名称时不带
明确的价值。 请注意，生成的标志按关键字排序，以确保
每次运行 scons 时，命令行上的选项顺序都是一致的。

# 将 -DA -DB=2 添加到 POSIX 编译器命令行，
# 和 /DA /DB=2 到 Microsoft Visual C++ 命令行。
env = 环境（CPPDEFINES={'B':2, 'A':None}）

CPPDEFP 前缀
用于在 C 编译器命令行上指定预处理器定义的前缀。
这将附加到每个定义的开头 $CPPD定义
构造变量当 $_CPPDEFFLAGS 变量是自动生成的。

CPPDEF后缀
用于在 C 编译器命令行上指定预处理器定义的后缀。
这将附加到每个定义的末尾 $CPPD定义 结构
变量时 $_CPPDEFFLAGS 变量是自动生成的。

CPPF标志
用户指定的 C 预处理器选项。 这些将包含在使用的任何命令中
C 预处理器，不仅包括通过
$CCCOM, $上海商会, $CXXCOM 和 $SHCXXCOM 命令行，还有 $FORTRANPPCOM,
$SHFORTRANPPCOM, $F77PPCOM 和 $SHF77PPCOM 用于编译 Fortran 的命令行
源文件，以及 $ASPPCOM 用于汇编汇编语言的命令行
源文件，首先通过 C 预处理器运行每个文件。 请注意，这
变量确实 而不去 包含 -I （或类似的）包括 scons 的搜索路径选项
从自动生成 $CPP路径。 看 $_CPPINCFLAGS，下面，对于变量
扩展到这些选项。

_CPPINCFLAGS
包含 C 预处理器的自动生成的构造变量
用于指定要搜索包含文件的目录的命令行选项。 这
价值 $_CPPINCFLAGS 通过附加创建 $INC前缀 和 $INC后缀 以及
每个目录的开头和结尾 $CPP路径.

路径
C 预处理器将搜索包含目录的目录列表。
C/C++ 隐式依赖扫描器将在这些目录中搜索包含文件。
不要在 CCFLAGS 或 CXXFLAGS 中明确放置包含目录参数，因为
结果将是不可移植的，并且依赖项不会搜索目录
扫描器。 注意：CPPPATH 中的目录名称将相对于 SConscript 进行查找
在命令中使用它们时的目录。 强制 scons 查找目录
相对于源树的根使用 #:

env = 环境（CPPPATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（CPPPATH=包括）

目录列表将通过自动生成的添加到命令行
$_CPPINCFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $INC前缀 和 $INC后缀 构造变量到每个的开头和结尾
目录 $CPP路径. 您定义的任何需要 CPPPATH 目录的命令行
清单应包括 $_CPPINCFLAGS:

env = Environment(CCCOM="my_compiler $_CPPINCFLAGS -c -o $TARGET $SOURCE")

CP后缀
将为 C 预处理器隐式扫描的文件的后缀列表
依赖项（#include 行）。 默认列表是：

[“.c”，“.C”，“.cxx”，“.cpp”，“.c++”，“.cc”，
“.h”、“.H”、“.hxx”、“.hpp”、“.hh”、
“.F”、“.fpp”、“.FPP”、
“.m”、“.mm”、
“.S”、“.spp”、“.SPP”]

CVS
CVS 可执行文件。

CVSCO标志
传递给 CVS checkout 子命令的选项。

CVSCOM
用于从 CVS 存储库获取源文件的命令行。

CVSCOMSTR
从 CVS 存储库获取源文件时显示的字符串。 如果这不是
设置，然后 $CVSCOM （命令行）显示。

简历标志
传递给 CVS 的常规选项。 默认情况下，这设置为 -d $CVSREPOSITORY
指定必须从哪里获取文件。

CVS存储库
CVS 存储库的路径。 这是默认引用的 $CVSFLAGS 计算值。

CXX
C++ 编译器。

西数通信
用于将 C++ 源文件编译为目标文件的命令行。 任何选项
在指定 $CXXFLAGS 和 $CPPFLAGS 构造变量包含在此
命令行。

CXXCOMSTR
当 C++ 源文件编译为（静态）目标文件时显示的字符串。 如果
这没有设置，那么 $CXXCOM （命令行）显示。

env = Environment(CXXCOMSTR = "编译静态对象 $TARGET")

CXX文件后缀
C++ 源文件的后缀。 这由内部 CXXFile 构建器使用
从 Lex (.ll) 或 YACC (.yy) 输入文件生成 C++ 文件。 默认后缀是
.cc。 SCons 还将后缀为 .cpp、.cxx、.c++ 和 .C++ 的文件视为 C++
文件和带有 .mm 后缀的文件作为 Objective C++ 文件。 在区分大小写的系统上
（Linux、UNIX 和其他类似 POSIX 的软件），SCons 还将 .C（大写）文件视为 C++
文件。

CXX标志
传递给 C++ 编译器的常规选项。 默认情况下，这包括
价值 $CCFLAGS, 这样设置 $CCFLAGS 影响 C 和 C++ 编译。 如果你
要添加特定于 C++ 的标志，您必须设置或覆盖 $CXXFLAGS.

CXX版本
C++ 编译器的版本号。 这可能会或可能不会设置，具体取决于
正在使用的特定 C++ 编译器。

DC
DC。

DCOM
DCOM。

DDBUG
调试。

_DDEBUGFLAGS
_DDEBUGFLAGS。

调试前缀
DDEBUGPREFIX。

DDBUGSUFFIX
DDBUG后缀。

商品描述
对正在打包的项目的详细描述。 这包含在相关的
控制打包构建的文件部分。

描述语言
特定语言的详细描述 郎. 这用于填充
RPM .spec 文件的 %description -l 部分。

DFILE后缀
DFILE后缀。

DFLAPGREFIX
DFLAGPREFIX。

_DFLAGS
_DFLAGS。

DFLAGS
标志。

DFLAG后缀
DFLAG后缀。

_DINCFLAGS
_DINCFLAGS。

DINCP前缀
DINCP 前缀。

DIN后缀
后缀。

你
将字符串转换为相对于目标的 Dir 实例的函数
内置的。

将字符串转换为相对于目标的 Dir 实例的函数
内置的。

DIRS
将字符串列表转换为 Dir 实例列表的函数
正在构建的目标。

DLIB
DLIB。

DLIBCOM
DLIBCOM。

_DLIBDIRFLAGS
_DLIBDIRFLAGS。

DLIB目录前缀
DLIBDIRPREFIX。

DLIB目录后缀
DLIBDIRSUFFIX。

DLIB标志前缀
DLIBFLAGPREFIX。

_DLIBFLAGS
_DLIBFLAGS。

DLIB标志后缀
DLIBFLAG 后缀。

DLIBLINK前缀
DLIBLINK 前缀。

DLIBLINK后缀
DLIBLINK后缀。

链接
链接。

联通
联通。

DLINK标志前缀
DLINKFLAGPREFIX。

链接标志
链接标志。

链接标志后缀
DLINK标志后缀。

DOCBOOK_DEFAULT_XSL_EPUB
的默认 XSLT 文件 文档电子书 当前环境中的构建器，如果
没有通过关键字指定其他 XSLT。

DOCBOOK_DEFAULT_XSL_HTML
的默认 XSLT 文件 文档Html 当前环境中的构建器，如果
没有通过关键字指定其他 XSLT。

DOCBOOK_DEFAULT_XSL_HTMLCHUNKED
的默认 XSLT 文件 DocbookHtml分块 当前的建设者
环境，如果没有通过关键字指定其他 XSLT。

DOCBOOK_DEFAULT_XSL_HTMLHELP
的默认 XSLT 文件 DocbookHtml帮助 当前环境中的构建器，
如果没有通过关键字指定其他 XSLT。

DOCBOOK_DEFAULT_XSL_MAN
的默认 XSLT 文件 文档人 当前环境中的builder，如果没有
其他 XSLT 通过关键字指定。

DOCBOOK_DEFAULT_XSL_PDF
的默认 XSLT 文件 Docbook.pdf 当前环境中的builder，如果没有
其他 XSLT 通过关键字指定。

DOCBOOK_DEFAULT_XSL_SLIDESHTML
的默认 XSLT 文件 文档幻灯片Html 当前的建设者
环境，如果没有通过关键字指定其他 XSLT。

DOCBOOK_DEFAULT_XSL_幻灯片PDF
的默认 XSLT 文件 Docbook幻灯片Pdf 当前环境中的构建器，
如果没有通过关键字指定其他 XSLT。

DOCBOOK_FOP
PDF 渲染器 fop 或 xep 的路径，如果已安装其中之一（检查 fop
第一）。

DOCBOOK_FOPCOM
PDF 渲染器 fop 或 xep 的完整命令行。

DOCBOOK_FOPCOMSTR
当使用 fop 或 xep 等渲染器创建 PDF 输出时显示的字符串
一个 XML 文件。

DOCBOOK_FOPFLAGS
PDF 渲染器 fop 或 xep 的附加命令行标志。

DOCBOOK_XMLLINT
外部可执行文件 xmllint 的路径（如果已安装）。 请注意，这是
如果没有 libxml2 或 lxml Python，则仅用作解析 XIncludes 的最后后备
绑定可以在当前系统中导入。

DOCBOOK_XMLLINTCOM
外部可执行文件 xmllint 的完整命令行。

DOCBOOK_XMLLINTCOMSTR
当 xmllint 用于解析给定 XML 文件的 XIncludes 时显示的字符串。

DOCBOOK_XMLLINTFLAGS
外部可执行文件 xmllint 的附加命令行标志。

DOCBOOK_XSLTPROC
外部可执行文件 xsltproc（或 saxon、xalan）的路径，如果其中之一是
安装。 请注意，这仅用作 XSL 转换的最后回退，如果
当前系统无法导入 libxml2 或 lxml Python 绑定。

DOCBOOK_XSLTPROCCOM
外部可执行文件 xsltproc（或 saxon、xalan）的完整命令行。

DOCBOOK_XSLTPROCCOMSTR
当 xsltproc 用于通过给定 XSLT 转换 XML 文件时显示的字符串
样式表。

DOCBOOK_XSLTPROCFLAGS
外部可执行文件 xsltproc（或 saxon、xalan）的附加命令行标志。

DOCBOOK_XSLTPROCPARAMS
不用于 XSLT 处理器可执行文件的附加参数，但
XSL 处理本身。 默认情况下，它们被附加在命令行的末尾
分别用于 saxon 和 saxon-xslt。

路径
路径。

后缀
将扫描导入的 D 包文件的文件后缀列表。 这
默认列表是：

['.d']

_DVERFLAGS
_DVERFLAGS。

DVER前缀
DVERP 前缀。

版本
版本。

后缀
后缀。

DVIPDF
TeX DVI 文件到 PDF 文件转换器。

DVIPDFCOM
用于将 TeX DVI 文件转换为 PDF 文件的命令行。

DVIPDFCOMSTR
将 TeX DVI 文件转换为 PDF 文件时显示的字符串。 如果这不是
设置，然后 $DVIPDFCOM （命令行）显示。

DVIPDF标志
传递给 TeX DVI 文件到 PDF 文件转换器的常规选项。

输出电压
TeX DVI 文件到 PostScript 转换器。

DVIPS标志
传递给 TeX DVI 文件到 PostScript 转换器的常规选项。

ENV
调用命令时使用的环境变量字典。 什么时候 $环境变量 用来
在命令中，所有列表值都将使用路径分隔符和任何其他值连接
非字符串值将被简单地强制转换为字符串。 请注意，默认情况下，scons
不 而不去 对命令执行 scons 时传播有效的环境
用于构建目标文件。 这样可以保证构建可重复
无论调用 scons 时设置的环境变量如何。

如果要将环境变量传播到执行构建的命令
目标文件，您必须明确地这样做：

导入操作系统
env = 环境（ENV = os.environ）

请注意，您只能选择传播某些环境变量。 普通的
例子是系统 PATH 环境变量，以便 scons 使用相同的实用程序
作为调用外壳（或其他进程）：

导入操作系统
env = Environment(ENV = {'PATH' : os.environ['PATH']})

- EP
将调用以在命令行中转义 shell 特殊字符的函数。
该函数应该有一个参数：要转义的命令行字符串； 并且应该
返回转义的命令行。

F03
Fortran 03 编译器。 您通常应该设置 $FORTRAN 语言 变量，其中
为所有 Fortran 版本指定默认的 Fortran 编译器。 你只需要设置
$03 如果您需要为 Fortran 03 文件使用特定的编译器或编译器版本。

F03COM
用于将 Fortran 03 源文件编译为目标文件的命令行。 只有你
需要设置 $F03COM 如果您需要对 Fortran 03 文件使用特定的命令行。
您通常应该设置 $Fortrancom 变量，它指定默认命令
所有 Fortran 版本的行。

F03COMSTR
将 Fortran 03 源文件编译为目标文件时显示的字符串。 如果
这没有设置，那么 $F03COM or $Fortrancom （命令行）显示。

F03文件后缀
将使用 F03 方言的文件扩展名列表。 默认情况下，这
是 ['.f03']

F03标志
传递给 Fortran 03 编译器的一般用户指定选项。 注意
这个变量确实 而不去 包含 -I （或类似的）包括 scons 的搜索路径选项
从自动生成 $F03路径。 看 $_F03INCFLAGS 下面，对于变量
扩展到这些选项。 你只需要设置 $F03标志 如果你需要定义
Fortran 03 文件的特定用户选项。 您通常应该设置 $FORTRAFLAGS
变量，它指定传递给默认 Fortran 的用户指定选项
所有 Fortran 版本的编译器。

_F03INCFLAGS
包含 Fortran 03 编译器的自动生成的构造变量
用于指定要搜索包含文件的目录的命令行选项。 这
价值 $_F03INCFLAGS 通过附加创建 $INC前缀 和 $INC后缀 以及
每个目录的开头和结尾 $F03路径.

F03路径
Fortran 03 编译器将搜索的目录列表包括
目录。 隐式依赖扫描器将在这些目录中搜索包含
文件。 不要将包含目录参数显式放入 $F03标志 因为
结果将是不可移植的，并且依赖项不会搜索目录
扫描器。 注意：目录名在 $F03路径 将相对于
在命令中使用它们时的 SConscript 目录。 强制 scons 查找
相对于源树根目录的目录使用 #: 你只需要设置 $F03路径
如果您需要为 Fortran 03 文件定义特定的包含路径。 你应该
通常设置 $FORTRANPATH 变量，它指定的包含路径
所有 Fortran 版本的默认 Fortran 编译器。

env = 环境（F03PATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（F03PATH=包括）

目录列表将通过自动生成的添加到命令行
$_F03INCFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $INC前缀 和 $INC后缀 构造变量到每个的开头和结尾
目录 $F03路径. 您定义的任何需要 F03PATH 目录的命令行
清单应包括 $_F03INCFLAGS:

env = 环境（F03COM="my_compiler $_F03INCFLAGS -c -o $TARGET $SOURCE"）

F03PPCOM
用于将 Fortran 03 源文件编译为目标文件的命令行
首先通过 C 预处理器运行文件。 中指定的任何选项
$F03标志 和 $CPPFLAGS 构造变量包含在此命令行中。 你
只需要设置 $F03PPCOM 如果您需要使用特定的 C 预处理器命令行
Fortran 03 文件。 您通常应该设置 $FORTRANPPCOM 变量，其中
为所有 Fortran 版本指定默认的 C 预处理器命令行。

F03PPCOMSTR
将 Fortran 03 源文件编译为目标文件后显示的字符串
首先通过 C 预处理器运行文件。 如果没有设置，那么 $F03PPCOM
or $FORTRANPPCOM （命令行）显示。

F03PP文件后缀
编译 + 预处理器为 F03 传递的文件扩展名列表
将使用方言。 默认情况下，这是空的

F08
Fortran 08 编译器。 您通常应该设置 $FORTRAN 语言 变量，其中
为所有 Fortran 版本指定默认的 Fortran 编译器。 你只需要设置
$08 如果您需要为 Fortran 08 文件使用特定的编译器或编译器版本。

F08COM
用于将 Fortran 08 源文件编译为目标文件的命令行。 只有你
需要设置 $F08COM 如果您需要对 Fortran 08 文件使用特定的命令行。
您通常应该设置 $Fortrancom 变量，它指定默认命令
所有 Fortran 版本的行。

F08COMSTR
将 Fortran 08 源文件编译为目标文件时显示的字符串。 如果
这没有设置，那么 $F08COM or $Fortrancom （命令行）显示。

F08文件后缀
将使用 F08 方言的文件扩展名列表。 默认情况下，这
是 ['.f08']

F08标志
传递给 Fortran 08 编译器的一般用户指定选项。 注意
这个变量确实 而不去 包含 -I （或类似的）包括 scons 的搜索路径选项
从自动生成 $F08路径。 看 $_F08INCFLAGS 下面，对于变量
扩展到这些选项。 你只需要设置 $F08标志 如果你需要定义
Fortran 08 文件的特定用户选项。 您通常应该设置 $FORTRAFLAGS
变量，它指定传递给默认 Fortran 的用户指定选项
所有 Fortran 版本的编译器。

_F08INCFLAGS
包含 Fortran 08 编译器的自动生成的构造变量
用于指定要搜索包含文件的目录的命令行选项。 这
价值 $_F08INCFLAGS 通过附加创建 $INC前缀 和 $INC后缀 以及
每个目录的开头和结尾 $F08路径.

F08路径
Fortran 08 编译器将搜索的目录列表包括
目录。 隐式依赖扫描器将在这些目录中搜索包含
文件。 不要将包含目录参数显式放入 $F08标志 因为
结果将是不可移植的，并且依赖项不会搜索目录
扫描器。 注意：目录名在 $F08路径 将相对于
在命令中使用它们时的 SConscript 目录。 强制 scons 查找
相对于源树根目录的目录使用 #: 你只需要设置 $F08路径
如果您需要为 Fortran 08 文件定义特定的包含路径。 你应该
通常设置 $FORTRANPATH 变量，它指定的包含路径
所有 Fortran 版本的默认 Fortran 编译器。

env = 环境（F08PATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（F08PATH=包括）

目录列表将通过自动生成的添加到命令行
$_F08INCFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $INC前缀 和 $INC后缀 构造变量到每个的开头和结尾
目录 $F08路径. 您定义的任何需要 F08PATH 目录的命令行
清单应包括 $_F08INCFLAGS:

env = 环境（F08COM="my_compiler $_F08INCFLAGS -c -o $TARGET $SOURCE"）

F08PPCOM
用于将 Fortran 08 源文件编译为目标文件的命令行
首先通过 C 预处理器运行文件。 中指定的任何选项
$F08标志 和 $CPPFLAGS 构造变量包含在此命令行中。 你
只需要设置 $F08PPCOM 如果您需要使用特定的 C 预处理器命令行
Fortran 08 文件。 您通常应该设置 $FORTRANPPCOM 变量，其中
为所有 Fortran 版本指定默认的 C 预处理器命令行。

F08PPCOMSTR
将 Fortran 08 源文件编译为目标文件后显示的字符串
首先通过 C 预处理器运行文件。 如果没有设置，那么 $F08PPCOM
or $FORTRANPPCOM （命令行）显示。

F08PP文件后缀
编译 + 预处理器为 F08 传递的文件扩展名列表
将使用方言。 默认情况下，这是空的

F77
Fortran 77 编译器。 您通常应该设置 $FORTRAN 语言 变量，其中
为所有 Fortran 版本指定默认的 Fortran 编译器。 你只需要设置
$77 如果您需要为 Fortran 77 文件使用特定的编译器或编译器版本。

F77COM
用于将 Fortran 77 源文件编译为目标文件的命令行。 只有你
需要设置 $F77COM 如果您需要对 Fortran 77 文件使用特定的命令行。
您通常应该设置 $Fortrancom 变量，它指定默认命令
所有 Fortran 版本的行。

F77COMSTR
将 Fortran 77 源文件编译为目标文件时显示的字符串。 如果
这没有设置，那么 $F77COM or $Fortrancom （命令行）显示。

F77文件后缀
将使用 F77 方言的文件扩展名列表。 默认情况下，这
是 ['.f77']

F77标志
传递给 Fortran 77 编译器的一般用户指定选项。 注意
这个变量确实 而不去 包含 -I （或类似的）包括 scons 的搜索路径选项
从自动生成 $F77路径。 看 $_F77INCFLAGS 下面，对于变量
扩展到这些选项。 你只需要设置 $F77标志 如果你需要定义
Fortran 77 文件的特定用户选项。 您通常应该设置 $FORTRAFLAGS
变量，它指定传递给默认 Fortran 的用户指定选项
所有 Fortran 版本的编译器。

_F77INCFLAGS
包含 Fortran 77 编译器的自动生成的构造变量
用于指定要搜索包含文件的目录的命令行选项。 这
价值 $_F77INCFLAGS 通过附加创建 $INC前缀 和 $INC后缀 以及
每个目录的开头和结尾 $F77路径.

F77路径
Fortran 77 编译器将搜索的目录列表包括
目录。 隐式依赖扫描器将在这些目录中搜索包含
文件。 不要将包含目录参数显式放入 $F77标志 因为
结果将是不可移植的，并且依赖项不会搜索目录
扫描器。 注意：目录名在 $F77路径 将相对于
在命令中使用它们时的 SConscript 目录。 强制 scons 查找
相对于源树根目录的目录使用 #: 你只需要设置 $F77路径
如果您需要为 Fortran 77 文件定义特定的包含路径。 你应该
通常设置 $FORTRANPATH 变量，它指定的包含路径
所有 Fortran 版本的默认 Fortran 编译器。

env = 环境（F77PATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（F77PATH=包括）

目录列表将通过自动生成的添加到命令行
$_F77INCFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $INC前缀 和 $INC后缀 构造变量到每个的开头和结尾
目录 $F77路径. 您定义的任何需要 F77PATH 目录的命令行
清单应包括 $_F77INCFLAGS:

env = 环境（F77COM="my_compiler $_F77INCFLAGS -c -o $TARGET $SOURCE"）

F77PPCOM
用于将 Fortran 77 源文件编译为目标文件的命令行
首先通过 C 预处理器运行文件。 中指定的任何选项
$F77标志 和 $CPPFLAGS 构造变量包含在此命令行中。 你
只需要设置 $F77PPCOM 如果您需要使用特定的 C 预处理器命令行
Fortran 77 文件。 您通常应该设置 $FORTRANPPCOM 变量，其中
为所有 Fortran 版本指定默认的 C 预处理器命令行。

F77PPCOMSTR
将 Fortran 77 源文件编译为目标文件后显示的字符串
首先通过 C 预处理器运行文件。 如果没有设置，那么 $F77PPCOM
or $FORTRANPPCOM （命令行）显示。

F77PP文件后缀
编译 + 预处理器为 F77 传递的文件扩展名列表
将使用方言。 默认情况下，这是空的

F90
Fortran 90 编译器。 您通常应该设置 $FORTRAN 语言 变量，其中
为所有 Fortran 版本指定默认的 Fortran 编译器。 你只需要设置
$90 如果您需要为 Fortran 90 文件使用特定的编译器或编译器版本。

F90COM
用于将 Fortran 90 源文件编译为目标文件的命令行。 只有你
需要设置 $F90COM 如果您需要对 Fortran 90 文件使用特定的命令行。
您通常应该设置 $Fortrancom 变量，它指定默认命令
所有 Fortran 版本的行。

F90COMSTR
将 Fortran 90 源文件编译为目标文件时显示的字符串。 如果
这没有设置，那么 $F90COM or $Fortrancom （命令行）显示。

F90文件后缀
将使用 F90 方言的文件扩展名列表。 默认情况下，这
是 ['.f90']

F90标志
传递给 Fortran 90 编译器的一般用户指定选项。 注意
这个变量确实 而不去 包含 -I （或类似的）包括 scons 的搜索路径选项
从自动生成 $F90路径。 看 $_F90INCFLAGS 下面，对于变量
扩展到这些选项。 你只需要设置 $F90标志 如果你需要定义
Fortran 90 文件的特定用户选项。 您通常应该设置 $FORTRAFLAGS
变量，它指定传递给默认 Fortran 的用户指定选项
所有 Fortran 版本的编译器。

_F90INCFLAGS
包含 Fortran 90 编译器的自动生成的构造变量
用于指定要搜索包含文件的目录的命令行选项。 这
价值 $_F90INCFLAGS 通过附加创建 $INC前缀 和 $INC后缀 以及
每个目录的开头和结尾 $F90路径.

F90路径
Fortran 90 编译器将搜索的目录列表包括
目录。 隐式依赖扫描器将在这些目录中搜索包含
文件。 不要将包含目录参数显式放入 $F90标志 因为
结果将是不可移植的，并且依赖项不会搜索目录
扫描器。 注意：目录名在 $F90路径 将相对于
在命令中使用它们时的 SConscript 目录。 强制 scons 查找
相对于源树根目录的目录使用 #: 你只需要设置 $F90路径
如果您需要为 Fortran 90 文件定义特定的包含路径。 你应该
通常设置 $FORTRANPATH 变量，它指定的包含路径
所有 Fortran 版本的默认 Fortran 编译器。

env = 环境（F90PATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（F90PATH=包括）

目录列表将通过自动生成的添加到命令行
$_F90INCFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $INC前缀 和 $INC后缀 构造变量到每个的开头和结尾
目录 $F90路径. 您定义的任何需要 F90PATH 目录的命令行
清单应包括 $_F90INCFLAGS:

env = 环境（F90COM="my_compiler $_F90INCFLAGS -c -o $TARGET $SOURCE"）

F90PPCOM
用于将 Fortran 90 源文件编译为目标文件的命令行
首先通过 C 预处理器运行文件。 中指定的任何选项
$F90标志 和 $CPPFLAGS 构造变量包含在此命令行中。 你
只需要设置 $F90PPCOM 如果您需要使用特定的 C 预处理器命令行
Fortran 90 文件。 您通常应该设置 $FORTRANPPCOM 变量，其中
为所有 Fortran 版本指定默认的 C 预处理器命令行。

F90PPCOMSTR
首次运行 Fortran 90 源文件后编译时显示的字符串
文件通过 C 预处理器。 如果没有设置，那么 $F90PPCOM or $FORTRANPPCOM
（命令行）显示。

F90PP文件后缀
编译 + 预处理器为 F90 传递的文件扩展名列表
将使用方言。 默认情况下，这是空的

F95
Fortran 95 编译器。 您通常应该设置 $FORTRAN 语言 变量，其中
为所有 Fortran 版本指定默认的 Fortran 编译器。 你只需要设置
$95 如果您需要为 Fortran 95 文件使用特定的编译器或编译器版本。

F95COM
用于将 Fortran 95 源文件编译为目标文件的命令行。 只有你
需要设置 $F95COM 如果您需要对 Fortran 95 文件使用特定的命令行。
您通常应该设置 $Fortrancom 变量，它指定默认命令
所有 Fortran 版本的行。

F95COMSTR
将 Fortran 95 源文件编译为目标文件时显示的字符串。 如果
这没有设置，那么 $F95COM or $Fortrancom （命令行）显示。

F95文件后缀
将使用 F95 方言的文件扩展名列表。 默认情况下，这
是 ['.f95']

F95标志
传递给 Fortran 95 编译器的一般用户指定选项。 注意
这个变量确实 而不去 包含 -I （或类似的）包括 scons 的搜索路径选项
从自动生成 $F95路径。 看 $_F95INCFLAGS 下面，对于变量
扩展到这些选项。 你只需要设置 $F95标志 如果你需要定义
Fortran 95 文件的特定用户选项。 您通常应该设置 $FORTRAFLAGS
变量，它指定传递给默认 Fortran 的用户指定选项
所有 Fortran 版本的编译器。

_F95INCFLAGS
包含 Fortran 95 编译器的自动生成的构造变量
用于指定要搜索包含文件的目录的命令行选项。 这
价值 $_F95INCFLAGS 通过附加创建 $INC前缀 和 $INC后缀 以及
每个目录的开头和结尾 $F95路径.

F95路径
Fortran 95 编译器将搜索的目录列表包括
目录。 隐式依赖扫描器将在这些目录中搜索包含
文件。 不要将包含目录参数显式放入 $F95标志 因为
结果将是不可移植的，并且依赖项不会搜索目录
扫描器。 注意：目录名在 $F95路径 将相对于
在命令中使用它们时的 SConscript 目录。 强制 scons 查找
相对于源树根目录的目录使用 #: 你只需要设置 $F95路径
如果您需要为 Fortran 95 文件定义特定的包含路径。 你应该
通常设置 $FORTRANPATH 变量，它指定的包含路径
所有 Fortran 版本的默认 Fortran 编译器。

env = 环境（F95PATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（F95PATH=包括）

目录列表将通过自动生成的添加到命令行
$_F95INCFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $INC前缀 和 $INC后缀 构造变量到每个的开头和结尾
目录 $F95路径. 您定义的任何需要 F95PATH 目录的命令行
清单应包括 $_F95INCFLAGS:

env = 环境（F95COM="my_compiler $_F95INCFLAGS -c -o $TARGET $SOURCE"）

F95PPCOM
用于将 Fortran 95 源文件编译为目标文件的命令行
首先通过 C 预处理器运行文件。 中指定的任何选项
$F95标志 和 $CPPFLAGS 构造变量包含在此命令行中。 你
只需要设置 $F95PPCOM 如果您需要使用特定的 C 预处理器命令行
Fortran 95 文件。 您通常应该设置 $FORTRANPPCOM 变量，其中
为所有 Fortran 版本指定默认的 C 预处理器命令行。

F95PPCOMSTR
将 Fortran 95 源文件编译为目标文件后显示的字符串
首先通过 C 预处理器运行文件。 如果没有设置，那么 $F95PPCOM
or $FORTRANPPCOM （命令行）显示。

F95PP文件后缀
编译 + 预处理器为 F95 传递的文件扩展名列表
将使用方言。 默认情况下，这是空的

文件
将字符串转换为相对于目标的 File 实例的函数
内置的。

将字符串转换为相对于目标的 File 实例的函数
内置的。

福特兰
所有 Fortran 版本的默认 Fortran 编译器。

美国运通公司
用于将 Fortran 源文件编译为目标文件的命令行。 默认，
中指定的任何选项 $FORTRAFLAGS, $CPPFLAGS, $_CPPDEFFLAGS,
$_FORTRANMODFLAG和 $_FORTRANINCFLAGS 构造变量包含在此
命令行。

运输公司
将 Fortran 源文件编译为目标文件时显示的字符串。 如果这
没有设置，那么 $Fortrancom （命令行）显示。

FORTRAN文件后缀
将使用 FORTRAN 方言的文件扩展名列表。 默认，
这是 ['.f', '.for', '.ftn']

FORTRAFLAGS
传递给 Fortran 编译器的一般用户指定选项。 请注意，这
变量确实 而不去 包含 -I （或类似的）包含或模块搜索路径选项
scons 自动生成 $FORTRANPATH。 看 $_FORTRANINCFLAGS 和
$_FORTRANMODFLAG，下面，用于扩展这些选项的变量。

_FORTRANINCFLAGS
包含 Fortran 编译器的自动生成的构造变量
用于指定要搜索包含文件的目录的命令行选项和
模块文件。 的价值 $_FORTRANINCFLAGS 通过前置/附加创建
$INC前缀 和 $INC后缀 到每个目录的开头和结尾 $FORTRANPATH.

弗兰莫迪尔
Fortran 编译器应放置它的任何模块文件的目录位置
生成。 默认情况下，此变量为空。 一些 Fortran 编译器将在内部
也将此目录附加到模块文件的搜索路径中。

FORTRANMODDIR前缀
用于在 Fortran 编译器命令行上指定模块目录的前缀。
这将附加到目录的开头 $FORTRANMODDIR
构造变量时 $_FORTRANMODFLAG 变量是自动生成的。

FORTRANMODDIR后缀
用于在 Fortran 编译器命令行上指定模块目录的后缀。
这将附加到目录的开头 $FORTRANMODDIR
构造变量时 $_FORTRANMODFLAG 变量是自动生成的。

_FORTRANMODFLAG
包含 Fortran 编译器的自动生成的构造变量
用于指定 Fortran 编译器所在目录位置的命令行选项
应该放置在编译期间碰巧生成的任何模块文件。 这
价值 $_FORTRANMODFLAG 通过前置/附加创建 $FORTRANMODDIR前缀 和
$FORTRANMOD目录后缀 到目录的开头和结尾 $FORTRANMODDIR.

FORTRANMOD前缀
Fortran 编译器使用的模块文件前缀。 SCons 假设 Fortran
编译器遵循模块文件的准标准命名约定
模块名称.mod。 因此，默认情况下，此变量为空。 对于情况
在编译器不一定遵循正常约定的情况下，用户可以
使用这个变量。 它的值将作为 scons 附加到每个模块文件名
尝试解决依赖关系。

FORTRANMOD后缀
Fortran 编译器使用的模块文件后缀。 SCons 假设 Fortran
编译器遵循模块文件的准标准命名约定
模块名称.mod。 因此，默认情况下，此变量设置为“.mod”。 为了
编译器不一定遵循正常约定的情况，
用户可以使用这个变量。 它的值将附加到每个模块文件名
作为 scons 尝试解决依赖关系。

FORTRAN路径
Fortran 编译器将搜索包含文件的目录列表和
（对于某些编译器）模块文件。 Fortran 隐式依赖扫描器将搜索
这些目录用于包含文件（但不是模块文件，因为它们是自动生成的
因此，在扫描发生时可能实际上并不存在）。 别
明确地将包含目录参数放在 FORTRANFLAGS 中，因为结果将是
不可移植，并且依赖项扫描程序不会搜索目录。 笔记：
FORTRANPATH 中的目录名称将相对于 SConscript 目录进行查找
当它们在命令中使用时。 强制 scons 查找相对于
源树的根使用 #:

env = 环境（FORTRANPATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（FORTRANPATH=包括）

目录列表将通过自动生成的添加到命令行
$_FORTRANINCFLAGS 构造变量，通过附加值来构造
的 $INC前缀 和 $INC后缀 构造变量的开头和结尾
中的每个目录 $FORTRANPATH. 您定义的任何需要 FORTRANPATH 的命令行
目录列表应包括 $_FORTRANINCFLAGS:

env = 环境（FORTRANCOM="my_compiler $_FORTRANINCFLAGS -c -o $TARGET $SOURCE"）

运输司令部
用于将 Fortran 源文件编译为目标文件的命令行
通过 C 预处理器运行文件。 默认情况下，在
$FORTRAFLAGS, $CPPFLAGS, $_CPPDEFFLAGS, $_FORTRANMODFLAG和 $_FORTRANINCFLAGS
构造变量包含在此命令行中。

运输司令部
将 Fortran 源文件编译为目标文件后显示的字符串
首先通过 C 预处理器运行文件。 如果没有设置，那么
$FORTRANPPCOM （命令行）显示。

FORTRANPP文件后缀
FORTRAN 的编译 + 预处理器传递的文件扩展名列表
将使用方言。 默认情况下，这是 ['.fpp', '.FPP']

换装
将扫描 Fortran 隐式依赖项的文件后缀列表
（包括行和使用语句）。 默认列表是：

[“.f”、“.F”、“.for”、“.FOR”、“.ftn”、“.FTN”、“.fpp”、“.FPP”、
“.f77”、“.F77”、“.f90”、“.F90”、“.f95”、“.F95”]

框架路径
在带有 gcc 的 Mac OS X 上，包含搜索框架的路径的列表。 使用者
查找框架样式的编译器包括#include . 使用者
链接器在链接时查找用户指定的框架（参见 $框架）。 对于
例：

env.AppendUnique(FRAMEWORKPATH='#myframeworkdir')

将添加

... -Fmyframeworkdir

到编译器和链接器命令行。

_框架路径
在带有 gcc 的 Mac OS X 上，自动生成的构造变量包含
链接器命令行选项对应于 $框架路径.

框架路径前缀
在带有 gcc 的 Mac OS X 上，用于 FRAMEWORKPATH 条目的前缀。 （看
$框架路径）。 默认值为 -F.

框架前缀
在带有 gcc 的 Mac OS X 上，用于在框架中链接的前缀（参见
$框架）。 默认值为 -框架.

_构架
在带有 gcc 的 Mac OS X 上，自动生成的构造变量包含
用于与 FRAMEWORKS 链接的链接器命令行选项。

构架
在带有 gcc 的 Mac OS X 上，要链接到程序中的框架名称列表或
共享库或捆绑包。 默认值为空列表。 例如：

env.AppendUnique(FRAMEWORKS=Split('System Cocoa SystemConfiguration'))

框架标志
在带有 gcc 的 Mac OS X 上，最后添加一般用户提供的框架选项
构建可加载模块的命令行。 （这在很大程度上已被
$框架路径, $框架路径前缀, $框架前缀 和 $框架 变量
如上所述。）

GS
Ghostscript 程序用于将 PostScript 转换为 PDF 文件。

GSCOM
用于转换过程的完整 Ghostscript 命令行。 它的默认值
是“$GS $GSFLAGS -sOutputFile=$TARGET $SOURCES”。

GSCOMSTR
为转换过程调用 Ghostscript 时显示的字符串。 如果这是
未设置（默认），则 $GSCOM （命令行）显示。

标志
将 PostScript 转换为 PDF 时传递给 Ghostscript 程序的常规选项
例如文件。 它的默认值为“-dNOPAUSE -dBATCH -sDEVICE=pdfwrite”

主机_ARCH
用于创建环境的主机硬件架构的名称。 如果一个
在创建环境时指定平台，然后平台的逻辑将
处理设置此值。 此值是不可变的，不应由
初始化环境后的用户。 目前仅针对 Win32 设置。

设置 Visual Studio 编译器的主机体系结构。 如果未设置，则默认为
检测到的主机架构：请注意，这可能取决于您使用的 python。
该变量必须作为参数传递给 Environment() 构造函数； 环境
后来没有效果。

有效值与 for 相同 $TARGET_ARCH.

目前仅在 Windows 上使用，但未来将在其他平台上使用
操作系统也是如此。

主机操作系统
用于创建环境的主机操作系统的名称。 如果一个平台是
在创建环境时指定，然后该平台的逻辑将处理
设置这个值。 此值是不可变的，不应由用户更改
环境初始化后。 目前仅针对 Win32 设置。

后缀
将扫描 IDL 隐式依赖项的文件后缀列表
（#include 或导入行）。 默认列表是：

[".idl", ".IDL"]

隐含符号链接
用于覆盖 $SHLIBNOVERSIONSYMLINKS/$LD模块转换符号链接 创建时
共享库/可加载模块的版本化导入库。 如果没有定义，那么
$SHLIBNOVERSIONSYMLINKS/$LD模块转换符号链接 用于确定是否
是否禁用符号链接生成。

隐含前缀
用于导入库名称的前缀。 例如 cygwin 使用导入库
(libfoo.dll.a) 与动态库 (cygfoo.dll) 配对。 cyglink 链接器集
$IMPLIBPREFIX 到“lib”和 $SHLIBPREFIX 到“cyg”。

隐含后缀
用于导入库名称的后缀。 例如 cygwin 使用导入库
(libfoo.dll.a) 与动态库 (cygfoo.dll) 配对。 cyglink 链接器集
$IMPLIB后缀 到“.dll.a”和 $SHLIB后缀 到“.dll”。

暗示版本
用于覆盖 $SHLIB版本/$LDMODULEVERSION 生成版本化导入时
共享库/可加载模块的库。 如果未定义，则
$SHLIB版本/$LDMODULEVERSION 用于确定版本化导入的版本
图书馆。

IMPLICIT_COMMAND_DEPENDENCIES
控制 SCons 是否会为执行的命令添加隐式依赖项
建立目标。

默认情况下，SCons 将为每个目标添加对命令的隐式依赖
由它执行的任何命令行上的第一个参数表示。 具体文件
因为依赖是通过搜索找到的 PATH 在变量 ENV 使用环境
执行命令。

如果构造变量 $IMPLICIT_COMMAND_DEPENDENCIES 设置为假值
(None, False, 0, etc.), 那么隐式依赖将不会被添加到目标中
用那个施工环境建造的。

env = 环境（IMPLICIT_COMMAND_DEPENDENCIES = 0）

前缀
用于在 C 编译器命令行上指定包含目录的前缀。 这个
将附加到每个目录的开头 $CPP路径 和 $FORTRANPATH
构造变量时 $_CPPINCFLAGS 和 $_FORTRANINCFLAGS 变量是
自动生成。

后缀
用于在 C 编译器命令行上指定包含目录的后缀。 这个
将附加到每个目录的末尾 $CPP路径 和 $FORTRANPATH
构造变量时 $_CPPINCFLAGS 和 $_FORTRANINCFLAGS 变量是
自动生成。

载点
要调用的函数以将文件安装到目标文件名中。 默认
函数将文件复制到目标（并设置目标文件的模式
和权限位以匹配源文件的）。 该函数采用以下
参数：

def 安装（目标、源、环境）：

DEST 是目标文件的路径名。 资源 是源的路径名
文件中。 ENV 是构造环境（构造值的字典）
强制安装此文件。

安装程序
将文件安装到目标文件名时显示的字符串。 这
默认为：

安装文件：“$SOURCE”作为“$TARGET”

INTEL_C_COMPILER_VERSION
由“intelc”工具设置为所选英特尔 C 编译器的主要版本号
用来。

JAR
Java 归档工具。

Java 归档工具。

贾奇迪尔
Java 归档工具应该更改到的目录（使用 -C 选项）。

Java 归档工具应该更改到的目录（使用 -C 选项）。

嘉康
用于调用 Java 归档工具的命令行。

用于调用 Java 归档工具的命令行。

JARCOMSTR
调用 Java 归档工具时显示的字符串 如果未设置，则
$JARCOM （命令行）显示。

env = Environment(JARCOMSTR = "JARchiving $SOURCES 到 $TARGET")

调用 Java 归档工具时显示的字符串 如果未设置，则
$JARCOM （命令行）显示。

env = Environment(JARCOMSTR = "JARchiving $SOURCES 到 $TARGET")

罐子旗
传递给 Java 归档工具的常规选项。 默认情况下，这设置为 cf 至
创造必要的 罐 文件中。

传递给 Java 归档工具的常规选项。 默认情况下，这设置为 cf 至
创造必要的 罐 文件中。

后缀
Java 档案的后缀：默认为 .jar。

Java 档案的后缀：默认为 .jar。

JAVABOOT类路径
指定将通过以下方式添加到 javac 命令行的目录列表
-引导类路径 选项。 各个目录名称将由
操作系统的路径分隔字符（：在 UNIX/Linux/POSIX 上，; 在 Windows 上）。

雅威克
Java 编译器。

JAVACCOM公司
用于编译包含 Java 源文件的目录树的命令行
对应的 Java 类文件。 中指定的任何选项 $JavaCFLAGS 结构
变量包含在此命令行中。

JavaComstr
编译 Java 源文件目录树时显示的字符串
对应的 Java 类文件。 如果没有设置，那么 $JAVACCOM （命令行）
被展示。

env = Environment(JAVACCOMSTR = "从 $SOURCES 编译类文件 $TARGETS")

javacflags
传递给 Java 编译器的常规选项。

Java类目录
可以找到 Java 类文件的目录。 这是从
提供给 JavaH 构建器的任何 Java .class 文件名的开头。

JAVAC 类路径
指定将搜索 Java .class 文件的目录列表。 这
此列表中的目录将通过
-类路径 选项。 各个目录名称将由操作分隔
系统的路径分隔字符（：在 UNIX/Linux/POSIX 上，; 在 Windows 上）。

请注意，这目前只是通过添加指定的目录 -类路径 选项。
SCons 目前不搜索 $JAVACCLASSPATH 依赖 .class 的目录
文件。

JAVAC 后缀
Java 类文件的后缀； .class 默认情况下。

爪哇
C 头文件和存根文件的 Java 生成器。

JavaHCOM
用于从 Java 类生成 C 头文件和存根文件的命令行。 任何
中指定的选项 $JAVAHF标志 构造变量包含在此
命令行。

JavaHCOMSTR
从 Java 类生成 C 头文件和存根文件时显示的字符串。 如果
这没有设置，那么 $JAVAHCOM （命令行）显示。

env = Environment(JAVAHCOMSTR = "从 $SOURCES 生成头文件/存根文件 $TARGETS")

JAVAH标志
传递给 Java 类的 C 头文件和存根文件生成器的常规选项。

Java源路径
指定将搜索输入 .java 文件的目录列表。 这
此列表中的目录将通过 -源路径
选项。 各个目录名称将由操作系统的
路径分隔字符（：在 UNIX/Linux/POSIX 上，; 在 Windows 上）。

请注意，这目前只是通过添加指定的目录 -源路径 选项。
SCons 目前不搜索 $Java源路径 依赖.java的目录
文件。

JAVA后缀
Java 文件的后缀； .java 默认情况下。

超凡脱俗
指定正在使用的 Java 版本 爪哇岛 建设者。 这是 而不去 目前使用
选择一个版本的 Java 编译器与另一个版本。 相反，你应该设置这个
指定 javac 编译器支持的 Java 版本。 默认值为 1.4。

这有时是必要的，因为 Java 1.5 更改了创建的文件名
对于嵌套的匿名内部类，这可能会导致与
SCons 期望将由 javac 编译器生成。 环境 $JAVERSION 至 1.5（或
1.6，视情况而定）可以使 SCons 意识到 Java 1.5 或 1.6 构建实际上是
最新。

胶乳
LaTeX 结构化格式化程序和排版程序。

莱特康
用于调用 LaTeX 结构化格式化程序和排版程序的命令行。

乳胶漆
调用 LaTeX 结构化格式化程序和排版程序时显示的字符串。 如果
这没有设置，那么 $LATEXCOM （命令行）显示。

env = Environment(LATEXCOMSTR = "从 LaTeX 输入 $SOURCES 构建 $TARGET")

乳胶标志
传递给 LaTeX 结构化格式化程序和排版程序的常规选项。

乳胶制品
如果生成的 .log，LaTeX 将重新运行的最大次数
$LATEXCOM command 表示有未定义的引用。 默认是尝试
通过重新运行 LaTeX 最多 XNUMX 次来解决未定义的引用。

乳胶后缀
将扫描 LaTeX 隐式依赖项的文件后缀列表
（\include 或 \import 文件）。 默认列表是：

[“.tex”、“.ltx”、“.latex”]

LD模块
用于构建可加载模块的链接器。 默认情况下，这与 $SHLINK.

LD模组
用于构建可加载模块的命令行。 在 Mac OS X 上，这使用 $LD模块,
$LD 模块标志 和 $FRAMEWORKFLAGS 变量。 在其他系统上，这与
$SHLINK.

LD模块COMSTR
构建可加载模块时显示的字符串。 如果没有设置，那么
$LDMODULECOM （命令行）显示。

LD模块标志
传递给链接器以构建可加载模块的一般用户选项。

LDMODULENOVERSYMLINKS
指示 可加载模块 构建器不会自动创建符号链接
版本化的模块。 默认为 $SHLIBNOVERSIONSYMLINKS

LD模块前缀
用于可加载模块文件名的前缀。 在 Mac OS X 上，这是 null； 在其他
系统，这与 $SHLIBPREFIX.

_LDMODULESONAME
一个基于 $TARGET 自动生成可加载模块 SONAME 的宏，
$LDMODULEVERSION 和 $LDMODULESUFIX。 使用者 可加载模块 builder 当链接器
工具支持 SONAME（例如 gnulink）。

LD模块后缀
用于可加载模块文件名的后缀。 在 Mac OS X 上，这是 null； 在其他
系统，这与 $SHLIBSUFFIX 相同。

LD模块版本
定义此构造变量时，将创建版本化的可加载模块
可加载模块 建设者。 这激活了 $_LDMODULEVERSIONFLAGS 从而修改
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $LDMODULECOM 根据需要，将版本号添加到库名称中，并创建
所需的符号链接。 $LDMODULEVERSION 版本应该存在于同一个
格式为 $SHLIB版本.

LD模块转换标志
添加了额外的标志 $LDMODULECOM 构建版本时 可加载模块. 这些标志
仅在使用时 $LDMODULEVERSION 置。

_LDMODULEVERSIONFLAGS
这个宏自动引入额外的标志 $LDMODULECOM 建造时
版本化 可加载模块 （也就是当 $LDMODULEVERSION 设置）。
_LDMODULEVERSIONFLAGS 通常添加 $SHLIB版本标志 还有一些额外的动态
生成的选项（例如 -Wl,-soname=$_LDMODULESONAME）。 素色未使用
（未版本化的）可加载模块。

LEX
词法分析器生成器。

莱科康
用于调用词法分析器生成器生成源的命令行
文件中。

莱克康斯特
使用词法分析器生成源文件时显示的字符串
发电机。 如果没有设置，那么 $莱克斯康 （命令行）显示。

env = Environment(LEXCOMSTR = "Lex'ing $TARGET from $SOURCES")

词标
传递给词法分析器生成器的常规选项。

_LIBDIRFLAGS
包含链接器命令行的自动生成的构造变量
用于指定要搜索库的目录的选项。 的价值
$_LIBDIRFLAGS 通过附加创建 $LIBDIRP前缀 和 $库目录后缀 到开始
和每个目录的结尾 $库路径.

库前缀
用于在链接器命令行上指定库目录的前缀。 这将
附加到每个目录的开头 $库路径 构造变量
当 $_LIBDIRFLAGS 变量是自动生成的。

库目录后缀
用于在链接器命令行上指定库目录的后缀。 这将
附加到每个目录的末尾 $库路径 构造变量当
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $_LIBDIRFLAGS 变量是自动生成的。

解放者
ALL

_LIBFLAGS
包含链接器命令行的自动生成的构造变量
用于指定要与结果目标链接的库的选项。 的价值
$_LIBFLAGS 通过附加创建 $LIBLINK前缀 和 $LIBLINK后缀 到开始
和每个文件名的结尾 $图书馆.

LIBLINK前缀
用于指定要在链接器命令行上链接的库的前缀。 这将是
附加到每个库的开头 $图书馆 构造变量当
$_LIBFLAGS 变量是自动生成的。

LIBLINK后缀
用于指定要在链接器命令行上链接的库的后缀。 这将是
附加到每个库的末尾 $图书馆 构造变量当
$_LIBFLAGS 变量是自动生成的。

路径
将搜索库的目录列表。 隐式依赖
扫描仪将在这些目录中搜索包含文件。 不要明确地包含
目录参数在 $LINKFLAGS or $SHLINKFLAGS 因为结果将是
不可移植，并且依赖项扫描程序不会搜索目录。 笔记：
LIBPATH 中的目录名称将相对于 SConscript 目录查找
它们在命令中使用。 强制 scons 查找相对于根目录的目录
源树使用#：

env = 环境（LIBPATH='#/libs'）

目录查找也可以使用 你（） 功能：

库=目录（'库'）
env = 环境（LIBPATH=libs）

目录列表将通过自动生成的添加到命令行
$_LIBDIRFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $LIBDIRP前缀 和 $库目录后缀 构造变量的开头和结尾
中的每个目录 $库路径. 您定义的任何需要 LIBPATH 的命令行
目录列表应包括 $_LIBDIRFLAGS:

env = Environment(LINKCOM="my_linker $_LIBDIRFLAGS $_LIBFLAGS -o $TARGET $SOURCE")

库前缀
用于（静态）库文件名的前缀。 为每个设置一个默认值
平台（posix、win32、os2 等），但该值被个别工具覆盖
(ar, mslib, sgiar, sunar, tlib, etc.) 来反映他们所使用的库的名称
创建。

库前缀
库文件名的所有合法前缀列表。 搜索图书馆时
依赖项，SCons 将查找具有这些前缀的文件，基本库名称，
和后缀 $LIB后缀 名单。

LIBS
将与任何可执行程序链接的一个或多个库的列表
由这种环境创造。

库列表将通过自动生成的添加到命令行
$_LIBFLAGS 构造变量，它是通过附加
$LIBLINK前缀 和 $LIBLINK后缀 构造变量的开头和结尾
每个文件名在 $图书馆. 您定义的任何需要 LIBS 库列表的命令行
应包括 $_LIBFLAGS:

env = Environment(LINKCOM="my_linker $_LIBDIRFLAGS $_LIBFLAGS -o $TARGET $SOURCE")

如果将 File 对象添加到 $图书馆 列表，该文件的名称将被添加到
$_LIBFLAGS，因此链接线，原样，没有 $LIBLINK前缀 or $LIBLINK后缀.
例如：

env.Append(LIBS=File('/tmp/mylib.so'))

在所有情况下，scons 都会将可执行程序的依赖项添加到所有
此列表中的库。

后缀
用于（静态）库文件名的后缀。 为每个设置一个默认值
平台（posix、win32、os2 等），但该值被个别工具覆盖
(ar, mslib, sgiar, sunar, tlib, etc.) 来反映他们所使用的库的名称
创建。

库后缀
库文件名的所有合法后缀列表。 搜索图书馆时
依赖项，SCons 将在 $LIBP前缀 列出
基本库名称和这些后缀。

许可
发布此项目的许可证的缩写名称（gpl、lpgl、
bsd 等）。 看 http://www.opensource.org/licenses/alphabetical 获取许可证列表
名称。

线分离器
使用的分隔符 子文件 和 文本文件 建设者。 该值用于
构建目标时的来源。 它默认为当前系统行
分隔器。

语言文件
这个 $LINGUAS_FILE 定义包含附加语言列表的文件
由...处理 初始化, PO更新 or MO文件 建设者。 也会影响 翻译 建造者。
如果变量包含一个字符串，它定义列表文件的名称。 这 $LINGUAS_FILE
也可能是文件名列表。 如果 $LINGUAS_FILE 设置为真（或非零
数值），列表将从名为 LINGUAS 的默认文件中读取。

友情链接
链接器。

联通
用于将目标文件链接到可执行文件的命令行。

LINKCOMSTR
目标文件链接到可执行文件时显示的字符串。 如果这不是
设置，然后 $LINKCOM （命令行）显示。

env = Environment(LINKCOMSTR = "链接 $TARGET")

链接标志
传递给链接器的一般用户选项。 注意这个变量应该 而不去 包含
-l （或类似的）选项，用于链接中列出的库 $图书馆也没有 -L （或
类似）scons 自动生成的库搜索路径选项 $库路径.
参见 $_LIBFLAGS 上面，对于扩展为库链接选项的变量，以及
$_LIBDIRFLAGS 上面，对于扩展为库搜索路径选项的变量。

M4
M4 宏预处理器。

M4COM
用于通过 M4 宏预处理器传递文件的命令行。

M4COMSTR
当文件通过 M4 宏预处理器时显示的字符串。 如果这
没有设置，那么 $M4COM （命令行）显示。

M4标志
传递给 M4 宏预处理器的常规选项。

制造指数
TeX 格式化程序和排版程序以及 LaTeX 结构化的 makeindex 生成器
格式化程序和排版程序。

制造指数
用于调用 TeX 格式化程序的 makeindex 生成器的命令行和
排版器和 LaTeX 结构化格式化程序和排版器。

制造指数
调用 TeX 格式化程序的 makeindex 生成器时显示的字符串和
排版器和 LaTeX 结构化格式化程序和排版器。 如果没有设置，那么
$MAKEINDEXCOM （命令行）显示。

制作索引标志
传递给 TeX 格式化程序和排版程序的 makeindex 生成器的常规选项
以及 LaTeX 结构化格式化程序和排版程序。

最大线长
外部命令行上允许的最大字符数。 在 Win32 上
系统，超过这么多字符的链接行通过临时文件链接
名称。

中间件
Microsoft IDL 编译器。

中间通信
用于将文件传递给 Microsoft IDL 编译器的命令行。

中控系统
调用 Microsoft IDL copmiler 时显示的字符串。 如果没有设置，
然后 $MIDLCOM （命令行）显示。

中旗
传递给 Microsoft IDL 编译器的常规选项。

后缀
用于 MO 文件的后缀（默认值：'.mo'）。 请参阅 msgfmt 工具和 MO文件 建造者。

MSGFMT
绝对路径 消息文件(1) 二进制，由 探测（）. 请参阅 msgfmt 工具和 MO文件
建造者。

MSGFMTCOM
完整的命令行运行 消息文件(1) 程序。 请参阅 msgfmt 工具和 MO文件 建造者。

MSGFMTCOMSTR
何时显示的字符串 消息文件(1) 被调用（默认值：''，这意味着 ``print
$MSGFMTCOM''）。 请参阅 msgfmt 工具和 MO文件 建造者。

MSGFMT标志
附加标志 消息文件(1). 请参阅 msgfmt 工具和 MO文件 建造者。

MSGINIT
路径 消息初始化(1) 程序（通过 Detect() 找到）。 请参阅 msginit 工具和 初始化 建造者。

MSGITCOM
完整的命令行运行 消息初始化(1) 程序。 请参阅 msginit 工具和 初始化 建造者。

MSGINITCOMSTR
何时显示的字符串 消息初始化(1) 被调用（默认值：''，这意味着 ``print
$MSGINITCOM''）。 请参阅 msginit 工具和 初始化 建造者。

MSGINI标志
附加标志列表 消息初始化(1) （默认： []）。 请参阅 msginit 工具和 初始化
建造者。

_MSGINITLOCAL
内部“宏”。 根据目标文件名计算区域（语言）名称（默认值：
'${TARGET.filebase}'）。

请参阅 msginit 工具和 初始化 建造者。

消息合并
绝对路径 消息合并(1) 发现的二进制文件 探测（）. 请参阅 msgmerge 工具和
PO更新 建造者。

MSGMERGECOM公司
完整的命令行运行 消息合并(1) 命令。 请参阅 msgmerge 工具和 PO更新
建造者。

MSG合并COMSTR
字符串何时显示 消息合并(1) 被调用（默认值：''，这意味着 ``print
$MSGMERGECOM''）。 请参阅 msgmerge 工具和 PO更新 建造者。

消息合并标志
附加标志 消息合并(1) 命令。 请参阅 msgmerge 工具和 PO更新 建造者。

MSSDK_DIR
包含 Microsoft SDK（平台 SDK 或 Windows SDK）的目录
用于编译。

MSSDK_VERSION
Microsoft SDK（Platform SDK 或 Windows SDK）的版本字符串
用于编译。 支持的版本包括 6.1、6.0A、6.0、2003R2 和 2003R1。

MSVC_BATCH
当设置为任何真值时，指定 SCons 应该批量编译对象
调用 Microsoft Visual C/C++ 编译器时的文件。 源码的所有编译
来自同一源目录的文件，在同一输出中生成目标文件
目录并在 SCons 中使用相同的构建环境进行配置
内置在对编译器的一次调用中。 仅从那时起更改的源文件
他们构建的目标文件将被传递给每个编译器调用（通过
$CHANGED_SOURCES 构造变量）。 对象（目标）的任何编译
文件基本名称（减去 .obj）与源文件基本名称不匹配
单独编译。

MSVC_USE_SCRIPT
使用批处理脚本设置 Microsoft Visual Studio 编译器

$MSVC_USE_SCRIPT 覆盖 $MSVC_VERSION 和 $TARGET_ARCH. 如果设置为一个名字
Visual Studio .bat 文件（例如 vcvars.bat），SCons 将运行该 bat 文件并解压
结果中的相关变量（通常为 %INCLUDE%、%LIB% 和 %PATH%）。
将 MSVC_USE_SCRIPT 设置为 None 会完全绕过 Visual Studio 自动检测； 利用
如果您在 Visual Studio cmd 窗口中运行 SCons 并导入 shell
环境变量。

MSVC_VERSION 版本
设置要使用的 Microsoft Visual C/C++ 的首选版本。

If $MSVC_VERSION 未设置，SCons 将（默认）选择最新版本
安装在您的系统上的 Visual C/C++。 如果没有安装指定的版本，工具
初始化将失败。 该变量必须作为参数传递给
Environment() 构造函数； 稍后设置它没有效果。

Windows 的有效值为 12.0、12.0Exp、11.0、11.0Exp、10.0、10.0Exp、9.0、9.0Exp、
8.0、8.0Exp、7.1、7.0 和 6.0。 以 Exp 结尾的版本指的是“Express”或“Express
桌面版”。

多媒体广告
初始化 Microsoft Visual Studio 工具时，它们会设置此字典
使用以下键：

VERSION
正在使用的 MSVS 版本（可以通过 $MSVS_VERSION)

版本
安装的可用版本的 MSVS

VCINSTALL目录
Visual C++的安装目录

安装目录
Visual Studio 安装目录

框架目录
.NET 框架的安装目录

框架版本
.NET 框架的已安装版本列表，按最新到最旧排序。

框架版本
.NET 框架的最新安装版本

框架SDK目录
.NET SDK 的安装位置。

平台SDK目录
Platform SDK 的安装位置。

平台SDK_MODULES
已安装 Platform SDK 模块的字典，其中字典键是
各种模块的关键字，值是 2 元组，其中第一个是
发布日期，第二个是版本号。

如果未设置值，则它在注册表中不可用。

MSVS_ARCH
设置生成的项目应该构建的架构。

默认值为 x86。 对于某些 Visual Studio，SCons 也支持 amd64
版本。 试图设置 $MSVS_ARCH 到给定不支持的架构
Visual Studio 版本会产生错误。

MSVS_PROJECT_GUID
放置在生成的 Microsoft Visual Studio 项目文件中的字符串作为值
ProjectGUID 属性。 没有默认值。 如果未定义，则为新的 GUID
产生。

MSVS_SCC_AUX_PATH
放置在生成的 Microsoft Visual Studio 项目文件中的路径名作为值
的 SccAuxPath 属性，如果 MSVS_SCC_PROVIDER 构造变量也是
放。 没有默认值。

MSVS_SCC_CONNECTION_ROOT
SCC 工作区中项目的根路径，即所有项目所在的路径
并生成解决方案文件。 它被用作参考路径，从中
生成的 Microsoft Visual Studio 项目和解决方案文件的相对路径是
计算。 相对工程文件路径放置为 SccLocalPath 的值
项目文件的属性并作为
SccProjectFilePathRelativizedFromConnection[i]（其中 [i] 范围从 0 到数字
解决方案中的项目) GlobalSection(SourceCodeControl) 的属性
Microsoft Visual Studio 解决方案文件的部分。 同样的相对解
文件路径作为 SccLocalPath[i] 的值放置（其中 [i] 的范围从 0 到
解决方案中的项目数）的属性
Microsoft Visual Studio 解决方案文件的 GlobalSection(SourceCodeControl) 部分。
仅当 MSVS_SCC_PROVIDER 还设置了构造变量。 这
默认值为当前工作目录。

MSVS_SCC_PROJECT_NAME
放置在生成的 Microsoft Visual Studio 项目文件中的项目名称作为
SccProjectName 属性的值，如果 MSVS_SCC_PROVIDER 构造变量
也设置了。 在这种情况下，字符串也放置在 SccProjectName0 属性中
Microsoft Visual Studio 的 GlobalSection(SourceCodeControl) 部分的
解决方案文件。 没有默认值。

MSVS_SCC_PROVIDER
放置在生成的 Microsoft Visual Studio 项目文件中的字符串作为值
SccProvider 属性。 该字符串也被放置在 SccProvider0 的属性中
Microsoft Visual Studio 解决方案的 GlobalSection(SourceCodeControl) 部分
文件。 没有默认值。

MSVS_VERSION 版本
设置要使用的 Microsoft Visual Studio 的首选版本。

If $MSVS_VERSION 未设置，SCons 将（默认）选择最新版本
Visual Studio 安装在您的系统上。 所以，如果你有版本 6 和版本 7（MSVS
.NET) 安装，它将更喜欢版本 7。您可以通过指定
MSVS_VERSION 版本 环境初始化中的变量，将其设置为适当的
版本（例如“6.0”或“7.0”）。 如果没有安装指定的版本，工具
初始化将失败。

这是过时的：使用 $MSVC_VERSION 反而。 如果 $MSVS_VERSION 设置好了 $MSVC_VERSION
不是， $MSVC_VERSION 将自动设置为 $MSVS_VERSION. 如果两者都设置为
不同的值，scons 会报错。

MSVSBuildCOM
构建命令行放置在生成的 Microsoft Visual Studio 项目文件中。 这
默认是让 Visual Studio 使用任何指定的构建目标调用 SCons。

MVS清洁程序
干净的命令行放置在生成的 Microsoft Visual Studio 项目文件中。 这
默认是让 Visual Studio 使用 -c 选项调用 SCons 以删除任何
指定的目标。

MSVS编码
放置在生成的 Microsoft Visual Studio 项目文件中的编码字符串。 这
默认是编码 Windows-1252。

MSVS项目通讯
用于生成 Microsoft Visual Studio 项目文件的操作。

MSVS项目后缀
用于 Microsoft Visual Studio 项目 (DSP) 文件的后缀。 默认值为
.vcproj 使用 Visual Studio 版本 7.x (.NET) 或更高版本，.dsp 使用
使用早期版本的 Visual Studio。

MSVS重建COM
重建命令行放置在生成的 Microsoft Visual Studio 项目文件中。
默认设置是让 Visual Studio 使用任何指定的重建目标调用 SCons。

MSVSSCONS
生成的 Microsoft Visual Studio 项目文件中使用的 SCons。 默认值为
用于生成项目文件的 SCons 版本。

MSVSS控制司令部
生成的 Microsoft Visual Studio 项目文件中使用的默认 SCons 命令。

MSVSS 脚本
将被调用的 sconscript 文件（即 SConstruct 或 SConscript 文件）
Visual Studio 项目文件（通过 $MSVSSCONSCOM 多变的）。 默认值为
包含调用的相同 sconscript 文件 MSVS项目 构建项目文件。

MSVSSCONFLAGS
生成的 Microsoft Visual Studio 项目文件中使用的 SCons 标志。

MSVS解决方案COM
用于生成 Microsoft Visual Studio 解决方案文件的操作。

MSVS解决方案后缀
用于 Microsoft Visual Studio 解决方案 (DSW) 文件的后缀。 默认值为
使用 Visual Studio 版本 7.x (.NET) 时为 .sln，使用早期版本时为 .dsw
的 Visual Studio。

MT
Windows 系统上用于将清单嵌入到 DLL 和 EXE 中的程序。 也可以看看
$WINDOWS_EMBED_MANIFEST.

美泰康
用于将清单嵌入到可执行文件中的 Windows 命令行。 也可以看看
$MTSHLIBCOM.

MTFLAG
标志传递给 $公吨 清单嵌入程序（仅限 Windows）。

MTSHLIBCOM
用于将清单嵌入共享库 (DLL) 的 Windows 命令行。 看
还 $MTEXECOM.

MWCW_VERSION 版本
要使用的 MetroWerks CodeWarrior C 编译器的版本号。

MWCW_版本
此系统上已安装的 MetroWerks CodeWarrior C 编译器版本列表。

您的姓名
指定要打包的项目的名称。

无导入库
当设置为非零时，禁止创建相应的 Windows 静态导入库
与 MinGW、Microsoft Visual Studio 或
地铁站。 这也禁止在使用时创建导出 (.exp) 文件
微软视觉工作室。

对象前缀
用于（静态）对象文件名的前缀。

对象后缀
用于（静态）对象文件名的后缀。

P4
Perforce 可执行文件。

P4COM
用于从 Perforce 获取源文件的命令行。

P4COMSTR
从 Perforce 获取源文件时显示的字符串。 如果没有设置，
然后 $P4COM （命令行）显示。

P4标志
传递给 Perforce 的常规选项。

包根
指定将放置结果存档中所有文件的目录，如果
适用的。 默认值为“$NAME-$VERSION”。

包装类型
选择要构建的包类型。 目前这些可用：

* msi - Microsoft 安装程序 * rpm - Redhat 包管理器 * ipkg - Itsy 包
管理系统 * tarbz2 - 压缩 tar * targz - 压缩 tar * zip - 压缩文件
* src_tarbz2 - 压缩的 tar 源 * src_targz - 压缩的 tar 源 * src_zip -
压缩文件源

这可以用“package_type”命令行选项覆盖。

包版本
包的版本（不是底层项目）。 目前只使用这个
由 rpm 打包程序，应该反映打包的变化，而不是底层的
项目代码本身。

PCH
编译对象时将使用的 Microsoft Visual C++ 预编译头文件
文件。 此变量会被 Microsoft Visual C++ 以外的工具忽略。 当这
变量已定义 SCons 将向编译器命令行添加选项以使其
使用预编译的头文件，并且还将设置 PCH 文件的依赖项。
计费示例：

env['PCH'] = 'StdAfx.pch'

PCHCOM
使用的命令行 PCH builder 生成一个预编译的头文件。

PCHCOMSTR
生成预编译头时显示的字符串。 如果没有设置，那么
$PCHCOM （命令行）显示。

PCHPDB标志
一个构造变量，在展开时会将 /yD 标志添加到命令行
只有在 $PDB 构造变量已设置。

PCH停止
此变量指定预编译源文件的数量。 这个变量是
被 Microsoft Visual C++ 以外的工具忽略，或者当 PCH 变量不是
正在使用。 定义此变量时，它必须是一个字符串，即
包含在源文件预编译部分末尾的标头，或
如果正在使用“#pragma hrdstop”构造，则为空字符串：

env['PCHSTOP'] = 'StdAfx.h'

PDB
将存储对象调试信息的 Microsoft Visual C++ PDB 文件
文件、共享库和程序。 此变量会被其他工具忽略
微软视觉 C++。 定义此变量时，SCons 将向
编译器和链接器命令行使它们生成外部调试
信息，并且还将设置 PDB 文件的依赖关系。 例子：

env['PDB'] = 'hello.pdb'

SCons 默认使用的 Visual C++ 编译器开关来生成 PDB 信息
is /Z7. 这适用于并行（-j) 构建，因为它嵌入了调试
中间对象文件中的信息，而不是共享单个 PDB 文件
多个目标文件之间。 这也是获取调试信息的唯一方法
嵌入到静态库中。 使用 /子 相反，可能会产生改进的链接时间
性能，尽管并行构建将不再起作用。 您可以生成 PDB 文件
与 /子 通过覆盖默认值进行切换 $CCPDBFLAGS 多变的; 见条目
该变量用于特定示例。

PDFCOM
已弃用的同义词 $DVIPDFCOM.

PDF乳胶
pdflatex 实用程序。

PDFLATEXCOM
用于调用 pdflatex 实用程序的命令行。

PDFLATEXCOMSTR
调用 pdflatex 实用程序时显示的字符串。 如果没有设置，那么
$PDFLATEXCOM （命令行）显示。

env = Environment(PDFLATEX;COMSTR = "从 LaTeX 输入 $SOURCES 构建 $TARGET")

PDF乳胶旗帜
传递给 pdflatex 实用程序的常规选项。

PDF前缀
用于 PDF 文件名的前缀。

PDF后缀
用于 PDF 文件名的后缀。

PDF文本
pdftex 实用程序。

PDFTEXCOM
用于调用 pdftex 实用程序的命令行。

PDFTEXCOMSTR
调用 pdftex 实用程序时显示的字符串。 如果没有设置，那么
$PDFEXCOM （命令行）显示。

env = Environment(PDFTEXCOMSTR = "从 TeX 输入 $SOURCES 构建 $TARGET")

PDF文本标记
传递给 pdftex 实用程序的常规选项。

PKGC香港
在 Solaris 系统上，将使用的包检查程序（连同
$PKGINFO) 以查找已安装的 Sun PRO C++ 编译器版本。 默认是
/usr/sbin/pgkchk.

包信息
在 Solaris 系统上，将使用的包信息程序（连同
$PKGC香港) 以查找已安装的 Sun PRO C++ 编译器版本。 默认是
包信息。

平台
用于创建环境的平台的名称。 如果没有指定平台
创建环境时，scons 会自动检测平台。

env = 环境（工具 = []）
如果 env['PLATFORM'] == 'cygwin'：
工具（'mingw'）（环境）
其他：
工具（'msvc'）（环境）

自动初始化
这个 $POAUTOINIT 变量，如果设置为 True（非零数值），让 msginit
自动初始化工具 失踪 PO 文件与 消息初始化(1)。 这适用于
都， 初始化 和 PO更新 建设者（和其他使用它们的人）。

POCREATE_ALIAS
所有 PO 文件的通用别名 初始化 生成器（默认值：'po-create'）。 看
msginit 工具和 初始化 建造者。

后缀
用于 PO 文件的后缀（默认值：'.po'）参见 msginit 工具和 初始化 建造者。

锅域
这个 $POTOMAIN 定义默认域，用于生成 POT 文件名 $POTOMAIN。锅
当用户没有提供 POT 文件名时。 这适用于 POT更新, 初始化 和
PO更新 建设者（和建设者，使用它们，例如 翻译）。 通常（如果
$POTOMAIN 未定义），构建器使用 messages.pot 作为默认 POT 文件名。

后缀
用于 PO 模板文件的后缀（默认值：'.pot'）。 请参阅 xgettext 工具和 POT更新
建造者。

POTUPDATE_ALIAS
使用创建的所有 PO 模板的通用虚假目标的名称 PO更新 （默认：
'锅更新'）。 请参阅 xgettext 工具和 POT更新 建造者。

POUPDATE_ALIAS
定义的所有 PO 文件的通用别名 PO更新 生成器（默认：
'po更新'）。 请参阅 msgmerge 工具和 PO更新 建造者。

PRINT_CMD_LINE_FUNC
用于在执行命令行时打印命令行的 Python 函数（假设
命令打印未被禁用 -q or -s 选项或其等价物）。 这
函数应该有四个参数： s，正在执行的命令（字符串）， 目标,
正在构建的目标（文件节点、列表或字符串名称）， 资源, 来源
已使用（文件节点、列表或字符串名称），以及 ENV, 使用的环境。

该功能必须自己进行打印。 默认实现，如果这样使用
变量未设置或为无，是：

def print_cmd_line(s, 目标, 源, env):
sys.stdout.write(s + "\n")

这是一个更有趣的函数的示例：

def print_cmd_line(s, 目标, 源, env):
sys.stdout.write("正在构建 %s -> %s...\n" %
(' and '.join([str(x) for x in source]),
' 和 '.join([str(x) for x in target])))
env=环境（PRINT_CMD_LINE_FUNC=print_cmd_line）
env.Program('foo', 'foo.c')

这只是打印“建筑 目标名称 ， 来源名称...”而不是实际的
命令。 这样的函数还可以将实际命令记录到日志文件中，例如
例。

发射器
ALL

程序前缀
用于可执行文件名的前缀。

后缀
用于可执行文件名的后缀。

PSCOM
用于将 TeX DVI 文件转换为 PostScript 文件的命令行。

PSCOMSTR
将 TeX DVI 文件转换为 PostScript 文件时显示的字符串。 如果这
没有设置，那么 $PSCOM （命令行）显示。

前缀
用于 PostScript 文件名的前缀。

PS后缀
用于 PostScript 文件名的前缀。

QT_自动扫描
关闭扫描移动文件。 使用 Moc Builder 显式指定文件
运行 moc。

QT_BINPATH
安装 qt 二进制文件的路径。 默认值为'$QTDIR/箱'.

QT_CPP路径
qt 头文件的安装路径。 默认值为
'$QTDIR/包括'。 注意：如果将此变量设置为 None，则该工具不会更改
$CPP路径 构造变量。

QT_调试
在扫描 moc 文件时打印大量调试信息。

QT_LIB
默认值为“qt”。 您可能希望将其设置为“qt-mt”。 注意：如果你设置这个
变量为无，该工具不会改变 $图书馆 变量。

QT_LIB路径
安装 qt 库的路径。 默认值为'$QTDIR/ lib目录'.
注意：如果将此变量设置为 None，则该工具不会更改 $库路径
构造变量。

QT_MOC
默认值为'$QT_BINPATH/moc'。

QT_MOCCXXPREFIX
默认值为''。 当源是 cxx 文件时，moc 输出文件的前缀。

QT_MOCCXXSUFFIX
默认值为“.moc”。 当源是 cxx 文件时，moc 输出文件的后缀。

QT_MOCFROMCXXCOM
从 cpp 文件生成 moc 文件的命令。

QT_MOCFROMCXXCOMSTR
从 cpp 文件生成 moc 文件时显示的字符串。 如果没有设置，
然后 $QT_MOCFROMCXXCOM （命令行）显示。

QT_MOCFROMCXXFLAGS
默认值为“-i”。 在 moccing C++ 文件时，这些标志被传递给 moc。

QT_MOCFROMHCOM
从标头生成 moc 文件的命令。

QT_MOCFROMHCOMSTR
从 cpp 文件生成 moc 文件时显示的字符串。 如果没有设置，
然后 $QT_MOCFROMHCOM （命令行）显示。

QT_MOCFROMHFLAGS
默认值为''。 这些标志在 moccing 头文件时传递给 moc。

QT_MOCHPREFIX
默认值为“moc_”。 当源是头文件时，moc 输出文件的前缀。

QT_MOCHSUFFIX
默认值为'$CXX 文件后缀'。 moc 输出文件的后缀，当 source 是
标头。

QT_UIC
默认值为'$QT_BINPATH/uic'。

QT_UICCOM
从 .ui 文件生成头文件的命令。

QT_UICCOMSTR
从 .ui 文件生成头文件时显示的字符串。 如果没有设置，
然后 $QT_UICCOM （命令行）显示。

QT_UICDECFLAGS
默认值为''。 这些标志被传递给 uic，当从
.ui 文件。

QT_UICDECLPREFIX
默认值为''。 uic 生成的头文件的前缀。

QT_UICDECLSUFFIX
默认值为“.h”。 uic 生成的头文件的后缀。

QT_UICIMPLFLAGS
默认值为''。 这些标志被传递给 uic，当从
.ui 文件。

QT_UICIMPLPREFIX
默认值为“uic_”。 uic 生成的实现文件的前缀。

QT_UICIMPLSUFFIX
默认值为'$CXX 文件后缀'。 uic 生成的实现文件的后缀。

QT_UISUFFIX
默认值为“.ui”。 设计器输入文件的后缀。

QTDIR
qt 工具试图从 os.environ 中获取它。 它还初始化所有 QT_*
下面列出的构造变量。 （请注意，所有路径都是用
python 的 os.path.join() 方法，但在这里列出时使用“/”分隔符更容易
阅读。）另外，构造环境变量 $CPP路径, $库路径 和
$图书馆 可以修改和变量 $PROGEMITTER, $SHLIBEMITTER 和 $解放者
被修改。 由于使用此工具时会影响构建性能，因此您有
在环境创建时明确指定它：

环境（工具=['默认'，'qt']）

qt 工具支持以下操作：

自动表 莫克 文件 代 ， 头 文件。 您不必指定 moc 文件
明确地说，该工具会为您完成。 但是，这样做有几个先决条件：
您的头文件必须与您的实现文件具有相同的文件库，并且必须保留
在同一目录中。 它必须具有后缀 .h、.hpp、.H、.hxx、.hh 之一。 你
可以通过将 QT_AUTOSCAN 设置为 0 来关闭自动 moc 文件生成。另见
相应 动力() 构建器方法。

自动表 莫克 文件 代 ， xxx 文件。 如 qt 文档中所述，
在 cxx 文件的末尾包含 moc 文件。 请注意，您必须包括
文件，由转换生成
${QT_MOCCXXPREFIX} ${QT_MOCCXXSUFFIX}，默认.moc。 一个警告
如果您不包含正确的文件，则在构建 moc 文件后生成。 如果
您正在使用 VariantDir，您可能需要指定 duplicate=1。 你可以关掉
通过将 QT_AUTOSCAN 设置为 0 来自动生成 moc 文件。另见相应的
动力 建造者方法。

自动表 处理 of .ui 文件。 从 .ui 文件生成的实现文件
处理方式与 yacc 或 lex 文件非常相似。 每个 .ui 文件作为
Program、Library 或 SharedLibrary 会生成三个文件，声明文件、
实现文件和 moc 文件。 因为还有生成的标头，你可以
需要在对 VariantDir 的调用中指定 duplicate=1。 另见相应的 国际商会
建造者方法。

随机库
存档索引器。

兰利康
用于索引静态库存档的命令行。

兰利博斯特
索引静态库归档时显示的字符串。 如果没有设置，
然后 $RANLIBCOM （命令行）显示。

env = Environment(RANLIBCOMSTR = "索引 $TARGET")

RANLIBF标志
传递给归档索引器的常规选项。

RC
用于构建 Microsoft Visual C++ 资源文件的资源编译器。

RCCOM
用于构建 Microsoft Visual C++ 资源文件的命令行。

RCCOMSTR
调用资源编译器构建 Microsoft Visual 时显示的字符串
C++ 资源文件。 如果没有设置，那么 $RCCOM （命令行）显示。

RCFLAG
RES 构建器传递给资源编译器的标志。

RCINCLAG
包含命令行选项的自动生成的构造变量
用于指定资源编译器要搜索的目录。 的价值
$RCINCFLAGS 通过附加创建 $RCINCPREFIX 和 $RCINC后缀 到开始和
每个目录的结尾 $CPP路径.

RCINC前缀
用于在资源编译器上指定包含目录的前缀（标志）
命令行。 这将附加到每个目录的开头 $CPP路径
构造变量当 $RCINCFLAGS 变量被扩展。

RCINC后缀
用于在资源编译器命令行上指定包含目录的后缀。
这将附加到每个目录的末尾 $CPP路径 结构
变量时 $RCINCFLAGS 变量被扩展。

RCS
RCS 可执行文件。 请注意，此变量实际上并未用于命令
从 RCS 获取源文件； 见 $RCS_CO 构造变量，如下。

RCS_CO
RCS "checkout" 可执行文件，用于从 RCS 获取源文件。

RCS_COCOM
用于从 RCS 获取（签出）源文件的命令行。

RCS_COCOMSTR
从 RCS 获取源文件时显示的字符串。 如果没有设置，那么
$RCS_COCOM （命令行）显示。

RCS_COFLAGS
传递给 $RCS_CO 命令。

目录
通过搜索将字符串转换为 Dir 实例列表的函数
仓库。

雷格斯VR
Windows 系统上用于注册一个新建的 DLL 库的程序，只要
共享库 builder 被传递了 register=1 的关键字参数。

寄存器VRCOM
Windows系统上用于注册新建DLL库的命令行
每当 共享库 builder 被传递了 register=1 的关键字参数。

寄存器VRCOMSTR
注册新建的 DLL 文件时显示的字符串。 如果没有设置，那么
$REGSVRCOM （命令行）显示。

寄存器标志
新建 DLL 时传递给 Windows 系统上的 DLL 注册程序的标志
图书馆已注册。 默认情况下，这包括 /s 防止对话框
从弹出并要求用户注意。

RMIC
Java RMI 存根编译器。

RMICCOM
用于从 Java 类编译存根和骨架类文件的命令行
包含 RMI 实现。 中指定的任何选项 $RMIC标志 结构
变量包含在此命令行中。

RMICCOMSTR
从 Java 类编译存根和骨架类文件时显示的字符串
包含 RMI 实现。 如果没有设置，那么 $RMICCOM （命令行）
被展示。

env = Environment(RMICCOMSTR = "从 $SOURCES 生成存根/骨架类文件 $TARGETS")

RMIC标志
传递给 Java RMI 存根编译器的常规选项。

_RPATH
包含要使用的 rpath 标志的自动生成的构造变量
将程序与共享库链接时。 的价值 $_RPATH 由...创建
附加 $RPATH前缀 和 $RPATH后缀 到每个目录的开头和结尾
$RPATH.

路径
运行程序时搜索共享库的路径列表。 目前仅
在 GNU (gnulink)、IRIX (sgilink) 和 Sun (sunlink) 链接器中使用。 忽略
不支持它的平台和工具链。 请注意，添加到 RPATH 的路径是
没有以任何方式被 scons 转换：如果你想要一个绝对路径，你必须做到
绝对的自己。

路径前缀
用于指定要搜索共享库的目录的前缀
运行程序。 这将附加到每个目录的开头
$RPATH 构造变量当 $_RPATH 变量是自动生成的。

RPATH后缀
用于指定要搜索共享库的目录的后缀
运行程序。 这将附加到每个目录的末尾 $RPATH
构造变量当 $_RPATH 变量是自动生成的。

RPC生成器
RPC 协议编译器。

RPCGenClientFLAGS
生成客户端存根时传递给 RPC 协议编译器的选项。 这些
除了在 $RPCGENFLAGS 构造变量。

RPC生成标志
传递给 RPC 协议编译器的常规选项。

RPCGEN头标志
生成头文件时传递给 RPC 协议编译器的选项。 这些是
除了在 $RPCGENFLAGS 构造变量。

RPC生成服务标志
生成服务器端存根时传递给 RPC 协议编译器的选项。 这些
除了在 $RPCGENFLAGS 构造变量。

RPCGENXDRFLAGS
生成 XDR 例程时传递给 RPC 协议编译器的选项。 这些在
除了在指定的任何标志 $RPCGENFLAGS 构造变量。

扫描仪
可用的隐式依赖扫描器列表。 可能会添加新的文件扫描仪
通过附加到这个列表，虽然更灵活的方法是关联
具有特定生成器的扫描仪。 请参阅“构建器对象”和“扫描器”部分
对象，”下面，以获取更多信息。

供应链服务中心
SCCS 可执行文件。

SCCSCOM
用于从 SCCS 获取源文件的命令行。

SCCSCOMSTR
从 CVS 存储库获取源文件时显示的字符串。 如果这不是
设置，然后 $SCCSCOM （命令行）显示。

SCCS标志
传递给 SCCS 的常规选项。

SCCSGETF标志
专门传递给 SCCS“get”子命令的选项。 这个可以设置
例如，到 -e 从 SCCS 签出可编辑文件。

SCONS_主页
SCons 库目录的（可选）路径，从外部初始化
环境。 如果设置，这将用于构建更短且更有效的搜索
路径 $MSVSSCONS 从 Microsoft Visual Studio 项目执行的命令行
文件。

沪港通
用于生成共享库对象的 C 编译器。

华侨城
用于将 C 源文件编译为共享库目标文件的命令行。 任何
中指定的选项 $SHCFLAGS, $SHCCFLAGS 和 $CPPFLAGS 构造变量
包含在此命令行中。

上海商会
当 C 源文件编译为共享对象文件时显示的字符串。 如果这
没有设置，那么 $上海商会 （命令行）显示。

env = Environment(SHCCCOMSTR = "编译共享对象 $TARGET")

SHCC标志
传递给 C 和 C++ 编译器以生成共享库对象的选项。

上海旗
传递给 C 编译器（仅；不是 C++）以生成共享库的选项
对象。

SHHCXX
用于生成共享库对象的 C++ 编译器。

上海华夏网络科技有限公司
用于将 C++ 源文件编译为共享库对象文件的命令行。
中指定的任何选项 $SHCXXFLAGS 和 $CPPFLAGS 构造变量是
包含在此命令行中。

SHCXXCOMSTR
C++源文件编译为共享对象文件时显示的字符串。 如果
这没有设置，那么 $SHCXXCOM （命令行）显示。

env = Environment(SHCXXCOMSTR = "编译共享对象 $TARGET")

SHCXX标志
传递给 C++ 编译器以生成共享库对象的选项。

上海发展中心
SHDC。

上海高清通信
SHDCOM。

上海联通
闪联。

上海联通
SHDLINKCOM。

SHDLINK标志
SHDLINKFLAGS。

SHELL
命名将传递给的 shell 程序的字符串 $SPAWN 功能。 见
$SPAWN 构造变量以获取更多信息。

03新郎
Fortran 03 编译器用于生成共享库对象。 你应该
通常设置 $SHFORTRAN 变量，它指定默认的 Fortran 编译器
所有 Fortran 版本。 你只需要设置 03 美元 如果您需要使用特定的
Fortran 03 文件的编译器或编译器版本。

SHF03COM
用于将 Fortran 03 源文件编译为共享库对象的命令行
文件。 你只需要设置 $SHF03COM 如果您需要使用特定的命令行
Fortran 03 文件。 你通常应该设置 $SHFORTRANCOM 变量，指定
所有 Fortran 版本的默认命令行。

SHF03COMSTR
Fortran 03 源文件编译为共享库时显示的字符串
目标文件。 如果没有设置，那么 $SHF03COM or $SHFORTRANCOM （命令行）是
显示。

SHF03旗帜
传递给 Fortran 03 编译器以生成共享库的选项
对象。 你只需要设置 $SHF03标志 如果您需要定义特定的用户选项
Fortran 03 文件。 您通常应该设置 $SHFORTRAFLAGS 变量，其中
为所有用户指定传递给默认 Fortran 编译器的用户指定选项
Fortran 版本。

SHF03PPCOM
用于将 Fortran 03 源文件编译为共享库对象的命令行
首先通过 C 预处理器运行文件后的文件。 中指定的任何选项
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $SHF03标志 和 $CPPFLAGS 此命令中包含构造变量
线。 你只需要设置 $SHF03PPCOM 如果您需要使用特定的 C 预处理器
Fortran 03 文件的命令行。 你通常应该设置 $SHFORTRANPPCOM
变量，指定所有 Fortran 的默认 C 预处理器命令行
版本。

SHF03PPCOMSTR
Fortran 03 源文件编译为共享库时显示的字符串
第一次通过 C 预处理器运行文件后的目标文件。 如果这不是
设置，然后 $SHF03PPCOM or $SHFORTRANPPCOM （命令行）显示。

08新郎
Fortran 08 编译器用于生成共享库对象。 你应该
通常设置 $SHFORTRAN 变量，它指定默认的 Fortran 编译器
所有 Fortran 版本。 你只需要设置 08 美元 如果您需要使用特定的
Fortran 08 文件的编译器或编译器版本。

SHF08COM
用于将 Fortran 08 源文件编译为共享库对象的命令行
文件。 你只需要设置 $SHF08COM 如果您需要使用特定的命令行
Fortran 08 文件。 你通常应该设置 $SHFORTRANCOM 变量，指定
所有 Fortran 版本的默认命令行。

SHF08COMSTR
Fortran 08 源文件编译为共享库时显示的字符串
目标文件。 如果没有设置，那么 $SHF08COM or $SHFORTRANCOM （命令行）是
显示。

SHF08旗帜
传递给 Fortran 08 编译器以生成共享库的选项
对象。 你只需要设置 $SHF08标志 如果您需要定义特定的用户选项
Fortran 08 文件。 您通常应该设置 $SHFORTRAFLAGS 变量，其中
为所有用户指定传递给默认 Fortran 编译器的用户指定选项
Fortran 版本。

SHF08PPCOM
用于将 Fortran 08 源文件编译为共享库对象的命令行
首先通过 C 预处理器运行文件后的文件。 中指定的任何选项
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $SHF08标志 和 $CPPFLAGS 此命令中包含构造变量
线。 你只需要设置 $SHF08PPCOM 如果您需要使用特定的 C 预处理器
Fortran 08 文件的命令行。 你通常应该设置 $SHFORTRANPPCOM
变量，指定所有 Fortran 的默认 C 预处理器命令行
版本。

SHF08PPCOMSTR
Fortran 08 源文件编译为共享库时显示的字符串
第一次通过 C 预处理器运行文件后的目标文件。 如果这不是
设置，然后 $SHF08PPCOM or $SHFORTRANPPCOM （命令行）显示。

77新郎
Fortran 77 编译器用于生成共享库对象。 你应该
通常设置 $SHFORTRAN 变量，它指定默认的 Fortran 编译器
所有 Fortran 版本。 你只需要设置 77 美元 如果您需要使用特定的
Fortran 77 文件的编译器或编译器版本。

SHF77COM
用于将 Fortran 77 源文件编译为共享库对象的命令行
文件。 你只需要设置 $SHF77COM 如果您需要使用特定的命令行
Fortran 77 文件。 你通常应该设置 $SHFORTRANCOM 变量，指定
所有 Fortran 版本的默认命令行。

SHF77COMSTR
Fortran 77 源文件编译为共享库时显示的字符串
目标文件。 如果没有设置，那么 $SHF77COM or $SHFORTRANCOM （命令行）是
显示。

SHF77旗帜
传递给 Fortran 77 编译器以生成共享库的选项
对象。 你只需要设置 $SHF77标志 如果您需要定义特定的用户选项
Fortran 77 文件。 您通常应该设置 $SHFORTRAFLAGS 变量，其中
为所有用户指定传递给默认 Fortran 编译器的用户指定选项
Fortran 版本。

SHF77PPCOM
用于将 Fortran 77 源文件编译为共享库对象的命令行
首先通过 C 预处理器运行文件后的文件。 中指定的任何选项
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $SHF77标志 和 $CPPFLAGS 此命令中包含构造变量
线。 你只需要设置 $SHF77PPCOM 如果您需要使用特定的 C 预处理器
Fortran 77 文件的命令行。 你通常应该设置 $SHFORTRANPPCOM
变量，指定所有 Fortran 的默认 C 预处理器命令行
版本。

SHF77PPCOMSTR
Fortran 77 源文件编译为共享库时显示的字符串
第一次通过 C 预处理器运行文件后的目标文件。 如果这不是
设置，然后 $SHF77PPCOM or $SHFORTRANPPCOM （命令行）显示。

90新郎
Fortran 90 编译器用于生成共享库对象。 你应该
通常设置 $SHFORTRAN 变量，它指定默认的 Fortran 编译器
所有 Fortran 版本。 你只需要设置 90 美元 如果您需要使用特定的
Fortran 90 文件的编译器或编译器版本。

SHF90COM
用于将 Fortran 90 源文件编译为共享库对象的命令行
文件。 你只需要设置 $SHF90COM 如果您需要使用特定的命令行
Fortran 90 文件。 你通常应该设置 $SHFORTRANCOM 变量，指定
所有 Fortran 版本的默认命令行。

SHF90COMSTR
Fortran 90 源文件编译为共享库时显示的字符串
目标文件。 如果没有设置，那么 $SHF90COM or $SHFORTRANCOM （命令行）是
显示。

SHF90旗帜
传递给 Fortran 90 编译器以生成共享库的选项
对象。 你只需要设置 $SHF90标志 如果您需要定义特定的用户选项
Fortran 90 文件。 您通常应该设置 $SHFORTRAFLAGS 变量，其中
为所有用户指定传递给默认 Fortran 编译器的用户指定选项
Fortran 版本。

SHF90PPCOM
用于将 Fortran 90 源文件编译为共享库对象的命令行
首先通过 C 预处理器运行文件后的文件。 中指定的任何选项
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $SHF90标志 和 $CPPFLAGS 此命令中包含构造变量
线。 你只需要设置 $SHF90PPCOM 如果您需要使用特定的 C 预处理器
Fortran 90 文件的命令行。 你通常应该设置 $SHFORTRANPPCOM
变量，指定所有 Fortran 的默认 C 预处理器命令行
版本。

SHF90PPCOMSTR
Fortran 90 源文件编译为共享库时显示的字符串
第一次通过 C 预处理器运行文件后的目标文件。 如果这不是
设置，然后 $SHF90PPCOM or $SHFORTRANPPCOM （命令行）显示。

95新郎
Fortran 95 编译器用于生成共享库对象。 你应该
通常设置 $SHFORTRAN 变量，它指定默认的 Fortran 编译器
所有 Fortran 版本。 你只需要设置 95 美元 如果您需要使用特定的
Fortran 95 文件的编译器或编译器版本。

SHF95COM
用于将 Fortran 95 源文件编译为共享库对象的命令行
文件。 你只需要设置 $SHF95COM 如果您需要使用特定的命令行
Fortran 95 文件。 你通常应该设置 $SHFORTRANCOM 变量，指定
所有 Fortran 版本的默认命令行。

SHF95COMSTR
Fortran 95 源文件编译为共享库时显示的字符串
目标文件。 如果没有设置，那么 $SHF95COM or $SHFORTRANCOM （命令行）是
显示。

SHF95旗帜
传递给 Fortran 95 编译器以生成共享库的选项
对象。 你只需要设置 $SHF95标志 如果您需要定义特定的用户选项
Fortran 95 文件。 您通常应该设置 $SHFORTRAFLAGS 变量，其中
为所有用户指定传递给默认 Fortran 编译器的用户指定选项
Fortran 版本。

SHF95PPCOM
用于将 Fortran 95 源文件编译为共享库对象的命令行
首先通过 C 预处理器运行文件后的文件。 中指定的任何选项
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $SHF95标志 和 $CPPFLAGS 此命令中包含构造变量
线。 你只需要设置 $SHF95PPCOM 如果您需要使用特定的 C 预处理器
Fortran 95 文件的命令行。 你通常应该设置 $SHFORTRANPPCOM
变量，指定所有 Fortran 的默认 C 预处理器命令行
版本。

SHF95PPCOMSTR
Fortran 95 源文件编译为共享库时显示的字符串
第一次通过 C 预处理器运行文件后的目标文件。 如果这不是
设置，然后 $SHF95PPCOM or $SHFORTRANPPCOM （命令行）显示。

上海外国语大学
用于生成共享库对象的默认 Fortran 编译器。

上海运输公司
用于将 Fortran 源文件编译为共享库对象的命令行
文件中。

上海运输公司
Fortran 源文件编译为共享库对象时显示的字符串
文件。 如果没有设置，那么 $SHFORTRANCOM （命令行）显示。

港铁旗帜
传递给 Fortran 编译器以生成共享库对象的选项。

上海运输公司
用于将 Fortran 源文件编译为共享库目标文件的命令行
在首先通过 C 预处理器运行文件之后。 中指定的任何选项
$SHFORTRAFLAGS 和 $CPPFLAGS 此命令中包含构造变量
线。

SHFORTRPCOMSTR
Fortran 源文件编译为共享库对象时显示的字符串
第一次通过 C 预处理器运行文件后的文件。 如果没有设置，那么
$SHFORTRANPPCOM （命令行）显示。

斜射发射器
ALL

SHLIBNOVERSIONSYMLINKS 符号链接
指示 共享库 构建器不为版本化共享创建符号链接
库。

SHLIBP前缀
用于共享库文件名的前缀。

_SHLIBSONAME
一个基于 $TARGET 自动生成共享库的 SONAME 的宏，
$SHLIBVERSION 和 $SHLIBSUFFIX。 被使用 共享库 链接器工具时的构建器
支持 SONAME（例如 gnulink）。

书名后缀
用于共享库文件名的后缀。

隐藏版本
定义此构造变量时，将创建一个版本化的共享库
共享库 建设者。 这激活了 $_SHLIBVERSIONFLAGS 从而修改
$上海联通 根据需要，将版本号添加到库名称，并创建
需要的符号链接。 $SHLIB版本 版本应该以字母数字形式存在，
由正则表达式“\w+[\.\w+]*”定义的小数分隔值。 例子
$SHLIB版本 值包括“1”、“1.2.3”和“1.2.gitaa412c8b”。

_SHLIB版本标志
这个宏自动引入额外的标志 $上海联通 构建版本时
共享库 （也就是当 $SHLIB版本 已设置）。 _SHLIBVERSIONFLAGS 通常添加
$SHLIB版本标志 和一些额外的动态生成的选项（例如
-Wl,-soname=$_SHLIBSONAME。 “普通”（未版本化）共享库未使用它。

隐藏版本标志
添加了额外的标志 $上海联通 构建版本时 共享库. 这些标志是
仅在 $SHLIB版本 置。

联通
使用共享库的程序的链接器。

闪联通讯
用于使用共享库链接程序的命令行。

SHLINKCOMSTR
链接使用共享库的程序时显示的字符串。 如果这不是
设置，然后 $上海联通 （命令行）显示。

env = Environment(SHLINKCOMSTR = "链接共享 $TARGET")

链接标志
为使用共享库的程序传递给链接器的一般用户选项。 笔记
这个变量应该 而不去 包含 -l （或类似的）链接选项
列出的图书馆 $图书馆也没有 -L （或类似的）包括 scons 的搜索路径选项
从自动生成 $库路径。 看 $_LIBFLAGS 上面，对于变量
扩展为库链接选项，并且 $_LIBDIRFLAGS 上面，对于变量
扩展到库搜索路径选项。

SHOBJ前缀
用于共享对象文件名的前缀。

SHOBJ后缀
用于共享对象文件名的后缀。

索名
用于为版本化共享库/可加载模块硬编码 SONAME 的变量。

env.SharedLibrary('test', 'test.c', SHLIBVERSION='0.1.2', SONAME='libtest.so.2')

例如，该变量由 gnulink 链接器工具使用。

源
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

SOURCE_URL
从中检索项目的位置的 URL（Web 地址）。 这是
用于填写Ipkg和RPM控制信息中的Source:字段
包。

来源
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

斯帕恩
将被调用以执行命令行字符串的命令解释器函数。
该函数必须期望以下参数：

def spawn(shell, escape, cmd, args, env):

sh 是一个字符串，命名要使用的 shell 程序。 逃生 是一个函数，可以是
在命令行中调用以转义 shell 特殊字符。 CMD 是通往
要执行的命令。 ARGS 是命令的参数。 ENV 是一本字典
应该在其中执行命令的环境变量。

STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME
当此变量为真时，静态对象和共享对象被假定为
相同的; 也就是说，SCons 不会检查将静态对象链接到共享库中。

SUBST_DICT
所使用的词典 子文件 or 文本文件 替换值的构建器。 它
可以是 dict() 构造函数可接受的任何内容，因此除了字典之外，
元组列表也是可以接受的。

子文件前缀
用于的前缀 子文件 文件名，默认为空字符串。

子文件后缀
后缀用于 子文件 文件名，默认为空字符串。

概要
项目内容的简短摘要。 这个用来填写Summary：
Ipkg 和 RPM 包的控制信息中的字段，以及
说明：MSI 包中的字段。

斯威格
脚本语言包装器和接口生成器。

SWIGC文件后缀
将用于生成的中间 C 源文件的后缀
脚本语言包装器和接口生成器。 默认值为
_裹$C文件后缀. 默认情况下，每当 -C++ 选项是 而不去
指定为的一部分 $SWIGFLAGS 构造变量。

SWIGCOM公司
用于调用脚本语言包装器和界面生成器的命令行。

斯维格康斯特
调用脚本语言包装器和接口时显示的字符串
发电机。 如果没有设置，那么 $SWIGCOM （命令行）显示。

SWIGCXX文件后缀
将用于生成的中间 C++ 源文件的后缀
脚本语言包装器和接口生成器。 默认值为
_裹$C文件后缀. 默认情况下，只要使用 -c++ 选项，就会使用此值
指定为的一部分 $SWIGFLAGS 构造变量。

SWIGDIRECTOR后缀
将用于生成的中间 C++ 头文件的后缀
脚本语言包装器和接口生成器。 这些仅为 C++ 生成
SWIG“导演”功能打开时的代码。 默认值为 _wrap.h。

SWIGFLAGS 旗帜
传递给脚本语言包装器和界面生成器的常规选项。 这个
是你应该设置的地方 -蟒蛇, -perl5, -tcl，或您想要的任何其他选项
指定给 SWIG。 如果你设置 -C++ 此变量中的选项，scons 默认情况下，
生成一个 C++ 中间源文件，其扩展名指定为
$CXX 文件后缀 变量。

_SWIGINCFLAGS
包含 SWIG 命令行的自动生成的构造变量
用于指定要搜索包含文件的目录的选项。 的价值
$_SWIGINCFLAGS 通过附加创建 $SWIGIN前缀 和 $SWIGINC后缀 以及
每个目录的开头和结尾 $SWIGPATH.

SWIGIN前缀
用于在 SWIG 命令行上指定包含目录的前缀。 这将是
附加到每个目录的开头 $SWIGPATH 构造变量
当 $_SWIGINCFLAGS 变量是自动生成的。

SWIGINC后缀
用于在 SWIG 命令行上指定包含目录的后缀。 这将是
附加到每个目录的末尾 $SWIGPATH 构造变量当
$_SWIGINCFLAGS 变量是自动生成的。

SWIGOUT目录
指定脚本语言包装器和接口所在的输出目录
生成器应该放置生成的特定于语言的文件。 这将由 SCons 使用
识别将由 swig 调用生成的文件，并翻译成
命令行上的 swig -outdir 选项。

斯威格路径
脚本语言包装器和接口生成的目录列表
将搜索包含的文件。 SWIG 隐式依赖扫描器将搜索这些
包含文件的目录。 默认值为空列表。

不要明确地将 include 目录参数放入 SWIGFLAGS； 结果将是
不可移植，并且依赖项扫描程序不会搜索目录。 笔记：
SWIGPATH 中的目录名称将相对于 SConscript 目录进行查找
当它们在命令中使用时。 强制 scons 查找相对于
源树的根使用 #:

env = 环境（SWIGPATH='#/include'）

目录查找也可以使用 你（） 功能：

包括=目录（'包括'）
env = 环境（SWIGPATH=include）

目录列表将通过自动生成的添加到命令行
$_SWIGINCFLAGS 构造变量，它是通过附加的值来构造的
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 $SWIGIN前缀 和 $SWIGINC后缀 构造变量到开始和结束
中的每个目录 $SWIGPATH. 您定义的任何需要 SWIGPATH 的命令行
目录列表应包括 $_SWIGINCFLAGS:

env = Environment(SWIGCOM="my_swig -o $TARGET $_SWIGINCFLAGS $SOURCES")

转向
SWIG 工具的版本号。

柏油
焦油归档器。

目标通信
用于调用 tar 归档程序的命令行。

塔康斯特
使用 tar 归档程序归档文件时显示的字符串。 如果没有设置，
然后 $目标通信 （命令行）显示。

env = Environment(TARCOMSTR = "归档 $TARGET")

关税旗
传递给 tar 归档程序的常规选项。

TARGET
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

TARGET_ARCH
由此创建的编译对象的目标硬件体系结构的名称
环境。 这默认为 HOST_ARCH 的值，用户可以覆盖它。
当前仅针对 Win32 设置。

为 Visual Studio 编译器设置目标体系结构（即二进制文件的架构
由编译器生成）。 如果不设置，默认为 $HOST_ARCH，或者，如果未设置，
到正在运行的机器操作系统的体系结构（注意 python 构建或
架构没有影响）。 该变量必须作为参数传递给
环境（）构造函数； 稍后设置它没有效果。 这个目前只用
在 Windows 上，但将来它也会在其他操作系统上使用。

Windows 的有效值为 x86、i386（对于 32 位）； amd64、emt64、x86_64（对于 64
位）； 和 ia64（安腾）。 例如，如果你想编译 64 位二进制文​​件，你
将在您的 SCons 环境中设置 TARGET_ARCH='x86_64'。

目标操作系统
由此创建的编译对象的目标操作系统的名称
环境。 这默认为 HOST_OS 的值，用户可以覆盖它。
当前仅针对 Win32 设置。

目标
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

后缀
用于 tar 文件名的后缀。

临时文件前缀
用于执行长于 $MAXLINELENGTH 的行的临时文件的前缀。 这
默认为“@”。 这可以为使用其他值的工具链设置，例如 '-@'
diab 编译器或 ARM 工具链的“-via”。

TEX
TeX 格式化程序和排版程序。

电信公司
用于调用 TeX 格式化程序和排版程序的命令行。

纺织科技
调用 TeX 格式化程序和排字程序时显示的字符串。 如果这不是
设置，然后 $德康 （命令行）显示。

env = Environment(TEXCOMSTR = "Building $TARGET from TeX input $SOURCES")

文本标志
传递给 TeX 格式化程序和排版程序的常规选项。

输出
LaTeX 程序将搜索的目录列表包括目录。 这
LaTeX 隐式依赖扫描器将在这些目录中搜索 \include 和
\导入文件。

文本文件前缀
用于的前缀 文本文件 文件名，默认为空字符串。

文本文件后缀
后缀用于 文本文件 文件名； 默认为 .txt。

工具
作为此构造一部分的工具规范的名称列表
环境。

未更改_来源
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

UNCHANGED_TARGETS 目标
一个保留的变量名，不能在构造环境中设置或使用。
（参见下面的“变量替换”。）

卖方
提供打包软件的个人或组织。 这个是用来填的
Vendor: RPM 包控制信息中的字段，以及
制造商：MSI 包控制信息中的字段。

VERSION
项目的版本，指定为字符串。

WIN32_INSERT_DEF
已弃用的同义词 $WINDOWS_INSERT_DEF.

WIN32DEFP修复
已弃用的同义词 $WINDOWSDEFPREFIX.

WIN32DEF后缀
已弃用的同义词 $WINDOWSDEF后缀.

WIN32EX前缀
已弃用的同义词 $WINDOWSEXP后缀.

WIN32EXP后缀
已弃用的同义词 $WINDOWSEXP后缀.

WINDOWS_EMBED_MANIFEST
将此变量设置为 True 或 1 以嵌入编译器生成的清单（通常
${TARGET}.manifest) 到使用此环境构建的所有 Windows exe 和 DLL，作为
在他们的链接步骤中的资源。 这是使用 $公吨 和 $MTEXECOM 和 $MTSHLIBCOM.

WINDOWS_INSERT_DEF
当此设置为 true 时，Windows 共享库（.dll 文件）的库构建将
如果还没有 .def 文件，也同时构建相应的 .def 文件
列为构建目标。 默认值为 0（不构建 .def 文件）。

WINDOWS_INSERT_MANIFEST
当这个设置为 true 时，scons 将知道生成的 .manifest 文件
微软 Visua C/C++ 8。

窗口前缀
用于 Windows .def 文件名的前缀。

WINDOWSDEFSUFIX
用于 Windows .def 文件名的后缀。

WINDOWSEXPP前缀
用于 Windows .exp 文件名的前缀。

WINDOWSEX后缀
用于 Windows .exp 文件名的后缀。

WINDOWSPROGMANIFEST前缀
Microsoft Visual 生成的可执行程序 .manifest 文件使用的前缀
C/C++。

WINDOWSPROGMANIFEST 后缀
Microsoft Visual 生成的可执行程序 .manifest 文件使用的后缀
C/C++。

WINDOWSSHIBMANIFESTPREFIX
用于 Microsoft Visual 生成的共享库 .manifest 文件的前缀
C/C++。

WINDOWSSHIBMANIFESTSUFFIX
Microsoft Visual 生成的共享库 .manifest 文件使用的后缀
C/C++。

X_IPK_DEPENDS
这个用来填写Ipkg控制信息中的Depends:字段
包。

X_IPK_DESCRIPTION
这个用来填写Ipkg控制信息中的Description:字段
包。 默认值为 $SUMMARY\n$DESCRIPTION

X_IPK_MAINTAINER
这是用来填写Ipkg控制信息中的Maintainer:字段
包。

X_IPK_PRIORITY
这个用来填写Ipkg控制信息中的Priority:字段
包。

X_IPK_SECTION
这个用来填写Ipkg的控制信息中的Section:字段
包。

X_MSI_语言
用于填写MSI控制信息中的Language:属性
包。

X_MSI_LICENSE_TEXT
RTF 格式的软件许可证文本。 回车字符将是
替换为等效的 RTF \\par。

X_MSI_升级_代码
ALL

X_RPM_AUTOREQPROV
这用于填写 RPM .spec 文件中的 AutoReqProv: 字段。

X_RPM_BUILD
内部，但可覆盖

X_RPM_BUILDREQUIRES
这用于填写 RPM .spec 文件中的 BuildRequires: 字段。

X_RPM_BUILDROOT
内部，但可覆盖

X_RPM_CLEAN
内部，但可覆盖

X_RPM_冲突
这用于填写冲突：RPM .spec 文件中的字段。

X_RPM_DEFATTR
此值用作 RPM 包中文件的默认属性。 这
默认值为（-，根，根）。

X_RPM_DISTRIBUTION
这用于填写 RPM .spec 文件中的 Distribution: 字段。

X_RPM_EPOCH
这用于填写 Epoch: RPM 控制信息中的字段
包。

X_RPM_EXCLUDEARCH
这用于填写 RPM .spec 文件中的 ExcludeArch: 字段。

X_RPM_EXLUSIVEARCH
这用于填写 RPM .spec 文件中的 ExclusiveArch: 字段。

X_RPM_GROUP
这用于填写 Group: RPM .spec 文件中的字段。

X_RPM_GROUP_lang
这用于填写 Group(lang): RPM .spec 文件中的字段。 注意 郎
不是文字，应该用适当的语言代码替换。

X_RPM_图标
这用于填写 RPM .spec 文件中的 Icon: 字段。

X_RPM_安装
内部，但可覆盖

X_RPM_PACKAGER
这用于填写 RPM .spec 文件中的 Packager: 字段。

X_RPM_POSTINSTALL
这用于填写 RPM .spec 文件中的 %post: 部分。

X_RPM_POSTUNINSTALL
这用于填写 RPM .spec 文件中的 %postun: 部分。

X_RPM_PREFIX
这用于填写 RPM .spec 文件中的 Prefix: 字段。

X_RPM_预安装
这用于填写 RPM .spec 文件中的 %pre: 部分。

X_RPM_PREP
内部，但可覆盖

X_RPM_PREUNINSTALL
这用于填写 RPM .spec 文件中的 %preun: 部分。

X_RPM_提供
这用于填写 RPM .spec 文件中的 Provides: 字段。

X_RPM_REQUIRES
这用于填写 RPM .spec 文件中的 Requires: 字段。

X_RPM_序列号
这用于填写 RPM .spec 文件中的 Serial: 字段。

X_RPM_URL
这用于填写 RPM .spec 文件中的 Url: 字段。

XGET文本
路径 获取文本(1) 程序（通过找到 探测（）). 请参阅 xgettext 工具和 POT更新
建造者。

XGETTEXCOM
完整的 xgettext 命令行。 请参阅 xgettext 工具和 POT更新 建造者。

XGETTEXTCOMSTR
显示的字符串 获取文本(1) 调用命令（默认值：''，这意味着
“打印 $XGETTEXTCOM”）。参见 xgettext 工具和 POT更新 建造者。

_XGETTEXT域
内部“宏”。 产生 获取文本 域名形式的来源和目标（默认：
'${TARGET.filebase}'）。

XGETTEXTFLAGS
附加标志 获取文本(1). 请参阅 xgettext 工具和 POT更新 建造者。

X获取文本
包含列表的文件的名称 获取文本(1)的源文件。 Autotools 的用户知道这一点
作为 POTFILES.in 所以他们在大多数情况下会在这里设置 XGETTEXTFROM="POTFILES.in"。 这
$XGETTEXTROM 文件具有与众所周知的 GNU POTFILES.in 相同的语法和语义。
请参阅 xgettext 工具和 POT更新 建造者。

_X从标志中获取文本
内部“宏”。 生成 -D 列表来自的旗帜 $XGETTEXTPATH 名单。

XGETTEXTROMPREFIX
此标志用于添加单个 $XGETTEXTROM 文件以 获取文本(1)的命令行
（默认值：'-f'）。

X从后缀获取文本
（默认： ''）

XGET文本路径
目录列表，那里 获取文本(1) 将查找源文件（默认值：[]）。

备注
此变量仅适用于 $XGETTEXTROM
另请参阅 xgettext 工具和 POT更新 建造者。

_XGETTEXTPATHFLAGS
内部“宏”。 生成 -f 列表来自的旗帜 $XGETTEXTROM.

XGETTEXTPATH前缀
此标志用于将单个搜索路径添加到 获取文本(1)的命令行（默认：
'-D'）。

XGETText路径后缀
（默认： ''）

亚克力
解析器生成器。

YACCCOM公司
用于调用解析器生成器生成源文件的命令行。

YACCCOMSTR
使用解析器生成器生成源文件时显示的字符串。 如果这
没有设置，那么 $YACCCOM （命令行）显示。

env = Environment(YACCCOMSTR = "Yacc'ing $TARGET from $SOURCES")

亚克旗
传递给解析器生成器的常规选项。 如果 $YACCFLAGS 包含一个 -d 选项，
SCons 假定该调用还将创建一个 .h 文件（如果 yacc 源文件结束
在 .y 后缀中）或 .hpp 文件（如果 yacc 源文件以 .yy 后缀结尾）

YACCH文件后缀
解析器生成器生成的C头文件的后缀 -d 选项
用来。 请注意，设置此变量不会导致解析器生成器
生成一个指定后缀的头文件，它的存在是为了让你指定
解析器生成器将自行使用什么后缀。 默认值为 .h。

YACCHXX文件后缀
解析器生成器生成的C++头文件的后缀 -d 选项
用来。 请注意，设置此变量不会导致解析器生成器
生成一个指定后缀的头文件，它的存在是为了让你指定
解析器生成器将自行使用什么后缀。 默认值为
.hpp，Mac OS X 除外，默认为 ${TARGET.suffix}.h。 因为默认
bison 解析器生成器只是将 .h 附加到生成的 C++ 文件的名称。

YACCVCG文件后缀
包含 VCG 文法自动机定义的文件的后缀
--图= 使用选项。 请注意，设置此变量不会导致解析器
generator 生成指定后缀的 VCG 文件，它的存在是为了让你
指定解析器生成器将自行使用的后缀。 默认值
是.vcg。

邮编
zip 压缩和文件打包实用程序。

邮电通信
用于调用 zip 实用程序的命令行，或用于调用 zip 的内部 Python 函数
创建一个 zip 存档。

邮编压缩
这个 压片 来自内部 Python 使用的 Python zipfile 模块的标志
函数来控制 zip 存档是否被压缩。 默认值为
zipfile.ZIP_DEFLATED，创建压缩的 zip 存档。 该值无效
如果 zipfile 模块不可用。

压缩包
使用 zip 实用程序归档文件时显示的字符串。 如果没有设置，
然后 $邮编 （命令行或内部 Python 函数）显示。

env = Environment(ZIPCOMSTR = "Zipping $TARGET")

邮政标志
传递给 zip 实用程序的常规选项。

压缩包
可选的 zip 根目录（默认为空）。 存储在 zip 文件中的文件名
将相对于此目录，如果给定的话。 否则文件名是相对于
命令的当前目录。 例如：

环境 = 环境（）
env.Zip('foo.zip', 'subdir1/subdir2/file1', ZIPROOT='subdir1')

将生成一个 zip 文件 foo.zip，其中包含一个名为 subdir2/file1 的文件
比 subdir1/subdir2/file1。

邮编后缀
用于 zip 文件名的后缀。

可以使用以下方法检索和设置构造变量 字典 的方法
施工环境：

dict = env.Dictionary()
字典 ["抄送"] = "抄送"

或使用 [] 运算符：

环境[“抄送”] =“抄送”

构造变量也可以传递给构造环境的构造函数：

env = 环境 (CC="cc")

或者在使用复制构造环境时 克隆 方法：

env2 = env.Clone(CC="cl.exe")

配置 语境
烤饼 支持 配置 语境， 类似于各种 AC_CHECK 的集成机制
GNU autoconf 中的宏，用于测试 C 头文件、库等的存在。在
与 autoconf 对比， 烤饼 不维护测试值的显式缓存，但是
使用其正常的依赖关系跟踪来使检查的值保持最新。 然而，用户
可以用 --配置 命令行选项。

可以使用以下方法来执行检查：

配置（ENV[自定义测试, 会议目录, 日志文件, 配置_h, 清洁, 帮助]）,
环境配置（[自定义测试, 会议目录, 日志文件, 配置_h, 清洁, 帮助]）
这将创建一个配置上下文，可用于执行检查。 ENV 指定
构建测试的环境。 这个环境可能会被修改时
执行检查。 自定义测试 是一个包含自定义测试的字典。 另见
下面是关于自定义测试的部分。 默认情况下，没有自定义测试添加到
配置上下文。 会议目录 指定构建测试用例的目录。
请注意，此目录不用于构建普通目标。 默认值为
目录#/.sconf_temp。 日志文件 指定一个文件，该文件收集来自
执行以检查头文件、库等是否存在的命令。
默认为文件 #/config.log。 如果您正在使用 变体目录() 方法，你
可能需要在您的变体目录下指定一个子目录。 配置_h 指定一个
将写入测试结果的 C 头文件，例如#define HAVE_STDIO_H，
#define HAVE_LIBM等。默认是不写的 配置文件 文件。 您可以指定
相同 配置文件 文件多次调用配置，在这种情况下 烤饼 将
连接指定文件中的所有结果。 请注意，SCons 使用其正常
依赖检查来决定是否有必要重建指定的 配置_h
文件。 这意味着每次运行 scons 时不一定都重新构建该文件，但是
只有在其内容发生变化并且某些目标依赖于
配置_h 正在构建文件。

可选的 清洁 和 帮助 参数可用于抑制执行
配置测试时 -c/--清洁 or -H/-h/--帮助 使用选项，
分别。 默认行为总是执行配置上下文测试，因为
测试的结果可能会影响要清理的目标列表或帮助
文本。 如果配置测试不影响这些，那么您可以添加 干净=假 or
帮助=假 参数（或两者）以避免不必要的测试执行。

一个创建 配置 实例具有以下关联方法：

SConf.完成（上下文), 安全会议。结束（）
配置完成后应调用此方法。 它返回环境
由执行的配置检查修改。 调用此方法后，不
可以使用此配置上下文执行进一步检查。 但是，您可以
创建一个新的 Configure 上下文来执行额外的检查。 只有一个上下文应该
一次活跃。

以下检查是预定义的。 （随着时间的推移，这个列表可能会越来越大
由开发人员贡献新的有用测试。）

SConf.CheckHeader(上下文, 头[包含引号, language]）， 安全会议.检查标头(头,
[包含引号, language])
检查是否 头 可用于指定语言。 头 可能是一个列表，其中
case 列表中的最后一项是要检查的头文件，而前一个列表
项目是头文件，其 的#include 行应该在标题行之前
检查。 可选参数 包含引号 必须是两个字符的字符串，
其中第一个字符表示开头引号，第二个字符表示
收盘价。 默认情况下，两个字符都是 "（双引号）。可选的
论点 language 应该是 C or C + +中 并选择要用于的编译器
支票。 成功返回 1，失败返回 0。

SConf.CheckCHeader(上下文, 头[包含引号]）， 安全会议.CheckCHeader(头,
[包含引号])
这是一个包装 SConf.CheckHeader 它检查是否 头 在 C 中可用
语言。 头 可能是一个列表，在这种情况下，列表中的最后一项是标题
要检查的文件，前面的列表项是头文件，其 的#include 生产线
应该在被检查的标题行之前。 可选参数 包含引号
必须是两个字符的字符串，其中第一个字符表示左引号
第二个字符表示结束引号（均默认为 \N'34'）。 返回 1
成功时为 0，失败时为 XNUMX。

SConf.CheckCXXHeader(上下文, 头[包含引号]）， 安全会议.CheckCXXHeader(头,
[包含引号])
这是一个包装 SConf.CheckHeader 它检查是否 头 在 C++ 中可用
语言。 头 可能是一个列表，在这种情况下，列表中的最后一项是标题
要检查的文件，前面的列表项是头文件，其 的#include 生产线
应该在被检查的标题行之前。 可选参数 包含引号
必须是两个字符的字符串，其中第一个字符表示左引号
第二个字符表示结束引号（均默认为 \N'34'）。 返回 1
成功时为 0，失败时为 XNUMX。

SConf.CheckFunc(语境，, 函数名[头, language]），
安全会议.CheckFunc(函数名[头, language])
检查指定的 C 或 C++ 函数是否可用。 函数名 是的名字
要检查的函数。 可选的 头 参数是一个字符串
放在将要编译的测试文件的顶部，以检查函数是否
存在； 默认值是：

#ifdef __cplusplus
外部“C”
#ENDIF
字符函数名（）；

可选的 language 论点应该是 C or C + +中 并选择要使用的编译器
支票； 默认值为“C”。

SConf.CheckLib(上下文[图书馆, 符号, 头, language, 自动添加=1]），
安全会议.CheckLib([图书馆, 符号, 头, language, 自动添加=1])
检查是否 图书馆 提供 符号。 如果值 自动添加 是 1 和图书馆
提供指定的 符号, 将库附加到 LIBS 构造中
环境变量。 图书馆 也可以是 None （默认值），在这种情况下 符号 is
检查当前的 LIBS 变量，或库名称列表，在这种情况下，每个
将检查列表中的库 符号。 如果 符号 未设置或是 没有， 然后
SConf.CheckLib文件() 只是检查您是否可以链接到指定的 图书馆。 该
可选 language 论点应该是 C or C + +中 并选择要用于的编译器
支票; 默认值为“C”。 默认值为 自动添加 为 1。此方法返回
1 表示成功，0 表示错误。

SConf.CheckLibWithHeader(上下文, 图书馆, 头, language[呼叫, 自动添加]），
安全会议.CheckLibWithHeader(图书馆, 头, language[呼叫, 自动添加])
与 SConf.CheckLib 调用相比，此调用提供了一种更复杂的方法来
检查库。 再次， 图书馆 指定库或库列表
去检查。 头 指定要检查的标头。 头 可能是一个列表，其中
case 列表中的最后一项是要检查的头文件，而前一个列表
项目是头文件，其 的#include 行应该在标题行之前
检查。 language 可能是 'C'、'c'、'CXX'、'cxx'、'C++' 和 'c++' 之一。 呼叫 可
任何有效的表达式（尾随“;”）。 如果 呼叫 没有设置，默认简单
检查您是否可以链接到指定的 图书馆. 自动添加 指定是否
将库添加到环境中（仅当检查成功时）。 此方法返回 1
成功时为 0，错误时为 XNUMX。

SConf.检查类型(上下文, 类型名称[包括, language]）， 安全会议.检查类型(类型名称,
[包括, language])
检查由定义的类型是否存在 类型定义. 类型名称 指定
要检查的 typedef 名称。 包括 是一个包含一个或多个的字符串 的#include 生产线
将被插入到将运行以测试是否存在的程序中
类型。 可选的 language 论点应该是 C or C + +中 并选择编译器
用于支票； 默认值为“C”。 例子：

sconf.CheckType('foo_type', '#include "my_types.h"', 'C++')

配置.CheckCC(自)
检查 C 编译器（由 CC 构造变量定义）是否工作
试图编译一个小的源文件。

默认情况下，SCons 仅检测是否存在具有正确名称的程序，而不检测是否存在
是一个正常运行的编译器。

这使用与 C 源代码的对象构建器使用的命令完全相同的命令
文件，因此它可用于检测特定编译器标志是否有效。

配置.CheckCXX(自)
检查 C++ 编译器（由 CXX 构造变量定义）是否工作
试图编译一个小的源文件。 默认情况下，SCons 只检测是否有
使用正确名称的程序，而不是如果它是一个正常运行的编译器。

这使用与 CXX 的对象构建器使用的命令完全相同的命令
源文件，因此它可用于检测特定编译器标志是否有效。

配置.CheckSHCC(自)
检查 C 编译器（由 SHCC 构造变量定义）是否工作
试图编译一个小的源文件。 默认情况下，SCons 只检测是否有
使用正确名称的程序，而不是如果它是一个正常运行的编译器。

这使用与 C 源代码的对象构建器使用的命令完全相同的命令
文件，因此它可用于检测特定编译器标志是否有效。 这个
不检查目标代码是否可用于构建共享库，仅
编译（不是链接）成功。

配置.CheckSHCXX(自)
检查 C++ 编译器（由 SHCXX 构造变量定义）是否工作
通过尝试编译一个小的源文件。 默认情况下，SCons 只检测是否有
使用正确名称的程序，而不是如果它是一个正常运行的编译器。

这使用与 CXX 的对象构建器使用的命令完全相同的命令
源文件，因此它可用于检测特定编译器标志是否有效。
这不检查目标代码是否可用于构建共享库，
只有编译（不是链接）成功。

典型配置用法示例：

环境 = 环境（）
conf = 配置（环境）
如果不是 conf.CheckCHeader( 'math.h' ):
打印 '我们真的需要 math.h!'
Exit 退出(1)
如果 conf.CheckLibWithHeader( 'qt', 'qapp.h', 'c++',
'QApplication qapp(0,0);' ):
# 为 qt 做一些事情 - 用法，例如
conf.env.Append( CPPFLAGS = '-DWITH_QT' )
env = conf.Finish()

SConf.CheckTypeSize(上下文, 类型名称[头, language, 期望]），
安全会议.检查类型大小(类型名称[头, language, 期望])
检查由定义的类型的大小 类型定义. 类型名称 指定类型定义
要检查的名称。 可选的 头 参数是一个字符串，将被放置在
将编译以检查函数是否存在的测试文件的顶部； 这
默认为空。 可选的 language 论点应该是 C or C + +中 并选择
用于检查的编译器； 默认值为“C”。 可选的 期望 论点
应该是一个整数。 如果使用这个参数，函数将只检查是否
type_name 中给定的类型具有预期的大小（以字节为单位）。 例如，
CheckTypeSize('短', 期望 = 2) 仅当 short 为两个字节时才会返回成功。

SConf.CheckDeclaration(上下文, 符号[包括, language]），
安全会议.检查声明(符号[包括, language])
检查是否指定 符号 被宣布。 包括 是一个包含一个或
更多 的#include 将被插入到将要运行以测试的程序中的行
对于类型的存在。 可选的 language 论点应该是 C or C + +中 和
选择要用于检查的编译器； 默认值为“C”。

SConf.定义(上下文, 符号[折扣值, 评论]）， 安全会议。定义（符号[折扣值, 评论])
此函数不检查任何内容，但定义了一个预处理器符号，它将
添加到配置头文件中。 它相当于 AC_DEFINE，并且
定义符号 姓名 与可选 折扣值 和可选评论 评论.

例子：

环境 = 环境（）
conf = 配置（环境）

# 将以下行放入配置头文件中：
##define A_SYMBOL
conf.Define('A_SYMBOL')

# 将以下行放入配置头文件中：
##define A_SYMBOL 1
conf.Define('A_SYMBOL', 1)

但是，在引用字符串值时要小心：

环境 = 环境（）
conf = 配置（环境）

# 将以下行放入配置头文件中：
# #define A_SYMBOL 亚
conf.Define('A_SYMBOL', "YA")

# 将以下行放入配置头文件中：
##define A_SYMBOL“YA”
conf.Define('A_SYMBOL', '"YA"')

评论：

环境 = 环境（）
conf = 配置（环境）

# 将以下行放入配置头文件中：
# /* 如果你有符号则设置为 1 */
##define A_SYMBOL 1
conf.Define('A_SYMBOL', 1, '如果有符号则设置为 1')

您可以定义自己的自定义检查。 除了预定义的检查。 这些是
将字典传递给 Configure 函数。 这本字典映射了
检查用户定义的 Python 可调用对象（Python 函数或类实例
实施 __呼叫__ 方法）。 调用的第一个参数始终是 检查上下文
实例后跟参数，必须由检查的用户提供。 这些
CheckContext 实例定义了以下方法：

检查上下文.消息(自, 文本)
通常在检查开始之前调用。 文本 将显示给用户，例如
'正在检查库 X...'

检查上下文.Result(自，, 水库)
通常在检查完成后调用。 水库 可以是整数或字符串。 在
前一种情况，“是”（res != 0）或“否”（res == 0）显示给用户，在
后一种情况显示给定的字符串。

CheckContext.TryCompile(自, 文本, 延期)
检查是否具有指定的文件 延期 （例如'.c'）包含 文本 可
使用环境的编译 摆件 建设者。 成功返回 1，成功返回 0
失败。

CheckContext.TryLink(自, 文本, 延期)
检查文件是否具有指定的 延期 （例如'.c'）包含 文本 可
使用环境的编译 教学计划 建设者。 成功返回 1，成功返回 0
失败。

CheckContext.TryRun(自, 文本, 延期)
检查文件是否具有指定的 延期 （例如'.c'）包含 文本 可
使用环境的编译 教学计划 建设者。 成功后，程序运行。 如果
程序执行成功（即返回状态为0），一个元组 （1，
输出Str) 返回，其中 输出结构 是程序的标准输出。 如果
程序执行失败（其返回状态为非零），然后返回 (0, '')。

CheckContext.TryAction(自, 行动[文本, 延期])
检查是否指定 行动 带有一个可选的源文件（内容 文本 , 扩展
延期 = '' ) 可以执行。 行动 可以是任何可以转换为
烤饼 行动。 成功时， （1， 输出Str) 返回，其中 输出结构 是内容
的目标文件。 失败时 （0， '') 返回。

CheckContext.TryBuild(自, 建设者[文本, 延期])
用于测试特定构建的低级实现； 以上方法是基于
这个方法。 给定 Builder 实例 建设者 和可选的 文本 一个源文件
可选 延期, 此方法成功返回 1，失败返回 0。 在
加成， self.lastTarget 设置为构建目标节点，如果构建是
成功。

实施和使用自定义测试的示例：

def CheckQt（上下文，qtdir）：
context.Message( '正在检查 qt ...' )
lastLIBS = context.env['LIBS']
lastLIBPATH = context.env['LIBPATH']
lastCPPPATH= context.env['CPPPATH']
context.env.Append(LIBS = 'qt', LIBPATH = qtdir + '/ lib目录', CPPPATH = qtdir + '/include' )
ret = context.TryLink("""
＃包括
int main(int argc, char **argv) {
QApplication qapp(argc, argv);
0返回;
}
""")
如果不退：
context.env.Replace（LIBS = lastLIBS，LIBPATH=lastLIBPATH，CPPPATH=lastCPPPATH）
context.Result( 返回 )
返回ret

环境 = 环境（）
conf =配置（env，custom_tests = {'CheckQt'：CheckQt}）
如果不是 conf.CheckQt('/usr/lib/qt'):
print '我们真的需要 qt!'
Exit 退出(1)
env = conf.Finish()

命令行 建筑业 变量
通常在构建软件时，必须在构建时指定一些变量。 例如，
构建所需的库可能位于非标准位置，或特定于站点的编译器
选项可能需要传递给编译器。 烤饼 提供了一个 变量 反对
支持在命令行上覆盖构造变量：

$ scons 变量=foo

也可以在基于文本的 SConscript 文件中指定变量值。 创建一个
变量对象，调用Variables()函数：

变量（[档]，[ARGS])
这将创建一个 Variables 对象，该对象将从文件中读取构造变量或
中指定的文件名列表 档. 如果没有指定文件，或者 档 论点
is 没有，则不会读取任何文件。 可选参数 ARGS 是一本字典
将覆盖从指定文件读取的任何内容的值； 它主要是
打算通过 争论 保存指定变量的字典
命令行。 例子：

vars = 变量('custom.py')
vars = Variables('overrides.py', ARGUMENTS)
vars = 变量（无，{FOO:'expansion', BAR:7}）

变量对象有以下方法：

添加（键[帮助, 默认, 验证器, 变流器])
这会向 Variables 对象添加一个可自定义的构造变量。 键 是
变量的名称。 帮助 是变量的帮助文本。 默认 是默认值
变量的值； 如果默认值为 没有 并且没有明确的价值
指定，构造变量将 而不去 加入建筑
环境。 验证器 被调用以验证变量的值，并且应该
采用三个参数：键、值和环境。 推荐的处理方式
无效值会引发异常（请参见下面的示例）。 变流器 被称为
在将值放入环境之前转换该值，并且应该采用
值，或值和环境，作为参数。 这 变流器 必须返回一个值，
在被验证之前，它将被转换成一个字符串 验证器 （如果有的话）
然后添加到环境中。

例子：

vars.Add('CC', 'C 编译器')

def validate_color(key, val, env):
如果在 ['red', 'blue', 'yellow'] 中不是 val：
raise Exception("无效的颜色值 '%s'" % val)
vars.Add('COLOR', validator=valid_color)

添加变量(名单)
将多个可自定义构造变量添加到 Variables 的包装器脚本
目的。 名单 是包含参数的元组或列表对象的列表
个人电话 添加 方法。

opt.AddVariables(
('调试', '', 0),
('CC', 'C 编译器'),
('VALIDATE', '用于测试验证的选项',
'notset'，验证器，无），
)

更新（ENV[ARGS])
这会更新构建环境 ENV 定制结构
变量。 任何指定的变量是 而不去 为变量对象配置
将被保存并可以用 未知变量() 方法，如下。

通常不直接调用此方法，而是通过传递
Environment() 函数的变量对象：

环境=环境（变量=变量）

创建变量对象时指定的文本文件被执行为
Python 脚本和文件中设置的（全局）Python 变量的值被添加到
施工环境。

计费示例：

抄送 = 'my_cc'

未知变量（)
返回包含在文件中指定的任何变量的字典
或用于初始化 Variables 对象的字典，但为此
未配置变量对象。

环境=环境（变量=变量）
对于键，vars.UnknownVariables() 中的值：
打印“未知变量：%s=%s”%（键，值）

节省（文件名, ENV)
这会将当前设置的变量保存到一个名为 文件名 这可以是
在下次调用时用于自动加载当前设置。 这个方法
结合 Variables 方法可用于支持变量之间的缓存
运行。

环境 = 环境（）
vars = 变量(['variables.cache', 'custom.py'])
vars.Add(...)
变种。更新（环境）
vars.Save('variables.cache', env)

生成帮助文本(ENV[分类])
这会生成帮助文本，记录适合的可定制构造变量
传递给 Help() 函数。 ENV 是施工环境，将
用于获取可自定义变量的实际值。 调用一个可选的
分类 函数将使输出按指定参数排序。 这
具体的 分类 函数应采用两个参数并返回 -1、0 或 1（如
标准蟒蛇 CMP 功能）。

帮助（vars.GenerateHelpText（env））
帮助(vars.GenerateHelpText(env, sort=cmp))

格式变量帮助文本(ENV, 选择, 帮助, 默认, 实际)
此方法返回一个格式化的字符串，其中包含一个的可打印帮助文本
选项。 通常不直接调用，而是由 生成帮助文本()
方法来创建返回的帮助文本。 它可能会被您自己的功能覆盖
它采用上面指定的参数并返回格式化的帮助文本字符串
随你喜欢。 请注意， 生成帮助文本() 不会放任何空行或多余的
条目之间的字符，因此您必须将这些字符添加到返回的
string 如果你想分隔条目。

def my_format（环境、选择、帮助、默认、实际）：
fmt = "\n%s: 默认=%s 实际=%s (%s)\n"
return fmt % (opt, default.actual, help)
vars.FormatVariableHelpText = my_format

为了更方便地使用可自定义的变量， 烤饼 提供了一个
使设置各种类型的变量变得容易的函数数量：

布尔变量（键, 帮助, 默认)
返回参数元组以设置布尔选项。 该选项将使用
指定名称 键, 默认值为 默认, 并显示指定的 帮助
文本。 该选项将解释值 y, 含, t, true，1， on 和 所有 为真，并且
价值 n, 没有, f, false，0， 折扣 和 没有 为假。

枚举变量(键, 帮助, 默认, 允许值[地图, 忽略大小写])
返回一个参数元组以设置一个选项，其值可能是指定的一个
合法枚举值列表。 该选项将使用指定的名称 键，有一个
默认值 默认, 并显示指定的 帮助 文本。 该选项只会
支持这些价值观 允许值 列表。 可选的 地图 论证是一个
可用于将输入值转换为特定合法值的字典
允许值 列表。 如果值 忽略大小写 为 0（默认值），则值
区分大小写。 如果值 忽略大小写 为 1，则匹配值
不区分大小写。 如果值 忽略大小写 为 2，则匹配值
不区分大小写，所有输入值都将转换为小写。

列表变量(键, 帮助, 默认, 名称[,地图])
返回一个参数元组以设置一个选项，其值可以是一个或多个
指定的合法枚举值列表。 该选项将使用指定的名称 键,
有一个默认值 默认, 并显示指定的 帮助 文本。 该选项将
只支持值 所有, 没有，或中的值 名称 列表。 超过一个
可以指定值，所有值都用逗号分隔。 默认值可能是
以逗号分隔的默认值字符串，或默认值列表。 这
可选 地图 argument 是一个字典，可用于将输入值转换为
在特定的法律价值 名称 名单。

包变量（键, 帮助, 默认)
返回一个参数元组以设置一个选项，其值是一个路径名
可以启用、禁用或给出显式路径名的包。 该选项将
使用指定的名称 键, 默认值为 默认, 并显示指定的
帮助 文本。 该选项将支持这些值 含, true, on, enable or 搜索、在
哪种情况下指定 默认 将被使用，或者该选项可以设置为
任意字符串（通常是正在启用的包的路径名）。 这
选项也将支持值 没有, false, 折扣 or 关闭 禁止使用
指定的选项。

路径变量(键, 帮助, 默认[验证器])
返回参数元组以设置其值应为路径的选项
姓名。 该选项将使用指定的名称 键, 默认值为 默认和
显示指定的 帮助 文本。 额外的 验证器 可以指定将是
调用以验证指定的路径是否可接受。 SCons 提供以下内容
现成的验证器： 路径变量.PathExists （默认值），它验证
存在指定路径； 路径变量.PathIsFile，它验证指定的路径
是现有文件； 路径变量.PathIsDir，它验证指定的路径是
现有目录； PathVariable.PathIsDirCreate，它验证指定的
path 是一个目录，如果路径不是，将创建指定的目录
存在; 和 路径变量.PathAccept, 它只接受特定的路径名
未经验证的参数，如果您希望用户能够
指定将作为构建过程的一部分创建的目录路径，例如
例子。 您可以提供自己的 验证器 函数，必须接受三个参数
(键, 要设置的变量名； VAL, 正在检查的指定值； 和
ENV，施工环境），如果指定
价值是不可接受的。

这些函数可以方便地创建多个具有一致性的变量
一次调用中的行为 添加变量 方法：

vars.AddVariables(
BoolVariable('警告', '用-Wall 和类似的编译', 1),
EnumVariable('debug', '调试输出和符号', 'no'
allowed_values=('是', '否', '满'),
map={}, ignorecase=0), #区分大小写
ListVariable('共享',
'要构建为共享库的库'，
'全部'，
名称 = list_of_libs),
包变量（'x11'，
'使用此处安装的 X11（是 = 搜索一些地方）',
'是的'），
PathVariable('qtdir', '安装Qt根目录', qtdir),
PathVariable('foopath', '安装foo库的位置', foopath,
PathVariable.PathIsDir),

)

文件 和 目录 Nodes
这个 文件（）和 你() 函数返回 文件 和 你 节点，分别。 蟒蛇对象，
分别。 这些对象有几个用户可见的属性和方法
经常有用：

径
给定文件或目录的构建路径。 这个路径是相对于顶层的
目录（其中 构造 找到文件）。 构建路径与
源路径如果 变体目录 没有被使用。

绝对的
给定文件或目录的绝对构建路径。

源节点()
这个 源节点() 方法返回另一个 文件 or 你 代表对象 资源 径
给定的 文件 or 你。 该

# 获取当前构建目录的路径，相对于顶部。
目录('.').路径
# 当前目录的绝对路径
目录（'.'）.abspath
# 下一行总是'.'，因为它是顶层目录相对于自身的路径。
Dir('#.').路径
File('foo.c').srcnode().path # 给定源文件的源路径。

# 构建器还返回文件对象：
foo = env.Program('foo.c')
打印“foo 将在 %s 中构建”%foo.path

A 你 节点或 文件 Node 也可以用来创建文件和子目录 Nodes
相对于生成节点。 一种 你 节点会将新节点放置在
它代表的目录。 一种 文件 节点会将新节点放置在其父节点中
目录（即，在相关文件的“旁边”）。 如果 d 是一个 你 （目录）节点和
f 是一个 文件 (file) 节点，那么可以使用这些方法：

d.目录(姓名)
返回子目录的目录节点 d 命名 姓名.

d。文件（姓名)
返回文件的文件节点 d 命名 姓名.

d。入口（姓名)
返回一个未解决的节点 d 命名 姓名.

f.目录(姓名)
返回名为的目录 姓名 在的父目录中 f.

f。文件（姓名)
返回一个名为 姓名 在的父目录中 f.

f。入口（姓名)
返回一个未解析的节点，名为 姓名 在的父目录中 f.

例如：

# 获取目录中文件的节点
incl = Dir('包括')
f = incl.File('header.h')

# 获取目录中子目录的节点
dist = Dir('项目-3.2.1)
src = dist.Dir('src')

# 获取同一目录下文件的节点
cfile = 文件('sample.c')
hfile = cfile.File('sample.h')

# 组合示例
文档=目录（'文档'）
html = docs.Dir('html')
index = html.File('index.html')
css = index.File('app.css')

扩展 斯康斯

生成器 对象
烤饼 可以通过添加新的 Builder 对象来扩展以构建不同类型的目标
一个施工环境。 In 一般, 你应该只需要添加一个新的 Builder 对象
当你想构建一种新类型的文件或其他外部目标时。 如果你只是想
调用不同的编译器或其他工具来构建程序、对象、库或任何
其他类型的输出文件 烤饼 已经有现成的Builder，一般是
在设置了
适当的构造变量（CC、LINK 等）。

Builder 对象是使用 生成器 功能。 的 生成器 函数接受
以下参数：

行动
用于从源构建目标的命令行字符串。 行动 也可以是：
表示要执行的命令及其参数的字符串列表（适合
用于在参数中包含空格），字典映射源文件名
命令行字符串的任意组合的后缀（如果构建器应该接受
多个源文件扩展名），一个 Python 函数； 一个 Action 对象（见下一个
部分）; 或上述任何一项的清单。

一个动作函数接受三个参数： 资源 - 源节点列表， 目标 - 到
目标节点列表， ENV ——施工环境。

字首
将添加到目标文件名的前缀。 这可以指定为：
* 绳子,

* 可召回的 对象 - 带有两个参数的函数或其他可调用对象（a
构建环境和源列表）并返回一个前缀，

* 字典 - 指定来自特定源后缀的映射（第一个源的
指定）到相应的目标前缀。 源后缀和目标前缀
规范可以使用环境变量替换和目标前缀（
字典中的“值”条目）也可能是可调用对象。 默认目标
前缀可以由键值为 None 的字典条目指示。

b = Builder("build_it < $SOURCE > $TARGET",
前缀=“文件-”）

def gen_prefix（环境，来源）：
返回“文件-”+ env['PLATFORM'] + '-'
b = Builder("build_it < $SOURCE > $TARGET",
前缀 = gen_prefix)

b = Builder("build_it < $SOURCE > $TARGET",
后缀= {无：“文件-”，
"$SRC_SFX_A": gen_prefix })

后缀
将附加到目标文件名的后缀。 这可以在
与上面的前缀相同的方式。 如果后缀是一个字符串，那么 烤饼 将附加一个
'.' 如果后缀不存在，则到后缀的开头。 返回的字符串
可调用对象（或从字典中获得）未被触及，必须附加自己的
'.' 如果需要，可以从头开始。

b = Builder("build_it < $SOURCE > $TARGET"
后缀=“-文件”）

def gen_suffix（环境，来源）：
返回 ”。” + env['PLATFORM'] + "-文件"
b = Builder("build_it < $SOURCE > $TARGET",
后缀 = gen_suffix)

b = Builder("build_it < $SOURCE > $TARGET",
后缀 = { 无：“.sfx1”，
"$SRC_SFX_A": gen_suffix })

确保后缀
当设置为任何真值时，导致 烤饼 添加由指定的目标后缀
后缀 具有不同后缀的任何目标字符串的关键字。 （默认
行为是保持任何看起来已经有任何目标文件名不变
后缀。）

b1 = Builder("build_it < $SOURCE > $TARGET"
后缀 = ".out")
b2 = Builder("build_it < $SOURCE > $TARGET"
后缀 = ".out",
确保后缀）
环境 = 环境（）
env['BUILDERS']['B1'] = b1
env['BUILDERS']['B2'] = b2

# 构建“foo.txt”，因为未设置 ensure_suffix。
env.B1('foo.txt', 'foo.in')

# 构建“bar.txt.out”，因为设置了 ensure_suffix。
env.B2('bar.txt', 'bar.in')

源后缀
预期的源文件名后缀。 这可能是一个字符串或一个字符串列表。

目标扫描仪
将被调用以查找此目标的隐式依赖项的 Scanner 对象
文件。 此关键字参数应用于发现隐式的 Scanner 对象
仅基于目标文件和构建环境的依赖关系， 而不去 HPMC胶囊
基于源文件的隐式依赖。 （请参阅下面的“扫描仪对象”部分，
有关创建 Scanner 对象的信息。）

来源扫描仪
将被调用以在任何源中查找隐式依赖项的 Scanner 对象
用于构建此目标文件的文件。 这是您要指定扫描仪的地方
找到类似的东西 的#include 源文件中的行。 预建的 目录扫描仪 扫描器
对象可用于指示此构建器应该扫描目录树以查找
对文件的磁盘更改 烤饼 不知道其他 Builder 或函数
电话。 （请参阅下面的“扫描仪对象”部分，了解有关创建您的
自己的扫描仪对象。）

目标工厂
Builder 将用于将指定为字符串的任何目标转换为工厂函数
进入 SCons 节点。 默认情况下，SCons 假定所有目标都是文件。 其他有用的
target_factory 值包括 你，当 Builder 创建目录目标时，以及
条目，当 Builder 可以创建文件或目录目标时。

计费示例：

MakeDirectoryBuilder = Builder(action=my_mkdir, target_factory=Dir)
环境 = 环境（）
env.Append(BUILDERS = {'MakeDirectory':MakeDirectoryBuilder})
env.MakeDirectory('new_directory', [])

请注意，对 MakeDirectory Builder 的调用需要指定一个空源列表
使字符串代表构建器的目标； 没有它，它会假设
argument 是源，并会尝试从中推断出目标名称，这在
缺少自动添加的前缀或后缀会导致匹配的目标和
源名称和循环依赖。

来源工厂
Builder 将用于将任何指定为字符串的源转换为工厂函数
进入 SCons 节点。 默认情况下，SCons 假定所有源都是文件。 其他有用的
source_factory 值包括 你，因为当 Builder 使用目录作为源时，
和 条目，当 Builder 可以使用文件或目录（或两者）作为源时。

计费示例：

CollectBuilder = Builder(action=my_mkdir, source_factory=条目)
环境 = 环境（）
env.Append(BUILDERS = {'Collect':CollectBuilder})
env.Collect('archive', ['directory_name', 'file_name'])

发射器
之前操作目标和源列表的函数或函数列表
建立依赖关系并实际构建目标。 发射器 还可以
是一个包含构造变量的字符串以扩展为发射器函数或
函数列表，或映射源文件后缀到发射器函数的字典。
（仅使用第一个源文件的后缀来选择实际的发射器
来自发射器字典的函数。）

发射器函数接受三个参数： 资源 - 源节点列表， 目标 - 到
目标节点列表， ENV ——施工环境。 一个发射器必须返回一个
包含两个列表的元组，该构建器要构建的目标列表，以及
此构建器的源列表。

计费示例：

def e（目标、源、环境）：
返回（目标 + ['foo.foo']，源 + ['foo.src']）

# 发射器函数与生成器的简单关联。
b = Builder("my_build < $TARGET > $SOURCE",
发射器 = e)

def e2（目标、源、环境）：
返回（目标+ ['bar.foo']，源+ ['bar.src']）

# 发射器函数列表与生成器的简单关联。
b = Builder("my_build < $TARGET > $SOURCE",
发射器 = [e, e2])

# 通过构造变量调用发射器函数。
env = 环境（MY_EMITTER = e）
b = Builder("my_build < $TARGET > $SOURCE",
发射器 = '$MY_EMITTER')

# 通过构造变量调用发射器函数列表。
env = 环境 (EMITTER_LIST = [e, e2])
b = Builder("my_build < $TARGET > $SOURCE",
emitter = '$EMITTER_LIST')

# 将多个发射器与不同的文件相关联
# 后缀使用字典。
def e_suf1（目标、来源、环境）：
返回（目标+ ['another_target_file']，来源）
def e_suf2（目标、来源、环境）：
返回（目标，来源+ ['another_source_file']）
b = Builder("my_build < $TARGET > $SOURCE",
emitter = {'.suf1' : e_suf1,
'.suf2' : e_suf2})

多
指定是否允许多次调用此构建器
目标文件。 默认为0，表示builder不能被多次调用
相同目标文件的次数。 多次调用构建器
target 只是将额外的源文件添加到目标； 不允许更改
与目标关联的环境，指定附加环境覆盖，或
将不同的构建器与目标相关联。

ENV
一个构建环境，可用于使用此构建器获取源代码。
（注意这个环境是 而不去 用于正常目标文件的正常构建，
它使用用于为目标文件调用 Builder 的环境。）

发电机
返回将执行以构建目标的操作列表的函数
从来源。 返回的动作可能是一个动作对象，或者任何
可以转换为 Action 对象（请参阅下一节）。

生成器函数有四个参数： 资源 - 源节点列表， 目标 -
目标节点列表， ENV - 施工环境， for_signature - 一个布尔值
指定是否调用生成器来生成构建的值
签名（与实际执行命令相反）。 例子：

def g（源、目标、环境、for_signature）：
返回 [["gcc", "-c", "-o"] + 目标 + 源]

b = 生成器(生成器=g)

这个 发电机 和 行动 arguments 不能同时用于同一个 Builder。

src_builder
指定当源文件名后缀与任何一个都不匹配时要使用的构建器
建造者的后缀。 使用此参数会生成一个多阶段构建器。

单一来源
指定此构建器每次调用只需要一个源文件。 给予超过
一个没有目标文件的源文件会导致隐式调用构建器
多次（给定的每个来源一次）。 一起提供多个源文件
使用目标文件会导致 UserError 异常。

这个 发电机 和 行动 arguments 不能同时用于同一个 Builder。

源分机匹配
当指定 行动 参数是一个字典，当一个
builder 传递多个源文件是为了确保所有的扩展
源文件匹配。 如果使用源列表调用此构建器是合法的
具有不同扩展名的文件，可以通过设置来抑制此检查
源分机匹配 至 没有 或其他一些非真实值。 什么时候 源分机匹配 is
禁用， 烤饼 将使用第一个指定源文件的后缀来选择
从适当的行动 行动 字典。

在下面的例子中，设置 源分机匹配 防止 烤饼 从退出
由于后缀不匹配而出错 foo.in 和 foo.extra.

b = Builder(action={'.in' : 'build $SOURCES > $TARGET'},
source_ext_match = 无）

env = 环境 (BUILDERS = {'MyBuild':b})
env.MyBuild('foo.out', ['foo.in', 'foo.extra'])

ENV
一个构建环境，可用于使用此构建器获取源代码。
（注意这个环境是 而不去 用于正常目标文件的正常构建，
它使用用于为目标文件调用 Builder 的环境。）

b = Builder(action="build < $SOURCE > $TARGET")
env = 环境（BUILDERS = {'MyBuild'：b}）
env.MyBuild('foo.out', 'foo.in', my_arg = 'xyzzy')

目录
scons 将从中执行为此构建器指定的操作的目录。 如果
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 目录 参数是一个字符串或者一个目录节点，scons会改变到指定的
目录。 如果 目录 不是字符串或节点且非零，则 scons 将
更改为目标文件的目录。

请注意，scons 将 而不去 自动修改其扩展构造变量
喜欢 $目标 和 $源 使用 chdir 关键字参数时——即扩展的
文件名仍将相对于顶级 SConstruct 目录，并且
因此相对于 chdir 目录不正确。 使用 chdir 创建的构建器
关键字参数，将需要使用构造变量扩展，如
${目标.文件} 和 ${SOURCE.文件} 仅使用目标的文件名部分和
资源。

b = Builder(action="build < ${SOURCE.file} > ${TARGET.file}",
目录=1)
env = 环境（BUILDERS = {'MyBuild'：b}）
env.MyBuild('sub/dir/foo.out', 'sub/dir/foo.in')

警告： Python 只为所有线程保留一个当前目录位置。 这个
意味着使用 目录 论证将 而不去 与 SCons 一起工作 -j 选项，因为
由 SCon 生成的各个工作线程在启动时会相互干扰
更改目录。

创建 Builder 对象时提供的任何附加关键字参数（即，当
Builder() 函数被调用）将在执行构建环境中设置
当调用 Builder 对象时。 这里的典型示例是设置一个
构建变量到源代码系统的存储库。

Builder 时提供的任何其他关键字参数 对象 被调用只会是
与特定 Builder 调用创建的目标相关联（以及任何其他文件
作为调用的结果构建）。

这些额外的关键字参数被传递给以下函数：命令生成器
功能、功能动作和发射器功能。

操作 对象
这个 生成器() 函数将把它的 行动 关键字参数转换为适当的内部
动作对象。 您还可以使用 操作（） 全球的
函数，然后可以将其传递给 生成器（） 功能。 这可以用来
更灵活地配置 Action 对象，或者它可能比让
当多个 Builder 对象需要时，每个单独的 Builder 对象创建一个单独的 Action
做同样的事情。

这个 操作() 全局函数为所代表的动作返回一个合适的对象
第一个参数的类型：

操作
如果第一个参数已经是一个 Action 对象，则简单地返回该对象。

串
如果第一个参数是字符串，则返回命令行操作。 请注意，
命令行字符串前面可以有 @ (at-sign) 禁止打印
指定的命令行，或通过 - （连字符）忽略退出状态
指定命令：

动作（'$CC -c -o $TARGET $SOURCES'）

# 不打印正在执行的行。
动作（'@build $TARGET $SOURCES'）

# 忽略返回值
动作（'-build $TARGET $SOURCES'）

列表
如果第一个参数是列表，则返回 Action 对象的列表。 一种行为
根据需要为列表中的每个元素创建对象。 如果一个元素 中 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。
list本身就是一个列表，内部list是要执行的命令和参数
通过命令行。 这允许将空格包含在参数中
在列表中的列表中定义命令：

行动（[['cc'，'-c'，'-DWHITE SPACE'，'-o'，'$TARGET'，'$SOURCES']]）

功能
如果第一个参数是 Python 函数，则返回函数 Action。 巨蟒
函数必须采用三个关键字参数， 目标 （一个 Node 对象代表
目标文件）， 资源 （表示源文件的节点对象）和 ENV （
用于构建目标文件的构建环境）。 这 目标 和 资源
如果有多个目标文件或源，则参数可以是 Node 对象列表
文件。 可以从它们的节点中检索实际的目标和源文件名
通过内置的 Python str() 函数获取对象：

target_file_name = str(目标)
source_file_names = map(lambda x: str(x), 来源)

该函数应返回 0 或 没有 指示目标构建成功
文件。 该函数可能引发异常或返回非零退出状态
表示构建不成功。

def build_it（目标=无，源=无，env =无）：
# 从源构建目标
返回0

a = 动作（build_it）

如果 action 参数不是上述之一，则返回 None。

第二个参数是可选的，用于定义当
实际执行了操作。 在没有此参数的情况下，或者它是一个空的
字符串，根据操作的类型使用默认输出。 例如，一个
命令行操作将打印执行的命令。 参数必须是 Python
函数或字符串。

在第一种情况下，它是一个函数，它返回一个要打印的字符串来描述
正在执行的动作。 该函数也可以由 函数=关键字
争论。 就像一个建立文件的函数，这个函数必须带三个关键字
参数： 目标 （表示目标文件的 Node 对象）， 资源 （一个节点对象
代表源文件）和 ENV （施工环境）。 这 目标 和 资源
如果有多个目标文件或源，则参数可以是 Node 对象列表
文件中。

在第二种情况下，您提供字符串本身。 该字符串也可以由
命令字符串= 关键字参数。 该字符串通常包含变量，特别是 $TARGET(S) 和
$SOURCE(S)，或者只包含一个变量，可以在某处定义
别的。 SCons 本身大量使用后一种变体。

例子：

def build_it（目标、源、环境）：
# 从源构建目标
返回0

def string_it（目标、源、环境）：
返回“从‘%s’构建‘%s’”%（目标[0]，源[0]）

# 使用位置参数。
f = 动作(build_it, string_it)
s = Action(build_it, "从 '$SOURCE' 构建 '$TARGET'")

# 或者，使用关键字参数。
f = 操作(build_it, strfunction=string_it)
s = Action(build_it, cmdstr="从'$SOURCE'构建'$TARGET'")

# 你可以提供一个可配置的变量。
l = Action(build_it, '$STRINGIT')

第三个和后续参数（如果存在）可以是构造变量或
构造变量列表，其值将包含在
决定是否应重建目标时的操作，因为操作已更改。 这
变量也可以由一个指定 变量列表=关键字参数； 如果两者都存在，则它们
被合并。 当您希望在特定的情况下重建目标时，这是必需的
构造变量变化。 字符串操作通常不需要这样做，因为
扩展变量通常是命令行的一部分，但如果
Python 函数动作在生成
命令行。

def build_it（目标、源、环境）：
# 从 'XXX' 构造变量构建目标
打开（目标[0]，'w'）。写（env ['XXX']）
返回0

# 使用位置参数。
a = Action(build_it, '$STRINGIT', ['XXX'])

# 或者，使用关键字参数。
a = Action(build_it, varlist=['XXX'])

这个 操作() 全局函数可以将以下可选关键字参数传递给
修改 Action 对象的行为：

目录 这个 目录 关键字参数指定 scons 将在之后执行操作
切换到指定目录。 如果 目录 参数是字符串或目录
节点，scons会切换到指定目录。 如果 目录 参数不是字符串
或 Node 且非零，则 scons 将更改为目标文件的目录。

请注意，scons 将 而不去 自动修改其构造变量的扩展，如
$目标 和 $源 使用 chdir 关键字参数时——即展开的文件
名称仍将相对于顶级 SConstruct 目录，因此
相对于 chdir 目录不正确。 使用 chdir 关键字参数创建的构建器，
将需要使用构造变量扩展，例如 ${目标.文件} 和 ${SOURCE.文件}
仅使用目标和源的文件名部分。

a = Action("构建 < ${SOURCE.file} > ${TARGET.file}",
目录=1)

退出状态函数 这个 操作() 全局函数也需要一个 退出状态函数 关键字参数
它指定一个函数，该函数从
指定的动作，可以返回任意值或修改后的值。 这可以用于
例如，指定在特殊情况下应忽略 Action 对象的返回值
因此，条件和 SCons 应该考虑该操作总是成功：

defalways_succeed(s):
# 始终返回0，表示成功。
返回0
a = Action("构建 < ${SOURCE.file} > ${TARGET.file}",
exitstatfunc=always_succeed)

批处理密钥 这个 批处理密钥 关键字参数可用于指定 Action 可以创建
通过同时处理多个独立的源文件来生成多个目标文件。 （这
典型的例子是通过传递多个目标文件来“批量编译”多个目标文件
源文件到编译器的单次调用，例如 Microsoft 的 Visual C / C++
编译器。）如果 批处理密钥 参数是任何非假的、不可调用的 Python 值，
配置的 Action 对象将导致 烤饼 收集所有使用 Action 构建的目标
对象并配置了相同的构造环境到单次调用中
Action 对象的命令行或函数。 命令行通常希望使用
已更改来源 构造变量（也可能 CHANGED_TARGETS 目标 以及）只通过
到命令行那些自从他们的目标
内置的。

计费示例：

a = Action('build $CHANGED_SOURCES', batch_key=True)

这个 批处理密钥 argument 也可以是一个可调用函数，它返回一个键
用于识别要为批量构建收集的不同“批次”目标文件。 一种
批处理密钥 函数必须采用以下参数：

行动
动作对象。

ENV
为目标配置的构建环境。

目标
特定配置操作的目标列表。

资源
特定配置操作的源列表。

返回的键通常应该是从参数派生的值的元组，
使用任何适当的逻辑来决定应该如何批处理多个调用。 为了
例如，一个 批处理密钥 函数可以决定返回特定的值
构造变量来自 ENV 将导致的争论 烤饼 批量构建
具有该变量匹配值的目标，或者可能返回 id（） 的
整个施工环境，在这种情况下 烤饼 将批量构建所有目标
配置相同的构建环境。 回归 没有 表示
特定目标应该 而不去 是任何批处理构建的一部分，而是将被构建
通过单独调用动作的命令或函数。 例子：

defbatch_key（操作，环境，目标，源）：
tdir = 目标[0].dir
如果 tdir.name == '特殊'：
# 不要批量构建任何目标
# 在 special/ 子目录中。
不返回
返回（id（动作），id（环境），tdir）
a = Action('build $CHANGED_SOURCES', batch_key=batch_key)

其他 操作 功能
烤饼 提供多种整理各种常用文件和目录的功能
要执行的操作。 这些在概念上类似于 Ant 构建中的“任务”
工具，尽管实现略有不同。 这些功能实际上并不
在调用函数时执行指定的操作，但返回一个
可以在适当的时候执行的动作对象。 （在面向对象中
术语，这些实际上是 Action 工厂面积 返回 Action 对象的函数。）

在实践中，这些动作函数有两种自然的方式
用过的。

首先，如果您需要在读取 SConscript 文件时执行操作，
您可以使用 执行 这样做的全局函数：

执行（触摸（'文件'））

其次，您可以使用这些函数在列表中提供操作以供 命令
方法。 这可以让您执行更复杂的文件操作序列
不依赖特定于平台的外部命令：

env = 环境（TMPBUILD = '/tmp/builddir'）
env.Command('foo.out', 'foo.in',
[Mkdir('$TMPBUILD'),
复制('$TMPBUILD', '${SOURCE.dir}'),
"cd $TMPBUILD && make",
删除('$TMPBUILD')])

修改(DEST, 模式)
返回一个更改指定权限的 Action 对象 DEST 文件或
到指定目录 模式。 例子：

执行（Chmod（'文件'，0755））

env.Command('foo.out', 'foo.in',
[复制('$TARGET', '$SOURCE'),
Chmod('$TARGET', 0755)])

复制（DEST, SRC)
返回一个将复制 SRC 源文件或目录到 DEST
目标文件或目录。 例子：

执行（复制（'foo.output'，'foo.input'））

env.Command('bar.out', 'bar.in',
复制('$TARGET', '$SOURCE'))

删除（条目[必须存在])
返回删除指定的 Action 条目, 可以是文件或目录
树。 如果指定了一个目录，整个目录树将被删除。 如果
必须存在 设置了标志，那么如果指定的条目不正确，将抛出 Python 错误
不存在; 默认是 必须存在=0，也就是说，Action 会默默地不做任何事情
如果条目不存在。 例子：

执行（删除（'/tmp/buildroot'））

env.Command('foo.out', 'foo.in',
[删除('${TARGET.dir}'),
我的构建动作])

执行（删除（'file_that_must_exist'，must_exist=1））

目录(DIR)
返回创建指定目录的 Action DIR . 例子：

执行（Mkdir（'/tmp/outputdir'））

env.Command('foo.out', 'foo.in',
[Mkdir('/tmp/builddir'),
复制('/tmp/builddir/foo.in', '$SOURCE'),
"cd /tmp/builddir && make",
复制('$TARGET', '/tmp/builddir/foo.out')])

移动（DEST, SRC)
返回一个移动指定的动作 SRC 指定的文件或目录 DEST
文件或目录。 例子：

执行（移动（'file.destination'，'file.source'））

env.Command('output_file', 'input_file',
[我的建造行动，
移动（'$TARGET'，'file_created_by_MyBuildAction'）]）

触碰（文件)
返回一个更新指定时间的修改时间的 Action 文件。 例子：

执行（触摸（'file_to_be_touched'））

env.Command('marker', 'input_file',
[我的建造行动，
触摸（'$TARGET'）]）

请按需咨询 换人
在执行命令之前， 烤饼 对构造变量插值
构成构建器命令行的字符串。 变量由a引入 $ 字首。
除了构造变量，scons 还为每个命令提供以下变量
执行：

已更改来源
自目标以来已更改的构建命令的所有源的文件名
是最后建造的。

CHANGED_TARGETS 目标
所有目标的文件名，这些目标将从自那以后发生变化的源构建
目标是上次构建的。

源
构建命令源的文件名，或者第一个源的文件名
如果正在构建多个源。

来源
构建命令源的文件名。

TARGET
正在构建的目标的文件名，或者第一个目标的文件名，如果
正在建造多个目标。

目标
正在构建的所有目标的文件名。

未更改_来源
具有的构建命令的所有源的文件名 而不去 自从改变了
目标是上次构建的。

UNCHANGED_TARGETS 目标
从具有的源构建的所有目标的文件名 而不去 变
自上次构建目标以来。

（注意上面的变量是保留的，不能在构造中设置
环境。）

例如，给定构造变量 CC='cc', targets=['foo']，以及
来源=['foo.c', 'bar.c']:

action='$CC -c -o $TARGET $SOURCES'

会产生命令行：

cc -c -o foo foo.c bar.c

变量名可以用花括号 ({}) 括起来，以将名称与变量名分开
尾随字符。 在大括号内，变量名可能有一个 Python 切片
附加下标以从列表中选择一个或多个项目。 在前面的例子中，
串：

${来源[1]}

会产生：

酒吧

此外，变量名可以在变量名中附加以下特殊修饰符
用花括号括起来修改内插字符串：

基地
文件名的基本路径，包括目录路径但不包括任何后缀。

DIR
文件所在目录的名称。

文件
文件名，减去任何目录部分。

文件库
只是文件的基本名称，减去任何后缀和目录。

后缀
只是文件后缀。

绝对的
文件的绝对路径名。

POSIX
路径的 POSIX 形式，目录由 / （正斜杠）不是
反斜杠。 在 Windows 系统上，当路径引用
其他 (POSIX) 系统上的文件。

源路径
链接到此文件的源文件的目录和文件名
变体目录(). 如果这个文件没有链接，它只返回目录和文件名
不变。

源目录
包含链接到此文件的源文件的目录 变体目录(). 如果
此文件未链接，它仅返回文件名的目录部分。

资源路径
链接到此文件的源文件的目录和文件名
变体目录(). 如果该文件在本地不存在但存在于存储库中，则路径
在存储库中被返回。 如果这个文件没有链接，它只是返回
目录和文件名不变。

目录
包含链接到此文件的源文件的存储库目录
变体目录(). 如果这个文件没有链接，它只返回目录部分
文档名称。

例如，指定的目标将针对相应的修饰符展开如下：

$TARGET => sub/dir/file.x
${TARGET.base} => 子/目录/文件
${TARGET.dir} => 子/目录
${TARGET.file} => file.x
${TARGET.filebase} => 文件
${TARGET.suffix} => .x
${TARGET.abspath} => /top/dir/sub/dir/file.x

SConscript('src/SConscript', variant_dir='sub/dir')
$SOURCE => sub/dir/file.x
${SOURCE.srcpath} => src/file.x
${SOURCE.srcdir} => 源

存储库（'/usr/存储库'）
$SOURCE => sub/dir/file.x
${SOURCE.rsrcpath} => /usr/repository/src/file.x
${SOURCE.rsrcdir} => /usr/repository/src

请注意，花括号也可用于将任意 Python 代码括起来
评估。 （其实上面的修饰符就是这样代入的，简直就是
表示 TARGET、SOURCES 等的 Python 对象的属性）请参阅部分
下面的“Python 代码替换”，提供更详尽的示例，说明如何使用它。

最后，变量名可以是与结构关联的可调用 Python 函数
环境中的变量。 该函数应采用四个参数： 目标 - 的列表
目标节点， 资源 - 源节点列表， ENV - 施工环境，
for_signature - 一个布尔值，指定函数是否被调用
生成构建签名。 SCons 将插入被调用函数返回的任何内容
扩展字符串：

def foo（目标、源、环境、for_signature）：
返回“酒吧”

# 将 $BAR 扩展为“bar baz”
env=环境(FOO=foo, BAR="$FOO baz")

您可以使用此功能通过创建可调用对象将参数传递给 Python 函数
在一个对象中存储一个或多个参数，然后在调用时使用它们的类
__称呼__（） 方法被调用。 请注意，在这种情况下，整个变量扩展必须是
用大括号括起来，以便参数与实例化相关联
班级：

类 foo（对象）：
def __init__（自我，参数）：
self.arg = arg

def __call__(自身、目标、源、环境、for_signature):
返回 self.arg + "bar"

# 将 $BAR 扩展为“my argument bar baz”
env=Environment(FOO=foo, BAR="${FOO('my argument')} baz")

特殊伪变量 $( 和 $) 可用于包围命令行的部分
可能会改变 也完全不需要 导致重建——也就是说，这不包括在
使用此命令构建的目标文件的签名。 之间的所有文本 $( 和 $) 会
在将其添加到文件签名之前从命令行中删除，并且 $( 和 $)
将在执行命令之前被删除。 例如，命令行：

echo 上次构建发生在 $( $TODAY $). > $目标

将执行命令：

echo 上次构建发生在 $TODAY。 > $目标

但添加到任何目标文件的命令签名将是：

echo 最后一次构建发生。 > $目标

Python 代码 换人
其中的任何 python 代码 ${-} 对由 python 'eval' 和 python globals 评估
设置为当前环境的构造变量集。 所以在下面的情况下：

环境 ['COND'] = 0
env.Command('foo.out', 'foo.in',
'''echo ${COND==1 and 'FOO' or 'BAR'} > $TARGET''')

执行的命令将是

回声 FOO > foo.out

or

回声栏 > foo.out

根据命令执行时env['COND']的当前值。 评价
在构建目标时发生，而不是在读取 SConscript 时发生。 因此，如果
env['COND'] 稍后在 SConscript 中更改，将使用最终值。

这是一个更有趣的例子。 请注意，所有 COND、FOO 和 BAR 都是环境
变量，并将它们的值代入最终命令。 FOO 是一个列表，所以它
元素由空格分隔。

env=环境（）
环境 ['COND'] = 0
env['FOO'] = ['foo1', 'foo2']
env['BAR'] = 'barbar'
env.Command('foo.out', 'foo.in',
'echo ${COND==1 and FOO or BAR} > $TARGET')

# 会执行这个：
# echo foo1 foo2 > foo.out

SCons 在将构造变量转换为命令行时使用以下规则：

串
当值为字符串时，它被解释为空格分隔的命令行列表
参数。

列表
当该值是一个列表时，它被解释为一个命令行参数列表。 每个
列表的元素被转换为字符串。

其他
任何不是列表或字符串的内容都将转换为字符串并解释为
单个命令行参数。

新队
换行符 (\n) 分隔行。 换行符解析在所有其他之后完成
解析，因此参数（例如文件名）不可能包含嵌入的
换行符。 此限制可能会在 SCons 的未来版本中消失。

扫描器 对象
您可以使用 扫描器 定义对象以扫描新文件类型的隐式函数
依赖项。 这 扫描器 函数接受以下参数：

function
这可以是：1) 一个 Python 函数，它将处理节点（文件）并返回
文件节点列表，表示在中找到的隐式依赖项（文件名）
内容; 或者：2) 映射键的字典（通常是文件后缀，但见下文
更多讨论）到其他应该调用的扫描器。

如果参数实际上是 Python 函数，则该函数必须取三个或四个
参数：

def scanner_function（节点，环境，路径）：

def Scanner_function（节点，环境，路径，arg =无）：

这个 节点 参数是代表文件的内部 SCons 节点。 采用 海峡（节点） 至
获取文件的名称，以及 节点.get_contents() 获取文件的内容。
请注意，该文件是 而不去 保证在调用扫描器之前存在，所以
扫描仪功能应该检查扫描的文件是否有可能
不存在（例如，如果它是从其他文件构建的）。

这个 ENV 参数是扫描的构建环境。 从中获取值
使用 env.Dictionary() 方法。

这个 径 参数是可以搜索文件的目录的元组（或列表）。
这通常是 路径函数 论证（见下文）。

这个 ARG argument 是创建扫描器时提供的参数，如果有的话。

姓名
扫描程序的名称。 这主要用于内部识别Scanner。

论点
一个可选参数，如果指定，将传递给扫描仪函数
（如上所述）和路径函数（在下面指定）。

钥匙扣
一个可选列表，可用于确定应该使用哪个扫描仪
给定的节点。 在扫描文件名的通常情况下，此参数将是一个列表
此扫描程序知道如何扫描的不同文件类型的后缀。 如果
argument 是一个字符串，那么它会被当前环境扩展成一个列表。

路径函数
一个有四个或五个参数的 Python 函数：一个构造环境，一个
包含第一个目标所在的 SConscript 文件的目录的节点
已定义、目标节点列表、源节点列表和可选参数
创建扫描仪时提供。 这 路径函数 返回一个元组
可以搜索此 Scanner 对象要返回的文件的目录。
（请注意， 查找路径目录() 函数可以用来返回一个现成的
路径函数 对于给定的构造变量名称，而不必编写您的
从头开始拥有自己的功能。）

节点类
此 Scanner 对象应返回的节点类。 任何字符串或其他
扫描仪函数返回的不属于此类的对象将被运行
通过 节点工厂 功能。

节点工厂
一个 Python 函数，它将接受一个字符串或其他对象并将其转换为
此 Scanner 对象返回的适当的节点类。

扫描检查
一个可选的 Python 函数，它有两个参数，一个节点（文件）和一个构造
环境，并返回节点实际上是否应该被扫描
依赖项。 此检查可用于消除对扫描仪的不必要调用
例如，当 Node 表示的底层文件还没有
存在。

递归
一个可选标志，指定是否应在
扫描器返回的依赖文件。 当此标志未设置时，节点
子系统只会在被扫描的文件上调用扫描器，而不会（对于
示例）也在被扫描文件中的#include 行指定的文件上。
递归 可能是一个可调用函数，在这种情况下，它将用一个列表调用
找到节点并应返回应递归扫描的节点列表； 这个
可用于选择特定的节点子集进行额外扫描。

需要注意的是 烤饼 拥有全球 源文件扫描器 使用的对象 摆件（）
共享对象（）， 和 静态对象() 建设者决定应该使用哪个扫描仪
不同的文件扩展名。 您可以使用 SourceFileScanner.add_scanner 文件扫描器() 方法添加
你自己的 Scanner 对象到 烤饼 构建目标程序或
来自不同类型源文件列表的库：

def xyz_scan（节点，环境，路径）：
内容 = node.get_text_contents()
# 扫描内容并返回包含的文件。

XYZScanner = 扫描仪(xyz_scan)

SourceFileScanner.add_scanner('.xyz', XYZScanner)

env.Program('my_prog', ['file1.c', 'file2.f', 'file3.xyz'])

特定系统 行为

SCons 及其配置文件非常便携，主要是因为它在
Python。 然而，有一些可移植性问题等待着粗心的人。

.C 文件 后缀
SCons 处理大写 .C 文件后缀不同，取决于功能
底层系统。 在 Linux 或 UNIX 等区分大小写的系统上，SCons 将
带有一个文件 .C 后缀作为 C++ 源文件。 在 Windows 等不区分大小写的系统上，
SCons 将文件视为 .C 后缀为 C 源文件。

.F 文件 后缀
SCons 处理大写 .F 文件后缀不同，取决于功能
底层系统。 在 Linux 或 UNIX 等区分大小写的系统上，SCons 将
带有一个文件 .F 后缀作为要首先运行的 Fortran 源文件
标准 C 预处理器。 在 Windows 等不区分大小写的系统上，SCons 将文件
用 .F 后缀作为 Fortran 源文件，应该 而不去 通过C运行
预处理器。

Windows上： Cygwin的 工具 和 Cygwin的 Python 与 Windows 蟒蛇
Cygwin 提供了一组工具和实用程序，让用户可以在 Windows 系统上使用
更像 POSIX 的环境。 Cygwin 工具，包括 Cygwin Python，在
部分，通过共享解释类 UNIX 路径名的能力。 例如，Cygwin
工具会在内部将 Cygwin 路径名（如 /cygdrive/c/mydir）翻译成等效的
C:/mydir 的 Windows 路径名（等同于 C:\mydir）。

为本机 Windows 执行构建的 Python 版本，例如 python.org 和
ActiveState 版本没有 Cygwin 路径名语义。 这意味着使用
使用 Cygwin 工具（例如
gcc、bison 和 flex) 可能会产生不可预知的结果。 以这种方式“混搭”
可以工作，但需要特别注意路径名的使用
征兵文件。

在实践中，用户可以通过采用以下规则来回避这个问题： 当使用 gcc 时，
使用 Cygwin 提供的 Python 解释器来运行 SCons； 使用 Microsoft Visual C/C++ 时
（或其他一些 Windows 编译器）使用 python.org 或 ActiveState 版本的 Python 来
运行 SCons。

Windows上： scons.bat 文件
在 Windows 系统上，SCons 通过包装器执行 scons.bat 文件。 这有（至少）
两个后果：

一、想在命令行使用变量赋值的Windows命令行用户
可能必须在作业周围加上双引号：

scons "FOO=BAR" "BAZ=BLEH"

其次，Cygwin shell 无法将此文件识别为与 烤饼
在命令行提示符下发出的命令。 您可以通过执行来解决这个问题
scons.bat 从 Cygwin 命令行，或通过创建一个名为 烤饼
.

MinGW的
MinGW bin 目录必须在您的 PATH 环境变量或 PATH 变量中
在 SCons 的 ENV 构造变量下检测和使用 MinGW 工具。 什么时候
在本机 Windows Python 解释器下运行，SCons 将更喜欢 MinGW 工具
在 Cygwin 工具上，如果它们都安装了，不管 bin 的顺序
PATH 变量中的目录。 如果您同时安装了 MSVC 和 MinGW，并且您想要
要使用 MinGW 而不是 MSVC，则必须明确告诉 SCons 使用 MinGW，方法是传递

工具=['mingw']

到 Environment() 函数，因为 SCons 比 MinGW 更喜欢 MSVC 工具
工具。

示例

为了帮助您开始使用 SCons，本节简要概述了一些常见的
任务。

基础版 汇编 从 a 集成的 来源 文件
环境 = 环境（）
env.Program(target = 'foo', source = 'foo.c')

注意：通过将目标指定为参数（“scons foo”或“scons
foo.exe”）。或通过指定一个点（“scons.”）。

基础版 汇编 从 多 来源 档
环境 = 环境（）
env.Program(target = 'foo', source = Split('f1.c f2.c f3.c'))

设置 a 汇编 旗
环境 = 环境（CCFLAGS = '-g'）
env.Program(target = 'foo', source = 'foo.c')

搜索 这个 本地 目录 对于 .h 档
注意：你做 而不去 需要设置 CCFLAGS 以手动指定 -I 选项。 SCons 将构建
CPPPATH 中正确的 -I 选项。

env = 环境（CPPPATH = ['.']）
env.Program(target = 'foo', source = 'foo.c')

搜索 多 目录 对于 .h 档
env = 环境（CPPPATH = ['include1', 'include2']）
env.Program(target = 'foo', source = 'foo.c')

构建 a 静止 自学资料库
环境 = 环境（）
env.StaticLibrary(target = 'foo', source = Split('l1.c l2.c'))
env.StaticLibrary(target = 'bar', source = ['l3.c', 'l4.c'])

构建 a 共享 自学资料库
环境 = 环境（）
env.SharedLibrary(target = 'foo', source = ['l5.c', 'l6.c'])
env.SharedLibrary(target = 'bar', source = Split('l7.c l8.c'))

链接 a 本地 自学资料库 成 a 教学计划
env = Environment(LIBS = 'mylib', LIBPATH = ['.'])
env.Library(target = 'mylib', source = Split('l1.c l2.c'))
env.Program(target = 'prog', source = ['p1.c', 'p2.c'])

定义 您的 购买 生成器 摆件
请注意，当您调用 Builder 时，您可以省略目标文件后缀，并且
SCons 会自动添加它。

bld = Builder(action = 'pdftex < $SOURCES > $TARGET'
后缀 = '.pdf',
src_suffix = '.tex')
env = Environment(BUILDERS = {'PDFBuilder' : bld})
env.PDFBuilder(target = 'foo.pdf', source = 'foo.tex')

# 下面从“bar.tex”创建“bar.pdf”
env.PDFBuilder(target = 'bar', source = 'bar')

另请注意，上面的初始化会覆盖默认的 Builder 对象，因此
上面创建的环境不能调用 env.Program(), env.Object(),
env.StaticLibrary() 等

添加 您的 购买 生成器 摆件 至 an 环境
bld = Builder(action = 'pdftex < $SOURCES > $TARGET'
后缀 = '.pdf',
src_suffix = '.tex')
环境 = 环境（）
env.Append(BUILDERS = {'PDFBuilder' : bld})
env.PDFBuilder(target = 'foo.pdf', source = 'foo.tex')
env.Program(target = 'bar', source = 'bar.c')

您还可以使用其他 Pythonic 技术添加到 BUILDERS 构造变量中，
的条件，如

环境 = 环境（）
env['BUILDERS]['PDFBuilder'] = bld

定义 您的 购买 扫描器 摆件
以下示例显示了一个极其简单的扫描仪（ kfile_scan() 函数) 那
根本不使用搜索路径，只是返回任何文件中存在的文件名 包括
扫描文件中的行。 这将隐含地假设所有包含的文件都存在于
顶级目录：

汇入

include_re = re.compile(r'^include\s+(\S+)$', re.M)

def kfile_scan（节点、环境、路径、arg）：
内容 = node.get_text_contents()
包括 = include_re.findall（内容）
返回 env.File(包括)

kscan = 扫描仪(名称 = 'kfile',
函数 = kfile_scan,
参数 = 无，
skeys = ['.k'])
扫描仪 = Environment().Dictionary('SCANNERS')
env = 环境（扫描仪 = 扫描仪 + [kscan]）

env.Command('foo', 'foo.k', 'kprocess < $SOURCES > $TARGET')

bar_in = 文件('bar.in')
env.Command('bar', bar_in, 'kprocess $SOURCES > $TARGET')
bar_in.target_scanner = kscan

重要的是要注意，您必须从扫描中返回文件节点列表
函数，文件名的简单字符串是行不通的。 正如我们展示的例子
在这里，您可以使用 文件（） 您当前环境的功能以创建节点
从具有相对路径的一系列文件名中即时获取。

这是一个类似但更完整的示例，它搜索目录路径（指定
作为 我自己的路 构造变量）对于实际存在的文件：

汇入
导入操作系统
include_re = re.compile(r'^include\s+(\S+)$', re.M)

def my_scan（节点，环境，路径，arg）：
内容 = node.get_text_contents()
包括 = include_re.findall（内容）
如果包括 == []：
返回[]
结果= []
对于公司包括：
对于路径中的目录：
文件 = str(目录) + os.sep + inc
如果 os.path.exists（文件）：
结果.追加（文件）
打破
返回环境文件（结果）

扫描仪=扫描仪（名称='myscanner'，
功能=我的扫描，
参数 = 无，
skeys = ['.x'],
path_function = FindPathDirs('MYPATH')
)
扫描仪 = Environment().Dictionary('SCANNERS')
env = 环境（扫描仪 = 扫描仪 + [扫描仪]，
MYPATH = ['incs'])

env.Command('foo', 'foo.x', 'xprocess < $SOURCES > $TARGET')

这个 查找路径目录() 函数在前面的例子中使用返回一个函数（实际上是一个
可调用的 Python 对象），它将返回在 $我的路径
构造变量。 它让 SCons 检测文件 公司/foo.inc ， 即使 foo.x 包含
行 包括 富公司 只要。 如果您需要自定义搜索路径的派生方式，
你会提供你自己的 路径函数 创建 Scanner 对象时的参数，如
如下：

# MYPATH 是要在其中搜索文件的目录列表
def pf(env, dir, 目标, 源, arg):
top_dir = Dir('#').abspath
结果= []
如果环境中有“MYPATH”：
对于 env['MYPATH'] 中的 p：
结果.append(top_dir + os.sep + p)
返回结果

扫描仪=扫描仪（名称='myscanner'，
功能=我的扫描，
参数 = 无，
skeys = ['.x'],
路径函数 = pf
)

创造 a 分级 构建
请注意，子目录的 SConscript 文件中指定的文件名是相对于
那个子目录。

S构造：

环境 = 环境（）
env.Program(target = 'foo', source = 'foo.c')

SConscript('sub/SConscript')

子/S应征者：

环境 = 环境（）
# 从 sub/foo.c 构建 sub/foo
env.Program(target = 'foo', source = 'foo.c')

SConscript('目录/SConscript')

子/目录/SConscript：

环境 = 环境（）
# 从 sub/dir/foo.c 构建 sub/dir/foo
env.Program(target = 'foo', source = 'foo.c')

共享 变量 之间 新兵 档
您必须显式地共享要共享的 Export() 和 Import() 变量
征兵文件。

S构造：

环境 = 环境（）
env.Program(target = 'foo', source = 'foo.c')

出口（“环境”）
SConscript('子目录/SConscript')

子目录/SConscript：

导入（“环境”）
env.Program(target = 'foo', source = 'foo.c')

构建 多 变种 从 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 同 来源
使用 SConscript 函数的 variant_dir 关键字参数来建立一个或多个
给定源目录的单独变体构建目录树：

S构造：

cppdefines = ['FOO']
导出（“cpp定义”）
SConscript('src/SConscript', variant_dir='foo')

cppdefines = ['BAR']
导出（“cpp定义”）
SConscript('src/SConscript', variant_dir='bar')

源/SConscript：

导入（“cpp定义”）
env = 环境（CPPDEFINES = cppdefines）
env.Program(target = 'src', source = 'src.c')

注意使用 Export() 方法将“cppdefines”变量设置为不同的值
每次我们调用 SConscript 函数。

分级 构建 of 二 图书馆 链接 通过 a 教学计划
S构造：

env = 环境（LIBPATH = ['#libA', '#libB']）
出口（'环境'）
SConscript('libA/SConscript')
SConscript('libB/SConscript')
SConscript('主要/SConscript')

libA/S征兵：

导入（'env'）
env.Library('a', Split('a1.c a2.c a3.c'))

libB/S征兵：

导入（'env'）
env.Library('b', Split('b1.c b2.c b3.c'))

主要/S应征者：

导入（'env'）
e = env.Copy(LIBS = ['a', 'b'])
e.Program('foo', Split('m1.c m2.c m3.c'))

LIBPATH 目录中的“#”指定它们是相对于顶层的
目录，因此当它们在 Main/SConscript 中使用时，它们不会变成“Main/libA”。

仅为库名称指定 'a' 和 'b' 允许 SCons 附加适当的
当前平台的库前缀和后缀（例如，POSIX 上的“liba.a”
系统，'a.lib' 在 Windows 上）。

定制 结构 变量 ， 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 命令 线。
以下将允许在命令行或在
文件自定义.py。

vars = 变量('custom.py')
vars.Add('CC', 'C 编译器。')
环境=环境（变量=变量）
帮助（vars.GenerateHelpText（env））

用户可以在命令行指定 C 编译器：

scons“CC=my_cc”

或者在 custom.py 文件中：

抄送 = 'my_cc'

或获取有关选项的文档：

$ scons -h

CC：C 编译器。
默认值：无
实际：抄送

运用 Microsoft 视觉 C + +中 预编译 头
由于 windows.h 包含所有内容和厨房水槽，因此可能需要相当长的时间
一遍又一遍地编译一堆目标文件，所以微软提供了一个
一次编译一组标头然后包括先前编译的机制
任何目标文件中的标头。 这种技术称为预编译标头。 一般
配方是创建一个名为“StdAfx.cpp”的文件，其中包含一个名为
“StdAfx.h”，然后在“StdAfx.h”中包含您要预编译的每个标头，以及
最后将“StdAfx.h”作为您正在编译的所有源文件中的第一个标头
到目标文件。 例如：

标准Afx.h：

＃包括
＃包括

标准Afx.cpp：

＃包括

文件.cpp：

＃包括

/* 做一些事情 */

酒吧.cpp：

＃包括

/* 做一些其他的事情 */

S构造：

env=环境（）
env['PCHSTOP'] = 'StdAfx.h'
env['PCH'] = env.PCH('StdAfx.cpp')[0]
env.Program('MyApp', ['Foo.cpp', 'Bar.cpp'])

有关详细信息，请参阅 PCH 构建器以及 PCH 和 PCHSTOP 的文档
构造变量。 要了解预编译标头的详细信息，请参阅 MSDN
/Yc、/Yu 和 /Yp 的文档。

运用 Microsoft 视觉 C + +中 外部 调试 信息
由于在程序和共享库中包含调试信息会导致它们
大小显着增加，微软提供了一种机制，包括调试
称为 PDB 文件的外部文件中的信息。 SCons 通过以下方式支持 PDB 文件
PDB 构造变量。

S构造：

env=环境（）
env['PDB'] = 'MyApp.pdb'
env.Program('MyApp', ['Foo.cpp', 'Bar.cpp'])

有关详细信息，请参阅 PDB 构造变量的文档。

环境

SCONS_LIB_DIR
指定包含 SCons Python 模块目录的目录（例如
/home/aroach/scons-src-0.01/src/engine）。

旗帜
scons 使用的一串选项，除了传递给
命令行。

使用 onworks.net 服务在线使用 scons