Vadim Lebedev wrote: > Hello, > > I've promised some time ago to show my SCons based build system > > Here it is: > > > There is BuildJob.py module in Env directory which holds the main > functionality > > I'm attaching also the main SConstruct and SConscript file and > minua/SConscript > > > The main advantage over WengoScons > > 1) It is 3-4 times faster > 2) It avoid copying of the source files into the build directory > 3) There is component system where you can declare a component > and specify what you need to include and/or link in order to use the > component > and later you simply saye that your module uses the component all > link and include flags > will bes set automatically > 4) IMO it is much easier to understand >
The advantages of CMake:
* libsuffix handling (lib64) by default
* easy package finding
* you can build only one component e.g. "make phapi"
* faster than scons
* easier to understand
* creates msvc or makefiles
in short: scons sucks!
-- andreas
>
> Vadim
>
>
>
>
>
> ------------------------------------------------------------------------
>
> from Env import BuildJob
> import sys
>
>
> opts = Options('version.py')
> opts.AddOptions(
> BoolOption('video', "Enable Video Support", False),
> BoolOption('ssl', "Enable SSL support", True),
> BoolOption('httptunnel', "Enable HTTP tunneling support", False),
> BoolOption('netlib', "Enable netlib module support", False),
> BoolOption('phapi_embed', 'Compile PHPAPI for embedded environment',
> True),
> BoolOption('phapi_video_hack', "enable VIDEO HACK", False),
> BoolOption('shared_phapi', "Compile PHAPI as shared library", False),
> BoolOption('vcproj', "Build .vcproj files for use with debugger",
> False),
> BoolOption('libsamplerate', "Enable usage of libsamplerate", False),
> BoolOption('phapi_audio_arts', "Build PortAudio/arts support", False),
> BoolOption('phapi_audio_esd', "Build PortAudio/esd support", False),
> BoolOption('portaudio_oss', "Build PortAudio/OSS", False),
> BoolOption('portaudio_dsound', "Build PortAudio/DirectSound support",
> False),
> BoolOption('speex', "Build speex codec", True),
> BoolOption('speexwb_replaces_amrwb', "if set replace negotiated AMR-WB
> payload by SPEEX WB", False),
> BoolOption('speexwb_replaces_amrnb', "if set replace negotiated AMR-NB
> payload by SPEEX WB", False),
> BoolOption('speexwb_replaces_g726wb', "if set replace negotiated G726wb
> payload by SPEEX WB", False),
> BoolOption('ipp', "Enable usage of INTEL IPP Library", False),
> BoolOption('amr', "Enable usage of AMR codec", False),
> BoolOption('debug', "Enable debug build", True),
> BoolOption('qos_debug', "Enable QoS debugging functionality", False),
> BoolOption('enable_alsa', "Disable ALSA driver", False),
> ('target_os', "Target platform", sys.platform),
> ('VERONA_VERSION', "Software version", "0.0.2")
> )
>
> BJ = BuildJob.BuildJobInfo(opts)
> Export("BJ")
>
>
> env = BJ.NewEnv()
> if env["shared_phapi"]:
> BJ.sharedtarget = True
>
> #Duplicate = 0 is very important: it tells SCons
> #to not duplicate the source code inside the build directory;
> #without this it cannot work.
> TARNAME='Verona-' + env['VERONA_VERSION'] + '.tar.gz'
> x=env.Command(TARNAME,'',"tar cvfz " + TARNAME + " ../verona
> --exclude='debug' --exclude=*.sconsign --exclude=*.bak --exclude=*.dblite
> --exclude=*.gz --exclude=*.hg")
> env.Alias('dist',[x])
>
>
> print "VERONA Building in ", BJ.buildpath
>
> env.SConscript('SConscript', build_dir = BJ.buildpath, duplicate = 0)
>
>
>
> ------------------------------------------------------------------------
>
> Import("BJ")
>
> lib_projects = [
> # 'Env/libs/boost',
> 'Env/libs/sdl',
> 'libs/portaudio',
> 'libs/timer',
> 'libs/openssl',
> 'libs/curl',
> 'libs/util',
> 'libs/ffmpeg',
> 'libs/pixertool',
> 'libs/webcam',
>
> ]
>
>
> if BJ.msvc:
> phapi_optimization_flags = [
> '/Ox',
> '/Ob2',
> '/Oi',
> '/Ot',
> '/Oy',
> '/G7',
> '/GX-',
> '/GR-' ,
> '/arch:SSE'
> ]
> else:
> phapi_optimization_flags = [ '-O6' ]
>
>
>
> BJ.phapi_optimization_flags = phapi_optimization_flags
>
>
> #SConscript(dirs = lib_projects)
>
> env = BJ.NewEnv()
>
> #print "SConscript Compiling with", env.subst('$CC')
>
> projects = []
>
> if env["video"]:
> print "With Video"
>
> projects += [
> 'libs/ffmpeg',
> 'libs/util',
> 'libs/timer',
> 'libs/pixertool',
> 'libs/webcam',
> ]
> else:
> print "No Video"
>
>
> projects += [
> 'libs/openssl',
> 'libs/portaudio',
> 'libs/curl',
> 'httptunnel',
> 'libosip2',
> 'ortp',
> 'eXosip',
> 'phapi/stun',
> 'phapi/gsm',
> 'phapi/ilbc',
> env["speex"] and 'phapi/speex',
> 'phapi',
> 'miniua'
> ]
>
> projects1 = [
> ]
>
>
> print "Verona SConscript"
> SConscript(dirs = [ x for x in projects if x != False])
>
>
> ------------------------------------------------------------------------
>
> Import("BJ")
>
> print "Building minua"
>
> env = BJ.NewEnv()
>
> if BJ.armlinuxTarget:
> defines = { }
> else:
> defines = { 'PHAPI_DLL' : 1}
>
>
> libs = [
> 'phapi'
> ]
>
> lib_path = []
> includes = ['../phapi']
> headers = []
> sources = [ 'miniua.c' ]
>
> link_flags = []
> cc_flags = []
>
> if BJ.osxTarget:
> link_flags = [
> '-framework CoreAudio',
> '-framework AudioToolbox',
> '-framework AudioUnit',
> '-framework Cocoa',
> '-framework Quicktime',
> ]
>
>
> if BJ.linuxTarget:
> libs += ["z", "veronacurl", "portaudio"]
>
> env.ParseConfig('pkg-config alsa --cflags --libs')
>
> if env["video"]:
> env.ParseConfig('sdl-config --cflags --libs')
>
> if BJ.armlinuxTarget:
> libs += ["z", "veronacurl","asound"]
> # libs += ["z", "veronacurl", "portaudio", "asound"]
>
>
>
> if env["video"]:
> env.ParseConfig('sdl-config --cflags --libs')
>
>
>
> if BJ.win32Target:
> defines['WIN32'] = 1
> link_flags += ['/subsystem:console']
>
> if env["video"]:
> sdlpath = "C:/SDL-1.2.9"
> sdllibpath = sdlpath + "/VisualC"
> env.Append(CPPPATH = [ sdlpath + "/include"],
> LIBPATH = [ sdllibpath + "/SDL/Debug/",
> sdllibpath + "/SDLMain/Debug/" ],
> LIBS = ["sdl.lib", "sdlmain.lib"])
>
> if env["video"]:
> defines["ENABLE_VIDEO"] = 1
> libs += ["pixertool"]
>
>
>
> env.Append(CCFLAGS = cc_flags, LINKFLAGS = link_flags, CPPDEFINES = defines,
> CPPPATH = includes)
> print 'CCFLAGS', env['CCFLAGS']
>
> print "BJ.Use(env, libs)"
> BJ.Use(env, libs)
>
>
>
> m = env.Program('miniua', sources)
>
>
> ------------------------------------------------------------------------
>
> import sets, os, time, sys
> from SCons.Environment import Environment
>
> Set = sets.Set
>
> class CompInfo:
>
> def __init__(self, name, includes = [], libpathes = [], libs = [] , uses
> = [], node = None):
> self.name = name
> self.includes = sets.ImmutableSet(includes)
> self.libpathes = sets.ImmutableSet(libpathes)
> self.libs = sets.ImmutableSet(libs)
> self.depends = uses
> self.node = node
>
>
> def use(self, env):
> """ add to the given environement information needed to use this
> moduel"""
>
> dict = env.Dictionary()
>
> def evar(k):
> if dict.has_key(k):
> return dict[k]
>
> return []
>
>
>
> env.AppendUnique(LIBPATH = list(self.libpathes))
> env.AppendUnique(CPPPATH = list(self.includes))
> env.AppendUnique(LIBS = list(self.libs))
>
> # print "Preparing for:", self.name, " libs=", self.libs
> for m in self.depends:
> m.use(env)
>
>
>
>
> class BuildJobInfo:
>
>
> def __init__(self, opts):
>
>
> env = Environment(options = opts)
> env.Help(opts.GenerateHelpText(env))
>
> self.env = env
> self.debug = env["debug"]
> self.targetos = env["target_os"]
>
> if "CC" in os.environ.keys():
> self.cc = os.environ['CC']
> else:
> self.cc = env["CC"]
>
> if "CFLAGS" in os.environ.keys():
> self.cf = os.environ['CFLAGS']
> else:
> self.cf = []
>
> # print "self CFLAGS is ", self.cf
>
> self.armlinuxTarget = "arm-linux" in self.cc
>
> if not self.armlinuxTarget:
> self.linuxTarget = "linux" in self.targetos
> else:
> self.linuxTarget = 0
>
> self.win32Target = self.targetos == "win32"
> self.posixTarget = self.targetos in [ "linux", "osx" ]
> self.osxTarget = self.targetos == "osx"
> self.bsdTarget = "BSD" in self.targetos
>
> self.msvc = self.cc == "cl"
> self.gcc = ("gcc" in self.cc) or ("mingw" in self.cc)
> self.mingw = "mingw" in self.cc
> self.components = { }
> self.opts = opts
>
> if self.armlinuxTarget:
> self.buildpath = "armlinux"
> elif self.mingw:
> self.buildpath = "mingw"
> elif self.win32Target:
> self.buildpath = "win32"
> elif self.osxTarget:
> self.buildpath = "osx"
> elif self.linuxTarget:
> self.buildpath = "linux"
>
>
>
> if self.debug:
> self.buildpath += "/debug"
> else:
> self.buildpath += "/release"
>
>
> self.sharedtarget = False
>
>
> def Component(self, name, includes = [], libpath = [], libs = [], uses =
> [], node = None):
> if self.components.has_key(name):
> return self.components[name]
>
> def compinfo(x):
> if isinstance(x, CompInfo):
> return x
>
> if not x in self.components.keys():
> self.components[x] = CompInfo(x, libs = [ x ])
>
> return self.components[x]
>
> if uses and len(uses):
> newuses = [ compinfo(x) for x in uses ]
> else:
> newuses = []
>
> if node:
> self.env.Alias(name, node)
>
> if node:
> if len(libpath) == 0:
> libpath = [node[0].dir]
> if len(libs) == 0:
> libs = [name]
>
> m = CompInfo(name, includes, libpath, libs, newuses, node)
> self.components[name] = m
> if node:
> self.env.Alias(name, node)
>
> return m
>
>
> def CompNode(self, name):
> return self.components[name].node
>
>
> def Use(self, env, uses, USEDEBUG=False):
>
> dict = env.Dictionary()
> def showprep(msg):
> l = []
> for k in ["CPPPATH", "LIBPATH", "LIBS"]:
> v = ""
> if dict.has_key(k):
> v = dict[k]
> l += [(k,v)]
> print msg, l
>
> #showprep("Before preparing")
> usedComponents = [ self.components[x] for x in ( Set(uses) &
> Set(self.components.keys())) ]
> for m in usedComponents:
> m.use(env)
>
> stdlibs = Set(uses) - Set(self.components.keys())
> env.AppendUnique(LIBS = list(stdlibs))
>
>
> #showprep("After preparing")
>
>
>
>
> def NewEnv(self):
> env = Environment(options = self.opts)
> env['CC'] = self.cc
> if self.armlinuxTarget:
> env.Append( CCFLAGS = self.cf )
>
> if self.win32Target:
> # print "preparing for Win32"
> env['CC']=self.cc
> env.Append( CPPDEFINES = { 'WIN32' : 1, '_WIN32' : 1 } )
> if self.msvc:
> debug = ""
> if self.debug:
> debug = "d"
> env.AppendUnique(LINKFLAGS = [ "/DEBUG", "/MAP",
> "/NODEFAULTLIB:LIBC.LIB" ])
> env.AppendUnique(SHCCFLAGS = "/MD" + debug, SHCXXFLAGS = "/MD"
> + debug)
>
> return env
>
>
> def Autoconf(self, env, moduleName, outputFiles,
> configureCommand = './configure', makeCommand = 'make',
> configureFiles = 'configure', makeFiles = 'Makefile',
> uses = None, includes = None, libpath = None, libs =
> None):
> """
> Build a library using autotools: configure and make.
>
> Algorithm:
> - Launch the configure command
> - Launch the make command
> - Declare the library as an internal library
>
> @type libraryName string
> @param libraryName name of the library to compile
> @type outputFiles stringlist
> @param outputFiles list of awaited files (.a, .so, .dll, .dylib...)
> @type configureCommand string
> @param configureCommand command line for 'configure' (e.g
> './configure --enable-gtk --disable-blahblah')
> @type makeCommand string
> @param makeCommand command line for 'make' (e.g 'make blahblah')
> @type configureFiles string
> @param configureFiles files needed by configure (e.g the configure
> script 'configure' is needed by configure)
> @type makeFiles string
> @param makeFiles files needed by male (e.g the file 'Makefile' is
> needed by make)
> """
>
>
> bldDir = env.Dir(".").path
>
> makefile = env.Command(makeFiles, configureFiles,
> 'cd ' + bldDir + ' && ' +
> configureCommand)
> make = env.Command(outputFiles, makeFiles,
> 'cd ' + bldDir + ' && ' + makeCommand)
>
> env.Depends(make, makefile)
> #self.Component(moduleName, includes, libpath, libs, uses)
> env.Alias(moduleName, [make])
>
>
>
> def Plugin(self, env, target, source, **kw):
> lib = None
> try:
> #SCons 0.96.91 support (pre-release for 0.97)
> tmp = env['LDMODULEPREFIX']
> #Removes the library name prefix
> env['LDMODULEPREFIX'] = ''
> lib = env.LoadableModule(target, source, **kw)
> env['LDMODULEPREFIX'] = tmp
> except KeyError:
> #SCons 0.96.1 support (stable version)
> tmp = env['SHLIBPREFIX']
> #Removes the library name prefix
> env['SHLIBPREFIX'] = ''
> lib = env.SharedLibrary(target, source, **kw)
> env['SHLIBPREFIX'] = tmp
>
> return lib
>
>
> def Library(self, env, target, source = None, uses = [], includes = [],
> libpath = [], libs = [], sharedtarget = None, **kw):
>
> if sharedtarget == None:
> sharedtarget = self.sharedtarget
>
>
> self.Use(env, uses)
> env.AppendUnique( **kw )
> if sharedtarget:
> obj = env.SharedObject( source = source)
> else:
> obj = env.StaticObject( source = source)
>
>
> lib = env.StaticLibrary( target, obj )
> self.Component(target, includes = includes, libpath = libpath, libs =
> libs, uses = uses, node = lib)
>
> return lib
>
>
> def SharedLibrary(self, env, target, source, uses = [], includes = [],
> libpath = [], libs = [], **kw):
>
> self.Use(env, uses)
> env.AppendUnique( **kw )
> lib = env.SharedLibrary( target, source = source )
> self.Component(target, includes = includes, libpath = libpath, libs =
> libs, uses = uses, node = lib)
>
> return lib
>
>
>
> ------------------------------------------------------------------------
>
> _______________________________________________
> Wengophone-devel mailing list
> [email protected]
> http://dev.openwengo.com/mailman/listinfo/wengophone-devel
--
http://www.cynapses.org/ - cybernetic synapses
signature.asc
Description: OpenPGP digital signature
_______________________________________________ Wengophone-devel mailing list [email protected] http://dev.openwengo.com/mailman/listinfo/wengophone-devel
