PK -Fkm cuppa/__init__.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
def run( *args, **kwargs ):
import cuppa.core
cuppa.core.run( *args, **kwargs )
def add_option( *args, **kwargs ):
import cuppa.core
cuppa.core.add_option( *args, **kwargs )
import cuppa.build_with_header_library
from cuppa.build_with_header_library import header_library_dependency
PK 'FoSҊ
cuppa/tree.py# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Tree
#-------------------------------------------------------------------------------
def get_all_children( node ):
return node.all_children()
def filter_out( path, ignore_filter ):
for ignore in ignore_filter:
if path.startswith( ignore ):
return True
return False
# process_callback should have the signature process( node )
def process_tree( root, process_callback, ignore_filter=[], visited=set() ):
path = str( root )
children = get_all_children( root )
if path in visited and children:
process_callback( root )
return
visited.add( path )
if filter_out( path, ignore_filter ):
return
process_callback( root )
if children:
for child in children[:-1]:
process_tree( child, process_callback, ignore_filter, visited )
process_tree( children[-1], process_callback, ignore_filter, visited )
def print_tree( root, ignore_filter=[], margin=[0], visited=set() ):
path = str( root )
children = get_all_children( root )
def get_margin(m):
return [" ","| "][m]
margins = list(map(get_margin, margin[:-1]))
if path in visited and children:
print ''.join(margins + ['+-[', path, ']'])
return
visited.add( path )
if filter_out( path, ignore_filter ):
return
print ''.join(margins + ['+-', path])
if children:
margin.append(1)
for child in children[:-1]:
print_tree( child, ignore_filter, margin, visited )
margin[-1] = 0
print_tree( children[-1], ignore_filter, margin, visited )
margin.pop()
PK FL: : cuppa/location.py# Copyright Jamie Allsop 2014-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Location
#-------------------------------------------------------------------------------
import os
import urlparse
import urllib
import zipfile
import tarfile
import shutil
import re
import shlex
import subprocess
import ntpath
import fnmatch
import pip.vcs
import pip.download
import pip.exceptions
import scms.subversion
import scms.git
import scms.mercurial
class LocationException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
def path_leaf(path):
base, leaf = ntpath.split( path )
return leaf or ntpath.basename( base )
def get_common_top_directory_under( path ):
dirs = os.listdir( path )
top_dir = os.path.join( path, dirs[0] )
if len(dirs) == 1 and os.path.isdir( top_dir ):
return dirs[0]
return None
class Location(object):
def get_cached_archive( self, cache_root, path ):
print "cuppa: location: Checking for cached archive [{}]...".format( self._as_info( path ) )
for archive in os.listdir(cache_root):
if fnmatch.fnmatch( archive, path ):
print "cuppa: location: Found cached archive [{}] skipping download".format( self._as_info( archive ) )
return os.path.join( cache_root, archive )
return None
def remove_common_top_directory_under( self, path ):
dirs = os.listdir( path )
if not dirs:
raise LocationException( "Uncompressed archive [{}] is empty".format( path ) )
top_dir = os.path.join( path, dirs[0] )
if len(dirs) == 1 and os.path.isdir( top_dir ):
print "cuppa: location: Removing redundant top directory [{}] from [{}]".format( self._as_info( dirs[0] ), self._as_info( path ) )
# we have a single top-level directory
move_dirs = os.listdir( top_dir )
for d in move_dirs:
shutil.move( os.path.join( top_dir, d ), os.path.join( path, d ) )
shutil.rmtree( top_dir )
return True
return False
def extract( self, filename, target_dir ):
os.makedirs( target_dir )
if tarfile.is_tarfile( filename ):
print "cuppa: location: Extracting [{}] into [{}]".format( self._as_info( filename ), self._as_info( target_dir ) )
try:
with tarfile.TarFile( filename ) as tf:
tf.extractall( target_dir )
except tarfile.ReadError:
command = "tar -xf {filename}".format( filename=filename )
if subprocess.call( shlex.split( command ), cwd=target_dir ) != 0:
raise LocationException( "Could not untar downloaded file from [{}]".format( filename ) )
if zipfile.is_zipfile( filename ):
print "cuppa: location: extracting [{}] into [{}]".format( self._as_info( filename ), self._as_info( target_dir ) )
with zipfile.ZipFile( filename ) as zf:
zf.extractall( target_dir )
while self.remove_common_top_directory_under( target_dir ):
pass
def url_is_download_archive_url( self, path ):
base, download = os.path.split( path )
if download == "download":
return pip.download.is_archive_file( base )
else:
return pip.download.is_archive_file( path )
def get_local_directory( self, env, location, sub_dir, branch, full_url ):
local_directory = None
base = env['download_root']
if not os.path.isabs( base ):
base = os.path.join( env['working_dir'], base )
if location.startswith( 'file:' ):
location = pip.download.url_to_path( location )
if not pip.download.is_url( location ):
if pip.download.is_archive_file( location ):
local_directory = os.path.splitext( path_leaf( location ) )[0]
name, ext = os.path.splitext( local_directory )
if ext == ".tar":
local_directory = name
local_directory = re.sub( r'[\\/+:() ]', r'#', local_directory )
local_directory = os.path.join( base, local_directory )
if os.path.exists( local_directory ):
try:
os.rmdir( local_directory )
except:
return local_directory
self.extract( location, local_directory )
else:
local_directory = branch and os.path.join( location, branch ) or location
return local_directory
else:
local_name = '#'.join( [ full_url.scheme, full_url.netloc, urllib.unquote( full_url.path ) ] )
local_name = re.sub( r'[\\/+:() ]', r'#', local_name )
local_directory = os.path.join( base, local_name )
if full_url.scheme.startswith( 'http' ) and self.url_is_download_archive_url( full_url.path ):
print "cuppa: location: [{}] is an archive download".format( self._as_info( location ) )
local_dir_with_sub_dir = os.path.join( local_directory, sub_dir )
# First we check to see if we already downloaded and extracted this archive before
if os.path.exists( local_dir_with_sub_dir ):
try:
# If not empty this will fail
os.rmdir( local_dir_with_sub_dir )
except:
# Not empty so we'll return this as the local_directory
return local_directory
# If not we then check to see if we cached the download
cached_archive = self.get_cached_archive( env['cache_root'], local_name )
if cached_archive:
print "cuppa: location: Cached archive [{}] found for [{}]".format( self._as_info( cached_archive ), self._as_info( location ) )
self.extract( cached_archive, local_dir_with_sub_dir )
else:
print "cuppa: location: downloading [{}]...".format( self._as_info( location ) )
filename, headers = urllib.urlretrieve( location )
name, extension = os.path.splitext( filename )
print "cuppa: location: [{}] successfully downloaded to [{}]".format( self._as_info( location ), self._as_info( filename ) )
self.extract( filename, local_dir_with_sub_dir )
if env['cache_root']:
cached_archive = os.path.join( env['cache_root'], local_name )
print "cuppa: location: caching downloaded file as [{}]".format( self._as_info( cached_archive ) )
shutil.copyfile( filename, cached_archive )
elif '+' in full_url.scheme:
vc_type = location.split('+', 1)[0]
backend = pip.vcs.vcs.get_backend( vc_type )
if backend:
vcs_backend = backend( location )
rev_options = self.get_rev_options( vc_type, vcs_backend )
local_dir_with_sub_dir = os.path.join( local_directory, sub_dir )
if os.path.exists( local_directory ):
url, repository, branch, revision = self.get_info( location, local_dir_with_sub_dir, full_url )
version = self.ver_rev_summary( branch, revision, self._full_url.path )[0]
print "cuppa: location: updating [{}] in [{}]{} at [{}]".format(
self._as_info( location ),
self._as_notice( local_dir_with_sub_dir ),
( rev_options and " on {}".format( self._as_notice( str(rev_options) ) ) or "" ),
self._as_info( version )
)
try:
vcs_backend.update( local_dir_with_sub_dir, rev_options )
print "cuppa: location: successfully updated [{}]".format( self._as_info( location ) )
except pip.exceptions.InstallationError as error:
print "cuppa: {}: location: could not update [{}] in [{}]{} due to error [{}]".format(
self._as_warning_label( " warning " ),
self._as_warning_text( location ),
self._as_warning_text( local_dir_with_sub_dir ),
( rev_options and " at {}".format( self._as_warning_text( str(rev_options) ) ) or "" ),
self._as_warning_text( str(error) )
)
else:
action = "cloning"
if vc_type == "svn":
action = "checking out"
print "cuppa: location: {} [{}] into [{}]".format( action, self._as_info( location ), self._as_info( local_dir_with_sub_dir ) )
try:
vcs_backend.obtain( local_dir_with_sub_dir )
print "cuppa: location: successfully retrieved [{}]".format( self._as_info( location ) )
except pip.exceptions.InstallationError as error:
print "cuppa: {}: location: could not retrieve [{}] into [{}]{} due to error [{}]".format(
self._as_error_label( " error " ),
self._as_error_text( location ),
self._as_error_text( local_dir_with_sub_dir ),
( rev_options and " to {}".format( self._as_error_text( str(rev_options) ) ) or ""),
self._as_error_text( str( error ) )
)
raise LocationException( "Error obtaining [{}]: {}".format( location, error ) )
return local_directory
def get_rev_options( self, vc_type, vcs_backend ):
url, rev = vcs_backend.get_url_rev()
if vc_type == 'git':
if rev:
return [rev]
else:
return ['origin/master']
elif vc_type == 'hg' and rev:
return vcs_backend.get_rev_options( url, rev )
elif vc_type == 'bzr' and rev:
return ['-r', rev]
return []
def get_info( self, location, local_directory, full_url ):
url = location
repository = urlparse.urlunparse( ( full_url.scheme, full_url.netloc, '', '', '', '' ) )
branch = urllib.unquote( full_url.path )
revision = None
info = ( url, repository, branch, revision )
vcs_directory = local_directory
try:
info = scms.git.info( vcs_directory )
return info
except scms.git.GitException:
pass
try:
info = scms.subversion.info( vcs_directory )
return info
except scms.subversion.SubversionException:
pass
try:
info = scms.mercurial.info( vcs_directory )
return info
except scms.mercurial.MercurialException:
pass
return info
def ver_rev_summary( self, branch, revision, full_url_path ):
if branch and revision:
version = ' rev. '.join( [ str(branch), str(revision) ] )
elif branch and revision:
version = ' rev. '.join( [ str(branch), str(revision) ] )
else:
version = os.path.splitext( path_leaf( urllib.unquote( full_url_path ) ) )[0]
name, ext = os.path.splitext( version )
if ext == ".tar":
version = name
version = version
revision = "not under version control"
return version, revision
def _as_error_label( self, text ):
return self._colouriser.highlight( 'error', text )
def _as_error_text( self, text ):
return self._colouriser.as_error( text )
def _as_warning_label( self, text ):
return self._colouriser.highlight( 'warning', text )
def _as_warning_text( self, text ):
return self._colouriser.as_warning( text )
def _as_info( self, text ):
return self._colouriser.as_info( text )
def _as_notice( self, text ):
return self._colouriser.as_notice( text )
def __init__( self, env, location, branch=None, extra_sub_path=None ):
self._colouriser = env['colouriser']
self._location = location
self._full_url = urlparse.urlparse( location )
self._sub_dir = ""
if extra_sub_path:
if os.path.isabs( extra_sub_path ):
raise LocationException()
else:
self._sub_dir = os.path.normpath( extra_sub_path )
## Get the location for the source dependency. If the location is a URL or an Archive we'll need to
## retrieve the URL and extract the archive. get_local_directory() returns the location of the source
## once this is done
local_directory = self.get_local_directory( env, location, self._sub_dir, branch, self._full_url )
self._base_local_directory = local_directory
self._local_directory = os.path.join( local_directory, self._sub_dir )
## Now that we have a locally accessible version of the dependency we can try to collate some information
## about it to allow us to specify what we are building with.
self._url, self._repository, self._branch, self._revision = self.get_info( self._location, self._local_directory, self._full_url )
self._version, self._revision = self.ver_rev_summary( self._branch, self._revision, self._full_url.path )
print "cuppa: location: using [{}]{} at [{}] stored in [{}]".format(
self._as_info( location ),
( branch and ":[{}]".format( self._as_info( str(branch) ) ) or "" ),
self._as_info( self._version ),
self._as_notice( self._local_directory )
)
def local( self ):
return self._local_directory
def base_local( self ):
return self._base_local_directory
def sub_dir( self ):
return self._sub_dir
def location( self ):
return self._location
def url( self ):
return self._url
def branch( self ):
return self._branch
def repository( self ):
return self._repository
def version( self ):
return str(self._version)
def revisions( self ):
return [ self._revision ]
PK Fr] ] cuppa/timer.py
# Copyright Jamie Allsop 2013-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Timer
#-------------------------------------------------------------------------------
# Python Standard Library Imports
import os
import timeit
import time
import sys
nanosecs_multiple = 1000000000
def wall_time_nanosecs():
return int( timeit.default_timer()*nanosecs_multiple )
def process_times_nanosecs():
process = time.clock()
user, system, children_user, children_system, real = os.times()
return int( process*nanosecs_multiple), int( user*nanosecs_multiple ), int( system*nanosecs_multiple )
class CpuTimes(object):
def __init__( self, wall, process, system, user ):
self.wall = wall
self.process = process
self.system = system
self.user = user
def __add__( self, other ):
if isinstance( other, self.__class__ ):
return CpuTimes(
self.wall + other.wall,
self.process + other.process,
self.system + other.system,
self.user + other.user
)
else:
raise TypeError("Unsupported operand type(s) for +: '{}' and '{}'").format(self.__class__, type(other))
def __sub__( self, other ):
if isinstance( other, self.__class__ ):
return CpuTimes(
self.wall - other.wall,
self.process - other.process,
self.system - other.system,
self.user - other.user
)
else:
raise TypeError("Unsupported operand type(s) for -: '{}' and '{}'").format(self.__class__, type(other))
class Timer(object):
@classmethod
def _current_time( cls ):
wall = wall_time_nanosecs()
process, user, system = process_times_nanosecs()
return CpuTimes( wall, process, system, user )
@classmethod
def _elapsed_time( cls, current, start ):
return current - start
def __init__( self ):
self.start()
def elapsed( self ):
if not self._stopped:
self._current = self._current_time()
return self._elapsed_time( self._current, self._start )
def start( self ):
self._stopped = False
self._start = self._current_time()
def stop( self ):
self._stopped = True
self._current = self._current_time()
def resume( self ):
self.start()
class no_colourising(object):
def emphasise( self, text ):
return text
def emphasise_time_by_digit( self, text ):
return text
def colour( self, text ):
return text
def as_duration_string( total_nanosecs ):
secs, remainder = divmod( total_nanosecs, 1000000000 )
millisecs, remainder = divmod( remainder, 1000000 )
microsecs, nanosecs = divmod( remainder, 1000 )
hours, remainder = divmod( secs, 3600 )
minutes, secs = divmod( remainder, 60 )
duration = "%02d:%02d:%02d.%03d,%03d,%03d" % ( hours, minutes, secs, millisecs, microsecs, nanosecs )
return duration
def as_wall_cpu_percent_string( cpu_times ):
wall_cpu_percent = "n/a"
if cpu_times.wall:
percent = "{:.2f}".format( float(cpu_times.process) * 100 / cpu_times.wall )
wall_cpu_percent = "%6s%%" % percent.upper()
return wall_cpu_percent
def write_time( cpu_times, colouriser=no_colourising(), emphasise=False ):
def write( text ):
if not emphasise:
sys.stdout.write( text )
else:
sys.stdout.write( colouriser.emphasise( text ) )
write( " Time:" )
write( " Wall [ {}".format( colouriser.emphasise_time_by_digit( as_duration_string( cpu_times.wall ) ) ) )
write( " ] CPU [ {}".format( colouriser.emphasise_time_by_digit( as_duration_string( cpu_times.process ) ) ) )
write( " ] CPU/Wall [ {}".format( colouriser.colour( 'time', as_wall_cpu_percent_string( cpu_times ) ) ) )
write( " ]" )
PK FO " cuppa/build_with_header_library.py# Copyright Jamie Allsop 2014-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# build_with_header_library
#-------------------------------------------------------------------------------
import os
import cuppa.location
class HeaderLibraryException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class base(object):
_name = None
@classmethod
def add_options( cls, add_option ):
location_name = cls._name + "-location"
branch_name = cls._name + "-branch"
include_name = cls._name + "-include"
sys_include_name = cls._name + "-sys-include"
add_option( '--' + location_name, dest=location_name, type='string', nargs=1, action='store',
help = cls._name + ' location to build against' )
add_option( '--' + branch_name, dest=branch_name, type='string', nargs=1, action='store',
help = cls._name + ' branch to build against. Providing a branch is optional' )
add_option( '--' + include_name, dest=include_name, type='string', nargs=1, action='store',
help = cls._name + ' include sub-directory to be added to the include path. Optional' )
add_option( '--' + sys_include_name, dest=sys_include_name, type='string', nargs=1, action='store',
help = cls._name + ' include sub-directory to be added to the system include path. Optional' )
@classmethod
def add_to_env( cls, env, add_dependency ):
location = env.get_option( cls._name + "-location" )
branch = env.get_option( cls._name + "-branch" )
if not location and branch:
location = env['branch_root']
if not location and branch:
location = env['thirdparty']
if not location:
print "cuppa: No location specified for dependency [{}]. Dependency not available.".format( cls._name.title() )
include = env.get_option( cls._name + "-include" )
includes = include and [include] or []
sys_include = env.get_option( cls._name + "-sys-include" )
sys_includes = sys_include and [sys_include] or []
add_dependency( cls._name, cls( env, location, branch=branch, includes=includes, sys_includes=sys_includes) )
def __init__( self, env, location, branch=None, includes=[], sys_includes=[] ):
self._location = cuppa.location.Location( env, location, branch )
if not includes and not sys_includes:
includes = [self._location.local()]
self._includes = []
for include in includes:
if include:
self._includes.append( os.path.isabs(include) and include or os.path.join( self._location.local(), include ) )
self._sys_includes = []
for include in sys_includes:
if include:
self._sys_includes.append( os.path.isabs(include) and include or os.path.join( self._location.local(), include ) )
def __call__( self, env, toolchain, variant ):
env.AppendUnique( INCPATH = self._includes )
env.AppendUnique( SYSINCPATH = self._sys_includes )
def name( self ):
return self._name
def version( self ):
return str(self._location.version())
def repository( self ):
return self._location.repository()
def branch( self ):
return self._location.branch()
def revisions( self ):
return self._location.revisions()
def header_library_dependency( name ):
return type( 'BuildWith' + name.title(), ( base, ), { '_name': name } )
PK 5Fy y
cuppa/path.py# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Path
#-------------------------------------------------------------------------------
# Python Standard
import os.path
def split_common( path1, path2 ):
drive1, p1 = os.path.splitdrive( path1 )
drive2, p2 = os.path.splitdrive( path2 )
if drive1 != drive2:
return None, path1, path2
p1_elements = p1.split( os.path.sep )
p2_elements = p2.split( os.path.sep )
p1_len = len( p1_elements )
p2_len = len( p2_elements )
max_index = min( p1_len, p2_len )
index = 0
common = [ drive1 ]
while index < max_index:
if p1_elements[index] == p2_elements[index]:
common.append( p1_elements[index] )
index = index+1
else:
break;
return os.path.join( '', *common ), os.path.join( '', *p1_elements[index:] ), os.path.join( '', *p2_elements[index:] )
PK F
cuppa/progress.py
# Copyright Jamie Allsop 2013-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Progress
#-------------------------------------------------------------------------------
class NotifyProgress(object):
_callbacks = set()
_sconstruct_begin = None
_sconstruct_end = None
_begin = {}
_end = {}
_started = {}
_finished = {}
@classmethod
def register_callback( cls, env, callback ):
if env:
if not 'cuppa_progress_callbacks' in env:
env['cuppa_progress_callbacks'] = set()
env['cuppa_progress_callbacks'].add( callback )
else:
cls._callbacks.add( callback )
@classmethod
def call_callbacks( cls, event, sconscript, variant, env, target, source ):
if 'cuppa_progress_callbacks' in env:
for callback in env['cuppa_progress_callbacks']:
callback( event, sconscript, variant, env, target, source )
for callback in cls._callbacks:
callback( event, sconscript, variant, env, target, source )
@classmethod
def _variant( cls, env ):
return env['build_dir']
@classmethod
def _sconscript( cls, env ):
return env['sconscript_file']
@classmethod
def add( cls, env, target ):
default_env = env['default_env']
sconscript_env = env['sconscript_env']
sconscript = cls._sconscript( sconscript_env )
variant = cls._variant( env )
if not cls._sconstruct_begin:
cls._sconstruct_begin = progress( '#SconstructBegin', 'sconstruct_begin', None, None, default_env )
if not sconscript in cls._begin:
cls._begin[sconscript] = progress( 'Begin', 'begin', sconscript, None, sconscript_env )
begin = cls._begin[sconscript]
env.Requires( begin, cls._sconstruct_begin )
if variant not in cls._started:
cls._started[variant] = progress( 'Started', 'started', sconscript, env['build_dir'], env )
env.Requires( target, cls._started[variant] )
env.Requires( cls._started[variant], begin )
if variant not in cls._finished:
cls._finished[variant] = progress( 'Finished', 'finished', sconscript, env['build_dir'], env )
finished = env.Depends(
cls._finished[variant],
[ target, '#' + env['sconscript_file'], '#' + env['sconstruct_file'] ]
)
if not sconscript in cls._end:
cls._end[sconscript] = progress( 'End', 'end', sconscript, None, sconscript_env )
end = env.Requires( cls._end[sconscript], finished )
if not cls._sconstruct_end:
cls._sconstruct_end = progress( '#SconstructEnd', 'sconstruct_end', None, None, default_env )
env.Requires( cls._sconstruct_end, end )
def progress( label, event, sconscript, variant, env ):
return env.Command( label, [], Progress( event, sconscript, variant, env ) )
class Progress(object):
def __init__( self, event, sconscript, variant, env ):
self._event = event
self._file = sconscript
self._variant = variant
self._env = env
def __call__( self, target, source, env ):
NotifyProgress.call_callbacks( self._event, self._file, self._variant, self._env, target, source )
return None
PK FfNE E cuppa/colourise.py
# Copyright Declan Traynor 2012
# Copyright Jamie Allsop 2012-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Colouriser
#-------------------------------------------------------------------------------
import re
try:
import colorama
colorama_available = True
except ImportError:
print 'Output Colourisation disabled. To enabled, install colorama'
colorama_available = False
class Colouriser(object):
@classmethod
def create( cls ):
if colorama_available:
colorama.init()
return cls()
def __init__( self ):
self.use_colour = False
def enable( self ):
self.use_colour = True
def colour( self, meaning, text ):
if not self.use_colour:
return text
else:
return self.start_colour( meaning ) + text + colorama.Style.RESET_ALL
def emphasise( self, text ):
if not self.use_colour:
return text
else:
return colorama.Style.BRIGHT + text + colorama.Style.RESET_ALL
def emphasise_time_by_group( self, time_text ):
if not self.use_colour:
return time_text
else:
time_elements = re.findall( r'[0-9]+[:.,]?', time_text )
time_found = False
emphasised = self.start_colour('time')
empty = re.compile( r'00[:.]|000[,]?' )
for element in time_elements:
if not time_found and not empty.match( element ):
time_found = True
emphasised += self.start_highlight('time')
emphasised += element
emphasised += colorama.Style.RESET_ALL
return emphasised
def emphasise_time_by_digit( self, time_text ):
if not self.use_colour:
return time_text
else:
time_found = False
emphasised = self.start_colour('time')
for char in time_text:
if not time_found and char.isdigit() and int(char) > 0:
time_found = True
emphasised += self.start_highlight('time')
emphasised += char
emphasised += colorama.Style.RESET_ALL
return emphasised
def highlight( self, meaning, text ):
if not self.use_colour:
return text
else:
return self.start_highlight( meaning ) + text + colorama.Style.RESET_ALL
def start_colour( self, meaning ):
if self.use_colour:
return self._start_colour( meaning )
return ''
def start_highlight( self, meaning ):
if self.use_colour:
return self._start_highlight( meaning )
return ''
def reset( self ):
if self.use_colour:
return self._reset()
return ''
def _reset( self ):
return colorama.Style.RESET_ALL
## Make these functions into simple dictionary lookups
def _start_colour( self, meaning ):
if meaning == 'error':
return colorama.Fore.RED
elif meaning == 'warning':
return colorama.Fore.MAGENTA
elif meaning == 'summary':
return colorama.Fore.BLACK
elif meaning == 'passed':
return colorama.Fore.GREEN
elif meaning == 'success':
return colorama.Fore.GREEN
elif meaning == 'unexpected_success':
return colorama.Fore.GREEN
elif meaning == 'expected_failure':
return colorama.Fore.YELLOW
elif meaning == 'failure':
return colorama.Fore.RED
elif meaning == 'failed':
return colorama.Fore.RED
elif meaning == 'aborted':
return colorama.Fore.RED
elif meaning == 'skipped':
return colorama.Fore.BLACK
elif meaning == 'notice':
return colorama.Fore.YELLOW
elif meaning == 'time':
return colorama.Fore.BLUE
elif meaning == 'info':
return colorama.Fore.BLUE
elif meaning == 'message':
return ''
def _start_highlight( self, meaning ):
if meaning == 'error':
return colorama.Style.BRIGHT + colorama.Back.RED + colorama.Fore.WHITE
elif meaning == 'warning':
return colorama.Style.BRIGHT + colorama.Back.MAGENTA + colorama.Fore.WHITE
elif meaning == 'summary':
return colorama.Style.BRIGHT + colorama.Back.BLACK + colorama.Fore.WHITE
elif meaning == 'success':
return colorama.Style.BRIGHT + colorama.Back.GREEN + colorama.Fore.WHITE
elif meaning == 'unexpected_success':
return colorama.Style.BRIGHT + colorama.Back.GREEN + colorama.Fore.BLACK
elif meaning == 'passed':
return colorama.Style.BRIGHT + colorama.Back.GREEN + colorama.Fore.WHITE
elif meaning == 'expected_failure':
return colorama.Style.BRIGHT + colorama.Back.YELLOW + colorama.Fore.WHITE
elif meaning == 'failure':
return colorama.Style.BRIGHT + colorama.Back.RED + colorama.Fore.WHITE
elif meaning == 'failed':
return colorama.Style.BRIGHT + colorama.Back.RED + colorama.Fore.WHITE
elif meaning == 'aborted':
return colorama.Style.BRIGHT + colorama.Back.RED + colorama.Fore.BLACK
elif meaning == 'skipped':
return colorama.Style.BRIGHT + colorama.Back.BLACK + colorama.Fore.WHITE
elif meaning == 'notice':
return colorama.Style.BRIGHT + colorama.Back.YELLOW + colorama.Fore.WHITE
elif meaning == 'time':
return colorama.Style.BRIGHT + colorama.Back.BLUE + colorama.Fore.WHITE
elif meaning == 'info':
return colorama.Style.BRIGHT + colorama.Back.BLUE + colorama.Fore.WHITE
elif meaning == 'message':
return ''
def as_error( self, text ):
return self.colour( "error", text )
def as_warning( self, text ):
return self.colour( "warning", text )
def as_info( self, text ):
return self.colour( "info", text )
def as_message( self, text ):
return self.colour( "message", text )
def as_notice( self, text ):
return self.colour( "notice", text )
def as_emphasised( env, text ):
return env['colouriser'].emphasise( text )
def as_error( env, text ):
return env['colouriser'].colour( 'error', text )
def as_warning( env, text ):
return env['colouriser'].colour( 'warning', text )
def as_info( env, text ):
return env['colouriser'].colour( 'info', text )
def as_message( env, text ):
return env['colouriser'].colour( 'message', text )
def as_notice( env, text ):
return env['colouriser'].colour( 'notice', text )
PK F [9 cuppa/configure.py
# Copyright Jamie Allsop 2013-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Configure
#-------------------------------------------------------------------------------
# standard library Imports
import os
import ast
# Scons Imports
import SCons.Script
import cuppa.options
SCons.Script.AddOption( '--show-conf', dest='show_conf', action='store_true',
help='Show the current values in the configuration file if one exists' )
SCons.Script.AddOption( '--save-conf', dest='save_conf', action='store_true',
help='Save the current command-line a configuration file' )
SCons.Script.AddOption( '--update-conf', dest='update_conf', action='store_true',
help='Update the configuration file with the current command-line' )
SCons.Script.AddOption( '--remove-settings', type='string', nargs=1,
action='callback', callback=cuppa.options.list_parser( 'remove_settings' ),
help='Remove the listed settings from the configuration file' )
SCons.Script.AddOption( '--clear-conf', dest='clear_conf', action='store_true',
help='Clear the configuration file' )
class never_save(object):
pass
default_scons_options = {
'debug_explain': False,
'debug_includes': False,
'climb_up': never_save
}
class Configure(object):
def __init__( self, env, conf_path="configure.conf", callback=None ):
self._env = env
self._conf_path = conf_path
self._callback = callback
env['configured_options'] = {}
self._colouriser = env['colouriser']
self._configured_options = {}
def load( self ):
self._show = self._env.get_option( 'show_conf' )
self._save = self._env.get_option( 'save_conf' )
self._remove = self._env.get_option( 'remove_settings' )
self._update = self._env.get_option( 'update_conf' )
self._clear = self._env.get_option( 'clear_conf' )
self._configure = self._save or self._remove or self._update
self._clean = self._env.get_option( 'clean' )
self._unconfigure = ( self._save and self._clean ) or self._clear
if self._unconfigure:
self._configure = False
print "cuppa: configure - {}".format( self._colouriser.as_notice( "Clear configuration requested..." ) )
if os.path.exists( self._conf_path ):
print "cuppa: configure - removing configure file [{}]".format(
self._colouriser.as_info( self._conf_path ) )
os.remove( self._conf_path )
else:
print "cuppa: configure - configure file [{}] does not exist. Unconfigure not needed".format(
self._colouriser.as_info( self._conf_path ) )
return
elif self._configure:
print "cuppa: configure - {}".format( self._colouriser.as_notice( "Update configuration requested..." ) )
if not self._save:
self._loaded_options = self._load_conf()
else:
self._loaded_options = {}
self._env['configured_options'] = self._loaded_options
self._env['default_options'].update( self._loaded_options )
def save( self ):
if self._configure and not self._clean:
if self._save:
self._save_conf()
else:
if self._update:
self._update_conf()
if self._remove:
self._remove_settings()
def handle_conf_only( self ):
return self._save or self._update or self._remove or self._clear or self._show
def action( self ):
if self._save:
return "save"
elif self._update:
return "update"
elif self._remove:
return "remove"
elif self._clear:
return "clear"
elif self._show:
return "show"
def configure( self, env ):
configure = SCons.Script.Configure( env )
if self._callback:
self._callback( configure )
env = configure.Finish()
def _load_conf( self ):
settings = {}
if os.path.exists(self._conf_path):
with open(self._conf_path) as config_file:
print "cuppa: configure - configure file [{}] exists. Load stored settings...".format(
self._colouriser.as_info( self._conf_path ) )
for line in config_file.readlines():
name, value = tuple( l.strip() for l in line.split('=', 1) )
try:
value = ast.literal_eval( str(value) )
except:
pass
self._print_setting( 'loading', name, value )
settings[name] = value
if settings:
print "cuppa: configure - load complete"
else:
print "cuppa: configure - no settings to load, skipping configure"
return settings
def _is_defaulted_scons_option( self, key, value ):
if key in default_scons_options:
if default_scons_options[key] == value:
return True
elif default_scons_options[key] == never_save:
return True
return False
def _is_saveable( self, key, value ):
return( not key.startswith("__")
and not self._is_defaulted_scons_option( key, value )
and not key =='save_conf'
and not key =='update_conf'
and not key =='remove_settings'
and not key =='show_conf'
and not key =='clear_conf' )
def _print_setting( self, action, key, value ):
print "cuppa: configure - {} [{}] = [{}]".format(
action,
self._colouriser.colour( 'notice', key ),
self._colouriser.colour( 'notice', str(value) ) )
def _save_settings( self ):
options = self._loaded_options
for key, value in SCons.Script.Main.OptionsParser.values.__dict__.items():
if self._is_saveable( key, value ):
try:
value = ast.literal_eval( str(value) )
except:
pass
options[key] = value
with open(self._conf_path, "w") as config_file:
for key, value in options.items():
self._print_setting( 'saving', key, value )
config_file.write( "{} = {}\n".format( key, value ) )
def _remove_settings( self ):
initial_option_count = len(self._loaded_options)
print "cuppa: configure - Remove settings requested for the following options {}".format( self._remove )
for setting in self._remove:
if setting in self._loaded_options:
del self._loaded_options[setting]
print "cuppa: configure - removing option [{}] as requested".format( self._colouriser.colour( 'notice', "--" + setting ) )
if initial_option_count != len(self._loaded_options):
self._update_conf()
def _save_conf( self ):
print "cuppa: configure - {}".format( self._colouriser.colour( 'notice', "save current settings..." ) )
self._save_settings()
print "cuppa: configure - {}".format( self._colouriser.colour( 'notice', "save complete" ) )
def _update_conf( self ):
print "cuppa: configure - {}".format( self._colouriser.colour( 'notice', "updating current settings..." ) )
self._save_settings()
print "cuppa: configure - {}".format( self._colouriser.colour( 'notice', "update complete" ) )
PK -F̄ cuppa/build_platform.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Build Platform
#-------------------------------------------------------------------------------
import platform
# Custom
import cuppa.modules.registration
from cuppa.platforms import *
class PlatformException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class Platform(object):
@classmethod
def _get_supported_platforms( cls, supported ):
cuppa.modules.registration.add_to_env( 'platforms', { 'env': supported } )
@classmethod
def _create( cls ):
cls._supported = { 'platforms': {} }
cls._get_supported_platforms( cls._supported )
system = platform.system()
if system not in cls._supported['platforms']:
raise PlatformException( 'Platform [' + system + '] not supported. Supported platforms are ' + str(cls._supported['platforms']) )
cls._platform = cls._supported['platforms'][ system ]
cls._platform.initialise()
@classmethod
def supported( cls ):
if not hasattr(cls, '_supported'):
cls._create()
return cls._supported['platforms']
@classmethod
def current( cls ):
if not hasattr(cls, '_platform'):
cls._create()
return cls._platform
def name():
return Platform.current().name()
def constants():
return Platform.current().constants()
PK cFew} cuppa/recursive_glob.py
# Copyright Jamie Allsop 2012-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# RecursiveGlob
#-------------------------------------------------------------------------------
import fnmatch
import re
import os
import cuppa.utility
def glob( start, file_pattern, exclude_dirs_pattern=None, discard_pattern=None ):
if cuppa.utility.is_string( file_pattern ):
file_pattern = re.compile( fnmatch.translate( file_pattern ) )
if exclude_dirs_pattern:
if cuppa.utility.is_string( exclude_dirs_pattern ):
exclude_dirs_pattern = re.compile( fnmatch.translate( exclude_dirs_pattern ) )
if discard_pattern:
if cuppa.utility.is_string( discard_pattern ):
discard_pattern = re.compile( fnmatch.translate( discard_pattern ) )
matches = []
subdir = False
for root, dirnames, filenames in os.walk( start ):
if exclude_dirs_pattern:
# remove any directories from the search that match the exclude regex
dirnames[:] = [ d for d in dirnames if not exclude_dirs_pattern.match(d) ]
exclude_this_dir = False
matches_in_this_dir = []
for filename in filenames:
if subdir and discard_pattern and discard_pattern.match( filename ):
# if we are in a subdir and it contains a file that matches the discard_pattern
# set exclude_this_dir to True so later we can discard any local matches we'd
# already encountered while walking the directory
exclude_this_dir = True
break
if file_pattern.match( filename ):
matches_in_this_dir.append( os.path.join( root, filename ) )
if not exclude_this_dir:
matches += matches_in_this_dir
else:
# We are excluding this directory and therefore all of its subdirs
dirnames[:] = []
# After the first pass through the loop we will be in a subdirectory
subdir = True
return matches
PK -F
tDb b cuppa/options.py
# Copyright Jamie Allsop 2014-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Options
#-------------------------------------------------------------------------------
class list_parser(object):
def __init__( self, attribute ):
self._attribute = attribute
def __call__( self, option, opt, value, parser):
setattr( parser.values, self._attribute, value.split(',') )
PK qFǯ6
cuppa/VERSION0.1.50
PK QFR{P P cuppa/version.py# Copyright Jamie Allsop 2014-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# version.py
#-------------------------------------------------------------------------------
import sys
import os
import xmlrpclib
import pip
from pkg_resources import parse_version
def get_version():
module = sys.modules[__name__]
if not hasattr( module, '_version' ):
version_path = os.path.join( os.path.split( __file__ )[0], 'VERSION' )
with open( version_path ) as version_file:
module._version = version_file.read().strip()
return module._version
def check_current_version():
installed_version = get_version()
sys.stdout.write( "cuppa: version {}".format( installed_version ) )
try:
pypi = xmlrpclib.ServerProxy('http://pypi.python.org/pypi')
latest_available = pypi.package_releases('cuppa')[0]
if parse_version( installed_version ) < parse_version( latest_available ):
sys.stdout.write( " - " )
sys.stdout.write( "Newer version [{}] available\n".format( latest_available ) )
else:
sys.stdout.write( "\n" )
except:
pass
PK -FÞX~ ~ cuppa/output_processor.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Output Processor
#-------------------------------------------------------------------------------
import subprocess
import sys
import os
import re
import time
import threading
import shlex
import colorama
def command_available( command ):
try:
with open(os.devnull) as devnull:
subprocess.Popen( shlex.split( command ), stdout=devnull, stderr=devnull ).communicate()
except OSError as e:
if e.errno == os.errno.ENOENT:
return False
return True
class AutoFlushFile:
def __init__( self, f ):
self.f = f
def flush( self ):
self.f.flush()
def write( self, x ):
self.f.write(x)
self.f.flush()
class LineConsumer:
def __init__( self, call_readline, processor=None ):
self.call_readline = call_readline
self.processor = processor
def __call__( self ):
for line in iter( self.call_readline, "" ):
line = line.rstrip()
if line:
if self.processor:
line = self.processor( line )
if line:
print line
else:
print line
class IncrementalSubProcess:
@classmethod
def Popen2( cls, stdout_processor, stderr_processor, args_list, **kwargs ):
kwargs['stdout'] = subprocess.PIPE
kwargs['stderr'] = subprocess.PIPE
sys.stdout = AutoFlushFile( colorama.initialise.wrapped_stdout )
sys.stderr = AutoFlushFile( colorama.initialise.wrapped_stderr )
process = subprocess.Popen(
args_list,
**kwargs
)
stderr_consumer = LineConsumer( process.stderr.readline, stderr_processor )
stdout_consumer = LineConsumer( process.stdout.readline, stdout_processor )
stderr_thread = threading.Thread( target=stderr_consumer )
stderr_thread.start()
stdout_consumer();
stderr_thread.join()
process.wait()
return process.returncode
@classmethod
def Popen( cls, processor, args_list, **kwargs ):
return cls.Popen2( processor, processor, args_list, **kwargs )
class Processor:
def __init__( self, scons_env ):
self.scons_env = scons_env
@classmethod
def install( cls, env ):
output_processor = cls( env )
env['SPAWN'] = output_processor.spawn
def spawn( self, sh, escape, cmd, args, env ):
processor = SpawnedProcessor( self.scons_env )
returncode = IncrementalSubProcess.Popen(
processor,
[ arg.strip('"') for arg in args ],
env=env
)
summary = processor.summary( returncode )
if summary:
print summary
return returncode
class SpawnedProcessor(object):
def __init__( self, scons_env ):
self._processor = ToolchainProcessor(
scons_env['colouriser'],
scons_env['toolchain'],
scons_env['minimal_output'],
scons_env['ignore_duplicates'] )
def __call__( self, line ):
return self._processor( line )
def summary( self, returncode ):
return self._processor.summary( returncode )
class ToolchainProcessor:
def __init__( self, colouriser, toolchain, minimal_output, ignore_duplicates ):
self.toolchain = toolchain
self.colouriser = colouriser
self.minimal_output = minimal_output
self.ignore_duplicates = ignore_duplicates
self.errors = 0
self.warnings = 0
self.start_time = time.time()
self.error_messages = {}
self.warning_messages = {}
self.ignore_current_message = False
def filtered_duplicate( self, line, existing_messages ):
if self.ignore_duplicates and line in existing_messages:
existing_messages[line] +=1
self.ignore_current_message = True
return None
else:
self.ignore_current_message = False
existing_messages[line] = 1
return line
def filtered_line( self, line=None, meaning=None ):
if meaning == "error":
return self.filtered_duplicate( line, self.error_messages )
if meaning == "warning":
return self.filtered_duplicate( line, self.warning_messages )
if self.minimal_output or self.ignore_current_message:
return None
else:
return line
def __call__( self, line ):
( matches, interpretor, error_id, warning_id ) = self.interpret( line )
if matches:
highlights = interpretor['highlight']
display = interpretor['display']
meaning = interpretor['meaning']
file = interpretor['file']
message = ''
for match in display:
element = matches.group( match )
if match == file and ( meaning == 'error' or meaning == 'warning' ):
element = self.normalise_path( element )
element = self.colouriser.colour( meaning, element )
if match in highlights:
element = self.colouriser.emphasise( element )
message += element
message = self.filtered_line( message + "\n", meaning )
if meaning == 'error':
if message:
message = self.colouriser.highlight( meaning, " = Error " + str(error_id) + " = ") + "\n" + message
else:
self.errors -= 1
elif meaning == 'warning':
if message:
message = self.colouriser.highlight( meaning, " = Warning " + str(warning_id) + " = ") + "\n" + message
else:
self.warnings -= 1
return message
return self.filtered_line( line )
def normalise_path( self, file_path ):
normalised_path = file_path
if os.path.exists( file_path ):
normalised_path = os.path.relpath( os.path.realpath( file_path ) )
# if normalised_path[0] != '.' and normalised_path[0] != os.path.sep:
# normalised_path = '.' + os.path.sep + normalised_path
# return os.path.abspath( normalised_path )
return normalised_path
def interpret( self, line ):
Interpretors = self.toolchain.output_interpretors()
for interpretor in Interpretors:
Regex = interpretor['regex']
Matches = re.match( Regex, line )
if Matches:
error_id = 0
warning_id = 0
if interpretor['meaning'] == 'error':
self.errors += 1
error_id = self.errors
elif interpretor['meaning'] == 'warning':
self.warnings += 1
warning_id = self.warnings
return ( Matches, interpretor, error_id, warning_id, )
return ( None, None, None, None, )
def summary( self, returncode ):
elapsed_time = time.time() - self.start_time
Summary = ''
if returncode:
Summary += self.colouriser.highlight( 'summary', " === Process Terminated with status " + str(returncode) + " (Elapsed " + str(elapsed_time) + "s)" + " === ") + "\n"
if self.errors:
Summary += self.colouriser.highlight( 'error', " === Errors " + str(self.errors) + " === ")
if self.warnings:
Summary += self.colouriser.highlight( 'warning', " === Warnings " + str(self.warnings) + " === ")
return Summary
PK -Fg;H H cuppa/utility.py
# Copyright Jamie Allsop 2014-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Utility
#-------------------------------------------------------------------------------
# Check if an object is a string
try:
basestring
def is_string( x ):
return isinstance( x, basestring )
except NameError:
def is_string( x ):
return isinstance( x, str )
PK Fh{vr r
cuppa/core.py# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Core
#-------------------------------------------------------------------------------
# Python Standard
import os.path
import os
import re
import fnmatch
import multiprocessing
import pkg_resources
# Scons
import SCons.Script
# Custom
import cuppa.modules.registration
import cuppa.build_platform
import cuppa.output_processor
import cuppa.colourise
import cuppa.recursive_glob
import cuppa.configure
import cuppa.options
import cuppa.version
#import cuppa.cpp.stdcpp
from cuppa.toolchains import *
from cuppa.methods import *
from cuppa.dependencies import *
from cuppa.profiles import *
from cuppa.variants import *
from cuppa.project_generators import *
SCons.Script.Decider( 'MD5-timestamp' )
def add_option( *args, **kwargs ):
SCons.Script.AddOption( *args, **kwargs )
def add_base_options():
add_option( '--raw-output', dest='raw_output', action='store_true',
help='Disable output processing like colourisation of output' )
add_option( '--standard-output', dest='standard_output', action='store_true',
help='Perform standard output processing but not colourisation of output' )
add_option( '--minimal-output', dest='minimal_output', action='store_true',
help='Show only errors and warnings in the output' )
add_option( '--ignore-duplicates', dest='ignore_duplicates', action='store_true',
help='Do not show repeated errors or warnings' )
add_option( '--projects', type='string', nargs=1,
action='callback', callback=cuppa.options.list_parser( 'projects' ),
help='Projects to build (alias for scripts)' )
add_option( '--scripts', type='string', nargs=1,
action='callback', callback=cuppa.options.list_parser( 'projects' ),
help='Sconscripts to run' )
add_option( '--thirdparty', type='string', nargs=1, action='store',
dest='thirdparty',
metavar='DIR',
help='Thirdparty directory' )
add_option( '--build-root', type='string', nargs=1, action='store',
dest='build_root',
help='The root directory for build output. If not specified then _build_ is used' )
add_option( '--download-root', type='string', nargs=1, action='store',
dest='download_root',
help='The root directory for downloading external libraries to. If not specified then _cuppa_ is used' )
add_option( '--cache-root', type='string', nargs=1, action='store',
dest='cache_root',
help='The root directory for caching downloaded external archived libraries. If not specified then ~/_cuppa_/cache is used' )
add_option( '--runner', type='string', nargs=1, action='store',
dest='runner',
help='The test runner to use for executing tests. The default is the process test runner' )
add_option( '--dump', dest='dump', action='store_true',
help='Dump the default environment and exit' )
add_option( '--parallel', dest='parallel', action='store_true',
help='Enable parallel builds utilising the available concurrency. Translates to -j N with N chosen based on the current hardware' )
add_option( '--show-test-output', dest='show-test-output', action='store_true',
help='When executing tests display all outout to stdout and stderr as appropriate' )
# add_option( '--b2', dest='b2', action='store_true',
# help='Execute boost.build by calling b2 or bjam' )
# add_option( '--b2-path', type='string', nargs=1, action='store',
# dest='b2_path',
# help='Specify a path to bjam or b2' )
decider_choices = ( 'timestamp-newer', 'timestamp-match', 'MD5', 'MD5-timestamp' )
add_option( '--decider', dest='decider', choices=decider_choices, nargs=1, action='store',
help='The decider to use for determining if a dependency has changed. Refer to the Scons manual for more details. By default "MD5-timestamp" is used' )
def set_base_options():
SCons.Script.SetOption( 'warn', 'no-duplicate-environment' )
class ConstructException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class ParseToolchainsOption(object):
def __init__( self, supported_toolchains, available_toolchains ):
self._supported = supported_toolchains
self._available = available_toolchains
def __call__(self, option, opt, value, parser):
toolchains = set()
requested = value.split(',')
for toolchain in requested:
supported = fnmatch.filter( self._supported, toolchain )
if not supported:
print "cuppa: requested toolchain(s) [{}] does not match any supported, skipping".format( toolchain )
else:
available = fnmatch.filter( self._available, toolchain )
if not available:
print "cuppa: requested toolchain(s) [{}] supported does not match any available, skipping".format( toolchain )
else:
toolchains.update( available )
if not toolchains:
print "cuppa: None of the requested toolchains are available"
parser.values.toolchains = list(toolchains)
class Construct(object):
platforms_key = 'platforms'
variants_key = 'variants'
actions_key = 'actions'
toolchains_key = 'toolchains'
dependencies_key = 'dependencies'
profiles_key = 'profiles'
methods_key = 'methods'
project_generators_key = 'project_generators'
cached_options = {}
@classmethod
def get_option( cls, env, option, default=None ):
if option in cls.cached_options:
return cls.cached_options[ option ]
value = SCons.Script.GetOption( option )
source = None
colouriser = env['colouriser']
if value == None or value == '':
if env['default_options'] and option in env['default_options']:
value = env['default_options'][ option ]
source = "in the sconstruct file"
elif default:
value = default
source = "using default"
else:
source = "on command-line"
if option in env['configured_options']:
source = "using configure"
if value:
print "cuppa: option [{}] set {} as [{}]".format(
colouriser.colour( 'info', option ),
source,
colouriser.colour( 'info', str(value) ) )
cls.cached_options[option] = value
return value
def add_platforms( self, env ):
platforms = self.platforms_key
env[platforms] = cuppa.build_platform.Platform.supported()
def add_project_generators( self, env ):
project_generators = self.project_generators_key
env[project_generators] = {}
cuppa.modules.registration.add_to_env( project_generators, env )
def add_variants( self, env ):
variants = self.variants_key
actions = self.actions_key
env[variants] = {}
env[actions] = {}
def add_variant( name, variant ):
env[variants][name] = variant
def add_action( name, action ):
env[actions][name] = action
cuppa.modules.registration.add_to_env( variants, env, add_variant, add_action )
cuppa.modules.registration.add_options( variants )
def add_toolchains( self, env ):
toolchains = self.toolchains_key
env[toolchains] = {}
env['supported_toolchains'] = []
def add_to_supported( name ):
env['supported_toolchains'].append( name )
def add_toolchain( name, toolchain ):
env['toolchains'][name] = toolchain
cuppa.modules.registration.add_to_env( toolchains, env, add_toolchain, add_to_supported )
colouriser = env['colouriser']
print "cuppa: supported toolchains are {}".format( colouriser.colour( 'notice', str( env["supported_toolchains"] ) ) )
print "cuppa: available toolchains are {}".format( colouriser.colour( 'info', str( sorted( env[toolchains].keys(), reverse=True ) ) ) )
SCons.Script.AddOption(
'--toolchains',
type = 'string',
nargs = 1,
action = 'callback',
callback = ParseToolchainsOption( env['supported_toolchains'], env[toolchains].keys() ),
help = 'The Toolchains you wish to build against' )
def initialise_options( self, env, default_options, dependencies ):
env['default_options'] = default_options or {}
env.AddMethod( self.get_option, "get_option" )
add_base_options()
cuppa.modules.registration.add_options( self.toolchains_key )
cuppa.modules.registration.add_options( self.dependencies_key )
cuppa.modules.registration.add_options( self.profiles_key )
cuppa.modules.registration.add_options( self.project_generators_key )
cuppa.modules.registration.add_options( self.methods_key )
if dependencies:
for dependency in dependencies.itervalues():
dependency.add_options( SCons.Script.AddOption )
# cuppa.cpp.stdcpp.add_options( SCons.Script.AddOption )
def print_construct_variables( self, env ):
keys = {
'raw_output',
'standard_output',
'minimal_output',
'ignore_duplicates',
'working_dir',
'launch_dir',
'launch_offset_dir',
'run_from_launch_dir',
'base_path',
'branch_root',
'branch_dir',
'download_root',
'cache_root',
'thirdparty',
'build_root',
'default_dependencies',
'BUILD_WITH',
'dependencies',
'sconscript_dir',
'sconscript_file',
'build_dir',
'offset_dir',
'parallell',
'show_test_output',
'decider'
}
for key in keys:
if key in env:
print "cuppa: Env[%s] = %s" % ( key, env[key] )
def __init__( self,
base_path = os.path.abspath( '.' ),
branch_root = None,
default_options = None,
default_projects = None,
default_variants = None,
default_dependencies = None,
default_profiles = None,
default_runner = None,
configure_callback = None,
dependencies = None,
tools = [] ):
cuppa.version.check_current_version()
set_base_options()
self._default_env = SCons.Script.Environment( tools=['default'] + tools )
default_env = self._default_env
self.initialise_options( default_env, default_options, dependencies )
default_env['configured_options'] = {}
default_env['colouriser'] = cuppa.colourise.Colouriser.create()
self._configure = cuppa.configure.Configure( default_env, callback=configure_callback )
default_env['sconstruct_file'] = default_env.get_option( 'file' )
if not default_env['sconstruct_file']:
for path in [ 'SConstruct', 'Sconstruct', 'sconstruct' ]:
if os.path.exists( path ):
default_env['sconstruct_file'] = path
print "cuppa: using sconstruct file [{}]".format( default_env['sconstruct_file'] )
default_env['raw_output'] = default_env.get_option( 'raw_output' ) and True or False
default_env['standard_output'] = default_env.get_option( 'standard_output' ) and True or False
if not default_env['raw_output'] and not default_env['standard_output']:
default_env['colouriser'].enable()
help = default_env.get_option( 'help' ) and True or False
self._configure.load()
decider = default_env.get_option( 'decider' )
if decider:
default_env.Decider( decider )
default_env['minimal_output'] = default_env.get_option( 'minimal_output' )
default_env['ignore_duplicates'] = default_env.get_option( 'ignore_duplicates' )
default_env['working_dir'] = os.getcwd()
default_env['launch_dir'] = os.path.relpath( SCons.Script.GetLaunchDir(), default_env['working_dir'] )
default_env['run_from_launch_dir'] = default_env['launch_dir'] == "."
default_env['launch_offset_dir'] = "."
if not default_env['run_from_launch_dir']:
levels = len( default_env['launch_dir'].split( os.path.sep ) )
default_env['launch_offset_dir'] = os.path.sep.join( ['..' for i in range(levels)] )
default_env['base_path'] = os.path.normpath( os.path.expanduser( base_path ) )
default_env['branch_root'] = branch_root and os.path.normpath( os.path.expanduser( branch_root ) ) or base_path
default_env['branch_dir'] = default_env['branch_root'] and os.path.relpath( default_env['base_path'], default_env['branch_root'] ) or None
thirdparty = default_env.get_option( 'thirdparty' )
if thirdparty:
thirdparty = os.path.normpath( os.path.expanduser( thirdparty ) )
default_env['thirdparty'] = thirdparty
build_root = default_env.get_option( 'build_root', default='_build' )
default_env['build_root'] = os.path.normpath( os.path.expanduser( build_root ) )
download_root = default_env.get_option( 'download_root', default='_cuppa' )
default_env['download_root'] = os.path.normpath( os.path.expanduser( download_root ) )
cache_root = default_env.get_option( 'cache_root', default='~/_cuppa/_cache' )
default_env['cache_root'] = os.path.normpath( os.path.expanduser( cache_root ) )
if not os.path.exists( default_env['cache_root'] ):
os.makedirs( default_env['cache_root'] )
default_env['default_projects'] = default_projects
default_env['default_variants'] = default_variants and set( default_variants ) or set()
default_env['default_dependencies'] = default_dependencies and default_dependencies or []
default_env['BUILD_WITH'] = default_env['default_dependencies']
default_env['dependencies'] = {}
default_env['default_profiles'] = default_profiles and default_profiles or []
default_env['BUILD_PROFILE'] = default_env['default_profiles']
default_env['profiles'] = {}
test_runner = default_env.get_option( 'runner', default=default_runner and default_runner or 'process' )
default_env['default_runner'] = test_runner
default_env['show_test_output'] = default_env.get_option( 'show-test-output' ) and True or False
self.add_variants ( default_env )
self.add_toolchains ( default_env )
self.add_platforms ( default_env )
default_env['platform'] = cuppa.build_platform.Platform.current()
toolchains = default_env.get_option( 'toolchains' )
default_toolchain = default_env['platform'].default_toolchain()
if not toolchains:
toolchains = [ default_env[self.toolchains_key][default_toolchain] ]
else:
toolchains = [ default_env[self.toolchains_key][t] for t in toolchains ]
default_env['active_toolchains'] = toolchains
def add_dependency( name, dependency ):
default_env['dependencies'][name] = dependency
cuppa.modules.registration.get_options( "methods", default_env )
if not help and not self._configure.handle_conf_only():
default_env[self.project_generators_key] = {}
cuppa.modules.registration.add_to_env( "dependencies", default_env, add_dependency )
cuppa.modules.registration.add_to_env( "profiles", default_env )
cuppa.modules.registration.add_to_env( "methods", default_env )
cuppa.modules.registration.add_to_env( "project_generators", default_env )
for method_plugin in pkg_resources.iter_entry_points( group='cuppa.method.plugins', name=None ):
method_plugin.load().add_to_env( default_env )
if dependencies:
for name, dependency in dependencies.iteritems():
dependency.add_to_env( default_env, add_dependency )
# TODO - default_profile
if default_env.get_option( 'dump' ):
print default_env.Dump()
SCons.Script.Exit()
job_count = default_env.get_option( 'num_jobs' )
parallel = default_env.get_option( 'parallel' )
parallel_mode = "manually"
if job_count==1 and parallel:
job_count = multiprocessing.cpu_count()
if job_count > 1:
SCons.Script.SetOption( 'num_jobs', job_count )
parallel_mode = "automatically"
default_env['job_count'] = job_count
default_env['parallel'] = parallel
if job_count>1:
print "cuppa: Running in {} with option [{}] set {} as [{}]".format(
self._as_emphasised("parallel mode"),
self._as_info( "jobs" ),
self._as_emphasised(parallel_mode),
self._as_info( str( SCons.Script.GetOption( 'num_jobs') ) ) )
if not help and self._configure.handle_conf_only():
self._configure.save()
if not help and not self._configure.handle_conf_only():
self.build( default_env )
if self._configure.handle_conf_only():
print "cuppa: Handling onfiguration only, so no builds will be attempted."
print "cuppa: With the current configuration executing 'scons -D' would be equivalent to:"
print ""
print "scons -D {}".format( self._command_line_from_settings( default_env['configured_options'] ) )
print ""
print "cuppa: Nothing to be done. Exiting."
SCons.Script.Exit()
def _as_emphasised( self, text ):
return self._default_env['colouriser'].emphasise( text )
def _as_error( self, text ):
return self._default_env['colouriser'].colour( 'error', text )
def _as_warning( self, text ):
return self._default_env['colouriser'].colour( 'warning', text )
def _as_info( self, text ):
return self._default_env['colouriser'].colour( 'info', text )
def _as_notice( self, text ):
return self._default_env['colouriser'].colour( 'notice', text )
def _command_line_from_settings( self, settings ):
commands = []
for key, value in settings.iteritems():
command = self._as_emphasised( "--" + key )
if value != True and value != False:
if not isinstance( value, list ):
command += "=" + self._as_info( str(value) )
else:
command += "=" + self._as_info( ",".join( value ) )
commands.append( command )
commands.sort()
return " ".join( commands )
def get_active_actions_for_variant( self, default_env, active_variants, variant ):
available_variants = default_env[ self.variants_key ]
available_actions = default_env[ self.actions_key ]
specified_actions = {}
for key, action in available_actions.items():
if default_env.get_option( action.name() ):
specified_actions[ action.name() ] = action
if not specified_actions:
default_variants = active_variants
if default_variants:
for variant in default_variants:
if available_actions.has_key( variant ):
specified_actions[ variant ] = available_actions[ variant ]
active_actions = {}
for key, action in specified_actions.items():
if key not in available_variants:
active_actions[ key ] = action
elif key == variant.name():
active_actions[ key ] = action
return active_actions
def create_build_variants( self, toolchain, default_env ):
variants = default_env[ self.variants_key ]
active_variants = {}
for key, variant in variants.items():
if default_env.get_option( variant.name() ):
active_variants[ variant.name() ] = variant
if not active_variants:
default_variants = default_env['default_variants'] or toolchain.default_variants()
if default_variants:
for variant in default_variants:
if variants.has_key( variant ):
active_variants[ variant ] = variants[ variant ]
variant_envs = {}
for key, variant in active_variants.items():
variant_envs[ key ] = variant.create( default_env.Clone(), toolchain )
if not default_env['raw_output']:
cuppa.output_processor.Processor.install( variant_envs[ key ] )
variant_envs[ key ]['toolchain'] = toolchain
variant_envs[ key ]['variant'] = variant
variant_envs[ key ]['variant_actions'] = self.get_active_actions_for_variant( default_env, active_variants, variant )
return variant_envs
def get_sub_sconscripts( self, path, exclude_dirs ):
file_regex = re.compile( r'([^.]+[.])?sconscript$', re.IGNORECASE )
discard_if_subdir_contains_regex = re.compile( r'(SC|Sc|sc)onstruct' )
def up_dir( path ):
element = next( e for e in path.split(os.path.sep) if e )
return element == ".."
exclude_dirs = [ re.escape(d) for d in exclude_dirs if not os.path.isabs(d) and not up_dir(d) ]
exclude_dirs = "|".join( exclude_dirs )
exclude_dirs_regex = re.compile( exclude_dirs, re.IGNORECASE )
return cuppa.recursive_glob.glob(
path,
file_regex,
exclude_dirs_pattern= exclude_dirs_regex,
discard_pattern=discard_if_subdir_contains_regex
)
def colour_items( self, items ):
return "'{}'".format( "', '".join( self._as_notice( item ) for item in items ) )
def build( self, default_env ):
projects = default_env.get_option( 'projects' )
toolchains = default_env['active_toolchains']
if projects == None:
projects = default_env['default_projects']
if projects == None or not default_env['run_from_launch_dir']:
sub_sconscripts = self.get_sub_sconscripts(
default_env['launch_dir'],
[ default_env['build_root'], default_env['download_root'] ]
)
if sub_sconscripts:
projects = sub_sconscripts
print "cuppa: Using sub-sconscripts [{}]".format( self.colour_items( projects ) )
elif projects != None:
print "cuppa: Using default_projects [{}]".format( self.colour_items( projects ) )
if projects:
sconscripts = []
for project in projects:
if os.path.exists( project ) and os.path.isdir( project ):
sub_sconscripts = self.get_sub_sconscripts(
project,
[ default_env['build_root'], default_env['download_root'] ]
)
if sub_sconscripts:
print "cuppa: Reading project folder [{}] and using sub-sconscripts [{}]".format(
project, self.colour_items( sub_sconscripts ) )
sconscripts.extend( sub_sconscripts )
else:
sconscripts.append( project )
for toolchain in toolchains:
toolchain_env = default_env.Clone()
toolchain_env['default_env'] = default_env
toolchain.initialise_env( toolchain_env )
variants = self.create_build_variants( toolchain, toolchain_env )
for variant, env in variants.items():
for sconscript in sconscripts:
self.call_project_sconscript_files( toolchain, variant, env, sconscript )
else:
print "cuppa: No projects to build. Nothing to be done"
def call_project_sconscript_files( self, toolchain, variant, sconscript_env, project ):
sconscript_file = project
if not os.path.exists( project ) or os.path.isdir( project ):
sconscript_file = sconscript_file + '.sconscript'
if os.path.exists( sconscript_file ) and os.path.isfile( sconscript_file ):
print "cuppa: project exists and added to build [{}] using [{},{}]".format(
self._as_notice( sconscript_file ),
self._as_notice( toolchain.name() ),
self._as_notice( variant )
)
path_without_ext = os.path.splitext( sconscript_file )[0]
sconstruct_offset_path, sconscript_name = os.path.split( sconscript_file )
name = os.path.splitext( sconscript_name )[0]
if name.lower() == "sconscript":
path_without_ext = sconstruct_offset_path
name = path_without_ext
sconscript_env['sconscript_file'] = sconscript_file
build_root = sconscript_env['build_root']
cloned_env = sconscript_env.Clone()
cloned_env['sconscript_env'] = sconscript_env
cloned_env['sconscript_build_dir'] = path_without_ext
cloned_env['sconscript_toolchain_build_dir'] = os.path.join( path_without_ext, toolchain.name() )
cloned_env['sconscript_dir'] = os.path.join( sconscript_env['base_path'], sconstruct_offset_path )
cloned_env['build_dir'] = os.path.normpath( os.path.join( build_root, path_without_ext, toolchain.name(), variant, 'working', '' ) )
cloned_env['abs_build_dir'] = os.path.abspath( cloned_env['build_dir'] )
cloned_env['offset_dir'] = sconstruct_offset_path
cloned_env['final_dir'] = '..' + os.path.sep + 'final' + os.path.sep
cloned_env['active_toolchain']= toolchain
def abs_final_dir( abs_build_dir, final_dir ):
return os.path.isabs( final_dir ) and final_dir or os.path.normpath( os.path.join( abs_build_dir, final_dir ) )
cloned_env['abs_final_dir'] = abs_final_dir( cloned_env['abs_build_dir'], cloned_env['final_dir'] )
cloned_env.AppendUnique( INCPATH = [
cloned_env['offset_dir']
] )
sconscript_exports = {
'env' : cloned_env,
'sconscript_env' : sconscript_env,
'build_root' : build_root,
'build_dir' : cloned_env['build_dir'],
'abs_build_dir' : cloned_env['abs_build_dir'],
'final_dir' : cloned_env['final_dir'],
'abs_final_dir' : cloned_env['abs_final_dir'],
'common_variant_final_dir': '../../../common/final/',
'common_project_final_dir': build_root + '/common/final/',
'project' : name,
}
self._configure.configure( sconscript_exports['env'] )
cuppa.modules.registration.init_env_for_variant( "methods", sconscript_exports )
SCons.Script.SConscript(
[ sconscript_file ],
variant_dir = sconscript_exports['build_dir'],
duplicate = 0,
exports = sconscript_exports
)
else:
print "cuppa: Skipping non-existent project [{}]".format( self._as_error( sconscript_file ) )
def run( *args, **kwargs ):
Construct( *args, **kwargs )
PK -F2* * cuppa/platforms/__init__.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import cuppa.modules
__all__ = cuppa.modules.registration.get_module_list( __file__ )
PK -FH\]M M cuppa/platforms/linux.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Linux Platform
#-------------------------------------------------------------------------------
from subprocess import Popen, PIPE
from re import match, search, MULTILINE
from os import path
import platform
import SCons.Script
class LinuxException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class Linux:
@classmethod
def add_to_env( cls, args ):
args['env']['platforms']['Linux'] = cls()
def __init__( self ):
self._toolchain = None
self.values = {}
def default_toolchain( self ):
if not self._toolchain:
env = SCons.Script.Environment()
self._toolchain = env['CC']
return self._toolchain
return self._toolchain
def __getitem__( self, key ):
return self.values.get( key )
def _bit_depth( self, machine ):
if machine == "i386":
return '32'
elif machine == "i686":
return '32'
elif machine == "x86_64":
return '64'
else:
return 'unknown'
def _libc_version( self, machine, system ):
libc_file = "libc.so.6"
libc_path = "/lib/" + libc_file
if not path.exists( libc_path ):
multiarch_lib_path = '-'.join( [ machine, system.lower(), 'gnu' ] )
libc_path = "/lib/" + multiarch_lib_path + "/" + libc_file
libc_version = Popen([libc_path], stdout=PIPE).communicate()[0]
return 'libc' + search( r'^GNU C Library [()a-zA-Z ]*([0-9][.0-9]+)', libc_version, MULTILINE ).expand(r'\1').replace('.','')
def initialise( self ):
( system, node, release, version, machine, processor ) = platform.uname()
self.values['system'] = system
self.values['node'] = node
self.values['release'] = release
self.values['version'] = version
self.values['machine'] = machine
self.values['processor'] = processor
self.values['os'] = system
self.values['architecture'] = machine
self.values['os_version'] = match( r'(\d+\.\d+)', release ).group(0)
self.values['bit_width'] = self._bit_depth( machine )
self.values['libc_version'] = self._libc_version( machine, system )
self.values['platform_path'] = self.values['architecture'] + '_' + self.values['os'] + '_' + self.values['os_version']
class Constants(object):
CLOCK_REALTIME = 0 # System-wide realtime clock.
CLOCK_MONOTONIC = 1 # Monotonic system-wide clock.
CLOCK_PROCESS_CPUTIME_ID = 2 # High-resolution timer from the CPU.
CLOCK_THREAD_CPUTIME_ID = 3 # Thread-specific CPU-time clock.
CLOCK_MONOTONIC_RAW = 4 # Monotonic system-wide clock, not adjusted for frequency scaling.
CLOCK_REALTIME_COARSE = 5 # System-wide realtime clock, updated only on ticks.
CLOCK_MONOTONIC_COARSE = 6 # Monotonic system-wide clock, updated only on ticks.
CLOCK_BOOTTIME = 7 # Monotonic system-wide clock that includes time spent in suspension.
@classmethod
def constants( cls ):
return cls.Constants
@classmethod
def name( cls ):
return cls.__name__
PK -F:8 cuppa/platforms/darwin.py
# Copyright Jamie Allsop 2014-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Darwin Platform
#-------------------------------------------------------------------------------
import platform
import SCons.Script
class DarwinException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class Darwin:
@classmethod
def add_to_env( cls, args ):
args['env']['platforms']['Darwin'] = cls()
def __init__( self ):
self._toolchain = "clang"
self.values = {}
def default_toolchain( self ):
if not self._toolchain:
env = SCons.Script.Environment()
self._toolchain = env['CC']
return self._toolchain
return self._toolchain
def __getitem__( self, key ):
return self.values.get( key )
def _bit_depth( self, machine ):
if machine == "i386":
return '32'
elif machine == "i686":
return '32'
elif machine == "x86_64":
return '64'
else:
return 'unknown'
def initialise( self ):
( system, node, release, version, machine, processor ) = platform.uname()
self.values['system'] = system
self.values['node'] = node
self.values['release'] = release
self.values['version'] = version
self.values['machine'] = machine
self.values['processor'] = processor
self.values['os'] = system
self.values['architecture'] = machine
self.values['os_version'] = release # re.match( r'(\d+\.\d+)', release ).group(0)
self.values['bit_width'] = self._bit_depth( machine )
self.values['platform_path'] = self.values['architecture'] + '_' + self.values['os'] + '_' + self.values['os_version']
class Constants(object):
CLOCK_REALTIME = 0 # System-wide realtime clock.
CLOCK_MONOTONIC = 1 # Monotonic system-wide clock.
CLOCK_PROCESS_CPUTIME_ID = 2 # High-resolution timer from the CPU.
CLOCK_THREAD_CPUTIME_ID = 3 # Thread-specific CPU-time clock.
CLOCK_MONOTONIC_RAW = 4 # Monotonic system-wide clock, not adjusted for frequency scaling.
CLOCK_REALTIME_COARSE = 5 # System-wide realtime clock, updated only on ticks.
CLOCK_MONOTONIC_COARSE = 6 # Monotonic system-wide clock, updated only on ticks.
CLOCK_BOOTTIME = 7 # Monotonic system-wide clock that includes time spent in suspension.
@classmethod
def constants( cls ):
return cls.Constants
@classmethod
def name( cls ):
return cls.__name__
PK GEg cuppa/platforms/windows.py
# Copyright Jamie Allsop 2014-2014
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Windows Platform
#-------------------------------------------------------------------------------
import platform
import SCons.Script
class WindowsException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class Windows:
@classmethod
def add_to_env( cls, args ):
args['env']['platforms']['Windows'] = cls()
def __init__( self ):
self._toolchain = None
self.values = {}
def default_toolchain( self ):
if not self._toolchain:
env = SCons.Script.Environment()
self._toolchain = env['CC']
return self._toolchain
return self._toolchain
def __getitem__( self, key ):
return self.values.get( key )
def _bit_depth( self, machine ):
if machine == "i386":
return '32'
elif machine == "i686":
return '32'
elif machine == "x86_64":
return '64'
else:
return 'unknown'
def initialise( self ):
( system, node, release, version, machine, processor ) = platform.uname()
self.values['system'] = system
self.values['node'] = node
self.values['release'] = release
self.values['version'] = version
self.values['machine'] = machine
self.values['processor'] = processor
self.values['os'] = system
self.values['architecture'] = machine
self.values['os_version'] = release
self.values['bit_width'] = self._bit_depth( machine )
self.values['platform_path'] = self.values['architecture'] + '_' + self.values['os'] + '_' + self.values['os_version']
class Constants(object):
pass
@classmethod
def constants( cls ):
return cls.Constants
@classmethod
def name( cls ):
return cls.__name__
PK -F2* * $ cuppa/project_generators/__init__.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import cuppa.modules
__all__ = cuppa.modules.registration.get_module_list( __file__ )
PK ؽFPDB DB & cuppa/project_generators/codeblocks.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Codeblocks
#-------------------------------------------------------------------------------
import os
from exceptions import Exception
import cuppa.path
import cuppa.progress
import cuppa.tree
import cuppa.options
from cuppa.colourise import as_error, as_notice
class CodeblocksException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
def ignored_types( env ):
return [
env['PROGSUFFIX'],
env['LIBSUFFIX'],
env['SHLIBSUFFIX'],
env['OBJSUFFIX'],
env['SHOBJSUFFIX'],
'.log'
]
class Codeblocks(object):
@classmethod
def add_options( cls, add_option ):
add_option( '--generate-cbs', dest='generate-cbs',
action='store_true',
help='Tell scons to generate a Codeblocks project',
default=False )
add_option( '--generate-cbs-include-thirdparty', dest='generate_cbs_include_thirdparty',
action='store_true',
help='Include dependencies under the thirdparty directory or in downloaded libraries.',
default=False )
add_option( '--generate-cbs-exclude-relative-branches', dest='generate_cbs_exclude_relative_branches',
action='store_true',
help='Exclude branches outside of the working directory',
default=False )
add_option( '--generate-cbs-place-with-sconscript', dest='generate_cbs_place_with_sconscript',
action='store_true',
help='Exclude branches outside of the working directory',
default=False )
add_option( '--generate-cbs-exclude-paths-starting', type='string', nargs=1,
action='callback', callback=cuppa.options.list_parser( 'generate_cbs_exclude_paths_starting' ),
help='Exclude dependencies starting with the specified paths from the file list for the project' )
@classmethod
def add_to_env( cls, env ):
try:
generate = env.get_option( 'generate-cbs' )
if generate:
obj = cls( env,
env.get_option( 'generate_cbs_include_thirdparty' ),
env.get_option( 'generate_cbs_exclude_relative_branches' ),
env.get_option( 'generate_cbs_exclude_paths_starting' ),
env.get_option( 'generate_cbs_place_with_sconscript' ) )
env['project_generators']['codeblocks'] = obj
except CodeblocksException as error:
print as_error( env, "cuppa: error: failed to create CodeBlocks project generator with error [{}]".format( error ) )
def __init__( self, env, include_thirdparty, exclude_branches, excluded_paths_starting, place_cbs_by_sconscript ):
self._include_thirdparty = include_thirdparty
self._exclude_branches = exclude_branches
self._excluded_paths_starting = excluded_paths_starting and excluded_paths_starting or []
self._place_cbs_by_sconscript = place_cbs_by_sconscript
self._projects = {}
base_include = self._exclude_branches and env['base_path'] or env['branch_root']
base = os.path.realpath( base_include )
download = os.path.realpath( env['download_root'] )
thirdparty = env['thirdparty'] and os.path.realpath( env['thirdparty'] ) or None
common, tail1, tail2 = cuppa.path.split_common( base, download )
download_under_base = common and not tail1
thirdparty_under_base = None
if thirdparty:
common, tail1, tail2 = cuppa.path.split_common( base, thirdparty )
thirdparty_under_base = common and not tail1
self._exclude_paths = self._excluded_paths_starting
self._build_root = [ env['build_root'] ]
if not self._include_thirdparty:
if download_under_base:
self._exclude_paths.append( env['download_root'] )
if thirdparty and thirdparty_under_base:
self._exclude_paths.append( env['thirdparty'] )
self._include_paths = [ base_include ]
if self._include_thirdparty:
if not download_under_base:
self._include_paths.append( env['download_root'] )
if thirdparty and not thirdparty_under_base:
self._include_paths.append( env['thirdparty'] )
self._ignored_types = ignored_types( env )
cuppa.progress.NotifyProgress.register_callback( None, self.on_progress )
print "cuppa: project-generator (CodeBlocks): Including Paths Under = {}".format( as_notice( env, str( self._include_paths ) ) )
print "cuppa: project-generator (CodeBlocks): Excluding Paths Starting = {}".format( as_notice( env, str( self._exclude_paths ) ) )
def on_progress( self, progress, sconscript, variant, env, target, source ):
if progress == 'begin':
self.on_sconscript_begin( env, sconscript )
elif progress == 'started':
self.on_variant_started( env, sconscript )
elif progress == 'finished':
self.on_variant_finished( env, sconscript, target[0], source )
elif progress == 'end':
self.on_sconscript_end( env, sconscript )
elif progress =='sconstruct_end':
self.on_sconstruct_end( env )
def on_sconscript_begin( self, env, sconscript ):
pass
def on_variant_started( self, env, sconscript ):
project = sconscript
toolchain = env['toolchain'].name()
variant = env['variant'].name()
build_root = env['build_root']
working_dir = env['build_dir']
final_dir_offset = env['final_dir']
self.update( env, project, toolchain, variant, build_root, working_dir, final_dir_offset )
def on_variant_finished( self, env, sconscript, root_node, source ):
project = sconscript
tree_processor = ProcessNodes(
env,
self._projects[project]['path'],
self._projects[project]['files'],
self._include_paths,
self._exclude_paths + self._build_root,
self._ignored_types
)
cuppa.tree.process_tree( root_node, tree_processor, self._exclude_paths )
self._projects[project]['files'] = tree_processor.file_paths()
def on_sconscript_end( self, env, sconscript ):
self.write( env, sconscript )
def on_sconstruct_end( self, env ):
workspace_dir = os.path.join( env['working_dir'], "cbs" )
workspace_path = os.path.join( workspace_dir, "all.workspace" )
if workspace_dir and not os.path.exists( workspace_dir ):
os.makedirs( workspace_dir )
print "cuppa: project-generator (CodeBlocks): write workspace [{}]".format(
as_notice( env, workspace_path )
)
with open( workspace_path, "w" ) as workspace_file:
workspace_file.write( "\n".join( self.create_workspace( self._projects ) ) )
def update( self, env, project, toolchain, variant, build_root, working_dir, final_dir_offset ):
print "cuppa: project-generator (CodeBlocks): update project [{}] for [{}, {}]".format( as_notice( env, project ), as_notice( env, toolchain) , as_notice( env, variant ) )
if project not in self._projects:
title = os.path.splitext( project )[0]
directory, filename = os.path.split( title )
cbs_file_name = filename
if cbs_file_name in [ 'sconscript', 'SConscript', 'Sconscript' ]:
cbs_file_name = os.path.split( directory )[1]
if cbs_file_name == ".":
cbs_file_name = os.path.split( os.path.abspath( env['sconscript_dir'] ) )[1]
if not cbs_file_name:
cbs_file_name = "sconscript"
if not self._place_cbs_by_sconscript:
directory = env['working_dir']
directory = os.path.join( directory, "cbs")
project_file = directory + os.path.sep + cbs_file_name + ".cbp"
execution_dir = ''
if directory:
execution_dir = os.path.relpath( os.getcwd(), directory )
execution_dir = ( os.path.pardir
+ os.path.sep
+ os.path.join( execution_dir,
os.path.split( os.path.abspath( os.getcwd() ) )[1] ) )
self._projects[project] = {}
self._projects[project]['title'] = title
self._projects[project]['directory'] = directory
self._projects[project]['path'] = os.path.join( os.getcwd(), directory )
self._projects[project]['execution_dir'] = execution_dir
self._projects[project]['project_file'] = project_file
self._projects[project]['working_dir'] = os.path.join( execution_dir, working_dir )
self._projects[project]['final_dir'] = os.path.normpath(
os.path.join(
self._projects[project]['working_dir'],
final_dir_offset
)
)
self._projects[project]['variants'] = set()
self._projects[project]['toolchains'] = set()
self._projects[project]['files'] = set()
self._projects[project]['targets'] = {}
self._projects[project]['lines_header'] = []
self._projects[project]['lines_footer'] = []
if not self._projects[project]['lines_header']:
self._projects[project]['lines_header'] = self.create_header( self._projects[project]['title'],
execution_dir )
if not self._projects[project]['lines_footer']:
self._projects[project]['lines_footer'] = self.create_footer()
self._projects[project]['variants'].add( variant )
self._projects[project]['toolchains'].add( toolchain )
target = "{}-{}".format( toolchain, variant )
test_actions = [ "", "--test" ]
for action in test_actions:
target_name = target + action
if target_name not in self._projects[project]['targets']:
self._projects[project]['targets'][target_name] = self.create_target(
target_name,
project,
toolchain,
variant,
action,
self._projects[project]['working_dir'],
self._projects[project]['final_dir'] )
def write( self, env, project ):
project_file = self._projects[project]['project_file']
directory = self._projects[project]['directory']
print "cuppa: project-generator (CodeBlocks): write [{}] for [{}]".format(
as_notice( env, self._projects[project]['project_file'] ),
as_notice( env, project )
)
if directory and not os.path.exists( directory ):
os.makedirs( directory )
lines = []
lines += self._projects[project]['lines_header']
for target in sorted( self._projects[project]['targets'].itervalues() ):
lines += target
lines += [ '\t\t' ]
for filepath in sorted( self._projects[project]['files'] ):
lines += [ '\t\t' ]
lines += self._projects[project]['lines_footer']
with open( project_file, "w" ) as cbs_file:
cbs_file.write( "\n".join( lines ) )
def create_header( self, project, execution_dir ):
lines = [
'\n'
'\n'
'\t\n'
'\t' ]
lines += [
'\t\t' ]
lines += [
'\t\t\n'
'\t\t' ]
lines += [
'\t\t' ]
# lines += [
#'\t\t' ]
lines += [
'\t\t\n'
'\t\t\t\n'
'\t\t\t\n'
'\t\t\t\n'
'\t\t\t\n'
'\t\t\t\n'
'\t\t\t\n'
'\t\t' ]
lines += [
'\t\t' ]
return lines
def create_footer( self ):
lines = [
'\t\n'
'\n' ]
return lines
def create_target( self, target, project, toolchain, variant, test, working_dir, final_dir ):
lines = [
'\t\t\t\n'
'\t\t\t\t\n'
'\t\t\t\t\n'
'\t\t\t\t\n'
'\t\t\t\t\n'
'\t\t\t\t\n'
'\t\t\t\t' ]
lines += [
'\t\t\t\t\t\n'
'\t\t\t\t\t\n'
'\t\t\t\t\t'
'\t\t\t\t\t' ]
lines += [
'\t\t\t\t\n'
'\t\t\t\t\n'
'\t\t\t\t\t\n'
'\t\t\t\t\t\n'
'\t\t\t\t\t\n'
'\t\t\t\t\t\n'
'\t\t\t\t\t\n'
'\t\t\t\t\t\n'
'\t\t\t\t\n'
'\t\t\t' ]
return lines
def create_workspace( self, projects ):
lines = [
'\n'
'\n'
'\t' ]
for project in projects.itervalues():
project_file = project['project_file']
base_path = project['path']
project_file = os.path.relpath( os.path.abspath( project_file ), base_path )
lines += [
'\t\t' ]
lines += [
'\t\n'
'\n' ]
return lines
class ProcessNodes(object):
def __init__( self, env, base_path, files, allowed_paths, excluded_paths, ignored_types ):
self._env = env
self._base_path = base_path
self._files = files
self._allowed_paths = allowed_paths
self._excluded_paths = excluded_paths
self._ignored_types = ignored_types
def __call__( self, node ):
file_path = str(node)
for excluded in self._excluded_paths:
if file_path.startswith( excluded ):
return
path, ext = os.path.splitext( file_path )
if ext and ext in self._ignored_types:
return
for allowed in self._allowed_paths:
prefix = os.path.commonprefix( [ os.path.abspath( file_path ), allowed ] )
# print "cuppa: project-generator (CodeBlocks): str(file)=[{}], file.path=[{}], allowed=[{}], prefix=[{}]".format(
# as_notice( self._env, str(node) ),
# as_notice( self._env, node.path ),
# as_notice( self._env, str(allowed) ),
# as_notice( self._env, str(prefix) )
# )
if prefix != allowed:
return
# print "cuppa: project-generator (CodeBlocks): str(file)=[{}], file.path=[{}], allowed=[{}], prefix=[{}]".format(
# as_notice( self._env, str(node) ),
# as_notice( self._env, node.path ),
# as_notice( self._env, str(allowed) ),
# as_notice( self._env, str(prefix) )
# )
file_path = os.path.relpath( os.path.abspath( file_path ), self._base_path )
self._files.add( file_path )
return
def file_paths( self ):
return self._files
PK -F2* * cuppa/profiles/__init__.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import cuppa.modules
__all__ = cuppa.modules.registration.get_module_list( __file__ )
PK F/5A A cuppa/methods/coverage.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# CoverageMethod
#-------------------------------------------------------------------------------
from SCons.Script import Flatten
import cuppa.progress
class CoverageMethod(object):
def __init__( self ):
pass
def __call__( self, env, program, sources, final_dir=None ):
if final_dir == None:
final_dir = env['abs_final_dir']
emitter, builder = env['toolchain'].coverage_runner( program, final_dir )
env['BUILDERS']['CoverageBuilder'] = env.Builder( action=builder, emitter=emitter )
coverage = env.CoverageBuilder( [], Flatten( [ sources ] ) )
cuppa.progress.NotifyProgress.add( env, coverage )
return coverage
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "Coverage" )
PK -F ^/ k k cuppa/methods/build_with.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# BuildWithMethod
#-------------------------------------------------------------------------------
class BuildWithException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class BuildWithMethod:
def __init__( self, env ):
self.__build_with = env['BUILD_WITH']
def __call__( self, env, build_with ):
if isinstance( build_with, basestring ):
build_with = [ build_with ]
for name in build_with:
if name in env['dependencies']:
dependency = env['dependencies'][name]
if not dependency:
raise BuildWithException(
"The sconscript [{}] requires the dependency [{}] but it has not been initialised."
.format( env['sconscript_file'], name )
)
env.AppendUnique( BUILD_WITH = name )
dependency( env, env['toolchain'], env['variant'].name() )
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls( env ), "BuildWith" )
@classmethod
def init_env_for_variant( cls, sconscript_exports ):
env = sconscript_exports['env']
if env['default_dependencies']:
env.BuildWith( env['default_dependencies'] )
PK -FTvB cuppa/methods/using.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# UseMethod
#-------------------------------------------------------------------------------
class UseMethod:
def __init__( self, dependencies ):
self.__dependencies = dependencies
def __call__( self, env, dependency ):
if dependency in self.__dependencies:
return self.__dependencies[ dependency ]
return None
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls( env['dependencies'] ), "Using" )
PK -Ft cuppa/methods/toolchain.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# ToolchainMethod
#-------------------------------------------------------------------------------
class ToolchainMethod:
def __init__( self, toolchains ):
self.__toolchains = toolchains
def __call__( self, env, toolchain ):
if toolchain and toolchain in self.__toolchains:
return self.__toolchains[ toolchain ]
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls( env['toolchains'] ), "Toolchain" )
PK VxFOWE2 2 ( cuppa/methods/relative_recursive_glob.py
# Copyright Jamie Allsop 2012-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# RelativeRecursiveGlob
#-------------------------------------------------------------------------------
import os
import fnmatch
import re
import cuppa.recursive_glob
class RecursiveGlobMethod:
default = ()
def __call__( self, env, pattern, start=default, exclude_dirs=default ):
if start == self.default:
start = env['sconscript_dir']
start = os.path.expanduser( start )
if not os.path.isabs( start ):
start = os.path.join( env['sconscript_dir'], start )
if exclude_dirs == self.default:
exclude_dirs = [ env['download_root'], env['build_root' ] ]
exclude_dirs_regex = None
if exclude_dirs:
def up_dir( path ):
element = next( e for e in path.split(os.path.sep) if e )
return element == ".."
exclude_dirs = [ re.escape(d) for d in exclude_dirs if not os.path.isabs(d) and not up_dir(d) ]
exclude_dirs = "|".join( exclude_dirs )
exclude_dirs_regex = re.compile( exclude_dirs )
matches = cuppa.recursive_glob.glob( start, pattern, exclude_dirs_pattern=exclude_dirs_regex )
nodes = [ env.File( os.path.relpath( match, env['sconscript_dir'] ) ) for match in matches ]
return nodes
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "RecursiveGlob" )
class GlobFilesMethod:
def __call__( self, env, pattern ):
filenames = []
for filename in os.listdir(env['sconscript_dir']):
if fnmatch.fnmatch( filename, pattern):
filenames.append( filename )
nodes = [ env.File(f) for f in filenames ]
return nodes
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "GlobFiles" )
PK -F2* * cuppa/methods/__init__.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import cuppa.modules
__all__ = cuppa.modules.registration.get_module_list( __file__ )
PK -F}W W cuppa/methods/remove_flags.py
# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# RemoveFlags method
#-------------------------------------------------------------------------------
class RemoveFlagsMethod:
def __init__( self ):
pass
def _remove_flags( self, remove, flags ):
return [f for f in flags if not f.split('=')[0] in remove]
def __call__( self, env, flags ):
remove = set( f.split('=')[0] for f in flags )
env.Replace( CCFLAGS = self._remove_flags( remove, env['CCFLAGS'] ) )
env.Replace( CXXFLAGS = self._remove_flags( remove, env['CXXFLAGS'] ) )
env.Replace( CFLAGS = self._remove_flags( remove, env['CFLAGS'] ) )
env.Replace( LINKFLAGS = self._remove_flags( remove, env['LINKFLAGS'] ) )
return None
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "RemoveFlags" )
PK -Fɿ cuppa/methods/stdcpp.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# StdCpp method
#-------------------------------------------------------------------------------
from cuppa.colourise import as_error
class StdCppMethod:
stdcpp_choices = ( "c++98", "c++03", "c++0x", "c++11", "c++1y", "c++14" )
@classmethod
def add_options( cls, add_option ):
add_option( '--stdcpp', dest='stdcpp', choices=cls.stdcpp_choices, nargs=1, action='store',
help="Use this option to override the default language compliance of your cpp compiler which by dafault is the highest compliance available. Value may be one of {}".format( str(cls.stdcpp_choices) ) )
@classmethod
def get_options( cls, env ):
env['stdcpp'] = env.get_option( 'stdcpp' )
def __init__( self ):
pass
def __call__( self, env, standard ):
if standard not in self.stdcpp_choices:
print as_error( env, "cuppa: stdcpp: error: [{}] not in allowed list {}".format( standard, self.stdcpp_choices ) )
return None
env[ 'stdcpp' ] = standard
toolchain = env['toolchain']
flag = toolchain.stdcpp_flag_for( standard )
env.ReplaceFlags( [ flag ] )
return None
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "StdCpp" )
PK qFU(~ ~ cuppa/methods/test.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# TestMethod
#-------------------------------------------------------------------------------
import cuppa.progress
from SCons.Script import Flatten
class TestMethod(object):
def __init__( self, default_test_runner=None ):
self._default_runner = default_test_runner
def __call__( self, env, source, final_dir=None, data=None, runner=None, expected='passed' ):
if final_dir == None:
final_dir = env['abs_final_dir']
if not runner:
runner = self._default_runner
test_builder, test_emitter = env['toolchain'].test_runner( runner, final_dir, expected )
env['BUILDERS']['TestBuilder'] = env.Builder( action=test_builder, emitter=test_emitter )
sources = source
if data:
sources = Flatten( [ source, data ] )
test = env.TestBuilder( [], sources )
cuppa.progress.NotifyProgress.add( env, test )
return test
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls( env['default_runner'] ), "Test" )
test_runners = set()
for toolchain in env['active_toolchains']:
for test_runner in toolchain.test_runners():
test_runners.add( test_runner )
for test_runner in test_runners:
env.AddMethod( cls( test_runner ), "{}Test".format( test_runner.title() ) )
PK qFAX cuppa/methods/build_test.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# BuildTestMethod
#-------------------------------------------------------------------------------
from SCons.Script import Flatten
class BuildTestMethod:
def __init__( self, default_test_runner=None ):
self._default_runner = default_test_runner
def __call__( self, env, target, source, final_dir=None, data=None, append_variant=None, runner=None, expected='passed', **kwargs ):
nodes = []
program = env.Build( target, source, final_dir=final_dir, append_variant=append_variant, **kwargs )
nodes.append( program )
if env['variant_actions'].has_key('test') or env['variant_actions'].has_key('cov'):
if not runner:
runner = self._default_runner
test = env.Test( program, final_dir=final_dir, data=data, runner=runner, expected=expected )
nodes.append( test )
if 'cov' in env['variant_actions']:
coverage = env.Coverage( program, source, final_dir=final_dir )
nodes.append( coverage )
return Flatten( nodes )
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls( env['default_runner'] ), "BuildTest" )
test_runners = set()
for toolchain in env['active_toolchains']:
for test_runner in toolchain.test_runners():
test_runners.add( test_runner )
for test_runner in test_runners:
env.AddMethod( cls( test_runner ), "Build{}Test".format( test_runner.title() ) )
PK DnF0 R* * cuppa/methods/compile.py
# Copyright Jamie Allsop 2013-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# CompileMethod
#-------------------------------------------------------------------------------
import cuppa.progress
from SCons.Script import Flatten
class CompileMethod:
def __call__( self, env, source, **kwargs ):
sources = Flatten( [ source ] )
objects = []
if 'CPPPATH' in env:
env.AppendUnique( INCPATH = env['CPPPATH'] )
for source in sources:
objects.append(
env.Object(
source = source,
CPPPATH = env['SYSINCPATH'] + env['INCPATH'],
**kwargs ) )
cuppa.progress.NotifyProgress.add( env, objects )
return objects
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "Compile" )
PK zFi`6 6 cuppa/methods/build.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# BuildMethod
#-------------------------------------------------------------------------------
import cuppa.progress
import os.path
class BuildMethod:
@classmethod
def build( cls, env, target, source, final_dir = None, append_variant = False, LIBS=[], DYNAMICLIBS=[], STATICLIBS=[], **kwargs ):
if final_dir == None:
final_dir = env['abs_final_dir']
exe = os.path.join( final_dir, target )
if append_variant and env['variant'] != 'rel':
exe += '_' + env['variant']
env.AppendUnique( DYNAMICLIBS = env['LIBS'] )
if 'CPPPATH' in env:
env.AppendUnique( INCPATH = env['CPPPATH'] )
all_libs = env['DYNAMICLIBS'] + env['STATICLIBS'] + LIBS + DYNAMICLIBS + STATICLIBS
program = env.Program( exe,
source,
CPPPATH = env['SYSINCPATH'] + env['INCPATH'],
LIBS = all_libs,
DYNAMICLIBS = env['DYNAMICLIBS'] + LIBS + DYNAMICLIBS,
STATICLIBS = env['STATICLIBS'] + STATICLIBS,
**kwargs )
cuppa.progress.NotifyProgress.add( env, program )
return program
def __call__( self, env, target, source, final_dir = None, append_variant = False, **kwargs ):
return self.build( env, target, source, final_dir=final_dir, append_variant=append_variant, **kwargs )
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "Build" )
PK -F" cuppa/methods/replace_flags.py
# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# ReplaceFlags method
#-------------------------------------------------------------------------------
class ReplaceFlagsMethod:
def __init__( self ):
pass
def __call__( self, env, flags ):
env.RemoveFlags( flags )
env.MergeFlags( flags )
return None
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "ReplaceFlags" )
PK -F< L L cuppa/methods/create_version.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# CreateVersionMethod
#-------------------------------------------------------------------------------
class CreateVersionMethod:
def __init__( self ):
pass
def __call__( self, env, target, source, namespaces, version, location ):
create_version_file_builder = env['toolchain'].version_file_builder( env, namespaces, version, location )
create_version_file_emitter = env['toolchain'].version_file_emitter( env, namespaces, version, location )
env.AppendUnique( BUILDERS = {
'CreateVersionFile' : env.Builder( action=create_version_file_builder, emitter=create_version_file_emitter )
} )
return env.CreateVersionFile( target, source )
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "CreateVersion" )
PK Fo ! cuppa/methods/markdown_to_html.py
# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# MarkdownToHtmlMethod
#-------------------------------------------------------------------------------
import os.path
import itertools
import grip
import cuppa.progress
class GripRunner(object):
def __call__( self, target, source, env ):
for s, t in itertools.izip( source, target ):
in_file = str(s)
out_file = str(t)
try:
grip.export( path=in_file, render_wide=True, out_filename=out_file )
except Exception as error:
print "cuppa: error: grip.export( path={}, render_wide=True, out_filename={}) failed with error [{}]".format( in_file, out_file, error )
return None
class GripEmitter(object):
def __init__( self, output_dir ):
self._output_dir = output_dir
def __call__( self, target, source, env ):
target = []
for s in source:
path = os.path.join( self._output_dir, os.path.split( str(s) )[1] )
t = os.path.splitext(path)[0] + ".html"
target.append(t)
return target, source
class MarkdownToHtmlMethod(object):
def __call__( self, env, source, final_dir=None ):
if final_dir == None:
final_dir = env['abs_final_dir']
env.AppendUnique( BUILDERS = {
'Grip' : env.Builder(
action = GripRunner(),
emitter = GripEmitter(final_dir) )
} )
html = env.Grip( [], source )
cuppa.progress.NotifyProgress.add( env, html )
return html
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "MarkdownToHtml" )
PK F6: cuppa/methods/build_library.py
# Copyright Jamie Allsop 2014-2014
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# BuildLibMethods
#-------------------------------------------------------------------------------
import cuppa.progress
import os.path
class BuildStaticLibMethod:
def __call__( self, env, target, source, final_dir=None, **kwargs ):
if final_dir == None:
final_dir = env['abs_final_dir']
lib = env.StaticLibrary( os.path.join( final_dir, target ), source, **kwargs )
cuppa.progress.NotifyProgress.add( env, lib )
return lib
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "BuildStaticLib" )
class BuildSharedLibMethod:
def __call__( self, env, target, source, final_dir=None, **kwargs ):
if final_dir == None:
final_dir = env['abs_final_dir']
lib = env.SharedLibrary( os.path.join( final_dir, target ), source, **kwargs )
cuppa.progress.NotifyProgress.add( env, lib )
return lib
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls(), "BuildSharedLib" )
PK -FOV cuppa/methods/build_profile.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# BuildProfileMethod
#-------------------------------------------------------------------------------
import cuppa.utility
class BuildProfileMethod:
def __init__( self, env ):
self.__build_profile = env['BUILD_PROFILE']
def __call__( self, env, build_profile ):
for profile in build_profile:
if cuppa.utility.is_string( profile ):
name = profile
if name in env['profiles']:
profile = env['profiles'][name]
else:
name = str( profile )
env.AppendUnique( BUILD_PROFILE = name )
profile( env, env['toolchain'], env['variant'].name() )
@classmethod
def add_to_env( cls, env ):
env.AddMethod( cls( env ), "BuildProfile" )
@classmethod
def init_env_for_variant( cls, sconscript_exports ):
env = sconscript_exports['env']
if env['default_profiles']:
env.BuildProfile( env['default_profiles'] )
PK -F-a\ cuppa/variants/dbg.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Dbg
#-------------------------------------------------------------------------------
class Dbg:
@classmethod
def name( cls ):
return cls.__name__.lower()
@classmethod
def add_options( cls, add_option ):
add_option(
'--dbg', dest=cls.name(), action='store_true',
help='Build a debug binary' )
@classmethod
def add_to_env( cls, env, add_variant, add_action ):
add_variant( cls.name(), cls() )
@classmethod
def create( cls, env, toolchain ):
toolchain.update_variant( env, cls.name() )
return env
PK -F2* * cuppa/variants/__init__.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import cuppa.modules
__all__ = cuppa.modules.registration.get_module_list( __file__ )
PK -F@q? cuppa/variants/cov.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Cov
#-------------------------------------------------------------------------------
class Cov:
@classmethod
def name( cls ):
return cls.__name__.lower()
@classmethod
def add_options( cls, add_option ):
add_option(
'--cov', dest=cls.name(), action='store_true',
help='Build an instrumented binary' )
@classmethod
def add_to_env( cls, env, add_variant, add_action ):
add_variant( cls.name(), cls() )
add_action( cls.name(), cls() )
@classmethod
def create( cls, env, toolchain ):
toolchain.update_variant( env, cls.name() )
return env
PK -F cuppa/variants/test.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Test
#-------------------------------------------------------------------------------
class Test:
@classmethod
def name( cls ):
return cls.__name__.lower()
@classmethod
def add_options( cls, add_option ):
add_option(
'--test', dest=cls.name(), action='store_true',
help='Run the binary as a test' )
@classmethod
def add_to_env( cls, env, add_variant, add_action ):
add_action( cls.name(), cls() )
PK -F,G cuppa/variants/rel.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Rel
#-------------------------------------------------------------------------------
class Rel:
@classmethod
def name( cls ):
return cls.__name__.lower()
@classmethod
def add_options( cls, add_option ):
add_option(
'--rel', dest=cls.name(), action='store_true',
help='Build a release (optimised) binary' )
@classmethod
def add_to_env( cls, env, add_variant, add_action ):
add_variant( cls.name(), cls() )
@classmethod
def create( cls, env, toolchain ):
toolchain.update_variant( env, cls.name() )
return env
PK -F2* * cuppa/dependencies/__init__.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import cuppa.modules
__all__ = cuppa.modules.registration.get_module_list( __file__ )
PK mF*Y
Y
$ cuppa/dependencies/build_with_qt4.py
# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Qt4
#-------------------------------------------------------------------------------
import subprocess
import shlex
# Cuppa Imports
import cuppa.location
import cuppa.output_processor
import cuppa.build_platform
from cuppa.colourise import as_info, as_warning
import SCons.Script
class Qt4Exception(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class build_with_qt4(object):
_name = "qt4"
@classmethod
def add_options( cls, add_option ):
pass
@classmethod
def add_to_env( cls, env, add_dependency ):
try:
add_dependency( cls._name, cls( env ) )
except Qt4Exception:
print as_warning( env, "cuppa: warning: Could not create dependency [{}]. Dependency not available.".format( cls._name ) )
def __init__( self, env ):
url = "hg+https://bitbucket.org/dirkbaechle/scons_qt4"
try:
self._location = cuppa.location.Location( env, url, extra_sub_path = "qt4" )
except cuppa.location.LocationException:
print as_warning( env, "cuppa: qt4: warning: Could not retrieve url [{}]".format( url ) )
raise Qt4Exception( "Could not retrieve scons_qt4 from [{}]".format( url ) )
self._version = "4"
if cuppa.build_platform.name() in ["Darwin", "Linux"]:
if not cuppa.output_processor.command_available( "pkg-config" ):
return
if 'QT4DIR' not in env:
self._set_qt4_dir( env )
self._version = self._get_qt4_version()
def _set_qt4_dir( self, env ):
command = "pkg-config --cflags QtCore"
try:
cflags = subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
if cflags:
flags = env.ParseFlags( cflags )
if 'CPPPATH' in flags:
shortest_path = flags['CPPPATH'][0]
for include in flags['CPPPATH']:
if len(include) < len(shortest_path):
shortest_path = include
env['QT4DIR'] = shortest_path
print "cuppa: qt4: Q4DIR detected as [{}]".format( as_info( env, env['QT4DIR'] ) )
except:
#TODO: Warning?
pass
def _get_qt4_version( self ):
command = "pkg-config --modversion QtCore"
try:
return subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
except:
#TODO: Warning?
return None
def __call__( self, env, toolchain, variant ):
SCons.Script.Tool( 'qt4', toolpath=[ self._location.base_local() ] )( env )
if cuppa.build_platform.name() in ["Darwin", "Linux"]:
env.MergeFlags("-fPIC")
def name( self ):
return self._name
def version( self ):
return self._version
def repository( self ):
return "N/A"
def branch( self ):
return "N/A"
def revisions( self ):
return []
PK F+
( ( ' cuppa/dependencies/build_with_quince.py
# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Quince
#-------------------------------------------------------------------------------
import os.path
import subprocess
import shlex
# Cuppa Imports
import cuppa.location
import cuppa.output_processor
class QuinceLibraryMethod(object):
def __init__( self, location, src_path ):
self._location = location
self._src_path = src_path
def __call__( self, env, linktype ):
build_dir = os.path.join( self._location, env['build_dir'] )
final_dir = os.path.normpath( os.path.join( build_dir, env['final_dir'] ) )
env.BuildWith( 'boost' )
objects = []
for source in env.RecursiveGlob( "*.cpp", start=self._src_path, exclude_dirs=[ env['build_dir'] ] ):
rel_path = os.path.relpath( str(source), self._location )
obj_path = os.path.join( build_dir, os.path.splitext( rel_path )[0] ) +env['OBJSUFFIX']
objects.append( env.Object( obj_path, source ) )
if linktype == "static":
return env.BuildStaticLib( "quince", objects, final_dir = final_dir )
else:
shared_lib = env.BuildSharedLib( "quince", objects, final_dir = final_dir )
return env.Install( env['abs_final_dir'], shared_lib )
class build_with_quince(object):
_name = "quince"
@classmethod
def add_options( cls, add_option ):
location_name = cls._name + "-location"
add_option( '--' + location_name, dest=location_name, type='string', nargs=1, action='store',
help = cls._name + ' location to build against' )
@classmethod
def add_to_env( cls, env, add_dependency ):
location = env.get_option( cls._name + "-location" )
if not location:
print "No location specified for dependency [{}]. Dependency not available.".format( cls._name.title() )
add_dependency( cls._name, cls( env, location ) )
def __init__( self, env, location ):
self._location = cuppa.location.Location( env, location )
self._includes = [ os.path.join( self._location.local(), "include" ) ]
self._src_path = os.path.join( self._location.local(), "src" )
env.AddMethod( QuinceLibraryMethod( self._location.local(), self._src_path ), "QuinceLibrary" )
def __call__( self, env, toolchain, variant ):
env.AppendUnique( INCPATH = self._includes )
env.AppendUnique( STATICLIBS = [
env.QuinceLibrary( 'static' ),
env.BoostStaticLibs( [
'filesystem',
'system',
'thread',
] ),
] )
def name( self ):
return self._name
def version( self ):
return str(self._location.version())
def repository( self ):
return self._location.repository()
def branch( self ):
return self._location.branch()
def revisions( self ):
return self._location.revisions()
class QuincePostgresqlLibraryMethod(object):
def __init__( self, location, src_path ):
self._location = location
self._src_path = src_path
def __call__( self, env, linktype ):
build_dir = os.path.join( self._location, env['build_dir'] )
final_dir = os.path.normpath( os.path.join( build_dir, env['final_dir'] ) )
env.BuildWith( 'boost' )
objects = []
for source in env.RecursiveGlob( "*.cpp", start=self._src_path, exclude_dirs=[ env['build_dir'] ] ):
rel_path = os.path.relpath( str(source), self._location )
obj_path = os.path.join( build_dir, os.path.splitext( rel_path )[0] ) +env['OBJSUFFIX']
objects.append( env.Object( obj_path, source ) )
if linktype == "static":
return env.BuildStaticLib( "quince-postgresql", objects, final_dir = final_dir )
else:
shared_lib = env.BuildSharedLib( "quince-postgresql", objects, final_dir = final_dir )
return env.Install( env['abs_final_dir'], shared_lib )
class quince_postgresql(object):
_name = "quince-postgresql"
@classmethod
def add_options( cls, add_option ):
location_name = cls._name + "-location"
add_option( '--' + location_name, dest=location_name, type='string', nargs=1, action='store',
help = cls._name + ' location to build against' )
@classmethod
def add_to_env( cls, env, add_dependency ):
location = env.get_option( cls._name + "-location" )
if not location:
print "No location specified for dependency [{}]. Dependency not available.".format( cls._name.title() )
add_dependency( cls._name, cls( env, location ) )
def __init__( self, env, location ):
self._location = cuppa.location.Location( env, location )
self._flags = {}
self._flags['INCPATH'] = [ os.path.join( self._location.local(), "include" ) ]
if cuppa.output_processor.command_available( "pg_config"):
command = "pg_config --includedir"
libpq_include = subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
self._flags['INCPATH'].append( libpq_include )
command = "pg_config --libdir"
libpq_libpath = subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
self._flags['LIBPATH'] = [ libpq_libpath ]
self._flags['DYNAMICLIBS'] = [ 'pq' ]
self._src_path = os.path.join( self._location.local(), "src" )
env.AddMethod( QuincePostgresqlLibraryMethod( self._location.local(), self._src_path ), "QuincePostgresqlLibrary" )
def __call__( self, env, toolchain, variant ):
env.AppendUnique( INCPATH = self._flags['INCPATH'] )
env.AppendUnique( LIBPATH = self._flags['LIBPATH'] )
env.AppendUnique( DYNAMICLIBS = self._flags['DYNAMICLIBS'] )
quince_postgresql_lib = env.QuincePostgresqlLibrary('static')
quince_lib = env.QuinceLibrary('static')
env.Append( STATICLIBS = [
quince_postgresql_lib,
quince_lib,
env.BoostStaticLibs( [ 'date_time' ] ),
] )
def name( self ):
return self._name
def version( self ):
return str(self._location.version())
def repository( self ):
return self._location.repository()
def branch( self ):
return self._location.branch()
def revisions( self ):
return self._location.revisions()
class QuinceSqliteLibraryMethod(object):
def __init__( self, location, src_path ):
self._location = location
self._src_path = src_path
def __call__( self, env, linktype ):
build_dir = os.path.join( self._location, env['build_dir'] )
final_dir = os.path.normpath( os.path.join( build_dir, env['final_dir'] ) )
env.BuildWith( 'boost' )
objects = []
for source in env.RecursiveGlob( "*.cpp", start=self._src_path, exclude_dirs=[ env['build_dir'] ] ):
rel_path = os.path.relpath( str(source), self._location )
obj_path = os.path.join( build_dir, os.path.splitext( rel_path )[0] ) +env['OBJSUFFIX']
objects.append( env.Object( obj_path, source ) )
if linktype == "static":
return env.BuildStaticLib( "quince-sqlite", objects, final_dir = final_dir )
else:
shared_lib = env.BuildSharedLib( "quince-sqlite", objects, final_dir = final_dir )
return env.Install( env['abs_final_dir'], shared_lib )
class quince_sqlite(object):
_name = "quince-sqlite"
@classmethod
def add_options( cls, add_option ):
location_name = cls._name + "-location"
add_option( '--' + location_name, dest=location_name, type='string', nargs=1, action='store',
help = cls._name + ' location to build against' )
@classmethod
def add_to_env( cls, env, add_dependency ):
location = env.get_option( cls._name + "-location" )
if not location:
print "No location specified for dependency [{}]. Dependency not available.".format( cls._name.title() )
add_dependency( cls._name, cls( env, location ) )
def __init__( self, env, location ):
self._location = cuppa.location.Location( env, location )
self._flags = {}
if cuppa.output_processor.command_available( "pkg-config"):
command = "pkg-config --cflags --libs sqlite3"
cflags = subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
self._flags = env.ParseFlags( cflags )
if 'CPPPATH' in self._flags:
self._flags['SYSINCPATH'] = self._flags['CPPPATH']
del self._flags['CPPPATH']
if 'LIBS' in self._flags:
self._flags['DYNAMICLIBS'] = self._flags['LIBS']
del self._flags['LIBS']
if not 'INCPATH' in self._flags:
self._flags['INCPATH'] = []
self._flags['INCPATH'].append( os.path.join( self._location.local(), "include" ) )
self._src_path = os.path.join( self._location.local(), "src" )
env.AddMethod( QuinceSqliteLibraryMethod( self._location.local(), self._src_path ), "QuinceSqliteLibrary" )
def __call__( self, env, toolchain, variant ):
for name, flags in self._flags.iteritems():
if flags:
env.AppendUnique( **{ name: flags } )
quince_sqlite_lib = env.QuinceSqliteLibrary('static')
quince_lib = env.QuinceLibrary('static')
env.Append( STATICLIBS = [
quince_sqlite_lib,
quince_lib,
env.BoostStaticLibs( [
'date_time',
'filesystem',
] ),
] )
def name( self ):
return self._name
def version( self ):
return str(self._location.version())
def repository( self ):
return self._location.repository()
def branch( self ):
return self._location.branch()
def revisions( self ):
return self._location.revisions()
PK Fn & cuppa/dependencies/build_with_boost.py
# Copyright Jamie Allsop 2011-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Boost
#-------------------------------------------------------------------------------
import shlex
import subprocess
import os
import shutil
import re
import string
import lxml.html
from exceptions import Exception
from SCons.Script import File, AlwaysBuild, Flatten
import cuppa.build_platform
import cuppa.location
from cuppa.output_processor import IncrementalSubProcess, ToolchainProcessor
from cuppa.colourise import as_warning, as_info, as_error
class BoostException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
def determine_latest_boost_verion( env ):
current_release = "1.58.0"
try:
html = lxml.html.parse('http://www.boost.org/users/download/')
current_release = html.xpath("/html/body/div[2]/div/div[1]/div/div/div[2]/h3[1]/span")[0].text
current_release = str( re.search( r'(\d[.]\d+([.]\d+)?)', current_release ).group(1) )
print "cuppa: boost: latest boost release detected as [{}]".format( as_info( env, current_release ) )
except Exception as e:
print as_warning( env, "cuppa: boost: warning: cannot determine latest version of boost - [{}]. Assuming [{}].".format( str(e), current_release ) )
return current_release
class Boost(object):
@classmethod
def add_options( cls, add_option ):
add_option( '--boost-latest', dest='boost-latest', action='store_true',
help='Specify that you want to use boost. The latest version will be downloaded and used.' )
add_option( '--boost-version', dest='boost-version', type='string', nargs=1, action='store',
help='Boost Version to build against' )
add_option( '--boost-home', dest='boost-home', type='string', nargs=1, action='store',
help='The location of the boost source code' )
add_option( '--boost-location', dest='boost-location', type='string', nargs=1, action='store',
help='The location of the boost source code' )
add_option( '--boost-build-always', dest='boost-build-always', action='store_true',
help="Pass this if your boost source may change (for example you are patching it) and you want boost build to be executed each time the library is asked for" )
add_option( '--boost-verbose-build', dest='boost-verbose-build', action='store_true',
help="Pass this option if you wish to see the command-line output of boost build" )
add_option( '--boost-verbose-config', dest='boost-verbose-config', action='store_true',
help="Pass this option if you wish to see the configuration output of boost build" )
add_option( '--boost-patch-boost-test', dest='boost-patch-boost-test', action='store_true',
help="Use this option to patch boost test so it uses the new Boost.Timer and provides more usable output" )
@classmethod
def add_to_env( cls, env, add_dependency ):
build_always = env.get_option( 'boost-build-always' )
verbose_build = env.get_option( 'boost-verbose-build' )
verbose_config = env.get_option( 'boost-verbose-config' )
patch_boost_test = env.get_option( 'boost-patch-boost-test' )
boost_location = env.get_option( 'boost-location' )
boost_home = env.get_option( 'boost-home' )
boost_version = env.get_option( 'boost-version' )
boost_latest = env.get_option( 'boost-latest' )
thirdparty = env[ 'thirdparty' ]
boost = None
try:
if boost_location:
boost = cls( env, env[ 'platform' ],
location = boost_location,
version = boost_version,
patch_test = patch_boost_test )
elif boost_home:
boost = cls( env, env[ 'platform' ],
base = boost_home,
patch_test = patch_boost_test )
elif thirdparty and boost_version:
boost = cls( env, env[ 'platform' ],
base = thirdparty,
version = boost_version,
patch_test = patch_boost_test )
elif boost_version:
boost = cls( env, env[ 'platform' ],
version = boost_version,
patch_test = patch_boost_test )
elif boost_latest:
boost = cls( env, env[ 'platform' ],
version = 'latest',
patch_test = patch_boost_test )
except BoostException as e:
print as_warning( env, "cuppa: boost: warning: Could not create boost dependency - {}".format(e) )
add_dependency( 'boost', boost )
env.AddMethod(
BoostStaticLibraryMethod(
add_dependents=False,
build_always=build_always,
verbose_build=verbose_build,
verbose_config=verbose_config ),
"BoostStaticLibrary" )
env.AddMethod(
BoostSharedLibraryMethod(
add_dependents=False,
build_always=build_always,
verbose_build=verbose_build,
verbose_config=verbose_config ),
"BoostSharedLibrary" )
env.AddMethod(
BoostStaticLibraryMethod(
add_dependents=False,
build_always=build_always,
verbose_build=verbose_build,
verbose_config=verbose_config ),
"BoostStaticLib" )
env.AddMethod(
BoostSharedLibraryMethod(
add_dependents=False,
build_always=build_always,
verbose_build=verbose_build,
verbose_config=verbose_config ),
"BoostSharedLib" )
env.AddMethod(
BoostStaticLibraryMethod(
add_dependents=True,
build_always=build_always,
verbose_build=verbose_build,
verbose_config=verbose_config ),
"BoostStaticLibs" )
env.AddMethod(
BoostSharedLibraryMethod(
add_dependents=True,
build_always=build_always,
verbose_build=verbose_build,
verbose_config=verbose_config ),
"BoostSharedLibs" )
def get_boost_version( self, location ):
version_hpp_path = os.path.join( location, 'boost', 'version.hpp' )
if not os.path.exists( version_hpp_path ):
raise BoostException("Boost version.hpp file not found")
with open( version_hpp_path ) as version_hpp:
for line in version_hpp:
match = re.search( r'BOOST_VERSION\s+(?P\d+)', line )
if match:
int_version = int(match.group('version'))
major = int_version/100000
minor = int_version/100%1000
patch = int_version%100
full_version = "{}.{}.{}".format( major, minor, patch )
short_version = "{}_{}".format( major, minor )
numeric_version = float(major) + float(minor)/100
return full_version, short_version, numeric_version
raise BoostException("Could not determine BoostVersion")
def set_home_if_exists( self, path ):
if os.path.exists( path ) and os.path.isdir( path ):
self.values['home'] = path
return True
return False
def location_from_boost_version( self, location ):
if location == "latest" or location == "current":
location = determine_latest_boost_verion( self._env )
if location:
match = re.match( r'(boost_)?(?P\d[._]\d\d(?P[._]\d)?)', location )
if match:
version = match.group('version')
if not match.group('minor'):
version += "_0"
print "cuppa: boost version specified as a location, attempt to download it from SourceForge"
return "http://sourceforge.net/projects/boost/files/boost/{numeric_version}/boost_{string_version}.tar.gz/download".format(
numeric_version = version.translate( string.maketrans( '._', '..' ) ),
string_version = version.translate( string.maketrans( '._', '__' ) )
)
return location
def patched_boost_test( self, home ):
patch_applied_path = os.path.join( home, "cuppa_test_patch_applied.txt" )
return os.path.exists( patch_applied_path )
def apply_patch_if_needed( self, env, home ):
patch_applied_path = os.path.join( home, "cuppa_test_patch_applied.txt" )
diff_file = "boost_test_patch.diff"
if os.path.exists( patch_applied_path ):
print "cuppa: boost: [{}] already applied".format( as_info( env, diff_file ) )
return
diff_path = os.path.join( os.path.split( __file__ )[0], "boost", diff_file )
command = "patch --batch -p1 --input={}".format( diff_path )
print "cuppa: boost: info: Applying [{}] using [{}] in [{}]".format(
as_info( env, diff_file ),
as_info( env, command ),
as_info( env, home )
)
if subprocess.call( shlex.split( command ), cwd=home ) != 0:
print as_error( env, "cuppa: boost: error: Could not apply [{}]".format( diff_file ) )
with open( patch_applied_path, "w" ) as patch_applied_file:
pass
def __init__( self, env, platform, base=None, location=None, version=None, patch_test=False ):
print "cuppa: boost: identify boost using base = [{}], location = [{}] and version = [{}]".format(
as_info( env, str(base) ),
as_info( env, str(location) ),
as_info( env, str(version) )
)
if not base and not version and not location:
raise BoostException("Cannot construct Boost Object. Invalid parameters")
self._env = env
self.values = {}
self.values['name'] = 'boost'
extra_sub_path = 'clean'
if patch_test:
extra_sub_path = 'patched'
if location:
location = self.location_from_boost_version( location )
if not location: # use version as a fallback in case both at specified
location = self.location_from_boost_version( version )
self._location = cuppa.location.Location( env, location, extra_sub_path=extra_sub_path )
elif base: # Find boost locally
if not os.path.isabs( base ):
base = os.path.abspath( base )
if not version:
self.values['home'] = base
elif version:
search_list = [
os.path.join( base, 'boost', version, 'source' ),
os.path.join( base, 'boost', 'boost_' + version ),
os.path.join( base, 'boost', version ),
os.path.join( base, 'boost_' + version ),
]
def exists_in( locations ):
for location in locations:
if self.set_home_if_exists( location ):
return True
return False
if not exists_in( search_list ):
raise BoostException("Cannot construct Boost Object. Home for Version [{}] cannot be found. Seached in [{}]".format(version, str([l for l in search_list])))
else:
raise BoostException("Cannot construct Boost Object. No Home or Version specified")
print "cuppa: boost: using boost found at [{}]".format( as_info( env, self.values['home'] ) )
self._location = cuppa.location.Location( env, self.values['home'], extra_sub_path=extra_sub_path )
else:
location = self.location_from_boost_version( version )
self._location = cuppa.location.Location( env, location, extra_sub_path=extra_sub_path )
self.values['home'] = self._location.local()
if patch_test:
self.apply_patch_if_needed( env, self.values['home'] )
self._patched_test = self.patched_boost_test( self.values['home'] )
self.values['full_version'], self.values['version'], self.values['numeric_version'] = self.get_boost_version( self.values['home'] )
self.values['revisions'] = self._location.revisions()
self.values['include'] = [ self.values['home'] ]
self.values['lib_base'] = os.path.join( self.values['home'], 'build' )
self.values['location'] = self.values['home']
if self.values['numeric_version'] > 1.39:
self.values['library_mt_tag'] = ''
else:
self.values['library_mt_tag'] = '-' + platform['toolchain_tag'] + '-mt'
self.values['defines'] = [
'BOOST_PARAMETER_MAX_ARITY=20',
'BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG'
]
def name( self ):
return self.values['name']
def version( self ):
return self.values['version']
def repository( self ):
return self._location.repository()
def branch( self ):
return self._location.branch()
def revisions( self ):
return self._location.revisions()
def local( self ):
return self._location.local()
def __call__( self, env, toolchain, variant ):
env.AppendUnique( SYSINCPATH = self.values['include'] )
env.AppendUnique( CPPDEFINES = self.values['defines'] )
def numeric_version( self ):
return self.values['numeric_version']
def full_version( self ):
return self.values['full_version']
def lib( self, library ):
return 'boost_' + library + self.values['library_mt_tag']
class BoostStaticLibraryMethod(object):
def __init__( self, add_dependents=False, build_always=False, verbose_build=False, verbose_config=False ):
self._add_dependents = add_dependents
self._build_always = build_always
self._verbose_build = verbose_build
self._verbose_config = verbose_config
def __call__( self, env, libraries ):
if not self._add_dependents:
print as_warning( env, "cuppa: boost: warning: BoostStaticLibrary() is deprecated, use BoostStaticLibs() or BoostStaticLib() instead" )
libraries = Flatten( [ libraries ] )
if not 'boost' in env['BUILD_WITH']:
env.BuildWith( 'boost' )
Boost = env['dependencies']['boost']
library = BoostLibraryBuilder(
Boost,
add_dependents = self._add_dependents,
verbose_build = self._verbose_build,
verbose_config = self._verbose_config )( env, None, None, libraries, 'static' )
if self._build_always:
return AlwaysBuild( library )
else:
return library
class BoostSharedLibraryMethod(object):
def __init__( self, add_dependents=False, build_always=False, verbose_build=False, verbose_config=False ):
self._add_dependents = add_dependents
self._build_always = build_always
self._verbose_build = verbose_build
self._verbose_config = verbose_config
def __call__( self, env, libraries ):
if not self._add_dependents:
print as_warning( env, "cuppa: boost: warning: BoostSharedLibrary() is deprecated, use BoostSharedLibs() or BoostSharedLib() instead" )
libraries = Flatten( [ libraries ] )
if not 'boost' in env['BUILD_WITH']:
env.BuildWith( 'boost' )
Boost = env['dependencies']['boost']
for library in libraries:
if library.startswith('log'):
env.AppendUnique( CPPDEFINES = 'BOOST_LOG_DYN_LINK' )
elif library == 'chrono':
env.AppendUnique( CPPDEFINES = 'BOOST_CHRONO_DYN_LINK' )
elif library == 'filesystem':
env.AppendUnique( CPPDEFINES = 'BOOST_FILESYSTEM_DYN_LINK' )
elif library == 'date_time':
env.AppendUnique( CPPDEFINES = 'BOOST_DATE_TIME_DYN_LINK' )
elif library == 'system':
env.AppendUnique( CPPDEFINES = 'BOOST_SYSTEM_DYN_LINK' )
library = BoostLibraryBuilder(
Boost,
add_dependents = self._add_dependents,
verbose_build = self._verbose_build,
verbose_config = self._verbose_config )( env, None, None, libraries, 'shared' )
if self._build_always:
return AlwaysBuild( library )
else:
return library
class ProcessBjamBuild(object):
def __call__( self, line ):
match = re.search( r'\[COMPILE\] ([\S]+)', line )
if match:
self.bjam_exe_path = match.expand( r'\1' )
return line
def exe_path( self ):
return self.bjam_exe_path
class BuildBjam(object):
def __init__( self, boost ):
self._location = boost.local()
self._version = boost.numeric_version()
def __call__( self, target, source, env ):
build_script_path = self._location + '/tools/build'
if self._version < 1.47:
build_script_path += '/src/v2/engine'
elif self._version > 1.55:
build_script_path += '/src/engine'
else:
build_script_path += '/v2/engine'
## TODO: change build script depending on platform
bjam_build_script = './build.sh'
print 'Execute ' + bjam_build_script + ' from ' + build_script_path
process_bjam_build = ProcessBjamBuild()
try:
IncrementalSubProcess.Popen(
process_bjam_build,
[ bjam_build_script ],
cwd=build_script_path
)
bjam_exe_path = process_bjam_build.exe_path()
if not bjam_exe_path:
print "Could not determine bjam exe path"
return 1
bjam_binary_path = build_script_path + '/' + bjam_exe_path
shutil.copy( bjam_binary_path, target[0].path )
except OSError as error:
print 'Error building bjam [' + str( error.args ) + ']'
return 1
return None
def toolset_name_from_toolchain( toolchain ):
toolset_name = toolchain.family()
if cuppa.build_platform.name() == "Darwin":
if toolset_name == "gcc":
toolset_name = "darwin"
elif toolset_name == "clang":
toolset_name = "clang-darwin"
return toolset_name
def toolset_from_toolchain( toolchain ):
toolset_name = toolset_name_from_toolchain( toolchain )
if toolset_name == "clang-darwin":
return toolset_name
return toolset_name + '-' + toolchain.cxx_version()
def build_with_library_name( library ):
return library == 'log_setup' and 'log' or library
def variant_name( variant ):
if variant == 'dbg':
return 'debug'
else:
return 'release'
def directory_from_abi_flag( abi_flag ):
flag, value = abi_flag.split('=')
if value:
return value
return abi_flag
def stage_directory( toolchain, variant, abi_flag ):
build_base = "build"
abi_dir = directory_from_abi_flag( abi_flag )
if abi_dir:
build_base += "." + abi_dir
return os.path.join( build_base, toolchain.name(), variant )
def boost_dependency_order():
return [ 'graph', 'regex', 'coroutine', 'context', 'log_setup', 'log', 'date_time', 'filesystem', 'test', 'timer', 'chrono', 'system', 'thread' ]
def boost_dependency_set():
return set( boost_dependency_order() )
def boost_libraries_with_no_dependencies():
return set( [
'context',
'date_time',
'exception',
'graph_parallel',
'iostreams',
'locale',
'math',
'mpi',
'program_options',
'python',
'random',
'regex',
'serialization',
'signals',
'system',
'thread',
'wave'
] )
def add_dependent_libraries( boost, linktype, libraries ):
version = boost.numeric_version()
patched_test = boost._patched_test
required_libraries = set( libraries )
for library in libraries:
if library in boost_libraries_with_no_dependencies():
continue
elif library == 'chrono':
required_libraries.update( ['system'] )
elif library == 'coroutine':
required_libraries.update( ['context', 'system'] )
if version > 1.55:
required_libraries.update( ['thread'] )
if linktype == 'shared':
required_libraries.update( ['chrono'] )
elif library == 'filesystem':
required_libraries.update( ['system'] )
elif library == 'graph':
required_libraries.update( ['regex'] )
elif library == 'log':
required_libraries.update( ['date_time', 'filesystem', 'system', 'thread'] )
elif library == 'log_setup':
required_libraries.update( ['log', 'date_time', 'filesystem', 'system', 'thread'] )
elif library == 'test' and patched_test:
required_libraries.update( ['timer, chrono'] )
elif library == 'timer':
required_libraries.update( ['chrono'] )
libraries = []
for library in boost_dependency_order():
if library in required_libraries:
libraries.append( library )
for library in required_libraries:
if library not in boost_dependency_set():
libraries.append( library )
return libraries
def lazy_update_library_list( env, emitting, libraries, built_libraries, add_dependents, linktype, boost ):
if add_dependents:
if not emitting:
libraries = set( build_with_library_name(l) for l in add_dependent_libraries( boost, linktype, libraries ) )
else:
libraries = add_dependent_libraries( boost, linktype, libraries )
# Use the sconscript_file + build_dir to identify this instance of the environment
variant_instance = env['sconscript_file'] + env['build_dir']
if not variant_instance in built_libraries:
built_libraries[ variant_instance ] = set( libraries )
else:
libraries = [ l for l in libraries if l not in built_libraries[ variant_instance ] ]
return libraries
class BoostLibraryAction(object):
_built_libraries = {}
def __init__( self, env, libraries, add_dependents, linktype, boost, verbose_build, verbose_config ):
self._env = env
self._libraries = lazy_update_library_list( env, False, libraries, self._built_libraries, add_dependents, linktype, boost )
self._location = boost.local()
self._version = boost.numeric_version()
self._full_version = boost.full_version()
self._verbose_build = verbose_build
self._verbose_config = verbose_config
self._linktype = linktype
self._variant = variant_name( self._env['variant'].name() )
self._toolchain = env['toolchain']
self._job_count = env['job_count']
self._parallel = env['parallel']
def _toolset_name_from_toolchain( self, toolchain ):
toolset_name = toolchain.family()
if cuppa.build_platform.name() == "Darwin":
if toolset_name == "gcc":
toolset_name = "darwin"
elif toolset_name == "clang":
toolset_name = "clang-darwin"
return toolset_name
def _toolset_from_toolchain( self, toolchain ):
toolset_name = toolset_name_from_toolchain( toolchain )
if toolset_name == "clang-darwin":
return toolset_name
return toolset_name + '-' + toolchain.version()
def _build_command( self, env, toolchain, libraries, variant, linktype, stage_dir ):
verbose = ""
if self._verbose_build:
verbose += " -d+2"
if self._verbose_config:
verbose += " --debug-configuration"
jobs = "1"
if self._job_count >= 2 and self._parallel:
if len(libraries)>4:
jobs = str( self._job_count - 1 )
else:
jobs = str( self._job_count/4 + 1 )
with_libraries = ""
for library in libraries:
with_libraries += " --with-" + library
build_flags = ""
abi_flag = toolchain.abi_flag(env)
if abi_flag:
build_flags = 'cxxflags="' + abi_flag + '"'
build_flags += ' define="BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG"'
if linktype == 'shared':
build_flags += ' define="BOOST_ALL_DYN_LINK"'
build_dir = "bin." + directory_from_abi_flag( abi_flag )
command_line = "./bjam{verbose} -j {jobs}{with_libraries} toolset={toolset} variant={variant} {build_flags} link={linktype} --build-dir=./{build_dir} stage --stagedir=./{stage_dir}".format(
verbose = verbose,
jobs = jobs,
with_libraries = with_libraries,
toolset = toolset_from_toolchain( toolchain ),
variant = variant,
build_flags = build_flags,
linktype = linktype,
build_dir = build_dir,
stage_dir = stage_dir )
print command_line
return shlex.split( command_line )
def __call__( self, target, source, env ):
if not self._libraries:
return None
stage_dir = stage_directory( self._toolchain, self._variant, self._toolchain.abi_flag(env) )
args = self._build_command( env, self._toolchain, self._libraries, self._variant, self._linktype, stage_dir )
processor = BjamOutputProcessor( env, self._verbose_build, self._verbose_config, self._toolset_name_from_toolchain( self._toolchain ) )
returncode = IncrementalSubProcess.Popen(
processor,
args,
cwd=self._location
)
summary = processor.summary( returncode )
if summary:
print summary
if returncode:
return returncode
return None
class BjamOutputProcessor(object):
def __init__( self, env, verbose_build, verbose_config, toolset_name ):
self._verbose_build = verbose_build
self._verbose_config = verbose_config
self._toolset_filter = toolset_name + '.'
self._colouriser = env['colouriser']
self._minimal_output = not self._verbose_build
ignore_duplicates = not self._verbose_build
self._toolchain_processor = ToolchainProcessor( self._colouriser, env['toolchain'], self._minimal_output, ignore_duplicates )
def __call__( self, line ):
if line.startswith( self._toolset_filter ):
return line
elif not self._verbose_config:
if( line.startswith( "Performing configuration" )
or line.startswith( "Component configuration" )
or line.startswith( " - " ) ):
return None
return self._toolchain_processor( line )
def summary( self, returncode ):
summary = self._toolchain_processor.summary( returncode )
if returncode and not self._verbose_build:
summary += "\nTry running with {} for more details".format( self._colouriser.emphasise( '--boost-verbose-build' ) )
return summary
def static_library_name( env, library ):
return env.subst('$LIBPREFIX') + 'boost_' + library + env.subst('$LIBSUFFIX')
def shared_library_name( env, library, full_version ):
if cuppa.build_platform.name() == "Darwin":
return env.subst('$SHLIBPREFIX') + 'boost_' + library + env.subst('$SHLIBSUFFIX')
else:
return env.subst('$SHLIBPREFIX') + 'boost_' + library + env.subst('$SHLIBSUFFIX') + '.' + full_version
class BoostLibraryEmitter(object):
_built_libraries = {}
def __init__( self, env, libraries, add_dependents, linktype, boost ):
self._env = env
self._libraries = lazy_update_library_list( env, True, libraries, self._built_libraries, add_dependents, linktype, boost )
self._location = boost.local()
self._linktype = linktype
self._version = boost.numeric_version()
self._full_version = boost.full_version()
self._variant = variant_name( self._env['variant'].name() )
self._toolchain = env['toolchain']
def __call__( self, target, source, env ):
stage_dir = stage_directory( self._toolchain, self._variant, self._toolchain.abi_flag(env) )
for library in self._libraries:
filename = None
if self._linktype == 'static':
filename = static_library_name( env, library )
else:
filename = shared_library_name( env, library, self._full_version )
built_library_path = os.path.join( self._location, stage_dir, 'lib', filename )
node = File( built_library_path )
target.append( node )
return target, source
class WriteToolsetConfigJam(object):
def _update_project_config_jam( self, project_config_path, current_toolset, toolset_config_line ):
config_added = False
changed = False
temp_path = os.path.splitext( project_config_path )[0] + ".new_jam"
if not os.path.exists( project_config_path ):
with open( project_config_path, 'w' ) as project_config_jam:
project_config_jam.write( "# File created by cuppa:boost\n" )
with open( project_config_path ) as project_config_jam:
with open( temp_path, 'w' ) as temp_file:
for line in project_config_jam.readlines():
if line.startswith( current_toolset ):
if line != toolset_config_line:
temp_file.write( toolset_config_line )
changed = True
config_added = True
else:
temp_file.write( line )
if not config_added:
temp_file.write( toolset_config_line )
changed = True
if changed:
os.remove( project_config_path )
shutil.move( temp_path, project_config_path )
else:
os.remove( temp_path )
def __call__( self, target, source, env ):
path = str(target[0])
if not os.path.exists( path ):
toolchain = env['toolchain']
current_toolset = "using {} : {} :".format( toolset_name_from_toolchain( toolchain ), toolchain.cxx_version() )
toolset_config_line = "{} {} ;\n".format( current_toolset, toolchain.binary() )
with open( path, 'w' ) as toolchain_config:
print "cuppa: boost: adding toolset config [{}] to dummy toolset config".format( str(toolset_config_line.strip()) )
toolchain_config.write( toolset_config_line )
self._update_project_config_jam(
os.path.join( os.path.split( path )[0], "project-config.jam" ),
current_toolset,
toolset_config_line
)
return None
class BoostLibraryBuilder(object):
_library_targets = {}
def __init__( self, boost, add_dependents, verbose_build, verbose_config ):
self._boost = boost
self._add_dependents = add_dependents
self._verbose_build = verbose_build
self._verbose_config = verbose_config
def __call__( self, env, target, source, libraries, linktype ):
library_action = BoostLibraryAction ( env, libraries, self._add_dependents, linktype, self._boost, self._verbose_build, self._verbose_config )
library_emitter = BoostLibraryEmitter( env, libraries, self._add_dependents, linktype, self._boost )
env.AppendUnique( BUILDERS = {
'BoostLibraryBuilder' : env.Builder( action=library_action, emitter=library_emitter )
} )
bjam_target = os.path.join( self._boost.local(), 'bjam' )
bjam = env.Command( bjam_target, [], BuildBjam( self._boost ) )
env.NoClean( bjam )
built_libraries = env.BoostLibraryBuilder( target, source )
prefix = env.subst('$LIBPREFIX')
if linktype == 'shared':
prefix = env.subst('$SHLIBPREFIX')
built_library_map = {}
for library in built_libraries:
name = os.path.splitext( os.path.split( str(library) )[1] )[0].replace( prefix + "boost_", "" )
built_library_map[name] = library
variant_instance = env['sconscript_file'] + env['build_dir']
if not variant_instance in self._library_targets:
self._library_targets[ variant_instance ] = {}
required_libraries = add_dependent_libraries( self._boost, linktype, libraries )
for library in required_libraries:
if library in self._library_targets[ variant_instance ]:
if library not in built_library_map:
env.Depends( built_libraries, self._library_targets[ variant_instance ][library] )
else:
self._library_targets[ variant_instance ][library] = built_library_map[library]
installed_libraries = []
if not built_libraries:
return installed_libraries
env.Requires( built_libraries, bjam )
if cuppa.build_platform.name() == "Linux":
toolset_target = os.path.join( self._boost.local(), env['toolchain'].name() + "._jam" )
toolset_config_jam = env.Command( toolset_target, [], WriteToolsetConfigJam() )
project_config_target = os.path.join( self._boost.local(), "project-config.jam" )
if not os.path.exists( project_config_target ):
project_config_jam = env.Requires( project_config_target, env.AlwaysBuild( toolset_config_jam ) )
env.Requires( built_libraries, project_config_jam )
env.Requires( built_libraries, toolset_config_jam )
install_dir = env['abs_build_dir']
library_path = os.path.split( str(built_libraries[0]) )[1]
if linktype == 'shared':
install_dir = os.path.split( os.path.join( env['abs_final_dir'], library_path ) )[0]
for library in required_libraries:
installed_libraries.append( env.Install( install_dir, self._library_targets[ variant_instance ][library] ) )
return installed_libraries
PK mFh[
[
$ cuppa/dependencies/build_with_qt5.py
# Copyright Jamie Allsop 2015-2015
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#-------------------------------------------------------------------------------
# Qt5
#-------------------------------------------------------------------------------
import subprocess
import shlex
# Cuppa Imports
import cuppa.location
import cuppa.output_processor
import cuppa.build_platform
from cuppa.colourise import as_info, as_warning
import SCons.Script
class Qt5Exception(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class build_with_qt5(object):
_name = "qt5"
@classmethod
def add_options( cls, add_option ):
pass
@classmethod
def add_to_env( cls, env, add_dependency ):
try:
add_dependency( cls._name, cls( env ) )
except Qt5Exception:
print as_warning( env, "cuppa: warning: Could not create dependency [{}]. Dependency not available.".format( cls._name ) )
def __init__( self, env ):
url = "hg+https://bitbucket.org/dirkbaechle/scons_qt5"
try:
self._location = cuppa.location.Location( env, url, extra_sub_path = "qt5" )
except cuppa.location.LocationException:
print as_warning( env, "cuppa: qt5: warning: Could not retrieve url [{}]".format( url ) )
raise Qt5Exception( "Could not retrieve scons_qt5 from [{}]".format( url ) )
self._version = "5"
if cuppa.build_platform.name() in ["Darwin", "Linux"]:
if not cuppa.output_processor.command_available( "pkg-config" ):
return
if 'QT5DIR' not in env:
self._set_qt5_dir( env )
self._version = self._get_qt5_version()
def _set_qt5_dir( self, env ):
command = "pkg-config --cflags Qt5Core"
try:
cflags = subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
if cflags:
flags = env.ParseFlags( cflags )
if 'CPPPATH' in flags:
shortest_path = flags['CPPPATH'][0]
for include in flags['CPPPATH']:
if len(include) < len(shortest_path):
shortest_path = include
env['QT5DIR'] = shortest_path
print "cuppa: qt5: Q5DIR detected as [{}]".format( as_info( env, env['QT5DIR'] ) )
except:
#TODO: Warning?
pass
def _get_qt5_version( self ):
command = "pkg-config --modversion Qt5Core"
try:
return subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
except:
#TODO: Warning?
return None
def __call__( self, env, toolchain, variant ):
SCons.Script.Tool( 'qt5', toolpath=[ self._location.base_local() ] )( env )
if cuppa.build_platform.name() in ["Darwin", "Linux"]:
env.MergeFlags("-fPIC")
def name( self ):
return self._name
def version( self ):
return self._version
def repository( self ):
return "N/A"
def branch( self ):
return "N/A"
def revisions( self ):
return []
PK cFC߈4 $ cuppa/dependencies/boost/__init__.py
PK cF| . cuppa/dependencies/boost/boost_test_patch.diffdiff -urN a/boost/test/impl/compiler_log_formatter.ipp b/boost/test/impl/compiler_log_formatter.ipp
--- a/boost/test/impl/compiler_log_formatter.ipp 2012-12-13 21:32:58.000000000 +0000
+++ b/boost/test/impl/compiler_log_formatter.ipp 2015-06-21 20:57:34.113753873 +0100
@@ -19,8 +19,10 @@
#include
#include
#include
+#include
#include
#include
+#include
// Boost
#include
@@ -52,6 +54,22 @@
: BOOST_TEST_L( "Test setup" );
}
+//____________________________________________________________________________//
+
+void
+print_result( std::ostream& ostr, counter_t v, counter_t total,
+ const_string name, const_string res )
+{
+ if( v > 0 ) {
+ ostr << v << ' ' << name << ( v != 1 ? "s" : "" );
+ if( total > 0 )
+ ostr << " out of " << total;
+
+ ostr << ' ' << res << ". ";
+ }
+}
+
+
} // local namespace
//____________________________________________________________________________//
@@ -90,25 +108,57 @@
void
compiler_log_formatter::test_unit_start( std::ostream& output, test_unit const& tu )
{
+ print_prefix( output, tu.p_file_name, tu.p_line_num );
output << "Entering test " << tu.p_type_name << " \"" << tu.p_name << "\"" << std::endl;
}
//____________________________________________________________________________//
void
-compiler_log_formatter::test_unit_finish( std::ostream& output, test_unit const& tu, unsigned long elapsed )
+compiler_log_formatter::test_unit_finish( std::ostream& output, test_unit const& tu, elapsed_t elapsed )
{
output << "Leaving test " << tu.p_type_name << " \"" << tu.p_name << "\"";
- if( elapsed > 0 ) {
+ if( has_time( elapsed ) ) {
output << "; testing time: ";
- if( elapsed % 1000 == 0 )
- output << elapsed/1000 << "ms";
- else
- output << elapsed << "mks";
+ output << to_string( elapsed );
+ }
+
+ output << ". ";
+
+ test_results const& tr = results_collector.results( tu.p_id );
+
+ const_string status;
+
+ if( tr.passed() )
+ status = "passed";
+ else if( tr.p_skipped )
+ status = "skipped";
+ else if( tr.p_aborted )
+ status = "aborted";
+ else
+ status = "failed";
+
+ output << "Test " << ( tu.p_type == tut_case ? "case" : "suite" ) << ' ' << status << ". ";
+
+ if( tr.p_skipped ) {
+ output << "due to " << ( tu.check_dependencies() ? "test aborting\n" : "failed dependency\n" );
+ return;
}
- output << std::endl;
+ counter_t total_assertions = tr.p_assertions_passed + tr.p_assertions_failed;
+ counter_t total_tc = tr.p_test_cases_passed + tr.p_test_cases_failed + tr.p_test_cases_skipped;
+
+ if( total_assertions > 0 || total_tc > 0 ) {
+ print_result( output, tr.p_assertions_passed, total_assertions, "assertion", "passed" );
+ print_result( output, tr.p_assertions_failed, total_assertions, "assertion", "failed" );
+ print_result( output, tr.p_expected_failures, 0 , "failure" , "expected" );
+ print_result( output, tr.p_test_cases_passed, total_tc , "test case", "passed" );
+ print_result( output, tr.p_test_cases_failed, total_tc , "test case", "failed" );
+ print_result( output, tr.p_test_cases_skipped, total_tc , "test case", "skipped" );
+ print_result( output, tr.p_test_cases_aborted, total_tc , "test case", "aborted" );
+ }
+ output << "\n";
}
//____________________________________________________________________________//
diff -urN a/boost/test/impl/framework.ipp b/boost/test/impl/framework.ipp
--- a/boost/test/impl/framework.ipp 2012-12-13 21:32:58.000000000 +0000
+++ b/boost/test/impl/framework.ipp 2015-06-21 20:58:16.588222869 +0100
@@ -32,9 +32,10 @@
#include
#include
+#include
// Boost
-#include
+// none
// STL
#include