root/branches/libffado-2.0/SConstruct

Revision 1329, 20.6 kB (checked in by ppalmers, 13 years ago)

re #156: should fix the build issue on x64

Line 
1 #! /usr/bin/python
2 #
3 # Copyright (C) 2007-2008 Arnold Krille
4 # Copyright (C) 2007-2008 Pieter Palmers
5 # Copyright (C) 2008 Jonathan Woithe
6 #
7 # This file is part of FFADO
8 # FFADO = Free Firewire (pro-)audio drivers for linux
9 #
10 # FFADO is based upon FreeBoB.
11 #
12 # This program is free software: you can redistribute it and/or modify
13 # it under the terms of the GNU General Public License as published by
14 # the Free Software Foundation, either version 2 of the License, or
15 # (at your option) version 3 of the License.
16 #
17 # This program is distributed in the hope that it will be useful,
18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 # GNU General Public License for more details.
21 #
22 # You should have received a copy of the GNU General Public License
23 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
24 #
25
26 FFADO_API_VERSION="8"
27 FFADO_VERSION="1.999.37"
28
29 import os
30 import re
31 from string import Template
32 import imp
33
34 build_dir = ARGUMENTS.get('BUILDDIR', "")
35 if build_dir:
36         build_base=build_dir+'/'
37         if not os.path.isdir( build_base ):
38                 os.makedirs( build_base )
39         print "Building into: " + build_base
40 else:
41         build_base=''
42
43 destdir = ARGUMENTS.get( 'DESTDIR', "" )
44
45 if not os.path.isdir( "cache" ):
46         os.makedirs( "cache" )
47
48 opts = Options( "cache/"+build_base+"options.cache" )
49
50 #
51 # If this is just to display a help-text for the variable used via ARGUMENTS, then its wrong...
52 opts.Add( "BUILDDIR", "Path to place the built files in", "")
53
54 opts.AddOptions(
55         BoolOption( "DEBUG", """\
56 Toggle debug-build. DEBUG means \"-g -Wall\" and more, otherwise we will use
57   \"-O2\" to optimise.""", True ),
58         BoolOption( "PROFILE", "Build with symbols and other profiling info", False ),
59         PathOption( "PREFIX", "The prefix where ffado will be installed to.", "/usr/local", PathOption.PathAccept ),
60         PathOption( "BINDIR", "Overwrite the directory where apps are installed to.", "$PREFIX/bin", PathOption.PathAccept ),
61         PathOption( "LIBDIR", "Overwrite the directory where libs are installed to.", "$PREFIX/lib", PathOption.PathAccept ),
62         PathOption( "INCLUDEDIR", "Overwrite the directory where headers are installed to.", "$PREFIX/include", PathOption.PathAccept ),
63         PathOption( "SHAREDIR", "Overwrite the directory where misc shared files are installed to.", "$PREFIX/share/libffado", PathOption.PathAccept ),
64         BoolOption( "ENABLE_BEBOB", "Enable/Disable the bebob part.", True ),
65         BoolOption( "ENABLE_FIREWORKS", "Enable/Disable the ECHO Audio FireWorks AV/C part.", True ),
66         BoolOption( "ENABLE_MOTU", "Enable/Disable the MOTU part.", True ),
67         BoolOption( "ENABLE_GENERICAVC", """\
68 Enable/Disable the the generic avc part (mainly used by apple).
69   Note that disabling this option might be overwritten by other devices needing
70   this code.""", False ),
71         BoolOption( "ENABLE_ALL", "Enable/Disable support for all devices.", False ),
72         BoolOption( "SERIALIZE_USE_EXPAT", "Use libexpat for XML serialization.", False ),
73         BoolOption( "BUILD_TESTS", """\
74 Build the tests in their directory. As some contain quite some functionality,
75   this is on by default.
76   If you just want to use ffado with jack without the tools, you can disable this.\
77 """, True ),
78     BoolOption( "BUILD_STATIC_TOOLS", "Build a statically linked version of the FFADO tools.", False ),
79     EnumOption('DIST_TARGET', 'Build target for cross compiling packagers', 'auto', allowed_values=('auto', 'i386', 'i686', 'x86_64', 'powerpc', 'powerpc64', 'none' ), ignorecase=2),
80     BoolOption( "ENABLE_OPTIMIZATIONS", "Enable optimizations and the use of processor specific extentions (MMX/SSE/...).", False ),
81
82         )
83
84 ## Load the builders in config
85 buildenv=os.environ
86 vars_to_check = [
87         'PATH',
88         'PKG_CONFIG_PATH',
89         'LD_LIBRARY_PATH',
90         'XDG_CONFIG_DIRS',
91         'XDG_DATA_DIRS',
92         'HOME',
93 ]
94 for var in vars_to_check:
95         if os.environ.has_key(var):
96                 buildenv[var]=os.environ[var]
97         else:
98                 buildenv[var]=''
99
100 env = Environment( tools=['default','scanreplace','pyuic','pyuic4','dbus','doxygen','pkgconfig'], toolpath=['admin'], ENV = buildenv, options=opts )
101
102 if os.environ.has_key('CC'):
103         env['CC'] = os.environ['CC']
104 if os.environ.has_key('CXX'):
105         env['CXX'] = os.environ['CXX']
106
107 Help( """
108 For building ffado you can set different options as listed below. You have to
109 specify them only once, scons will save the last value you used and re-use
110 that.
111 To really undo your settings and return to the factory defaults, remove the
112 "cache"-folder and the file ".sconsign.dblite" from this directory.
113 For example with: "rm -Rf .sconsign.dblite cache"
114
115 Note that this is a development version! Don't complain if its not working!
116 See www.ffado.org for stable releases.
117 """ )
118 Help( opts.GenerateHelpText( env ) )
119
120 # make sure the necessary dirs exist
121 if not os.path.isdir( "cache/" + build_base ):
122         os.makedirs( "cache/" + build_base )
123 if not os.path.isdir( 'cache/objects' ):
124         os.makedirs( 'cache/objects' )
125
126 CacheDir( 'cache/objects' )
127
128 opts.Save( 'cache/' + build_base + "options.cache", env )
129
130 def ConfigGuess( context ):
131         context.Message( "Trying to find the system triple: " )
132         ret = os.popen( "admin/config.guess" ).read()[:-1]
133         context.Result( ret )
134         return ret
135
136 def CheckForApp( context, app ):
137         context.Message( "Checking whether '" + app + "' executes " )
138         ret = context.TryAction( app )
139         context.Result( ret[0] )
140         return ret[0]
141
142 def CheckForPyModule( context, module ):
143         context.Message( "Checking for the python module '" + module + "' " )
144         ret = True
145         try:
146                 imp.find_module( module )
147         except ImportError:
148                 ret = False
149         context.Result( ret )
150         return ret
151
152 def CompilerCheck( context ):
153         context.Message( "Checking for a working C-compiler " )
154         ret = context.TryLink( """
155 #include <stdlib.h>
156
157 int main() {
158         printf( "Hello World!" );
159         return 0;
160 }""", '.c' )
161         context.Result( ret )
162         if ret == 0:
163                 return False;
164         context.Message( "Checking for a working C++-compiler " )
165         ret = context.TryLink( """
166 #include <iostream>
167
168 int main() {
169         std::cout << "Hello World!" << std::endl;
170         return 0;
171 }""", ".cpp" )
172         context.Result( ret )
173         return ret
174
175 tests = {
176         "ConfigGuess" : ConfigGuess,
177         "CheckForApp" : CheckForApp,
178         "CheckForPyModule": CheckForPyModule,
179         "CompilerCheck" : CompilerCheck,
180 }
181 tests.update( env['PKGCONFIG_TESTS'] )
182 tests.update( env['PYUIC_TESTS'] )
183 tests.update( env['PYUIC4_TESTS'] )
184
185 conf = Configure( env,
186         custom_tests = tests,
187         conf_dir = "cache/" + build_base,
188         log_file = "cache/" + build_base + 'config.log' )
189
190 if env['SERIALIZE_USE_EXPAT']:
191         env['SERIALIZE_USE_EXPAT']=1
192 else:
193         env['SERIALIZE_USE_EXPAT']=0
194
195 if not env.GetOption('clean'):
196 #       #
197 #       # Check if the environment can actually compile c-files by checking for a
198 #       # header shipped with gcc.
199 #       #
200 #       if not conf.CheckHeader( "stdio.h", language="C" ):
201 #               print "It seems as if stdio.h is missing. This probably means that your build environment is broken, please make sure you have a working c-compiler and libstdc installed and usable."
202 #               Exit( 1 )
203 #       #
204 #       # ... and do the same with a c++-header. Because some distributions have
205 #       # distinct packages for gcc and g++.
206 #       #
207 #       if not conf.CheckHeader( "iostream", language="C++" ):
208 #               print "It seems as if iostream is missing. This probably means that your build environment is broken, please make sure you have a working c++-compiler installed and usable."
209 #               Exit( 1 )
210
211         #
212         # Seems as if the above tests don't really work. This one should do the trick!?
213         #
214         if not conf.CompilerCheck():
215                 print "It seems as if your system isn't even able to compile any C-/C++-programs. Probably you don't have gcc and g++ installed. Compiling a package from source without a working compiler is very hard to do, please install the needed packages (Hint: on *ubuntu you need both gcc- and g++-packages installed)."
216                 Exit( 1 )
217
218         #
219         # The following checks are for headers and libs and packages we need.
220         #
221         allpresent = 1;
222         # for DBUS C++ bindings
223         allpresent &= conf.CheckHeader( "expat.h" )
224         allpresent &= conf.CheckLib( 'expat', 'XML_ExpatVersion', '#include <expat.h>' )
225        
226         allpresent &= conf.CheckForPKGConfig();
227
228         pkgs = {
229                 'libraw1394' : '1.3.0',
230                 'libavc1394' : '0.5.3',
231                 'libiec61883' : '1.1.0',
232                 'dbus-1' : '1.0',
233                 }
234         if not env['SERIALIZE_USE_EXPAT']:
235                 pkgs['libxml++-2.6'] = '2.13.0'
236
237         for pkg in pkgs:
238                 name2 = pkg.replace("+","").replace(".","").replace("-","").upper()
239                 env['%s_FLAGS' % name2] = conf.GetPKGFlags( pkg, pkgs[pkg] )
240                 if env['%s_FLAGS'%name2] == 0:
241                         allpresent &= 0
242
243         if not allpresent:
244                 print """
245 (At least) One of the dependencies is missing. I can't go on without it, please
246 install the needed packages for each of the lines saying "no".
247 (Remember to also install the *-devel packages!)
248
249 And remember to remove the cache with "rm -Rf .sconsign.dblite cache" so the
250 results above get rechecked.
251 """
252                 Exit( 1 )
253
254         # Check for C99 lrint() and lrintf() functions used to convert from
255         # float to integer more efficiently via float_cast.h.  If not
256         # present the standard slower methods will be used instead.  This
257         # might not be the best way of testing for these but it's the only
258         # way which seems to work properly.  CheckFunc() fails due to
259         # argument count problems.
260         if env.has_key( 'CFLAGS' ):
261                 oldcf = env['CFLAGS']
262         else:
263                 oldcf = ""
264         oldcf = env.Append(CFLAGS = '-std=c99')
265         if conf.CheckLibWithHeader( "m", "math.h", "c", "lrint(3.2);" ):
266                 HAVE_LRINT = 1
267         else:
268                 HAVE_LRINT = 0
269         if conf.CheckLibWithHeader( "m", "math.h", "c", "lrintf(3.2);" ):
270                 HAVE_LRINTF = 1
271         else:
272                 HAVE_LRINTF = 0
273         env['HAVE_LRINT'] = HAVE_LRINT;
274         env['HAVE_LRINTF'] = HAVE_LRINTF;
275         env.Replace(CFLAGS=oldcf)
276
277         #
278         # Optional checks follow:
279         #
280
281         # PyQT checks
282         build_mixer = False
283         if conf.CheckForApp( "which pyuic" ) and conf.CheckForPyModule( 'dbus' ) and conf.CheckForPyModule( 'qt' ):
284                 env['PYUIC'] = True
285                 build_mixer = True
286        
287                 if conf.CheckForApp( "xdg-desktop-menu --help" ):
288                         env['XDG_TOOLS'] = True
289                 else:
290                         print """
291         I couldn't find the program 'xdg-desktop-menu'. Together with xdg-icon-resource
292         this is needed to add the fancy entry to your menu. But the mixer will be installed, you can start it by executing "ffadomixer".
293         """
294         elif conf.CheckForApp( "which pyuic4" ) and conf.CheckForPyModule( 'dbus' ) and conf.CheckForPyModule( 'PyQt4' ):
295                 env['PYUIC4'] = True
296                 build_mixer = True
297        
298                 if conf.CheckForApp( "xdg-desktop-menu --help" ):
299                         env['XDG_TOOLS'] = True
300                 else:
301                         print """
302         I couldn't find the program 'xdg-desktop-menu'. Together with xdg-icon-resource
303         this is needed to add the fancy entry to your menu. But the mixer will be installed, you can start it by executing "ffadomixer".
304         """
305        
306         if not build_mixer:
307                 print """
308         I couldn't find all the prerequisites ('pyuic' / 'pyuic4' and the python-modules 'dbus' and
309         'qt', the packages could be named like dbus-python and PyQt) to build the mixer.
310         Therefor the mixer won't get installed.
311         """
312
313 config_guess = conf.ConfigGuess()
314
315 env = conf.Finish()
316
317 if env['DEBUG']:
318         print "Doing a DEBUG build"
319         # -Werror could be added to, which would force the devs to really remove all the warnings :-)
320         env.AppendUnique( CCFLAGS=["-DDEBUG","-Wall","-g"] )
321         env.AppendUnique( CFLAGS=["-DDEBUG","-Wall","-g"] )
322 else:
323         env.AppendUnique( CCFLAGS=["-O2","-DNDEBUG"] )
324         env.AppendUnique( CFLAGS=["-O2","-DNDEBUG"] )
325
326 if env['PROFILE']:
327         print "Doing a PROFILE build"
328         # -Werror could be added to, which would force the devs to really remove all the warnings :-)
329         env.AppendUnique( CCFLAGS=["-Wall","-g"] )
330         env.AppendUnique( CFLAGS=["-Wall","-g"] )
331
332
333 # this is required to indicate that the DBUS version we use has support
334 # for platform dependent threading init functions
335 # this is true for DBUS >= 0.96 or so. Since we require >= 1.0 it is
336 # always true
337 env.AppendUnique( CCFLAGS=["-DDBUS_HAS_THREADS_INIT_DEFAULT"] )
338
339 if env['ENABLE_ALL']:
340         env['ENABLE_BEBOB'] = True
341         env['ENABLE_FIREWORKS'] = True
342         env['ENABLE_MOTU'] = True
343
344 if env['ENABLE_BEBOB'] or env['ENABLE_FIREWORKS']:
345         env['ENABLE_GENERICAVC'] = True
346
347 env['BUILD_STATIC_LIB'] = False
348 if env['BUILD_STATIC_TOOLS']:
349     print "Building static versions of the tools..."
350     env['BUILD_STATIC_LIB'] = True
351
352 if build_base:
353         env['build_base']="#/"+build_base
354 else:
355         env['build_base']="#/"
356
357 #
358 # Uppercase variables are for usage in code, lowercase versions for usage in
359 # scons-files for installing.
360 #
361 env['BINDIR'] = Template( env['BINDIR'] ).safe_substitute( env )
362 env['LIBDIR'] = Template( env['LIBDIR'] ).safe_substitute( env )
363 env['INCLUDEDIR'] = Template( env['INCLUDEDIR'] ).safe_substitute( env )
364 env['SHAREDIR'] = Template( env['SHAREDIR'] ).safe_substitute( env )
365 env['bindir'] = Template( destdir + env['BINDIR'] ).safe_substitute( env )
366 env['libdir'] = Template( destdir + env['LIBDIR'] ).safe_substitute( env )
367 env['includedir'] = Template( destdir + env['INCLUDEDIR'] ).safe_substitute( env )
368 env['sharedir'] = Template( destdir + env['SHAREDIR'] ).safe_substitute( env )
369
370 env.Command( target=env['sharedir'], source="", action=Mkdir( env['sharedir'] ) )
371
372 env.Alias( "install", env['libdir'] )
373 env.Alias( "install", env['includedir'] )
374 env.Alias( "install", env['sharedir'] )
375 env.Alias( "install", env['bindir'] )
376
377 #
378 # shamelessly copied from the Ardour scons file
379 #
380
381 opt_flags = []
382 env['USE_SSE'] = 0
383
384 # guess at the platform, used to define compiler flags
385
386 config_cpu = 0
387 config_arch = 1
388 config_kernel = 2
389 config_os = 3
390 config = config_guess.split ("-")
391
392 # Autodetect
393 if env['DIST_TARGET'] == 'auto':
394     if re.search ("x86_64", config[config_cpu]) != None:
395         env['DIST_TARGET'] = 'x86_64'
396     elif re.search("i[0-5]86", config[config_cpu]) != None:
397         env['DIST_TARGET'] = 'i386'
398     elif re.search("powerpc64", config[config_cpu]) != None:
399         env['DIST_TARGET'] = 'powerpc64'
400     elif re.search("powerpc", config[config_cpu]) != None:
401         env['DIST_TARGET'] = 'powerpc'
402     else:
403         env['DIST_TARGET'] = 'i686'
404     print "Detected DIST_TARGET = " + env['DIST_TARGET']
405
406 if ((re.search ("i[0-9]86", config[config_cpu]) != None) or (re.search ("x86_64", config[config_cpu]) != None) or (re.search ("powerpc", config[config_cpu]) != None)):
407    
408     build_host_supports_sse = 0
409     build_host_supports_sse2 = 0
410     build_host_supports_sse3 = 0
411
412     if config[config_kernel] == 'linux' :
413        
414         if (env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64'):
415            
416             flag_line = os.popen ("cat /proc/cpuinfo | grep '^flags'").read()[:-1]
417             x86_flags = flag_line.split (": ")[1:][0].split ()
418            
419             if "mmx" in x86_flags:
420                 opt_flags.append ("-mmmx")
421             if "sse" in x86_flags:
422                 build_host_supports_sse = 1
423             if "sse2" in x86_flags:
424                 build_host_supports_sse2 = 1
425             #if "sse3" in x86_flags:
426                 #build_host_supports_sse3 = 1
427             if "3dnow" in x86_flags:
428                 opt_flags.append ("-m3dnow")
429            
430             if config[config_cpu] == "i586":
431                 opt_flags.append ("-march=i586")
432             elif config[config_cpu] == "i686":
433                 opt_flags.append ("-march=i686")
434
435         elif (env['DIST_TARGET'] == 'powerpc') or (env['DIST_TARGET'] == 'powerpc64'):
436
437             cpu_line = os.popen ("cat /proc/cpuinfo | grep '^cpu'").read()[:-1]
438
439             ppc_type = cpu_line.split (": ")[1]
440             if re.search ("altivec", ppc_type) != None:
441                 opt_flags.append ("-maltivec")
442                 opt_flags.append ("-mabi=altivec")
443
444             ppc_type = ppc_type.split (", ")[0]
445             if re.match ("74[0145][0578]A?", ppc_type) != None:
446                 opt_flags.append ("-mcpu=7400")
447                 opt_flags.append ("-mtune=7400")
448             elif re.match ("750", ppc_type) != None:
449                 opt_flags.append ("-mcpu=750")
450                 opt_flags.append ("-mtune=750")
451             elif re.match ("PPC970", ppc_type) != None:
452                 opt_flags.append ("-mcpu=970")
453                 opt_flags.append ("-mtune=970")
454             elif re.match ("Cell Broadband Engine", ppc_type) != None:
455                 opt_flags.append ("-mcpu=cell")
456                 opt_flags.append ("-mtune=cell")
457
458     if ((env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64')) \
459        and build_host_supports_sse and env['ENABLE_OPTIMIZATIONS']:
460         opt_flags.extend (["-msse", "-mfpmath=sse"])
461         env['USE_SSE'] = 1
462
463     if ((env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64')) \
464        and build_host_supports_sse2 and env['ENABLE_OPTIMIZATIONS']:
465         opt_flags.extend (["-msse2"])
466         env['USE_SSE2'] = 1
467
468     #if ((env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64')) \
469        #and build_host_supports_sse2 and env['ENABLE_OPTIMIZATIONS']:
470         #opt_flags.extend (["-msse3"])
471         #env['USE_SSE3'] = 1
472
473     # build for 64-bit userland?
474     if env['DIST_TARGET'] == "powerpc64":
475         print "Doing a 64-bit PowerPC build"
476         env.AppendUnique( CCFLAGS=["-m64"] )
477         env.AppendUnique( CFLAGS=["-m64"] )
478     elif env['DIST_TARGET'] == "x86_64":
479         print "Doing a 64-bit x86 build"
480         env.AppendUnique( CCFLAGS=["-m64","-fPIC"] )
481         env.AppendUnique( CFLAGS=["-m64","-fPIC"] )
482     else:
483         print "Doing a 32-bit build"
484         env.AppendUnique( CCFLAGS=["-m32"] )
485         env.AppendUnique( CFLAGS=["-m32"] )
486
487 # end of processor-specific section
488 if env['ENABLE_OPTIMIZATIONS']:
489     opt_flags.extend (["-fomit-frame-pointer","-ffast-math","-funroll-loops"])
490     env.AppendUnique( CCFLAGS=opt_flags )
491     env.AppendUnique( CFLAGS=opt_flags )
492     print "Doing an optimized build..."
493
494 env['REVISION'] = os.popen('svnversion .').read()[:-1]
495 # This may be as simple as '89' or as complex as '4123:4184M'.
496 # We'll just use the last bit.
497 env['REVISION'] = env['REVISION'].split(':')[-1]
498
499 if env['REVISION'] == 'exported':
500         env['REVISION'] = ''
501
502 env['FFADO_API_VERSION']=FFADO_API_VERSION
503
504 env['PACKAGE'] = "libffado"
505 env['VERSION'] = FFADO_VERSION
506 env['LIBVERSION'] = "1.0.0"
507
508 env['CONFIGDIR'] = "~/.ffado"
509 env['CACHEDIR'] = "~/.ffado"
510
511 env['USER_CONFIG_FILE'] = env['CONFIGDIR'] + "/configuration"
512 env['SYSTEM_CONFIG_FILE'] = env['SHAREDIR'] + "/configuration"
513
514 env['REGISTRATION_URL'] = "http://ffado.org/deviceregistration/register.php?action=register"
515
516 #
517 # To have the top_srcdir as the doxygen-script is used from auto*
518 #
519 env['top_srcdir'] = env.Dir( "." ).abspath
520
521 #
522 # Start building
523 #
524 env.ScanReplace( "config.h.in" )
525 # ensure that the config.h is updated with the version
526
527 env.Depends( "config.h", "SConstruct" )
528 env.Depends( "config.h", 'cache/' + build_base + "options.cache" )
529
530 # update config.h whenever the SVN revision changes
531 env.Depends( "config.h", env.Value(env['REVISION']))
532
533 env.Depends( "libffado.pc", "SConstruct" )
534 pkgconfig = env.ScanReplace( "libffado.pc.in" )
535 env.Install( env['libdir'] + '/pkgconfig', pkgconfig )
536
537 env.Install( env['SHAREDIR'], 'configuration' )
538
539 subdirs=['external','src','libffado','tests','support','doc']
540 if build_base:
541         env.SConscript( dirs=subdirs, exports="env", build_dir=build_base+subdir )
542 else:
543         env.SConscript( dirs=subdirs, exports="env" )
544
545 # By default only src is built but all is cleaned
546 if not env.GetOption('clean'):
547     Default( 'src' )
548     Default( 'support' )
549     if env['BUILD_TESTS']:
550         Default( 'tests' )
551
552 #
553 # Deal with the DESTDIR vs. xdg-tools conflict (which is basicely that the
554 # xdg-tools can't deal with DESTDIR, so the packagers have to deal with this
555 # their own :-/
556 #
557 if len(destdir) > 0:
558         if not len( ARGUMENTS.get( "WILL_DEAL_WITH_XDG_MYSELF", "" ) ) > 0:
559                 print """
560 WARNING!
561 You are using the (packagers) option DESTDIR to install this package to a
562 different place than the real prefix. As the xdg-tools can't cope with
563 that, the .desktop-files are not installed by this build, you have to
564 deal with them your own.
565 (And you have to look into the SConstruct to learn how to disable this
566 message.)
567 """
568 else:
569
570         def CleanAction( action ):
571                 if env.GetOption( "clean" ):
572                         env.Execute( action )
573
574         if env.has_key( 'XDG_TOOLS' ) and env.has_key( 'PYUIC' ):
575                 if not env.GetOption("clean"):
576                         action = "install"
577                 else:
578                         action = "uninstall"
579                 mixerdesktopaction = env.Action( "xdg-desktop-menu %s support/xdg/ffado.org-ffadomixer.desktop" % action )
580                 mixericonaction = env.Action( "xdg-icon-resource %s --size 64 --context apps support/xdg/hi64-apps-ffado.png" % action )
581                 env.Command( "__xdgstuff1", None, mixerdesktopaction )
582                 env.Command( "__xdgstuff2", None, mixericonaction )
583                 env.Alias( "install", ["__xdgstuff1", "__xdgstuff2" ] )
584                 CleanAction( mixerdesktopaction )
585                 CleanAction( mixericonaction )
586
587 #
588 # Create a tags-file for easier emacs/vim-source-browsing
589 #  I don't know if the dependency is right...
590 #
591 findcommand = "find . \( -path \"*.h\" -o -path \"*.cpp\" -o -path \"*.c\" \) \! -path \"*.svn*\" \! -path \"./doc*\" \! -path \"./cache*\""
592 env.Command( "tags", "", findcommand + " |xargs ctags" )
593 env.Command( "TAGS", "", findcommand + " |xargs etags" )
594 env.AlwaysBuild( "tags", "TAGS" )
595 if 'NoCache' in dir(env):
596     env.NoCache( "tags", "TAGS" )
597
Note: See TracBrowser for help on using the browser.