falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
17 Commits
16 Branches
14GB
Tree: d11d669174
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd11d669174'
${ noResults }
Carla/source/libs/lilv/lilv-0.14.4/wscript

379 lines
14KB
Raw Blame History 

  1. #!/usr/bin/env python

  2. import os

  3. import sys

  4. import subprocess

  5. 

  6. from waflib.extras import autowaf as autowaf

  7. import waflib.Options as Options

  8. 

  9. # Version of this package (even if built as a child)

  10. LILV_VERSION       = '0.14.4'

  11. LILV_MAJOR_VERSION = '0'

  12. 

  13. # Library version (UNIX style major, minor, micro)

  14. # major increment <=> incompatible changes

  15. # minor increment <=> compatible changes (additions)

  16. # micro increment <=> no interface changes

  17. # Lilv uses the same version number for both library and package

  18. LILV_LIB_VERSION = LILV_VERSION

  19. 

  20. # Variables for 'waf dist'

  21. APPNAME = 'lilv'

  22. VERSION = LILV_VERSION

  23. 

  24. # Mandatory variables

  25. top = '.'

  26. out = 'build'

  27. 

  28. def options(opt):

  29.     opt.load('compiler_c')

  30.     opt.load('compiler_cxx')

  31.     opt.load('python')

  32.     autowaf.set_options(opt)

  33.     opt.add_option('--no-utils', action='store_true', dest='no_utils',

  34.                    help='Do not build command line utilities')

  35.     opt.add_option('--bindings', action='store_true', dest='bindings',

  36.                    help='Build python bindings')

  37.     opt.add_option('--dyn-manifest', action='store_true', dest='dyn_manifest',

  38.                    help='Build support for dynamic manifests')

  39.     opt.add_option('--test', action='store_true', dest='build_tests',

  40.                    help='Build unit tests')

  41.     opt.add_option('--no-bash-completion', action='store_true',

  42.                    dest='no_bash_completion',

  43.                    help='Do not install bash completion script in CONFIGDIR')

  44.     opt.add_option('--static', action='store_true', dest='static',

  45.                    help='Build static library')

  46.     opt.add_option('--no-shared', action='store_true', dest='no_shared',

  47.                    help='Do not build shared library')

  48.     opt.add_option('--static-progs', action='store_true', dest='static_progs',

  49.                    help='Build programs as static binaries')

  50.     opt.add_option('--default-lv2-path', type='string', default='',

  51.                    dest='default_lv2_path',

  52.                    help='Default LV2 path to use if LV2_PATH is unset')

  53. 

  54. def configure(conf):

  55.     conf.load('compiler_c')

  56. 

  57.     if Options.options.bindings:

  58.         try:

  59.             conf.load('swig')

  60.             conf.load('python')

  61.             conf.load('compiler_cxx')

  62.             conf.check_python_headers()

  63.             autowaf.define(conf, 'LILV_PYTHON', 1);

  64.         except:

  65.             pass

  66. 

  67.     autowaf.configure(conf)

  68.     autowaf.set_c99_mode(conf)

  69.     autowaf.display_header('Lilv Configuration')

  70. 

  71.     conf.env.BASH_COMPLETION = not Options.options.no_bash_completion

  72.     conf.env.BUILD_TESTS     = Options.options.build_tests

  73.     conf.env.BUILD_UTILS     = not Options.options.no_utils

  74.     conf.env.BUILD_SHARED    = not Options.options.no_shared

  75.     conf.env.STATIC_PROGS    = Options.options.static_progs

  76.     conf.env.BUILD_STATIC    = (Options.options.static or

  77.                                 Options.options.static_progs)

  78. 

  79.     if not conf.env.BUILD_SHARED and not conf.env.BUILD_STATIC:

  80.         conf.fatal('Neither a shared nor a static build requested')

  81. 

  82.     autowaf.check_pkg(conf, 'lv2', uselib_store='LV2',

  83.                       atleast_version='1.0.0', mandatory=True)

  84.     autowaf.check_pkg(conf, 'serd-0', uselib_store='SERD',

  85.                       atleast_version='0.14.0', mandatory=True)

  86.     autowaf.check_pkg(conf, 'sord-0', uselib_store='SORD',

  87.                       atleast_version='0.8.0', mandatory=True)

  88.     autowaf.check_pkg(conf, 'sratom-0', uselib_store='SRATOM',

  89.                       atleast_version='0.2.0', mandatory=True)

  90. 

  91.     autowaf.define(conf, 'LILV_NEW_LV2', 1)  # New LV2 discovery API

  92. 

  93.     defines = ['_POSIX_C_SOURCE', '_BSD_SOURCE']

  94.     if Options.platform == 'darwin':

  95.         defines += ['_DARWIN_C_SOURCE']

  96. 

  97.     # Check for gcov library (for test coverage)

  98.     if conf.env.BUILD_TESTS:

  99.         conf.check_cc(lib='gcov',

  100.                       define_name='HAVE_GCOV',

  101.                       mandatory=False)

  102. 

  103.     conf.check_cc(function_name='flock',

  104.                   header_name='sys/file.h',

  105.                   defines=defines,

  106.                   define_name='HAVE_FLOCK',

  107.                   mandatory=False)

  108. 

  109.     conf.check_cc(function_name='fileno',

  110.                   header_name='stdio.h',

  111.                   defines=defines,

  112.                   define_name='HAVE_FILENO',

  113.                   mandatory=False)

  114. 

  115.     conf.check_cc(function_name='clock_gettime',

  116.                   header_name=['sys/time.h','time.h'],

  117.                   defines=['_POSIX_C_SOURCE=199309L'],

  118.                   define_name='HAVE_CLOCK_GETTIME',

  119.                   uselib_store='CLOCK_GETTIME',

  120.                   lib=['rt'],

  121.                   mandatory=False)

  122. 

  123.     autowaf.define(conf, 'LILV_VERSION', LILV_VERSION)

  124.     if Options.options.dyn_manifest:

  125.         autowaf.define(conf, 'LILV_DYN_MANIFEST', 1)

  126. 

  127.     lilv_path_sep = ':'

  128.     lilv_dir_sep  = '/'

  129.     if sys.platform == 'win32':

  130.         lilv_path_sep = ';'

  131.         lilv_dir_sep = '\\\\'

  132. 

  133.     autowaf.define(conf, 'LILV_PATH_SEP', lilv_path_sep)

  134.     autowaf.define(conf, 'LILV_DIR_SEP',  lilv_dir_sep)

  135. 

  136.     # Set default LV2 path

  137.     lv2_path = Options.options.default_lv2_path

  138.     if lv2_path == '':

  139.         if Options.platform == 'darwin':

  140.             lv2_path = lilv_path_sep.join(['~/Library/Audio/Plug-Ins/LV2',

  141.                                            '~/.lv2',

  142.                                            '/usr/local/lib/lv2',

  143.                                            '/usr/lib/lv2',

  144.                                            '/Library/Audio/Plug-Ins/LV2'])

  145.         elif Options.platform == 'haiku':

  146.             lv2_path = lilv_path_sep.join(['~/.lv2',

  147.                                            '/boot/common/add-ons/lv2'])

  148.         elif Options.platform == 'win32':

  149.             lv2_path = lilv_path_sep.join(['%APPDATA%\\\\LV2',

  150.                                            '%COMMONPROGRAMFILES%\\\\LV2'])

  151.         else:

  152.             libdirname = os.path.basename(conf.env.LIBDIR)

  153.             lv2_path = lilv_path_sep.join(['~/.lv2',

  154.                                            '/usr/%s/lv2' % libdirname,

  155.                                            '/usr/local/%s/lv2' % libdirname])

  156.     autowaf.define(conf, 'LILV_DEFAULT_LV2_PATH', lv2_path)

  157. 

  158.     conf.env.LIB_LILV = ['lilv-%s' % LILV_MAJOR_VERSION]

  159. 

  160.     conf.write_config_header('lilv_config.h', remove=False)

  161. 

  162.     autowaf.display_msg(conf, 'Default LV2_PATH',

  163.                         conf.env.LILV_DEFAULT_LV2_PATH)

  164.     autowaf.display_msg(conf, 'Utilities',

  165.                         bool(conf.env.BUILD_UTILS))

  166.     autowaf.display_msg(conf, 'Unit tests',

  167.                         bool(conf.env.BUILD_TESTS))

  168.     autowaf.display_msg(conf, 'Dynamic manifest support',

  169.                         bool(conf.env.LILV_DYN_MANIFEST))

  170.     autowaf.display_msg(conf, 'Python bindings',

  171.                         conf.is_defined('LILV_PYTHON'))

  172. 

  173.     conf.undefine('LILV_DEFAULT_LV2_PATH')  # Cmd line errors with VC++

  174.     print('')

  175. 

  176. def build_util(bld, name, defines):

  177.     obj = bld(features     = 'c cprogram',

  178.               source       = name + '.c',

  179.               includes     = ['.', './src', './utils'],

  180.               use          = 'liblilv',

  181.               target       = name,

  182.               defines      = defines,

  183.               install_path = '${BINDIR}')

  184.     if not bld.env.BUILD_SHARED or bld.env.STATIC_PROGS:

  185.         obj.use = 'liblilv_static'

  186.     if bld.env.STATIC_PROGS:

  187.         if not bld.env.MSVC_COMPILER:

  188.             obj.lib = ['m']

  189.             obj.env.SHLIB_MARKER = obj.env.STLIB_MARKER

  190.             obj.linkflags        = ['-static', '-Wl,--start-group']

  191.     return obj

  192. 

  193. def build(bld):

  194.     # C/C++ Headers

  195.     includedir = '${INCLUDEDIR}/lilv-%s/lilv' % LILV_MAJOR_VERSION

  196.     bld.install_files(includedir, bld.path.ant_glob('lilv/*.h'))

  197.     bld.install_files(includedir, bld.path.ant_glob('lilv/*.hpp'))

  198. 

  199.     # Pkgconfig file

  200.     autowaf.build_pc(bld, 'LILV', LILV_VERSION, LILV_MAJOR_VERSION, [],

  201.                      {'LILV_MAJOR_VERSION' : LILV_MAJOR_VERSION,

  202.                       'LILV_PKG_DEPS'      : 'lv2 serd-0 sord-0 sratom-0'})

  203. 

  204.     lib_source = '''

  205.         src/collections.c

  206.         src/instance.c

  207.         src/lib.c

  208.         src/node.c

  209.         src/plugin.c

  210.         src/pluginclass.c

  211.         src/port.c

  212.         src/query.c

  213.         src/scalepoint.c

  214.         src/state.c

  215.         src/ui.c

  216.         src/util.c

  217.         src/world.c

  218.         src/zix/tree.c

  219.     '''.split()

  220. 

  221.     lib      = ['dl']

  222.     libflags = ['-fvisibility=hidden']

  223.     defines  = []

  224.     if sys.platform == 'win32':

  225.         lib = []

  226.     if bld.env.MSVC_COMPILER:

  227.         libflags = []

  228.         defines  = ['snprintf=_snprintf']

  229.     elif sys.platform.find('bsd') > 0:

  230.         lib = []

  231. 

  232.     # Shared Library

  233.     if bld.env.BUILD_SHARED:

  234.         obj = bld(features        = 'c cshlib',

  235.                   export_includes = ['.'],

  236.                   source          = lib_source,

  237.                   includes        = ['.', './src'],

  238.                   name            = 'liblilv',

  239.                   target          = 'lilv-%s' % LILV_MAJOR_VERSION,

  240.                   vnum            = LILV_LIB_VERSION,

  241.                   install_path    = '${LIBDIR}',

  242.                   defines         = ['LILV_SHARED', 'LILV_INTERNAL'],

  243.                   cflags          = libflags,

  244.                   lib             = lib)

  245.         autowaf.use_lib(bld, obj, 'SORD SRATOM LV2')

  246. 

  247.     # Static library

  248.     if bld.env.BUILD_STATIC:

  249.         obj = bld(features        = 'c cstlib',

  250.                   export_includes = ['.'],

  251.                   source          = lib_source,

  252.                   includes        = ['.', './src'],

  253.                   name            = 'liblilv_static',

  254.                   target          = 'lilv-%s' % LILV_MAJOR_VERSION,

  255.                   vnum            = LILV_LIB_VERSION,

  256.                   install_path    = '${LIBDIR}',

  257.                   defines         = defines + ['LILV_INTERNAL'])

  258.         autowaf.use_lib(bld, obj, 'SORD SRATOM LV2')

  259. 

  260.     if bld.env.BUILD_TESTS:

  261.         test_libs   = lib

  262.         test_cflags = ['']

  263.         if bld.is_defined('HAVE_GCOV'):

  264.             test_libs   += ['gcov']

  265.             test_cflags += ['-fprofile-arcs', '-ftest-coverage']

  266. 

  267.         # Test plugin library

  268.         penv          = bld.env.derive()

  269.         shlib_pattern = penv.cshlib_PATTERN

  270.         if shlib_pattern.startswith('lib'):

  271.             shlib_pattern = shlib_pattern[3:]

  272.         penv.cshlib_PATTERN   = shlib_pattern

  273.         shlib_ext = shlib_pattern[shlib_pattern.rfind('.'):]

  274. 

  275.         obj = bld(features     = 'c cshlib',

  276.                   env          = penv,

  277.                   source       = 'test/test_plugin.c',

  278.                   name         = 'test_plugin',

  279.                   target       = 'test/test_plugin.lv2/test_plugin',

  280.                   install_path = None,

  281.                   defines      = defines,

  282.                   cflags       = test_cflags,

  283.                   lib          = test_libs,

  284.                   uselib       = 'LV2')

  285. 

  286.         # Test plugin data files

  287.         for i in [ 'manifest.ttl.in', 'test_plugin.ttl.in' ]:

  288.             bld(features     = 'subst',

  289.                 source       = 'test/' + i,

  290.                 target       = 'test/test_plugin.lv2/' + i.replace('.in', ''),

  291.                 install_path = None,

  292.                 SHLIB_EXT    = shlib_ext)

  293. 

  294.         # Static profiled library (for unit test code coverage)

  295.         obj = bld(features     = 'c cstlib',

  296.                   source       = lib_source,

  297.                   includes     = ['.', './src'],

  298.                   name         = 'liblilv_profiled',

  299.                   target       = 'lilv_profiled',

  300.                   install_path = None,

  301.                   defines      = defines + ['LILV_INTERNAL'],

  302.                   cflags       = test_cflags,

  303.                   lib          = test_libs)

  304.         autowaf.use_lib(bld, obj, 'SORD SRATOM LV2')

  305. 

  306.         # Unit test program

  307.         bpath = os.path.abspath(os.path.join(out, 'test', 'test_plugin.lv2'))

  308.         bpath = bpath.replace('\\', '/')

  309.         obj = bld(features     = 'c cprogram',

  310.                   source       = 'test/lilv_test.c',

  311.                   includes     = ['.', './src'],

  312.                   use          = 'liblilv_profiled',

  313.                   uselib       = 'SORD LV2',

  314.                   lib          = test_libs,

  315.                   target       = 'test/lilv_test',

  316.                   install_path = None,

  317.                   defines      = defines + ['LILV_TEST_BUNDLE=\"%s/\"' % bpath],

  318.                   cflags       = test_cflags)

  319.         autowaf.use_lib(bld, obj, 'SORD SRATOM LV2')

  320. 

  321.     # Utilities

  322.     if bld.env.BUILD_UTILS:

  323.         utils = '''

  324.             utils/lilv-bench

  325.             utils/lv2info

  326.             utils/lv2ls

  327.         '''

  328.         for i in utils.split():

  329.             build_util(bld, i, defines)

  330. 

  331.     # lv2bench (less portable than other utilities)

  332.     if bld.is_defined('HAVE_CLOCK_GETTIME'):

  333.         obj = build_util(bld, 'utils/lv2bench', defines)

  334.         if not bld.env.MSVC_COMPILER:

  335.             obj.lib = ['rt']

  336. 

  337.     # Documentation

  338.     autowaf.build_dox(bld, 'LILV', LILV_VERSION, top, out)

  339. 

  340.     # Man pages

  341.     bld.install_files('${MANDIR}/man1', bld.path.ant_glob('doc/*.1'))

  342. 

  343.     # Bash completion

  344.     if bld.env.BASH_COMPLETION:

  345.         bld.install_as(

  346.             '${SYSCONFDIR}/bash_completion.d/lilv', 'utils/lilv.bash_completion')

  347. 

  348.     if bld.is_defined('LILV_PYTHON'):

  349.         # Python Wrapper

  350.         obj = bld(features   = 'cxx cxxshlib pyext',

  351.                   source     = 'bindings/lilv.i',

  352.                   target     = 'bindings/_lilv',

  353.                   includes   = ['..'],

  354.                   swig_flags = '-c++ -python -Wall -I.. -llilv -features autodoc=1',

  355.                   use        = 'liblilv')

  356.         autowaf.use_lib(bld, obj, 'LILV')

  357. 

  358.         bld.install_files('${PYTHONDIR}', 'bindings/lilv.py')

  359. 

  360.     bld.add_post_fun(autowaf.run_ldconfig)

  361.     if bld.env.DOCS:

  362.         bld.add_post_fun(fix_docs)

  363. 

  364. def fix_docs(ctx):

  365.     if ctx.cmd == 'build':

  366.         autowaf.make_simple_dox(APPNAME)

  367. 

  368. def upload_docs(ctx):

  369.     os.system('rsync -ravz --delete -e ssh build/doc/html/ drobilla@drobilla.net:~/drobilla.net/docs/lilv/')

  370. 

  371. def test(ctx):

  372.     autowaf.pre_test(ctx, APPNAME)

  373.     os.environ['PATH'] = 'test' + os.pathsep + os.getenv('PATH')

  374.     autowaf.run_tests(ctx, APPNAME, ['lilv_test'], dirs=['./src','./test'])

  375.     autowaf.post_test(ctx, APPNAME)

  376. 

  377. def lint(ctx):

  378.     subprocess.call('cpplint.py --filter=+whitespace/comments,-whitespace/tab,-whitespace/braces,-whitespace/labels,-build/header_guard,-readability/casting,-readability/todo,-build/include,-runtime/sizeof src/* lilv/*', shell=True)