def test__CMAKE_CMDLINE_MACROS_local_only(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMDLINE_MACROS_local_only")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMDLINE_MACROS(macros={"macro1": "value1", "macro2": "value2"}, flags=CMAKE_BUILDINFO_LOCAL)'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.failUnless("-Dmacro1=value1" in find_cmake_output_builder(
package.rootbuilder()).local_cmakelists().get_definitions())
self.failUnless("-Dmacro2=value2" in find_cmake_output_builder(
package.rootbuilder()).local_cmakelists().get_definitions())
for buildinfo in package.rootbuilder().iter_buildinfos():
self.failIf(
isinstance(buildinfo, BuildInfo_CommandlineMacros_CMake))
pass
pass
def test__CMAKE_CMAKELISTS_ADD_INCLUDE_local_only(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMAKELISTS_ADD_INCLUDE_local_only")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_INCLUDE("include1", CMAKE_BUILDINFO_LOCAL)',
'CMAKE_CMAKELISTS_ADD_INCLUDE("include2", CMAKE_BUILDINFO_LOCAL)'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.failUnless('include1' in find_cmake_output_builder(
package.rootbuilder()).top_cmakelists().get_includes())
self.failUnless('include2' in find_cmake_output_builder(
package.rootbuilder()).top_cmakelists().get_includes())
for buildinfo in package.rootbuilder().iter_buildinfos():
self.failIf(
isinstance(buildinfo, BuildInfo_Toplevel_CMakeLists_Include))
pass
pass
def setUp(self):
fs = FileSystem(path=[], rootdirectory=intra_package.make_source_tree())
self.__package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(), ExplicitCSetup(), CMakeSetup()])
self.__package.boil(external_nodes=[])
self.__package.output()
self.__lo_output_builder = find_cmake_output_builder(self.__package.rootbuilder().find_entry_builder(['lo']))
self.__hi_output_builder = find_cmake_output_builder(self.__package.rootbuilder().find_entry_builder(['hi']))
self.__exe_output_builder = find_cmake_output_builder(self.__package.rootbuilder().find_entry_builder(['exe']))
pass
def test__CMAKE_CMAKELISTS_ADD_FIND_CALL_propagate_and_local(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMAKELISTS_ADD_FIND_CALL_propagate_and_local")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_FIND_CALL("call", (CMAKE_BUILDINFO_PROPAGATE, CMAKE_BUILDINFO_LOCAL))'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.failUnless('call' in find_cmake_output_builder(
package.rootbuilder()).top_cmakelists().get_find_calls())
for buildinfo in package.rootbuilder().iter_buildinfos():
if isinstance(buildinfo, BuildInfo_Toplevel_CMakeLists_FindCall):
break
pass
else:
self.fail()
pass
pass
def test(self):
output_builder = find_cmake_output_builder(
self.__hi_package_local.rootbuilder())
# hi uses two installed packages. nothing interesting with the
# includes. we need only one path, pointing to the installed
# include directory.
include_directories = output_builder.local_cmakelists(
).get_include_directories()
self.failUnlessEqual(len(include_directories), 2)
self.failUnlessEqual(include_directories[1],
'${CMAKE_INSTALL_PREFIX}/include')
# boring with the library path as well.
link_directories = output_builder.local_cmakelists(
).get_link_directories()
self.failUnlessEqual(len(link_directories), 1)
self.failUnlessEqual(link_directories[0],
'${CMAKE_INSTALL_PREFIX}/lib')
# more fun with the libraries.
exe_target_link_libraries = output_builder.local_cmakelists(
).get_target_link_libraries('exe')
self.failUnlessEqual(exe_target_link_libraries, ['mid', 'lo'])
pass
def test__CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY_local(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY_local")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(name=const.CONFIX2_DIR,
entry=File(lines=['DIRECTORY(["subdir"])']))
subdir = fs.rootdirectory().add(name='subdir', entry=Directory())
subdir.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY("include-directory", CMAKE_BUILDINFO_LOCAL)'
]))
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
cmake_output_builder = find_cmake_output_builder(
package.rootbuilder().find_entry_builder(['subdir']))
self.failUnless('include-directory' in cmake_output_builder.
local_cmakelists().get_include_directories())
pass
def test__basic(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("HierarchyInMemoryTest.basic")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'DIRECTORY(["directory0"])', 'DIRECTORY(["directory1"])'
]))
fs.rootdirectory().add(name='directory0', entry=Directory())
fs.rootdirectory().add(name='directory1', entry=Directory())
package = LocalPackage(rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
cmake_output_builder = find_cmake_output_builder(package.rootbuilder())
self.failUnlessEqual(
len(cmake_output_builder.local_cmakelists().get_subdirectories()),
2
# plus the admin stuff, confix-admin/cmake/Modules
+ 4)
self.failUnless('directory0' in cmake_output_builder.local_cmakelists(
).get_subdirectories())
self.failUnless('directory1' in cmake_output_builder.local_cmakelists(
).get_subdirectories())
pass
def output(self):
super(HeaderGenerator, self).output()
cmake_output = find_cmake_output_builder(self.parentbuilder())
cmake_output.local_cmakelists().add_custom_command__output(
outputs=['generated-header.h'],
commands=[('echo', ['generating generated-header.h']),
('touch', ['generated-header.h'])],
depends=[])
pass
def test(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('ExternalLibraryTest')",
"PACKAGE_VERSION('1.2.3')"
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(
lines=["DIRECTORY(['external'])", "DIRECTORY(['linked'])"]))
external = fs.rootdirectory().add(name='external', entry=Directory())
external.add(name=const.CONFIX2_DIR,
entry=File(lines=[
"PROVIDE_SYMBOL('the-external-library')",
"CMAKE_EXTERNAL_LIBRARY(",
" cflags=['my-cflag1', 'my-cflag2'],",
" cxxflags=['my-cxxflag1', 'my-cxxflag2'])",
]))
linked = fs.rootdirectory().add(name='linked', entry=Directory())
linked.add(name=const.CONFIX2_DIR,
entry=File(lines=[
"REQUIRE_SYMBOL('the-external-library', URGENCY_ERROR)",
"EXECUTABLE(center=C(filename='main.c'))"
]))
linked.add(name='main.c', entry=File(lines=["int main(void) {}"]))
package = LocalPackage(
rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
ExplicitCSetup(),
CMakeSetup()])
package.boil(external_nodes=[])
package.output()
linked_cmake_output_builder = find_cmake_output_builder(
package.rootbuilder().find_entry_builder(['linked']))
self.failUnless('my-cflag1' in linked_cmake_output_builder.
local_cmakelists().get_definitions())
self.failUnless('my-cflag2' in linked_cmake_output_builder.
local_cmakelists().get_definitions())
self.failUnless('my-cxxflag1' in linked_cmake_output_builder.
local_cmakelists().get_definitions())
self.failUnless('my-cxxflag2' in linked_cmake_output_builder.
local_cmakelists().get_definitions())
pass
def setUp(self):
rootdirectory = Directory()
rootdirectory.add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("package-name")', 'PACKAGE_VERSION("1.2.3")'
]))
rootdirectory.add(name=const.CONFIX2_DIR, entry=File())
package = LocalPackage(rootdirectory=rootdirectory,
setups=[CMakeSetup()])
package.boil(external_nodes=[])
package.output()
self.__cmakelists = find_cmake_output_builder(
package.rootbuilder()).top_cmakelists()
pass
def test__CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY_propagate(self):
fs = FileSystem(path=[''])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
'PACKAGE_NAME("test_CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY_propagate")',
'PACKAGE_VERSION("1.2.3")'
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(
lines=['DIRECTORY(["sender"])', 'DIRECTORY(["receiver"])']))
sender = fs.rootdirectory().add(name='sender', entry=Directory())
sender.add(
name=const.CONFIX2_DIR,
entry=File(lines=[
'PROVIDE_SYMBOL("sender")',
'CMAKE_CMAKELISTS_ADD_INCLUDE_DIRECTORY("include-directory", CMAKE_BUILDINFO_PROPAGATE)'
]))
receiver = fs.rootdirectory().add(name='receiver', entry=Directory())
receiver.add(name=const.CONFIX2_DIR,
entry=File(lines=[
'REQUIRE_SYMBOL("sender", URGENCY_ERROR)',
'C(filename="file.c")'
]))
# need a compiled file builder in order for the include path
# to show up in the CMakeLists.txt.
receiver.add(name='file.c', entry=File())
package = LocalPackage(
rootdirectory=fs.rootdirectory(),
setups=[Boilerplate(),
C(), CMake(library_dependencies=False)])
package.boil(external_nodes=[])
package.output()
cmake_output_builder = find_cmake_output_builder(
package.rootbuilder().find_entry_builder(['receiver']))
self.failUnless('include-directory' in cmake_output_builder.
local_cmakelists().get_include_directories())
pass
def output(self):
super(LibraryDependenciesBuilder, self).output()
cmake_output_builder = find_cmake_output_builder(self.parentbuilder())
found_exe = False
for exe in self.parentbuilder().iter_builders():
if not isinstance(exe, ExecutableBuilder):
continue
found_exe = True
for bi in exe.topo_libraries():
if isinstance(bi, BuildInfo_CLibrary_NativeInstalled):
cmake_output_builder.top_cmakelists().add_find_call(
'ConfixFindNativeInstalledLibrary(' + bi.basename() +
' ' + exe.exename() + ')')
cmake_output_builder.local_cmakelists(
).tighten_target_link_library(target=exe.exename(),
basename=bi.basename(),
tightened='${' +
bi.basename() + '_LIBRARY}')
pass
pass
pass
pass
def output(self):
super(CompiledOutputBuilder, self).output()
have_compiled = False
native_local_include_dirs = []
native_local_include_dirs_set = set()
using_locally_installed_headers = False
using_public_native_installed_headers = False
for compiled_builder in self.parentbuilder().iter_builders():
if not isinstance(compiled_builder, CompiledCBuilder):
continue
have_compiled = True
for include_directory in compiled_builder.native_local_include_dirs(
):
slashed_incdir = '/'.join(include_directory)
if slashed_incdir in native_local_include_dirs_set:
continue
native_local_include_dirs.append(slashed_incdir)
native_local_include_dirs_set.add(slashed_incdir)
pass
if compiled_builder.have_locally_installed_includes():
using_locally_installed_headers = True
pass
if compiled_builder.using_native_installed():
using_public_native_installed_headers = True
pass
pass
# no need to write out anything if we don't compile anything.
if not have_compiled:
return
cmake_output_builder = find_cmake_output_builder(self.parentbuilder())
# add the associated binary directory of the current source
# directory, in case there are generated headers.
cmake_output_builder.local_cmakelists().add_include_directory(
'${CMAKE_CURRENT_BINARY_DIR}')
# header files from directories in the local package, other
# than the directory being compiled: in addition to the source
# directory, add the associated build directory in case it
# contains generated headers.
for dir in native_local_include_dirs:
cmake_output_builder.local_cmakelists().add_include_directory(
'${' + self.package().name() + '_BINARY_DIR}/' + dir)
cmake_output_builder.local_cmakelists().add_include_directory(
'${' + self.package().name() + '_SOURCE_DIR}/' + dir)
pass
# if we have locally installed headers, add the
# 'confix-include' directory to the include path.
if using_locally_installed_headers:
cmake_output_builder.local_cmakelists().add_include_directory(
'${PROJECT_BINARY_DIR}/' + const.LOCAL_INCLUDE_DIR)
pass
# finding installed headers if need be. use our good old
# prefix/include and readonly prefixes.
if using_public_native_installed_headers:
cmake_output_builder.local_cmakelists().add_include_directory(
'${CMAKE_INSTALL_PREFIX}/include')
cmake_output_builder.local_cmakelists().add_include_directory(
directory=[
'FOREACH(dir ${READONLY_PREFIXES})',
' INCLUDE_DIRECTORIES(${dir}/include)',
'ENDFOREACH(dir)',
],
literally=True)
pass
# include paths contributed by external library definitions.
for p in self.__external_incpath:
for item in p:
cmake_output_builder.local_cmakelists().add_include_directory(
item)
pass
pass
# commandline macros floating in by external library
# definitions.
for macro, value in self.__external_cmdlinemacros.iteritems():
if value is None:
definition = '-D%s' % macro
else:
definition = '-D%s=%s' % (macro, value)
pass
cmake_output_builder.local_cmakelists().add_definitions(
[definition])
pass
# cflags and cxxflags, likewise
cmake_output_builder.local_cmakelists().add_definitions(
self.__external_cflags)
cmake_output_builder.local_cmakelists().add_definitions(
self.__external_cxxflags)
pass
def test(self):
fs = FileSystem(path=[])
source = fs.rootdirectory().add(
name='source',
entry=Directory())
# external definitions
if True:
externals = source.add(
name='externals',
entry=Directory())
externals.add(
name=const.CONFIX2_PKG,
entry=File(lines=["PACKAGE_NAME('ext1')",
"PACKAGE_VERSION('1.2.3')"]))
externals.add(
name=const.CONFIX2_DIR,
entry=File(lines=["DIRECTORY(['ext1'])",
"DIRECTORY(['ext2'])"]))
ext1 = externals.add(
name='ext1',
entry=Directory())
ext1.add(
name=const.CONFIX2_DIR,
entry=File(lines=["PROVIDE_SYMBOL('ext1')",
"CMAKE_EXTERNAL_LIBRARY(",
" incpath=['ext1-incpath1', 'ext1-incpath2'],",
" libpath=['ext1-libpath1', 'ext1-libpath2'],",
" libs=['ext1-lib1', 'ext1-lib2'],",
" cmdlinemacros={'ext1-macro1': 'ext1-value1', 'ext1-macro2': None})"
]))
ext2 = externals.add(
name='ext2',
entry=Directory())
ext2.add(
name=const.CONFIX2_DIR,
entry=File(lines=["REQUIRE_SYMBOL('ext1', URGENCY_ERROR)",
"PROVIDE_SYMBOL('ext2')",
"CMAKE_EXTERNAL_LIBRARY(",
" incpath=['ext2-incpath1', 'ext2-incpath2'],",
" libpath=['ext2-libpath1', 'ext2-libpath2'],",
" libs=['ext2-lib1', 'ext2-lib2'],",
" cmdlinemacros={'ext2-macro1': 'ext2-value1', 'ext2-macro2': None})"
]))
externals_package = LocalPackage(rootdirectory=externals,
setups=[ExplicitDirectorySetup(), ExplicitCSetup(), CMakeSetup()])
externals_package.boil(external_nodes=[])
externals_package.output()
externals_installed = externals_package.install()
pass
# native package #1
if True:
native1 = source.add(
name='native1',
entry=Directory())
native1.add(
name=const.CONFIX2_PKG,
entry=File(lines=["PACKAGE_NAME('native1')",
"PACKAGE_VERSION('1.2.3')"]))
native1.add(
name=const.CONFIX2_DIR,
entry=File(lines=["REQUIRE_SYMBOL('ext2', URGENCY_ERROR)",
"PROVIDE_SYMBOL('native1')",
"LIBRARY(basename='native1', members=[H(filename='native1.h'), C(filename='native1.c')])"]))
native1.add(
name='native1.h',
entry=File())
native1.add(
name='native1.c',
entry=File())
native1_package = LocalPackage(rootdirectory=native1,
setups=[ExplicitDirectorySetup(), ExplicitCSetup(), CMakeSetup()])
native1_package.boil(external_nodes=externals_installed.nodes())
native1_installed = native1_package.install()
pass
# native package #2
if True:
native2 = source.add(
name='native2',
entry=Directory())
native2.add(
name=const.CONFIX2_PKG,
entry=File(lines=["PACKAGE_NAME('native2')",
"PACKAGE_VERSION('1.2.3')"]))
native2.add(
name=const.CONFIX2_DIR,
entry=File(lines=["REQUIRE_SYMBOL('native1', URGENCY_ERROR)",
"PROVIDE_SYMBOL('native2')",
"LIBRARY(basename='native2', members=[H(filename='native2.h'), C(filename='native2.c')])"]))
native2.add(
name='native2.h',
entry=File())
native2.add(
name='native2.c',
entry=File())
native2_package = LocalPackage(rootdirectory=native2,
setups=[ExplicitDirectorySetup(), ExplicitCSetup(), CMakeSetup()])
native2_package.boil(external_nodes=externals_installed.nodes()+native1_installed.nodes())
native2_installed = native2_package.install()
pass
# final package
if True:
final = source.add(
name='final',
entry=Directory())
final.add(
name=const.CONFIX2_PKG,
entry=File(lines=["PACKAGE_NAME('final')",
"PACKAGE_VERSION('1.2.3')"]))
final.add(
name=const.CONFIX2_DIR,
entry=File(lines=["DIRECTORY(['local1'])",
"DIRECTORY(['local2'])",
"DIRECTORY(['bin'])"]))
local1 = final.add(
name='local1',
entry=Directory())
local1.add(
name=const.CONFIX2_DIR,
entry=File(lines=["REQUIRE_SYMBOL('native2', URGENCY_ERROR)",
"PROVIDE_SYMBOL('local1')",
"LIBRARY(basename='local1', members=[H(filename='local1.h'), C(filename='local1.c')])"]))
local1.add(
name='local1.h',
entry=File())
local1.add(
name='local1.c',
entry=File())
local2 = final.add(
name='local2',
entry=Directory())
local2.add(
name=const.CONFIX2_DIR,
entry=File(lines=["REQUIRE_SYMBOL('local1', URGENCY_ERROR)",
"PROVIDE_SYMBOL('local2')",
"LIBRARY(basename='local2', members=[H(filename='local2.h'), C(filename='local2.c')])"]))
local2.add(
name='local2.h',
entry=File())
local2.add(
name='local2.c',
entry=File())
bin = final.add(
name='bin',
entry=Directory())
bin.add(
name=const.CONFIX2_DIR,
entry=File(lines=["REQUIRE_SYMBOL('local2', URGENCY_ERROR)",
"EXECUTABLE(exename='exe', center=C(filename='main.c'))"]))
bin.add(
name='main.c',
entry=File())
final_package = LocalPackage(rootdirectory=final,
setups=[ExplicitDirectorySetup(), ExplicitCSetup(), CMakeSetup()])
final_package.boil(external_nodes=externals_installed.nodes()+native1_installed.nodes()+native2_installed.nodes())
final_package.output()
pass
cmake_output_builder = find_cmake_output_builder(final_package.rootbuilder().find_entry_builder(['bin']))
self.failUnlessEqual(cmake_output_builder.local_cmakelists().get_include_directories(),
['${CMAKE_CURRENT_BINARY_DIR}',
'${final_BINARY_DIR}/local2',
'${final_SOURCE_DIR}/local2',
'${final_BINARY_DIR}/local1',
'${final_SOURCE_DIR}/local1',
'${CMAKE_INSTALL_PREFIX}/include',
'ext2-incpath1', 'ext2-incpath2',
'ext1-incpath1', 'ext1-incpath2'])
self.failUnlessEqual(cmake_output_builder.local_cmakelists().get_link_directories(),
['${CMAKE_INSTALL_PREFIX}/lib',
'ext2-libpath1', 'ext2-libpath2',
'ext1-libpath1', 'ext1-libpath2'])
self.failUnlessEqual(cmake_output_builder.local_cmakelists().get_target_link_libraries('exe'),
['local2', 'local1', 'native2', 'native1',
'ext2-lib1', 'ext2-lib2', 'ext1-lib1', 'ext1-lib2'])
pass
def output(self):
super(HeaderOutputBuilder, self).output()
cmake_output_builder = find_cmake_output_builder(self.parentbuilder())
for header in self.parentbuilder().iter_builders():
if not isinstance(header, HeaderBuilder):
continue
# cmake makes a difference between files that have been
# generated in the build directory and regular ones from
# the source directory. we use the FileState.VIRTUAL as a
# heuristic, until we find a better way.
generated = header.file().state() is FileState.VIRTUAL
# install headers that want this.
if header.public():
if generated:
path = '${CMAKE_CURRENT_BINARY_DIR}/' + header.file().name(
)
else:
path = header.file().name()
pass
cmake_output_builder.local_cmakelists().add_install__files(
files=[path],
destination='/'.join(['include'] + header.visibility()))
pass
# local install
if header.package_visibility_action(
)[0] == HeaderBuilder.LOCALVISIBILITY_INSTALL:
destdir = '/'.join(
['${PROJECT_BINARY_DIR}', 'confix-include'] +
header.package_visibility_action()[1])
destfile = destdir + '/' + header.file().name()
destfile_all_target = '.'.join(
['confix-local-install'] +
header.package_visibility_action()[1] +
[header.file().name()])
if generated:
sourcefile = '${CMAKE_CURRENT_BINARY_DIR}/' + header.file(
).name()
else:
sourcefile = '${CMAKE_CURRENT_SOURCE_DIR}/' + header.file(
).name()
pass
# create rule for the header local install
cmake_output_builder.local_cmakelists(
).add_custom_command__output(
outputs=[destfile],
commands=[
('${CMAKE_COMMAND} -E make_directory ' + destdir, []),
('${CMAKE_COMMAND} -E copy ' + sourcefile + ' ' +
destfile, []),
],
depends=[sourcefile],
)
# hook header local install to the 'all' target.
cmake_output_builder.local_cmakelists().add_custom_target(
name=destfile_all_target, all=True, depends=[destfile])
pass
elif header.package_visibility_action(
)[0] is HeaderBuilder.LOCALVISIBILITY_DIRECT_INCLUDE:
pass
else:
assert False, package_visibility_action[0]
pass
pass
pass
def output(self):
super(LinkedOutputBuilder, self).output()
cmake_output_builder = find_cmake_output_builder(self.parentbuilder())
for linked in self.parentbuilder().iter_builders():
if not isinstance(linked, LinkedBuilder):
continue
# add the linked entity.
if True:
members = []
for member in linked.members():
if member.file().state() == FileState.VIRTUAL:
members.append('${CMAKE_CURRENT_BINARY_DIR}/%s' %
member.file().name())
else:
members.append(member.file().name())
pass
pass
if isinstance(linked, ExecutableBuilder):
target_name = linked.exename()
cmake_output_builder.local_cmakelists().add_executable(
target_name, members)
if linked.what() == ExecutableBuilder.BIN:
cmake_output_builder.local_cmakelists(
).add_install__targets(targets=[target_name],
destination='bin')
pass
pass
elif isinstance(linked, LibraryBuilder):
target_name = linked.basename()
cmake_output_builder.local_cmakelists().add_library(
target_name, members)
cmake_output_builder.local_cmakelists(
).add_install__targets(targets=[target_name],
destination='lib')
pass
else:
assert False, 'unknown LinkedBuilder type: ' + str(linked)
pass
pass
# add libraries and linker paths if any.
if True:
native_local_libraries = []
native_installed_libraries = []
for bi in linked.topo_libraries():
if isinstance(bi, BuildInfo_CLibrary_NativeLocal):
native_local_libraries.append(bi.basename())
continue
if isinstance(bi, BuildInfo_CLibrary_NativeInstalled):
native_installed_libraries.append(bi.basename())
continue
assert 0, 'missed some relevant build info type'
pass
# if there are libraries that have been installed
# natively using confix, then their path is added
# first.
if len(native_installed_libraries):
cmake_output_builder.local_cmakelists().add_link_directory(
'${CMAKE_INSTALL_PREFIX}/lib')
cmake_output_builder.local_cmakelists().add_link_directory(
directory=[
'FOREACH(dir ${READONLY_PREFIXES})',
' LINK_DIRECTORIES(${dir}/lib)',
'ENDFOREACH(dir)'
],
literally=True)
pass
# next come the paths pointing to external libraries.
for dir in self.__external_libpath:
cmake_output_builder.local_cmakelists().add_link_directory(
dir)
pass
link_libraries = []
have = set()
for lib in itertools.chain(native_local_libraries,
native_installed_libraries,
self.__external_libraries):
if lib in have:
continue
have.add(lib)
link_libraries.append(lib)
pass
if len(link_libraries):
cmake_output_builder.local_cmakelists(
).target_link_libraries(target_name, link_libraries)
pass
pass
pass
pass
def test__CMAKE_PKG_CONFIG_LIBRARY(self):
fs = FileSystem(path=[])
fs.rootdirectory().add(
name=const.CONFIX2_PKG,
entry=File(lines=[
"PACKAGE_NAME('test_CMAKE_PKG_CONFIG_LIBRARY')",
"PACKAGE_VERSION('1.2.3')"
]))
fs.rootdirectory().add(
name=const.CONFIX2_DIR,
entry=File(
lines=["DIRECTORY(['external'])", "DIRECTORY(['linked'])"]))
external = fs.rootdirectory().add(name='external', entry=Directory())
external.add(name=const.CONFIX2_DIR,
entry=File(lines=[
"PROVIDE_SYMBOL('xxx-glue')",
"CMAKE_PKG_CONFIG_LIBRARY(packagename='xxx')"
]))
linked = fs.rootdirectory().add(name='linked', entry=Directory())
linked.add(name=const.CONFIX2_DIR,
entry=File(lines=[
"REQUIRE_SYMBOL('xxx-glue', URGENCY_ERROR)",
"EXECUTABLE(exename='exe', center=C(filename='main.c'))"
]))
linked.add(name='main.c', entry=File(lines=['int main(void() {}']))
package = LocalPackage(
rootdirectory=fs.rootdirectory(),
setups=[ExplicitDirectorySetup(),
CMakeSetup(),
ExplicitCSetup()])
package.boil(external_nodes=[])
package.output()
linked_cmake_output_builder = find_cmake_output_builder(
package.rootbuilder().find_entry_builder(['linked']))
self.failUnless(
'FIND_PACKAGE(PkgConfig)' in
linked_cmake_output_builder.top_cmakelists().get_find_calls())
self.failUnless(
'PKG_CHECK_MODULES(CONFIX_CMAKE_PKG_CONFIG__xxx REQUIRED xxx)' in
linked_cmake_output_builder.top_cmakelists().get_find_calls())
self.failUnless('${CONFIX_CMAKE_PKG_CONFIG__xxx_LIBRARIES}' in
linked_cmake_output_builder.local_cmakelists(
).get_target_link_libraries('exe'))
self.failUnless('${CONFIX_CMAKE_PKG_CONFIG__xxx_LIBRARY_DIRS}' in
linked_cmake_output_builder.local_cmakelists(
).get_link_directories())
self.failUnless('${CONFIX_CMAKE_PKG_CONFIG__xxx_INCLUDE_DIRS}' in
linked_cmake_output_builder.local_cmakelists(
).get_include_directories())
self.failUnless(
'${CONFIX_CMAKE_PKG_CONFIG__xxx_CFLAGS}' in
linked_cmake_output_builder.local_cmakelists().get_definitions())
self.failUnless(
'${CONFIX_CMAKE_PKG_CONFIG__xxx_CFLAGS_OTHER}' in
linked_cmake_output_builder.local_cmakelists().get_definitions())
pass