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.
447 Commits
16 Branches
14GB
Tree: d60fc69a9d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd60fc69a9d'
${ noResults }
Carla/source/libs/lilv/lilv-0.16.0/wscript

370 lines
14KB
Raw Blame History 

  1. #!/usr/bin/env python

  2. import os

  3. import subprocess

  4. import sys

  5. import waflib.Options as Options

  6. import waflib.extras.autowaf as autowaf

  7. 

  8. # Library and package version (UNIX style major, minor, micro)

  9. # major increment <=> incompatible changes

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

  11. # micro increment <=> no interface changes

  12. LILV_VERSION       = '0.16.0'

  13. LILV_MAJOR_VERSION = '0'

  14. 

  15. # Mandatory waf variables

  16. APPNAME = 'lilv'        # Package name for waf dist

  17. VERSION = LILV_VERSION  # Package version for waf dist

  18. top     = '.'           # Source directory

  19. out     = 'build'       # Build directory

  20. 

  21. def options(opt):

  22.     opt.load('compiler_c')

  23.     opt.load('compiler_cxx')

  24.     opt.load('python')

  25.     autowaf.set_options(opt)

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

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

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

  29.                    help='Build python bindings')

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

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

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

  33.                    help='Build unit tests')

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

  35.                    dest='no_bash_completion',

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

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

  38.                    help='Build static library')

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

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

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

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

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

  44.                    dest='default_lv2_path',

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

  46. 

  47. def configure(conf):

  48.     conf.load('compiler_c')

  49. 

  50.     if Options.options.bindings:

  51.         try:

  52.             conf.load('swig')

  53.             conf.load('python')

  54.             conf.load('compiler_cxx')

  55.             conf.check_python_headers()

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

  57.         except:

  58.             pass

  59. 

  60.     autowaf.configure(conf)

  61.     autowaf.set_c99_mode(conf)

  62.     autowaf.display_header('Lilv Configuration')

  63. 

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

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

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

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

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

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

  70.                                 Options.options.static_progs)

  71. 

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

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

  74. 

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

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

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

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

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

  80.                       atleast_version='0.12.0', mandatory=True)

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

  82.                       atleast_version='0.4.0', mandatory=True)

  83. 

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

  85. 

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

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

  88.         defines += ['_DARWIN_C_SOURCE']

  89. 

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

  91.     if conf.env.BUILD_TESTS:

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

  93.                       define_name='HAVE_GCOV',

  94.                       mandatory=False)

  95. 

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

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

  98.                   defines=defines,

  99.                   define_name='HAVE_FLOCK',

  100.                   mandatory=False)

  101. 

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

  103.                   header_name='stdio.h',

  104.                   defines=defines,

  105.                   define_name='HAVE_FILENO',

  106.                   mandatory=False)

  107. 

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

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

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

  111.                   define_name='HAVE_CLOCK_GETTIME',

  112.                   uselib_store='CLOCK_GETTIME',

  113.                   lib=['rt'],

  114.                   mandatory=False)

  115. 

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

  117.     if Options.options.dyn_manifest:

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

  119. 

  120.     lilv_path_sep = ':'

  121.     lilv_dir_sep  = '/'

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

  123.         lilv_path_sep = ';'

  124.         lilv_dir_sep = '\\\\'

  125. 

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

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

  128. 

  129.     # Set default LV2 path

  130.     lv2_path = Options.options.default_lv2_path

  131.     if lv2_path == '':

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

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

  134.                                            '~/.lv2',

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

  136.                                            '/usr/lib/lv2',

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

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

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

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

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

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

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

  144.         else:

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

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

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

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

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

  150. 

  151.     autowaf.set_lib_env(conf, 'lilv', LILV_VERSION)

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

  153. 

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

  155.                         conf.env.LILV_DEFAULT_LV2_PATH)

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

  157.                         bool(conf.env.BUILD_UTILS))

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

  159.                         bool(conf.env.BUILD_TESTS))

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

  161.                         bool(conf.env.LILV_DYN_MANIFEST))

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

  163.                         conf.is_defined('LILV_PYTHON'))

  164. 

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

  166.     print('')

  167. 

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

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

  170.               source       = name + '.c',

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

  172.               use          = 'liblilv',

  173.               target       = name,

  174.               defines      = defines,

  175.               install_path = '${BINDIR}')

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

  177.         obj.use = 'liblilv_static'

  178.     if bld.env.STATIC_PROGS:

  179.         if not bld.env.MSVC_COMPILER:

  180.             obj.lib = ['m']

  181.             obj.env.SHLIB_MARKER = obj.env.STLIB_MARKER

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

  183.     return obj

  184. 

  185. def build(bld):

  186.     # C/C++ Headers

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

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

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

  190. 

  191.     # Pkgconfig file

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

  193.                      {'LILV_MAJOR_VERSION' : LILV_MAJOR_VERSION,

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

  195. 

  196.     lib_source = '''

  197.         src/collections.c

  198.         src/instance.c

  199.         src/lib.c

  200.         src/node.c

  201.         src/plugin.c

  202.         src/pluginclass.c

  203.         src/port.c

  204.         src/query.c

  205.         src/scalepoint.c

  206.         src/state.c

  207.         src/ui.c

  208.         src/util.c

  209.         src/world.c

  210.         src/zix/tree.c

  211.     '''.split()

  212. 

  213.     lib      = ['dl']

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

  215.     defines  = []

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

  217.         lib = []

  218.     if bld.env.MSVC_COMPILER:

  219.         libflags = []

  220.         defines  = ['snprintf=_snprintf']

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

  222.         lib = []

  223. 

  224.     # Shared Library

  225.     if bld.env.BUILD_SHARED:

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

  227.                   export_includes = ['.'],

  228.                   source          = lib_source,

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

  230.                   name            = 'liblilv',

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

  232.                   vnum            = LILV_VERSION,

  233.                   install_path    = '${LIBDIR}',

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

  235.                   cflags          = libflags,

  236.                   lib             = lib)

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

  238. 

  239.     # Static library

  240.     if bld.env.BUILD_STATIC:

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

  242.                   export_includes = ['.'],

  243.                   source          = lib_source,

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

  245.                   name            = 'liblilv_static',

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

  247.                   vnum            = LILV_VERSION,

  248.                   install_path    = '${LIBDIR}',

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

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

  251. 

  252.     if bld.env.BUILD_TESTS:

  253.         test_libs   = lib

  254.         test_cflags = ['']

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

  256.             test_libs   += ['gcov']

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

  258. 

  259.         # Test plugin library

  260.         penv          = bld.env.derive()

  261.         shlib_pattern = penv.cshlib_PATTERN

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

  263.             shlib_pattern = shlib_pattern[3:]

  264.         penv.cshlib_PATTERN   = shlib_pattern

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

  266. 

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

  268.                   env          = penv,

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

  270.                   name         = 'test_plugin',

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

  272.                   install_path = None,

  273.                   defines      = defines,

  274.                   cflags       = test_cflags,

  275.                   lib          = test_libs,

  276.                   uselib       = 'LV2')

  277. 

  278.         # Test plugin data files

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

  280.             bld(features     = 'subst',

  281.                 source       = 'test/' + i,

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

  283.                 install_path = None,

  284.                 SHLIB_EXT    = shlib_ext)

  285. 

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

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

  288.                   source       = lib_source,

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

  290.                   name         = 'liblilv_profiled',

  291.                   target       = 'lilv_profiled',

  292.                   install_path = None,

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

  294.                   cflags       = test_cflags,

  295.                   lib          = test_libs)

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

  297. 

  298.         # Unit test program

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

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

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

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

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

  304.                   use          = 'liblilv_profiled',

  305.                   lib          = test_libs,

  306.                   target       = 'test/lilv_test',

  307.                   install_path = None,

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

  309.                   cflags       = test_cflags)

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

  311. 

  312.     # Utilities

  313.     if bld.env.BUILD_UTILS:

  314.         utils = '''

  315.             utils/lilv-bench

  316.             utils/lv2info

  317.             utils/lv2ls

  318.         '''

  319.         for i in utils.split():

  320.             build_util(bld, i, defines)

  321. 

  322.     # lv2bench (less portable than other utilities)

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

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

  325.         if not bld.env.MSVC_COMPILER:

  326.             obj.lib = ['rt']

  327. 

  328.     # Documentation

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

  330. 

  331.     # Man pages

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

  333. 

  334.     # Bash completion

  335.     if bld.env.BASH_COMPLETION:

  336.         bld.install_as(

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

  338. 

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

  340.         # Python Wrapper

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

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

  343.                   target     = 'bindings/_lilv',

  344.                   includes   = ['..'],

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

  346.                   use        = 'liblilv')

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

  348. 

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

  350. 

  351.     bld.add_post_fun(autowaf.run_ldconfig)

  352.     if bld.env.DOCS:

  353.         bld.add_post_fun(fix_docs)

  354. 

  355. def fix_docs(ctx):

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

  357.         autowaf.make_simple_dox(APPNAME)

  358. 

  359. def upload_docs(ctx):

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

  361. 

  362. def test(ctx):

  363.     autowaf.pre_test(ctx, APPNAME)

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

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

  366.     autowaf.post_test(ctx, APPNAME)

  367. 

  368. def lint(ctx):

  369.     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)