def _load_build_file(source_dir, action_if_fail, processed_source_dirs, blade):
"""_load_build_file to load the BUILD and place the targets into database.
Invoked by _load_targets. Load and execute the BUILD
file, which is a Python script, in source_dir. Statements in BUILD
depends on global variable current_source_dir, and will register build
target/rules into global variables target_database. If path/BUILD
does NOT exsit, take action corresponding to action_if_fail. The
parameters processed_source_dirs refers to a set defined in the
caller and used to avoid duplicated execution of BUILD files.
"""
# Initialize the build_target at first time, to be used for BUILD file
# loaded by execfile
global build_target
if build_target is None:
build_target = TargetAttributes(blade.get_options())
build_rules.register_variable('build_target', build_target)
source_dir = os.path.normpath(source_dir)
# TODO(yiwang): the character '#' is a magic value.
if source_dir in processed_source_dirs or source_dir == '#':
return
processed_source_dirs.add(source_dir)
if not os.path.exists(source_dir):
_report_not_exist(source_dir, source_dir, blade)
old_current_source_path = blade.get_current_source_path()
blade.set_current_source_path(source_dir)
build_file = os.path.join(source_dir, 'BUILD')
if os.path.exists(build_file):
try:
from mm_env import SRC_DIR
from mm_env import OUT_DIR
from mm_env import BLADE_ROOT
from mm_env import WORK_DIR
# The magic here is that a BUILD file is a Python script,
# which can be loaded and executed by execfile().
build_rules.register_function(SRC_DIR)
execfile(build_file, build_rules.get_all(), None)
except SystemExit:
console.error_exit('%s: fatal error, exit...' % build_file)
except:
console.error_exit('Parse error in %s, exit...\n%s' %
(build_file, traceback.format_exc()))
else:
if action_if_fail == ABORT_IF_FAIL:
_report_not_exist(source_dir, build_file, blade)
blade.set_current_source_path(old_current_source_path)
(env_name, new_src_dir, new_src_dir))
self.java_jar_cmd_list.append(new_src_dir)
pack_list = []
classes_var_list = []
if self.java_jar_dep_source_list:
self._java_jar_rules_prepare_dep(new_src_dir)
self._java_jar_rules_compile_src(target_source_list, new_src_dir,
pack_list, classes_var_list)
self._java_jar_rules_make_jar(pack_list, classes_var_list)
def java_jar(name,
srcs=[],
deps=[],
prebuilt=False,
pre_build=False,
**kwargs):
"""Define java_jar target. """
target = JavaJarTarget(name, srcs, deps, prebuilt or pre_build,
blade.blade, kwargs)
if pre_build:
console.warning('//%s:%s: "pre_build" has been deprecated, '
'please use "prebuilt"' % (target.path, target.name))
blade.blade.register_target(target)
build_rules.register_function(java_jar)
srcs=[],
deps=[],
resources=[],
source_encoding=None,
warnings=None,
exclusions=[],
**kwargs):
"""Define scala_fat_library target. """
target = ScalaFatLibrary(name, srcs, deps, resources, source_encoding,
warnings, exclusions, kwargs)
blade.blade.register_target(target)
def scala_test(name,
srcs,
deps=[],
resources=[],
source_encoding=None,
warnings=None,
testdata=[],
**kwargs):
"""Define scala_test target. """
target = ScalaTest(name, srcs, deps, resources, source_encoding, warnings,
testdata, kwargs)
blade.blade.register_target(target)
build_rules.register_function(scala_library)
build_rules.register_function(scala_fat_library)
build_rules.register_function(scala_test)
always_optimize,
prebuilt or pre_build,
link_all_symbols,
deprecated,
extra_cppflags,
extra_linkflags,
blade.blade,
kwargs)
if pre_build:
console.warning("//%s:%s: 'pre_build' has been deprecated, "
"please use 'prebuilt'" % (target.path,
target.name))
blade.blade.register_target(target)
build_rules.register_function(cc_library)
class CcBinary(CcTarget):
"""A scons cc target subclass.
This class is derived from SconsCCTarget and it generates the cc_binary
rules according to user options.
"""
def __init__(self,
name,
srcs,
deps,
warning,
defs,
self._write_rule('%s = [%s]' % (self._objs_name(), ','.join(obj_names)))
self._write_rule('%s.Depends(%s, %s)' % (
env_name, self._objs_name(), sources))
self._cc_library()
options = self.blade.get_options()
if (getattr(options, 'generate_dynamic', False) or
self.data.get('build_dynamic')):
self._dynamic_cc_library()
def thrift_library(name,
srcs=[],
deps=[],
optimize=[],
deprecated=False,
**kwargs):
"""thrift_library target. """
thrift_library_target = ThriftLibrary(name,
srcs,
deps,
optimize,
deprecated,
blade.blade,
kwargs)
blade.blade.register_target(thrift_library_target)
build_rules.register_function(thrift_library)
self._java_jar_rules_compile_src(target_source_list,
new_src_dir,
pack_list,
classes_var_list)
self._java_jar_rules_make_jar(pack_list, classes_var_list)
def java_jar(name,
srcs=[],
deps=[],
prebuilt=False,
pre_build=False,
**kwargs):
"""Define java_jar target. """
target = JavaJarTarget(name,
srcs,
deps,
prebuilt or pre_build,
blade.blade,
kwargs)
if pre_build:
console.warning("//%s:%s: 'pre_build' has been deprecated, "
"please use 'prebuilt'" % (target.data['path'],
target.data['name']))
blade.blade.register_target(target)
build_rules.register_function(java_jar)
class JavaTest(JavaBinary):
"""JavaLibrary"""
def __init__(self, name, srcs, deps, **kwargs):
type = 'java_binary'
JavaTarget.__init__(self, name, type, srcs, deps, False, kwargs)
def java_library(name, srcs=[], deps=[], prebuilt=False, **kwargs):
"""Define java_jar target. """
target = JavaLibrary(name, srcs, deps, prebuilt, blade.blade, kwargs)
blade.blade.register_target(target)
def java_binary(name, srcs=[], deps=[], **kwargs):
"""Define java_jar target. """
target = JavaBinary(name, srcs, deps, blade.blade, kwargs)
blade.blade.register_target(target)
def java_test(name, srcs=[], deps=[], **kwargs):
"""Define java_jar target. """
target = JavaTest(name, srcs, deps, blade.blade, kwargs)
blade.blade.register_target(target)
build_rules.register_function(java_binary)
build_rules.register_function(java_library)
build_rules.register_function(java_test)
'proto',
inputs=self._source_file_path(src),
variables=vars)
cpp_headers.append(header)
names = self._proto_gen_file_names(src)
cpp_sources.append(names[1])
self._cc_objects_ninja(cpp_sources,
True,
generated_headers=cpp_headers)
self._cc_library_ninja()
self.ninja_proto_rules(self.blade.get_options(), plugin_flags)
def proto_library(name,
srcs=[],
deps=[],
optimize=[],
deprecated=False,
generate_descriptors=False,
plugins=[],
source_encoding='iso-8859-1',
**kwargs):
"""proto_library target. """
proto_library_target = ProtoLibrary(name, srcs, deps, optimize, deprecated,
generate_descriptors, plugins,
source_encoding, blade.blade, kwargs)
blade.blade.register_target(proto_library_target)
build_rules.register_function(proto_library)
srcs,
deps,
kwargs))
def go_binary(name,
srcs,
deps=[],
**kwargs):
blade.blade.register_target(GoBinary(name,
srcs,
deps,
kwargs))
def go_test(name,
srcs,
deps=[],
testdata=[],
**kwargs):
blade.blade.register_target(GoTest(name,
srcs,
deps,
testdata,
kwargs))
build_rules.register_function(go_library)
build_rules.register_function(go_binary)
build_rules.register_function(go_test)
vars = {
'entries' : ' '.join(entries),
'packageroot' : packageroot,
}
type = self.data['type']
rule = self.ninja_rule_from_package_type(type)
if type != 'zip':
vars['tarflags'] = self.tar_flags(type)
self.ninja_build(output, rule, inputs=package_sources, variables=vars)
def package(name,
srcs,
deps=[],
type='tar',
out=None,
shell=False,
**kwargs):
package_target = PackageTarget(name,
srcs,
deps,
type,
out,
shell,
blade.blade,
kwargs)
blade.blade.register_target(package_target)
build_rules.register_function(package)
# Each include in a BUILD file can only affect itself
__current_globles = None
# Include a defination file in a BUILD file
def include(name):
if name.startswith("//"):
dir = blade.blade.get_root_dir()
name = name[2:]
else:
dir = blade.blade.get_current_source_path()
execfile(os.path.join(dir, name), __current_globles, None)
build_rules.register_function(enable_if)
build_rules.register_function(glob)
build_rules.register_function(include)
IGNORE_IF_FAIL = 0
WARN_IF_FAIL = 1
ABORT_IF_FAIL = 2
def _load_build_file(source_dir, action_if_fail, processed_source_dirs, blade):
"""_load_build_file to load the BUILD and place the targets into database.
Invoked by _load_targets. Load and execute the BUILD
file, which is a Python script, in source_dir. Statements in BUILD
depends on global variable current_source_dir, and will register build
','.join(source_vars), ','.join(sorted(location_vars))))
package_type = self.data['type']
self._write_rule('%s.Append(PACKAGESUFFIX="%s")' % (env_name, package_type))
if package_path_list:
self._write_rule('%s.Depends(%s, %s.Value(%s))' % (
env_name, var_name, env_name, package_path_list))
locations = self.data['locations']
if locations:
self._write_rule('%s.Depends(%s, %s.Value("%s"))' % (
env_name, var_name, env_name, sorted(set(locations))))
def package(name,
srcs,
deps=[],
type='tar',
out=None,
**kwargs):
package_target = PackageTarget(name,
srcs,
deps,
type,
out,
blade.blade,
kwargs)
blade.blade.register_target(package_target)
build_rules.register_function(package)
# Each include in a BUILD file can only affect itself
__current_globles = None
# Include a defination file in a BUILD file
def include(name):
if name.startswith('//'):
dir = blade.blade.get_root_dir()
name = name[2:]
else:
dir = blade.blade.get_current_source_path()
execfile(os.path.join(dir, name), __current_globles, None)
build_rules.register_function(enable_if)
build_rules.register_function(glob)
build_rules.register_function(include)
def _load_build_file(source_dir, processed_source_dirs, blade):
"""Load the BUILD and place the targets into database.
Invoked by _load_targets. Load and execute the BUILD
file, which is a Python script, in source_dir. Statements in BUILD
depends on global variable current_source_dir, and will register build
target/rules into global variables target_database. Report error
and exit if path/BUILD does NOT exist.
The parameters processed_source_dirs refers to a set defined in the
caller and used to avoid duplicated execution of BUILD files.
def py_egg(name,
srcs=[],
deps=[],
prebuilt=False,
**kwargs):
"""python egg. """
target = PythonEgg(name,
srcs,
deps,
prebuilt,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(py_egg)
class PythonTarget(Target):
"""python target base class.
"""
def __init__(self,
name,
type,
srcs,
deps,
base,
visibility,
kwargs):
"""Init method. """
extra_linkflags=[],
**kwargs):
target = CuLibrary(name,
srcs,
deps,
warning,
defs,
incs,
extra_cppflags,
extra_linkflags,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(cu_library)
class CuBinary(CuTarget):
"""A scons cu target subclass
This class is derived from SconsCuTarget and it generates the cu_binary
rules according to user options.
"""
def __init__(self,
name,
srcs,
deps,
warning,
defs,
incs,
res_name = self._regular_variable_name(self.name)
res_file_name = res_name
res_file_header = res_file_name + '.h'
res_header_path = os.path.join(out_dir, res_file_header)
src_list = []
for src in self.srcs:
src_path = os.path.join(self.path, src)
src_list.append(src_path)
cmd_bld = '%s_header_cmd_bld' % res_name
self._write_rule('%s = %s.ResourceHeader("%s", %s)' %
(cmd_bld, env_name, res_header_path, src_list))
return (out_dir, res_file_name)
def resource_library(name,
srcs=[],
deps=[],
optimize=[],
extra_cppflags=[],
**kwargs):
"""scons_resource_library. """
target = ResourceLibrary(name, srcs, deps, optimize, extra_cppflags,
blade.blade, kwargs)
blade.blade.register_target(target)
build_rules.register_function(resource_library)
target_egg_file = '%s.egg' % self._target_file_path()
python_binary_var = '%s_python_binary_var' % (
self._generate_variable_name(self.path, self.name))
self._write_rule('%s = %s.PythonBinary(["%s"], %s)' % (
python_binary_var,
env_name,
target_egg_file,
binary_files))
for var in dep_var_list:
self._write_rule('%s.Depends(%s, %s)' % (
env_name, python_binary_var, var))
def py_binary(name,
srcs=[],
deps=[],
prebuilt=False,
**kwargs):
"""python binary - aka, python egg. """
target = PythonBinaryTarget(name,
srcs,
deps,
prebuilt,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(py_binary)
env_name,
yacc_cc_file,
yacc_cc_file))
self._write_rule('%s = [%s]' % (self._objs_name(), ','.join(obj_names)))
self._cc_library()
options = self.blade.get_options()
if (getattr(options, 'generate_dynamic', False) or
self.data.get('build_dynamic', False)):
self._dynamic_cc_library()
def lex_yacc_library(name,
srcs=[],
deps=[],
recursive=False,
prefix=None,
**kwargs):
"""lex_yacc_library. """
target = LexYaccLibrary(name,
srcs,
deps,
recursive,
prefix,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(lex_yacc_library)
def java_binary(name,
srcs=[],
deps=[],
**kwargs):
"""Define java_jar target. """
target = JavaBinary(name,
srcs,
deps,
blade.blade,
kwargs)
blade.blade.register_target(target)
def java_test(name,
srcs=[],
deps=[],
**kwargs):
"""Define java_jar target. """
target = JavaTest(name,
srcs,
deps,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(java_binary)
build_rules.register_function(java_library)
build_rules.register_function(java_test)
console.error_exit('failed to build //%s:%s, please install php modules' % (
self.path, self.name))
else:
self._swig_library_rules_php(dep_files_map)
def swig_library(name,
srcs=[],
deps=[],
warning='',
java_package='',
java_lib_packed=False,
optimize=[],
extra_swigflags=[],
**kwargs):
"""swig_library target. """
target = SwigLibrary(name,
srcs,
deps,
warning,
java_package,
java_lib_packed,
optimize,
extra_swigflags,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(swig_library)
python_binary_var = '%s_python_binary_var' % (self._var_name())
self._write_rule(
'%s = %s.PythonEgg(["%s"], %s)' %
(python_binary_var, env_name, target_egg_file, binary_files))
for var in dep_var_list:
self._write_rule('%s.Depends(%s, %s)' %
(env_name, python_binary_var, var))
def py_egg(name, srcs=[], deps=[], prebuilt=False, **kwargs):
"""python egg. """
target = PythonEgg(name, srcs, deps, prebuilt, blade.blade, kwargs)
blade.blade.register_target(target)
build_rules.register_function(py_egg)
class PythonTarget(Target):
"""python target base class.
"""
def __init__(self, name, type, srcs, deps, base, visibility, kwargs):
"""Init method. """
srcs = var_to_list(srcs)
deps = var_to_list(deps)
Target.__init__(self, name, type, srcs, deps, visibility, blade.blade,
kwargs)
if base:
console.error_exit('//%s not found, required by %s, exit...' % (path, depender))
else:
console.error_exit('//%s not found, exit...' % path)
def enable_if(cond, true_value, false_value=None):
"""A global function can be called in BUILD to filter srcs/deps by target"""
if cond:
ret = true_value
else:
ret = false_value
if ret is None:
ret = []
return ret
build_rules.register_function(enable_if)
IGNORE_IF_FAIL = 0
WARN_IF_FAIL = 1
ABORT_IF_FAIL = 2
def _load_build_file(source_dir, action_if_fail, processed_source_dirs, blade):
"""_load_build_file to load the BUILD and place the targets into database.
Invoked by _load_targets. Load and execute the BUILD
file, which is a Python script, in source_dir. Statements in BUILD
depends on global variable current_source_dir, and will register build
target/rules into global variables target_database. If path/BUILD
does NOT exsit, take action corresponding to action_if_fail. The
raise Exception('Failed to find package in %s' % path)
def go_target(name, deps=[], testdata=[]):
path = blade.blade.get_current_source_path()
srcs, tests = find_go_srcs(path)
if not srcs and not tests:
console.error_exit('Empty go sources in %s' % path)
if srcs:
main = False
for src in srcs:
package = extract_go_package(os.path.join(path, src))
if package == 'main':
main = True
break
if main:
go_binary(name=name, srcs=srcs, deps=deps)
else:
go_library(name=name, srcs=srcs, deps=deps)
if tests:
go_test(name='%s_test' % name,
srcs=tests,
deps=deps,
testdata=testdata)
build_rules.register_function(go_library)
build_rules.register_function(go_binary)
build_rules.register_function(go_test)
build_rules.register_function(go_target)
self._write_rule('%s = [%s]' % (self._objs_name(), ', '.join(obj_names)))
self._cc_library()
def lex_yacc_library(name,
srcs=[],
deps=[],
warning='yes',
defs=[],
incs=[],
allow_undefined=False,
recursive=False,
prefix=None,
**kwargs):
"""lex_yacc_library. """
target = LexYaccLibrary(name,
srcs,
deps,
warning,
defs,
incs,
allow_undefined,
recursive,
prefix,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(lex_yacc_library)
src_list = []
for src in self.srcs:
src_path = os.path.join(self.path, src)
src_list.append(src_path)
cmd_bld = '%s_header_cmd_bld' % res_name
self._write_rule('%s = %s.ResourceHeader("%s", %s)' % (
cmd_bld, env_name, res_header_path, src_list))
return (out_dir, res_file_name)
def resource_library(name,
srcs=[],
deps=[],
optimize=[],
extra_cppflags=[],
**kwargs):
"""scons_resource_library. """
target = ResourceLibrary(name,
srcs,
deps,
optimize,
extra_cppflags,
blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(resource_library)
'%s = %s.SharedObject(target="%s" + top_env["OBJSUFFIX"], '
'source="%s")' %
(obj_name, env_name, thrift_cpp_src, thrift_cpp_src))
sources.append(thrift_cpp_src)
self._write_rule('%s = [%s]' %
(self._objs_name(), ','.join(obj_names)))
self._write_rule('%s.Depends(%s, %s)' %
(env_name, self._objs_name(), sources))
self._cc_library()
options = self.blade.get_options()
if (getattr(options, 'generate_dynamic', False)
or self.data.get('build_dynamic')):
self._dynamic_cc_library()
def thrift_library(name,
srcs=[],
deps=[],
optimize=[],
deprecated=False,
**kwargs):
"""thrift_library target. """
thrift_library_target = ThriftLibrary(name, srcs, deps, optimize,
deprecated, blade.blade, kwargs)
blade.blade.register_target(thrift_library_target)
build_rules.register_function(thrift_library)
exclusions=[],
testdata=[],
target_under_test='',
**kwargs):
"""Define java_test target. """
target = JavaTest(name, srcs, deps, resources, source_encoding, warnings,
main_class, exclusions, testdata, target_under_test,
kwargs)
blade.blade.register_target(target)
def java_fat_library(name,
srcs=[],
deps=[],
resources=[],
source_encoding=None,
warnings=None,
exclusions=[],
**kwargs):
"""Define java_fat_library target. """
target = JavaFatLibrary(name, srcs, deps, resources, source_encoding,
warnings, exclusions, kwargs)
blade.blade.register_target(target)
build_rules.register_function(maven_jar)
build_rules.register_function(java_binary)
build_rules.register_function(java_library)
build_rules.register_function(java_test)
build_rules.register_function(java_fat_library)
def ninja_rules(self):
srcs = [self._source_file_path(s) for s in self.srcs]
output = self._target_file_path()
self.ninja_build(output, 'shelltest', inputs=srcs)
targets = self.blade.get_build_targets()
inputs, testdata = [], []
for key, type, dst in self.data['locations']:
path = targets[key]._get_target_file(type)
if not path:
console.warning('%s: Location %s %s is missing. Ignored.' %
(self.fullname, key, type))
else:
inputs.append(path)
if not dst:
testdata.append(os.path.basename(path))
else:
testdata.append(dst)
if inputs:
output = '%s.testdata' % self._target_file_path()
self.ninja_build(output,
'shelltestdata',
inputs=inputs,
variables={'testdata': ' '.join(testdata)})
def sh_test(name, srcs, deps=[], testdata=[], **kwargs):
blade.blade.register_target(ShellTest(name, srcs, deps, testdata, kwargs))
build_rules.register_function(sh_test)
build_targets = self.blade.get_build_targets()
deps = self.expanded_deps
lib_list = []
for lib in deps:
if not self._dep_is_library(lib):
continue
if (build_targets[lib].type == 'cc_library'
and not build_targets[lib].srcs):
continue
# system lib
if lib[0] == '#':
pass
else:
lib_name = self._generate_variable_name(
lib[0], lib[1], 'dynamic')
lib_list.append(lib_name)
return lib_list
def py_binary(name, srcs=[], deps=[], prebuilt=False, **kwargs):
"""python binary - aka, python egg. """
target = PythonBinaryTarget(name, srcs, deps, prebuilt, blade.blade,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(py_binary)
'%s = %s.SharedObject(target="%s" + top_env["OBJSUFFIX"], '
'source="%s")' % (obj_name, env_name, proto_src, proto_src)
)
sources.append(proto_src)
# *.o depends on *pb.cc
self._write_rule("%s = [%s]" % (self._objs_name(), ",".join(obj_names)))
self._write_rule("%s.Depends(%s, %s)" % (env_name, self._objs_name(), sources))
# pb.cc depends on other proto_library
for dep_name in self.deps:
dep = self.target_database[dep_name]
if not dep._generate_header_files():
continue
dep_var_name = self._generate_variable_name(dep.path, dep.name)
self._write_rule("%s.Depends(%s, %s)" % (self._env_name(), sources, dep_var_name))
self._cc_library()
options = self.blade.get_options()
if getattr(options, "generate_dynamic", False) or self.data.get("build_dynamic", False):
self._dynamic_cc_library()
def proto_library(name, srcs=[], deps=[], optimize=[], deprecated=False, **kwargs):
"""proto_library target. """
proto_library_target = ProtoLibrary(name, srcs, deps, optimize, deprecated, blade.blade, kwargs)
blade.blade.register_target(proto_library_target)
build_rules.register_function(proto_library)
source_encoding,
warnings,
exclusions,
kwargs)
blade.blade.register_target(target)
def scala_test(name,
srcs,
deps=[],
resources=[],
source_encoding=None,
warnings=None,
testdata=[],
**kwargs):
"""Define scala_test target. """
target = ScalaTest(name,
srcs,
deps,
resources,
source_encoding,
warnings,
testdata,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(scala_library)
build_rules.register_function(scala_fat_library)
build_rules.register_function(scala_test)
# TODO(phongchen): add Target.get_all_vars
dep_var_list = []
dep_skip_list = ['system_library', 'prebuilt_cc_library']
for i in self.expanded_deps:
dep = targets[i]
if dep.type in dep_skip_list:
continue
if dep.type == 'swig_library':
dep_var_name = dep._var_name('dynamic_py')
dep_var_list.append(dep_var_name)
dep_var_name = dep._var_name('dynamic_java')
dep_var_list.append(dep_var_name)
else:
dep_var_list += dep._get_target_vars()
for dep_var_name in dep_var_list:
self._write_rule('%s.Depends(%s, %s)' %
(env_name, var_name, dep_var_name))
def gen_rule(name, srcs=[], deps=[], outs=[], cmd='', **kwargs):
"""scons_gen_rule. """
gen_rule_target = GenRuleTarget(name, srcs, deps, outs, cmd, blade.blade,
kwargs)
blade.blade.register_target(gen_rule_target)
build_rules.register_function(gen_rule)
'source = [%s])' % (
var_name, env_name,
self._target_file_path(),
', '.join(sources)))
def scons_rules(self):
self._clone_env()
env_name = self._env_name()
var_name = self._var_name()
srcs = [self._source_file_path(s) for s in self.srcs]
self._write_rule('%s = %s.ShellTest(target = "%s", source = %s)' % (
var_name, env_name,
self._target_file_path(), srcs))
self._generate_test_data_rules()
def sh_test(name,
srcs,
deps=[],
testdata=[],
**kwargs):
blade.blade.register_target(ShellTest(name,
srcs,
deps,
testdata,
kwargs))
build_rules.register_function(sh_test)
def cu_library(name,
srcs=[],
deps=[],
warning='yes',
defs=[],
incs=[],
extra_cppflags=[],
extra_linkflags=[],
**kwargs):
target = CuLibrary(name, srcs, deps, warning, defs, incs, extra_cppflags,
extra_linkflags, blade.blade, kwargs)
blade.blade.register_target(target)
build_rules.register_function(cu_library)
class CuBinary(CuTarget):
"""A scons cu target subclass
This class is derived from SconsCuTarget and it generates the cu_binary
rules according to user options.
"""
def __init__(self, name, srcs, deps, warning, defs, incs, extra_cppflags,
extra_linkflags, blade, kwargs):
type = 'cu_binary'
CuTarget.__init__(self, name, type, srcs, deps, warning, defs, incs,
extra_cppflags, extra_linkflags, blade, kwargs)
def _cc_binary(self):
dep_var_list += dep_target.data.get('java_jars', [])
else:
dep_var_name = self._generate_variable_name(
dep_target.path, dep_target.name)
dep_var_list.append(dep_var_name)
for dep_var_name in dep_var_list:
self._write_rule('%s.Depends(%s, %s)' % (env_name,
var_name,
dep_var_name))
def gen_rule(name,
srcs=[],
deps=[],
outs=[],
cmd='',
**kwargs):
"""scons_gen_rule. """
gen_rule_target = GenRuleTarget(name,
srcs,
deps,
outs,
cmd,
blade.blade,
kwargs)
blade.blade.register_target(gen_rule_target)
build_rules.register_function(gen_rule)
always_optimize,
prebuilt or pre_build,
link_all_symbols,
deprecated,
extra_cppflags,
extra_linkflags,
blade.blade,
kwargs)
if pre_build:
console.warning("//%s:%s: 'pre_build' has been deprecated, "
"please use 'prebuilt'" % (target.path,
target.name))
blade.blade.register_target(target)
build_rules.register_function(cc_library)
class CcBinary(CcTarget):
"""A scons cc target subclass.
This class is derived from SconsCCTarget and it generates the cc_binary
rules according to user options.
"""
def __init__(self,
name,
srcs,
deps,
warning,
defs,
target_under_test,
kwargs)
blade.blade.register_target(target)
def java_fat_library(name,
srcs=[],
deps=[],
resources=[],
source_encoding=None,
warnings=None,
exclusions=[],
**kwargs):
"""Define java_fat_library target. """
target = JavaFatLibrary(name,
srcs,
deps,
resources,
source_encoding,
warnings,
exclusions,
kwargs)
blade.blade.register_target(target)
build_rules.register_function(maven_jar)
build_rules.register_function(java_binary)
build_rules.register_function(java_library)
build_rules.register_function(java_test)
build_rules.register_function(java_fat_library)
else:
console.error_exit('//%s not found, exit...' % path)
def enable_if(cond, true_value, false_value=None):
"""A global function can be called in BUILD to filter srcs/deps by target"""
if cond:
ret = true_value
else:
ret = false_value
if ret is None:
ret = []
return ret
build_rules.register_function(enable_if)
IGNORE_IF_FAIL = 0
WARN_IF_FAIL = 1
ABORT_IF_FAIL = 2
def _load_build_file(source_dir, action_if_fail, processed_source_dirs, blade):
"""_load_build_file to load the BUILD and place the targets into database.
Invoked by _load_targets. Load and execute the BUILD
file, which is a Python script, in source_dir. Statements in BUILD
depends on global variable current_source_dir, and will register build
target/rules into global variables target_database. If path/BUILD
does NOT exsit, take action corresponding to action_if_fail. The
parameters processed_source_dirs refers to a set defined in the
raise Exception('Failed to find package in %s' % path)
def go_package(name, deps=[], testdata=[]):
path = blade.blade.get_current_source_path()
srcs, tests = find_go_srcs(path)
if not srcs and not tests:
console.error_exit('Empty go sources in %s' % path)
if srcs:
main = False
for src in srcs:
package = extract_go_package(os.path.join(path, src))
if package == 'main':
main = True
break
if main:
go_binary(name=name, srcs=srcs, deps=deps)
else:
go_library(name=name, srcs=srcs, deps=deps)
if tests:
go_test(name='%s_test' % name,
srcs=tests,
deps=deps,
testdata=testdata)
build_rules.register_function(go_library)
build_rules.register_function(go_binary)
build_rules.register_function(go_test)
build_rules.register_function(go_package)
