root/trunk/libffado/SConstruct

Revision 1180, 20.0 kB (checked in by arnonym, 13 years ago)

Looks as if the old checks for gcc/g++ don't work reliably. Try a new one...

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.27"
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_DICE", "Enable/Disable the DICE part.", False ),
68         BoolOption( "ENABLE_METRIC_HALO", "Enable/Disable the Metric Halo part.", False ),
69         BoolOption( "ENABLE_RME", "Enable/Disable the RME part.", False ),
70         BoolOption( "ENABLE_BOUNCE", "Enable/Disable the BOUNCE part.", False ),
71         BoolOption( "ENABLE_GENERICAVC", """\
72 Enable/Disable the the generic avc part (mainly used by apple).
73   Note that disabling this option might be overwritten by other devices needing
74   this code.""", False ),
75         BoolOption( "ENABLE_ALL", "Enable/Disable support for all devices.", False ),
76         BoolOption( "SERIALIZE_USE_EXPAT", "Use libexpat for XML serialization.", False ),
77         BoolOption( "BUILD_TESTS", """\
78 Build the tests in their directory. As some contain quite some functionality,
79   this is on by default.
80   If you just want to use ffado with jack without the tools, you can disable this.\
81 """, True ),
82     BoolOption( "BUILD_STATIC_TOOLS", "Build a statically linked version of the FFADO tools.", False ),
83     EnumOption('DIST_TARGET', 'Build target for cross compiling packagers', 'auto', allowed_values=('auto', 'i386', 'i686', 'x86_64', 'powerpc', 'powerpc64', 'none' ), ignorecase=2),
84     BoolOption( "ENABLE_OPTIMIZATIONS", "Enable optimizations and the use of processor specific extentions (MMX/SSE/...).", False ),
85
86         )
87
88 ## Load the builders in config
89 buildenv=os.environ
90 vars_to_check = [
91         'PATH',
92         'PKG_CONFIG_PATH',
93         'LD_LIBRARY_PATH',
94         'XDG_CONFIG_DIRS',
95         'XDG_DATA_DIRS',
96         'HOME',
97 ]
98 for var in vars_to_check:
99         if os.environ.has_key(var):
100                 buildenv[var]=os.environ[var]
101         else:
102                 buildenv[var]=''
103
104 env = Environment( tools=['default','scanreplace','pyuic','dbus','doxygen','pkgconfig'], toolpath=['admin'], ENV = buildenv, options=opts )
105
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 wether '" + 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
184 conf = Configure( env,
185         custom_tests = tests,
186         conf_dir = "cache/" + build_base,
187         log_file = "cache/" + build_base + 'config.log' )
188
189 if env['SERIALIZE_USE_EXPAT']:
190         env['SERIALIZE_USE_EXPAT']=1
191 else:
192         env['SERIALIZE_USE_EXPAT']=0
193
194 if not env.GetOption('clean'):
195 #       #
196 #       # Check if the environment can actually compile c-files by checking for a
197 #       # header shipped with gcc.
198 #       #
199 #       if not conf.CheckHeader( "stdio.h", language="C" ):
200 #               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."
201 #               Exit( 1 )
202 #       #
203 #       # ... and do the same with a c++-header. Because some distributions have
204 #       # distinct packages for gcc and g++.
205 #       #
206 #       if not conf.CheckHeader( "iostream", language="C++" ):
207 #               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."
208 #               Exit( 1 )
209
210         #
211         # Seems as if the above tests don't really work. This one should do the trick!?
212         #
213         if not conf.CompilerCheck():
214                 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)."
215                 Exit( 1 )
216
217         #
218         # The following checks are for headers and libs and packages we need.
219         #
220         allpresent = 1;
221         # for DBUS C++ bindings
222         allpresent &= conf.CheckHeader( "expat.h" )
223         allpresent &= conf.CheckLib( 'expat', 'XML_ExpatVersion', '#include <expat.h>' )
224        
225         allpresent &= conf.CheckForPKGConfig();
226
227         pkgs = {
228                 'libraw1394' : '1.3.0',
229                 'libavc1394' : '0.5.3',
230                 'libiec61883' : '1.1.0',
231                 'dbus-1' : '1.0',
232                 }
233         if not env['SERIALIZE_USE_EXPAT']:
234                 pkgs['libxml++-2.6'] = '2.13.0'
235
236         for pkg in pkgs:
237                 name2 = pkg.replace("+","").replace(".","").replace("-","").upper()
238                 env['%s_FLAGS' % name2] = conf.GetPKGFlags( pkg, pkgs[pkg] )
239                 if env['%s_FLAGS'%name2] == 0:
240                         allpresent &= 0
241
242         if not allpresent:
243                 print """
244 (At least) One of the dependencies is missing. I can't go on without it, please
245 install the needed packages for each of the lines saying "no".
246 (Remember to also install the *-devel packages!)
247
248 And remember to remove the cache with "rm -Rf .sconsign.dblite cache" so the
249 results above get rechecked.
250 """
251                 Exit( 1 )
252
253         # Check for C99 lrint() and lrintf() functions used to convert from
254         # float to integer more efficiently via float_cast.h.  If not
255         # present the standard slower methods will be used instead.  This
256         # might not be the best way of testing for these but it's the only
257         # way which seems to work properly.  CheckFunc() fails due to
258         # argument count problems.
259         if env.has_key( 'CFLAGS' ):
260                 oldcf = env['CFLAGS']
261         else:
262                 oldcf = ""
263         oldcf = env.Append(CFLAGS = '-std=c99')
264         if conf.CheckLibWithHeader( "m", "math.h", "c", "lrint(3.2);" ):
265                 HAVE_LRINT = 1
266         else:
267                 HAVE_LRINT = 0
268         if conf.CheckLibWithHeader( "m", "math.h", "c", "lrintf(3.2);" ):
269                 HAVE_LRINTF = 1
270         else:
271                 HAVE_LRINTF = 0
272         env['HAVE_LRINT'] = HAVE_LRINT;
273         env['HAVE_LRINTF'] = HAVE_LRINTF;
274         env.Replace(CFLAGS=oldcf)
275
276         #
277         # Optional checks follow:
278         #
279
280 if conf.CheckForApp( "which pyuic" ) and conf.CheckForPyModule( 'dbus' ) and conf.CheckForPyModule( 'qt' ):
281         env['PYUIC'] = True
282
283         if conf.CheckForApp( "xdg-desktop-menu --help" ):
284                 env['XDG_TOOLS'] = True
285         else:
286                 print """
287 I couldn't find the program 'xdg-desktop-menu'. Together with xdg-icon-resource
288 this is needed to add the fancy entry to your menu. But the mixer will be installed, you can start it by executing "ffadomixer".
289 """
290
291 else:
292         print """
293 I couldn't find all the prerequisites ('pyuic' and the python-modules 'dbus' and
294 'qt', the packages could be named like dbus-python and PyQt) to build the mixer.
295 Therefor the mixer won't get installed.
296 """
297
298 config_guess = conf.ConfigGuess()
299
300 env = conf.Finish()
301
302 if env['DEBUG']:
303         print "Doing a DEBUG build"
304         # -Werror could be added to, which would force the devs to really remove all the warnings :-)
305         env.AppendUnique( CCFLAGS=["-DDEBUG","-Wall","-g"] )
306         env.AppendUnique( CFLAGS=["-DDEBUG","-Wall","-g"] )
307 else:
308         env.AppendUnique( CCFLAGS=["-O2","-DNDEBUG"] )
309         env.AppendUnique( CFLAGS=["-O2","-DNDEBUG"] )
310
311 if env['PROFILE']:
312         print "Doing a PROFILE build"
313         # -Werror could be added to, which would force the devs to really remove all the warnings :-)
314         env.AppendUnique( CCFLAGS=["-Wall","-g"] )
315         env.AppendUnique( CFLAGS=["-Wall","-g"] )
316
317
318 # this is required to indicate that the DBUS version we use has support
319 # for platform dependent threading init functions
320 # this is true for DBUS >= 0.96 or so. Since we require >= 1.0 it is
321 # always true
322 env.AppendUnique( CCFLAGS=["-DDBUS_HAS_THREADS_INIT_DEFAULT"] )
323
324 if env['ENABLE_ALL']:
325         env['ENABLE_BEBOB'] = True
326         env['ENABLE_FIREWORKS'] = True
327         env['ENABLE_MOTU'] = True
328         env['ENABLE_DICE'] = True
329         env['ENABLE_METRIC_HALO'] = True
330         env['ENABLE_RME'] = True
331         env['ENABLE_BOUNCE'] = True
332
333 if env['ENABLE_BEBOB'] or env['ENABLE_DICE'] or env['ENABLE_BOUNCE'] or env['ENABLE_FIREWORKS']:
334         env['ENABLE_GENERICAVC'] = True
335
336 env['BUILD_STATIC_LIB'] = False
337 if env['BUILD_STATIC_TOOLS']:
338     print "Building static versions of the tools..."
339     env['BUILD_STATIC_LIB'] = True
340
341 if build_base:
342         env['build_base']="#/"+build_base
343 else:
344         env['build_base']="#/"
345
346 #
347 # Uppercase variables are for usage in code, lowercase versions for usage in
348 # scons-files for installing.
349 #
350 env['BINDIR'] = Template( env['BINDIR'] ).safe_substitute( env )
351 env['LIBDIR'] = Template( env['LIBDIR'] ).safe_substitute( env )
352 env['INCLUDEDIR'] = Template( env['INCLUDEDIR'] ).safe_substitute( env )
353 env['SHAREDIR'] = Template( env['SHAREDIR'] ).safe_substitute( env )
354 env['bindir'] = Template( destdir + env['BINDIR'] ).safe_substitute( env )
355 env['libdir'] = Template( destdir + env['LIBDIR'] ).safe_substitute( env )
356 env['includedir'] = Template( destdir + env['INCLUDEDIR'] ).safe_substitute( env )
357 env['sharedir'] = Template( destdir + env['SHAREDIR'] ).safe_substitute( env )
358
359 env.Command( target=env['sharedir'], source="", action=Mkdir( env['sharedir'] ) )
360
361 env.Alias( "install", env['libdir'] )
362 env.Alias( "install", env['includedir'] )
363 env.Alias( "install", env['sharedir'] )
364 env.Alias( "install", env['bindir'] )
365
366 #
367 # shamelessly copied from the Ardour scons file
368 #
369
370 opt_flags = []
371 env['USE_SSE'] = 0
372
373 # guess at the platform, used to define compiler flags
374
375 config_cpu = 0
376 config_arch = 1
377 config_kernel = 2
378 config_os = 3
379 config = config_guess.split ("-")
380
381 # Autodetect
382 if env['DIST_TARGET'] == 'auto':
383     if re.search ("x86_64", config[config_cpu]) != None:
384         env['DIST_TARGET'] = 'x86_64'
385     elif re.search("i[0-5]86", config[config_cpu]) != None:
386         env['DIST_TARGET'] = 'i386'
387     elif re.search("powerpc64", config[config_cpu]) != None:
388         env['DIST_TARGET'] = 'powerpc64'
389     elif re.search("powerpc", config[config_cpu]) != None:
390         env['DIST_TARGET'] = 'powerpc'
391     else:
392         env['DIST_TARGET'] = 'i686'
393     print "Detected DIST_TARGET = " + env['DIST_TARGET']
394
395 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)):
396    
397     build_host_supports_sse = 0
398     build_host_supports_sse2 = 0
399     build_host_supports_sse3 = 0
400
401     if config[config_kernel] == 'linux' :
402        
403         if (env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64'):
404            
405             flag_line = os.popen ("cat /proc/cpuinfo | grep '^flags'").read()[:-1]
406             x86_flags = flag_line.split (": ")[1:][0].split ()
407            
408             if "mmx" in x86_flags:
409                 opt_flags.append ("-mmmx")
410             if "sse" in x86_flags:
411                 build_host_supports_sse = 1
412             if "sse2" in x86_flags:
413                 build_host_supports_sse2 = 1
414             #if "sse3" in x86_flags:
415                 #build_host_supports_sse3 = 1
416             if "3dnow" in x86_flags:
417                 opt_flags.append ("-m3dnow")
418            
419             if config[config_cpu] == "i586":
420                 opt_flags.append ("-march=i586")
421             elif config[config_cpu] == "i686":
422                 opt_flags.append ("-march=i686")
423
424         elif (env['DIST_TARGET'] == 'powerpc') or (env['DIST_TARGET'] == 'powerpc64'):
425
426             cpu_line = os.popen ("cat /proc/cpuinfo | grep '^cpu'").read()[:-1]
427
428             ppc_type = cpu_line.split (": ")[1]
429             if re.search ("altivec", ppc_type) != None:
430                 opt_flags.append ("-maltivec")
431                 opt_flags.append ("-mabi=altivec")
432
433             ppc_type = ppc_type.split (", ")[0]
434             if re.match ("74[0145][0578]A?", ppc_type) != None:
435                 opt_flags.append ("-mcpu=7400")
436                 opt_flags.append ("-mtune=7400")
437             elif re.match ("750", ppc_type) != None:
438                 opt_flags.append ("-mcpu=750")
439                 opt_flags.append ("-mtune=750")
440             elif re.match ("PPC970", ppc_type) != None:
441                 opt_flags.append ("-mcpu=970")
442                 opt_flags.append ("-mtune=970")
443             elif re.match ("Cell Broadband Engine", ppc_type) != None:
444                 opt_flags.append ("-mcpu=cell")
445                 opt_flags.append ("-mtune=cell")
446
447     if ((env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64')) \
448        and build_host_supports_sse and env['ENABLE_OPTIMIZATIONS']:
449         opt_flags.extend (["-msse", "-mfpmath=sse"])
450         env['USE_SSE'] = 1
451
452     if ((env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64')) \
453        and build_host_supports_sse2 and env['ENABLE_OPTIMIZATIONS']:
454         opt_flags.extend (["-msse2"])
455         env['USE_SSE2'] = 1
456
457     #if ((env['DIST_TARGET'] == 'i686') or (env['DIST_TARGET'] == 'x86_64')) \
458        #and build_host_supports_sse2 and env['ENABLE_OPTIMIZATIONS']:
459         #opt_flags.extend (["-msse3"])
460         #env['USE_SSE3'] = 1
461
462     # build for 64-bit userland?
463     if env['DIST_TARGET'] == "powerpc64" or env['DIST_TARGET'] == "x86_64":
464         print "Doing a 64-bit build"
465         env.AppendUnique( CCFLAGS=["-m64"] )
466         env.AppendUnique( CFLAGS=["-m64"] )
467     else:
468         print "Doing a 32-bit build"
469         env.AppendUnique( CCFLAGS=["-m32"] )
470         env.AppendUnique( CFLAGS=["-m32"] )
471
472 # end of processor-specific section
473 if env['ENABLE_OPTIMIZATIONS']:
474     opt_flags.extend (["-fomit-frame-pointer","-ffast-math","-funroll-loops"])
475     env.AppendUnique( CCFLAGS=opt_flags )
476     env.AppendUnique( CFLAGS=opt_flags )
477     print "Doing an optimized build..."
478
479 env['REVISION'] = os.popen('svnversion .').read()[:-1]
480 # This may be as simple as '89' or as complex as '4123:4184M'.
481 # We'll just use the last bit.
482 env['REVISION'] = env['REVISION'].split(':')[-1]
483
484 if env['REVISION'] == 'exported':
485         env['REVISION'] = ''
486
487 env['FFADO_API_VERSION']=FFADO_API_VERSION
488
489 env['PACKAGE'] = "libffado"
490 env['VERSION'] = FFADO_VERSION
491 env['LIBVERSION'] = "1.0.0"
492
493 env['CONFIGDIR'] = "~/.ffado"
494 env['CACHEDIR'] = "~/.ffado"
495
496 env['REGISTRATION_URL'] = "http://ffado.org/deviceregistration/register.php?action=register"
497
498 #
499 # To have the top_srcdir as the doxygen-script is used from auto*
500 #
501 env['top_srcdir'] = env.Dir( "." ).abspath
502
503 #
504 # Start building
505 #
506 env.ScanReplace( "config.h.in" )
507 # ensure that the config.h is updated with the version
508
509 env.Depends( "config.h", "SConstruct" )
510 env.Depends( "config.h", 'cache/' + build_base + "options.cache" )
511
512 # update config.h whenever the SVN revision changes
513 env.Depends( "config.h", env.Value(env['REVISION']))
514
515 env.Depends( "libffado.pc", "SConstruct" )
516 pkgconfig = env.ScanReplace( "libffado.pc.in" )
517 env.Install( env['libdir'] + '/pkgconfig', pkgconfig )
518
519 subdirs=['external','src','libffado','tests','support','doc']
520 if build_base:
521         env.SConscript( dirs=subdirs, exports="env", build_dir=build_base+subdir )
522 else:
523         env.SConscript( dirs=subdirs, exports="env" )
524
525 if 'debian' in COMMAND_LINE_TARGETS:
526         env.SConscript("deb/SConscript", exports="env")
527
528 # By default only src is built but all is cleaned
529 if not env.GetOption('clean'):
530     Default( 'src' )
531     Default( 'support' )
532     if env['BUILD_TESTS']:
533         Default( 'tests' )
534
535 #
536 # Deal with the DESTDIR vs. xdg-tools conflict (which is basicely that the
537 # xdg-tools can't deal with DESTDIR, so the packagers have to deal with this
538 # their own :-/
539 #
540 if len(destdir) > 0:
541         if not len( ARGUMENTS.get( "WILL_DEAL_WITH_XDG_MYSELF", "" ) ) > 0:
542                 print """
543 WARNING!
544 You are using the (packagers) option DESTDIR to install this package to a
545 different place than the real prefix. As the xdg-tools can't cope with
546 that, the .desktop-files are not installed by this build, you have to
547 deal with them your own.
548 (And you have to look into the SConstruct to learn how to disable this
549 message.)
550 """
551 else:
552
553         def CleanAction( action ):
554                 if env.GetOption( "clean" ):
555                         env.Execute( action )
556
557         if env.has_key( 'XDG_TOOLS' ) and env.has_key( 'PYUIC' ):
558                 if not env.GetOption("clean"):
559                         action = "install"
560                 else:
561                         action = "uninstall"
562                 mixerdesktopaction = env.Action( "xdg-desktop-menu %s support/xdg/ffado.org-ffadomixer.desktop" % action )
563                 mixericonaction = env.Action( "xdg-icon-resource %s --size 64 --context apps support/xdg/hi64-apps-ffado.png" % action )
564                 env.Command( "__xdgstuff1", None, mixerdesktopaction )
565                 env.Command( "__xdgstuff2", None, mixericonaction )
566                 env.Alias( "install", ["__xdgstuff1", "__xdgstuff2" ] )
567                 CleanAction( mixerdesktopaction )
568                 CleanAction( mixericonaction )
569
570 #
571 # Create a tags-file for easier emacs/vim-source-browsing
572 #  I don't know if the dependency is right...
573 #
574 findcommand = "find . \( -path \"*.h\" -o -path \"*.cpp\" -o -path \"*.c\" \) \! -path \"*.svn*\" \! -path \"./doc*\" \! -path \"./cache*\""
575 env.Command( "tags", "", findcommand + " |xargs ctags" )
576 env.Command( "TAGS", "", findcommand + " |xargs etags" )
577 env.AlwaysBuild( "tags", "TAGS" )
578 env.NoCache( "tags", "TAGS" )
579
Note: See TracBrowser for help on using the browser.