PK -¹ƒFkÒm• 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 DkRG?Ç Âð< ð< 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 hashlib
import platform
import pip.vcs
import pip.download
import pip.exceptions
import scms.subversion
import scms.git
import scms.mercurial
from cuppa.colourise import as_notice, as_info, as_warning, as_error
from cuppa.log import logger
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 ):
logger.debug( "Checking for cached archive [{}]...".format( as_info( path ) ) )
for archive in os.listdir(cache_root):
if fnmatch.fnmatch( archive, path ):
logger.debug( "Found cached archive [{}] skipping download".format( 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 ):
logger.debug( "Removing redundant top directory [{}] from [{}]".format(
as_info( dirs[0] ),
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 ):
logger.debug( "Extracting [{}] into [{}]".format( as_info( filename ), 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 ):
logger.debug( "Extracting [{}] into [{}]".format( as_info( filename ), 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 folder_name_from_path( self, path ):
def is_url( path ):
return isinstance( path, urlparse.ParseResult )
def name_from_url( url ):
return '#'.join( [ url.scheme, url.netloc, urllib.unquote( url.path ) ] )
def short_name_from_url( url ):
return re.sub( r'[\\/+:() ]', r'#', urllib.unquote( url.path ) )
def name_from_path( path ):
folder_name = os.path.splitext( path_leaf( path ) )[0]
name, ext = os.path.splitext( folder_name )
if ext == ".tar":
folder_name = name
return folder_name
local_folder = is_url( path ) and name_from_url( path ) or name_from_path( path )
local_folder = re.sub( r'[\\/+:() ]', r'#', local_folder )
if platform.system() == "Windows":
# Windows suffers from MAX_PATH limitations so we'll use a hash to shorten the name
hasher = hashlib.md5()
hasher.update( local_folder )
digest = hasher.hexdigest()
short_digest = digest[-8:]
name_hint = self._name_hint
if not name_hint:
name_hint = is_url( path ) and short_name_from_url( path ) or local_folder
name_hint = name_hint[:8]
local_folder = name_hint + short_digest
return local_folder
def get_local_directory( self, cuppa_env, location, sub_dir, branch, full_url ):
local_directory = None
base = cuppa_env['download_root']
if not os.path.isabs( base ):
base = os.path.join( cuppa_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_folder = self.folder_name_from_path( location )
local_directory = os.path.join( base, local_folder )
if os.path.exists( local_directory ):
try:
os.rmdir( local_directory )
except:
return local_directory, False
self.extract( location, local_directory )
else:
local_directory = branch and os.path.join( location, branch ) or location
return local_directory, False
else:
local_folder = self.folder_name_from_path( full_url )
local_directory = os.path.join( base, local_folder )
if full_url.scheme.startswith( 'http' ) and self.url_is_download_archive_url( full_url.path ):
logger.debug( "[{}] is an archive download".format( 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, True
# If not we then check to see if we cached the download
cached_archive = self.get_cached_archive( cuppa_env['cache_root'], local_folder )
if cached_archive:
logger.debug( "Cached archive [{}] found for [{}]".format(
as_info( cached_archive ),
as_info( location )
) )
self.extract( cached_archive, local_dir_with_sub_dir )
else:
logger.info( "Downloading [{}]...".format( as_info( location ) ) )
filename, headers = urllib.urlretrieve( location )
name, extension = os.path.splitext( filename )
logger.info( "[{}] successfully downloaded to [{}]".format(
as_info( location ),
as_info( filename )
) )
self.extract( filename, local_dir_with_sub_dir )
if cuppa_env['cache_root']:
cached_archive = os.path.join( cuppa_env['cache_root'], local_folder )
logger.debug( "Caching downloaded file as [{}]".format( 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]
logger.debug( "Updating [{}] in [{}]{} at [{}]".format(
as_info( location ),
as_notice( local_dir_with_sub_dir ),
( rev_options and " on {}".format( as_notice( str(rev_options) ) ) or "" ),
as_info( version )
) )
try:
vcs_backend.update( local_dir_with_sub_dir, rev_options )
logger.debug( "Successfully updated [{}]".format( as_info( location ) ) )
except pip.exceptions.InstallationError as error:
logger.warn( "Could not update [{}] in [{}]{} due to error [{}]".format(
as_warning( location ),
as_warning( local_dir_with_sub_dir ),
( rev_options and " at {}".format( as_warning( str(rev_options) ) ) or "" ),
as_warning( str(error) )
) )
else:
action = "Cloning"
if vc_type == "svn":
action = "Checking out"
logger.info( "{} [{}] into [{}]".format(
action, as_info( location ),
as_info( local_dir_with_sub_dir )
) )
try:
vcs_backend.obtain( local_dir_with_sub_dir )
logger.debug( "Successfully retrieved [{}]".format( as_info( location ) ) )
except pip.exceptions.InstallationError as error:
logger.error( "Could not retrieve [{}] into [{}]{} due to error [{}]".format(
as_error( location ),
as_error( local_dir_with_sub_dir ),
( rev_options and " to {}".format( as_error( str(rev_options) ) ) or ""),
as_error( str( error ) )
) )
raise LocationException( "Error obtaining [{}]: {}".format( location, error ) )
return local_directory, True
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 __init__( self, cuppa_env, location, branch=None, extra_sub_path=None, name_hint=None ):
self._location = location
self._full_url = urlparse.urlparse( location )
self._sub_dir = ""
self._name_hint = name_hint
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, use_sub_dir = self.get_local_directory( cuppa_env, location, self._sub_dir, branch, self._full_url )
self._base_local_directory = local_directory
self._local_directory = use_sub_dir and os.path.join( local_directory, self._sub_dir ) or local_directory
## 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 )
logger.debug( "Using [{}]{} at [{}] stored in [{}]".format(
as_info( location ),
( branch and ":[{}]".format( as_info( str(branch) ) ) or "" ),
as_info( self._version ),
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 {QGÙó† cuppa/log.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)
#-------------------------------------------------------------------------------
# Log
#-------------------------------------------------------------------------------
import logging
from cuppa.colourise import as_error_label, as_warning_label, as_emphasised
logging.TRACE = 5
def trace( self, message, *args, **kwargs ):
if self.isEnabledFor( logging.TRACE ):
self._log( logging.TRACE, message, args, **kwargs )
logging.Logger.trace = trace
logger = logging.getLogger('cuppa')
logger.setLevel( logging.INFO )
class _formatter(logging.Formatter):
@classmethod
def warn_fmt( cls ):
return "{} %(message)s".format( as_warning_label("%(name)s: %(module)s: [%(levelname)s]") )
@classmethod
def error_fmt( cls ):
return "{} %(message)s".format( as_error_label("%(name)s: %(module)s: [%(levelname)s]") )
@classmethod
def critical_fmt( cls ):
return "{} %(message)s".format( as_error_label( as_emphasised( "%(name)s: %(module)s: [%(levelname)s]") ) )
def __init__( self, fmt="%(name)s: %(module)s: [%(levelname)s] %(message)s" ):
logging.Formatter.__init__( self, fmt )
self._warn_fmt = self.warn_fmt()
self._error_fmt = self.error_fmt()
self._critical_fmt = self.critical_fmt()
def format( self, record ):
orig_fmt = self._fmt
if record.levelno == logging.WARN:
self._fmt = self._warn_fmt
elif record.levelno == logging.ERROR:
self._fmt = self._error_fmt
elif record.levelno == logging.CRITICAL:
self._fmt = self._critical_fmt
result = logging.Formatter.format( self, record )
self._fmt = orig_fmt
return result
_log_handler = logging.StreamHandler()
def initialise_logging():
logging.addLevelName( logging.TRACE, 'trace' )
logging.addLevelName( logging.DEBUG, 'debug' )
logging.addLevelName( logging.INFO, 'info' )
logging.addLevelName( logging.WARN, 'warn' )
logging.addLevelName( logging.ERROR, 'error' )
logging.addLevelName( logging.CRITICAL, 'critical' )
_log_handler.setFormatter( _formatter() )
logger.addHandler( _log_handler )
def reset_logging_format():
_log_handler.setFormatter( _formatter() )
def set_logging_level( level ):
if level == "trace":
logger.setLevel( logging.TRACE )
elif level == "debug":
logger.setLevel( logging.DEBUG )
elif level == "warn":
logger.setLevel( logging.WARN )
elif level == "error":
logger.setLevel( logging.ERROR )
else:
logger.setLevel( logging.INFO )
PK {QGr.Ì}œ œ 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
from cuppa.colourise import as_emphasised, as_colour, emphasise_time_by_digit
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()
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, emphasise=False ):
def write( text ):
if not emphasise:
sys.stdout.write( text )
else:
sys.stdout.write( as_emphasised( text ) )
write( " Time:" )
write( " Wall [ {}".format( emphasise_time_by_digit( as_duration_string( cpu_times.wall ) ) ) )
write( " ] CPU [ {}".format( emphasise_time_by_digit( as_duration_string( cpu_times.process ) ) ) )
write( " ] CPU/Wall [ {}".format( as_colour( 'time', as_wall_cpu_percent_string( cpu_times ) ) ) )
write( " ]" )
PK q‚RG#ho# # " 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
from cuppa.log import logger
from cuppa.colourise import as_notice, as_error
class HeaderLibraryException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
class base(object):
_name = None
_cached_locations = {}
_includes = None
_sys_includes = 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 ):
add_dependency( cls._name, cls.create )
@classmethod
def location_id( cls, env ):
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:
logger.debug( "No location specified for dependency [{}]. Dependency not available.".format( cls._name.title() ) )
return None
return (location, branch)
@classmethod
def _get_location( cls, env ):
location_id = cls.location_id( env )
if not location_id:
return None
if location_id not in cls._cached_locations:
location = location_id[0]
branch = location_id[1]
try:
cls._cached_locations[location_id] = cuppa.location.Location( env, location, branch )
except cuppa.location.LocationException as error:
logger.error(
"Could not get location for [{}] at [{}] with branch [{}]. Failed with error [{}]"
.format( as_notice( cls._name.title() ), as_notice( str(location) ), as_notice( str(branch) ), as_error( error ) )
)
return None
return cls._cached_locations[location_id]
@classmethod
def create( cls, env ):
location = cls._get_location( env )
if not location:
return None
if not cls._includes:
include = env.get_option( cls._name + "-include" )
cls._includes = include and [include] or []
if not cls._sys_includes:
sys_include = env.get_option( cls._name + "-sys-include" )
cls._sys_includes = sys_include and [sys_include] or []
return cls( env, location, includes=cls._includes, sys_includes=cls._sys_includes)
def __init__( self, env, location, includes=[], sys_includes=[] ):
self._location = location
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 5¿®F©‚y 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 {QGÅ\qo o 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 ''
colouriser = Colouriser.create()
def as_colour( meaning, text ):
return colouriser.colour( meaning, text )
def as_highlighted( meaning, text ):
return colouriser.highlight( meaning, text )
def as_emphasised( text ):
return colouriser.emphasise( text )
def as_error( text ):
return colouriser.colour( 'error', text )
def as_error_label( text ):
return colouriser.highlight( 'error', text )
def as_warning( text ):
return colouriser.colour( 'warning', text )
def as_warning_label( text ):
return colouriser.highlight( 'warning', text )
def as_info( text ):
return colouriser.colour( 'info', text )
def as_message( text ):
return colouriser.colour( 'message', text )
def as_notice( text ):
return colouriser.colour( 'notice', text )
def start_colour( meaning ):
return colouriser.start_colour( meaning )
def start_highlight( meaning ):
return colouriser.start_highlight( meaning )
def colour_reset():
return colouriser.reset()
def emphasise_time_by_group( time_text ):
return colouriser.emphasise_time_by_group( time_text )
def emphasise_time_by_digit( time_text ):
return colouriser.emphasise_time_by_digit( time_text )
PK {QG“W8¨ ¨ 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
from cuppa.colourise import as_info, as_notice
from cuppa.log import logger
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._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
logger.info( "{}".format( as_notice( "Clear configuration requested..." ) ) )
if os.path.exists( self._conf_path ):
logger.info( "Removing configure file [{}]".format(
as_info( self._conf_path ) ) )
os.remove( self._conf_path )
else:
logger.info( "Configure file [{}] does not exist. Unconfigure not needed".format(
as_info( self._conf_path ) ) )
return
elif self._configure:
print logger.info( "{}".format( 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:
logger.info( "Configure file [{}] exists. Load stored settings...".format(
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:
logger.info( "Load complete" )
else:
logger.info( "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 ):
logger.info( "{} [{}] = [{}]".format(
action,
as_notice( key ),
as_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)
logger.info( "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]
logger.info( "Removing option [{}] as requested".format( as_notice( "--" + setting ) ) )
if initial_option_count != len(self._loaded_options):
self._update_conf()
def _save_conf( self ):
logger.info( "{}".format( as_notice( "Save current settings..." ) ) )
self._save_settings()
logger.info( "{}".format( as_notice( "Save complete" ) ) )
def _update_conf( self ):
logger.info( "{}".format( as_notice( "Updating current settings..." ) ) )
self._save_settings()
logger.info( "{}".format( as_notice( "Update complete" ) ) )
PK Õf=Göìë!„ „ 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
import subprocess
import shlex
import os.path
# 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 which( program ):
exe = 'which'
if platform.system() == "Windows":
exe = 'where.exe'
command = "{} {}".format( exe, program )
try:
path = subprocess.check_output( shlex.split( command ) )
return os.path.dirname( path )
except subprocess.CalledProcessError as error:
print "ERROR calling command \"{}\"; Failed with error: {}".format( command, str(error) )
return None
def name():
return Platform.current().name()
def constants():
return Platform.current().constants()
PK îcáFew}» » 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
tDøb 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 ±»SGG4*K
cuppa/VERSION0.9.0
PK Q¶FRâ{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 DkRGÏ«*¼)/ )/ 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
import Queue
import platform
from cuppa.colourise import as_colour, as_emphasised, as_highlighted
from cuppa.log import logger
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 )
try:
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
except Exception as e:
logger.error( "output_processor: IncrementalSubProcess.Popen2() failed with error [{}]".format( str(e) ) )
@classmethod
def Popen( cls, processor, args_list, **kwargs ):
return cls.Popen2( processor, processor, args_list, **kwargs )
class PSpawn(object):
def __init__( self, pspawn, sh, escape, cmd, args, env, stdout, stderr ):
self._pspawn = pspawn
self._sh = sh
self._escape = escape
self._cmd = cmd
self._args = args
self._env = env
self._stdout = stdout
self._stderr = stderr
self._exception = None
def __call__( self ):
try:
self._returncode = self._pspawn( self._sh, self._escape, self._cmd, self._args, self._env, self._stdout, self._stderr )
except BaseException:
self._exception = sys.exc_info()
def returncode( self ):
if self._exception != None:
logger.error("pspawn terminated with exception [{}]".format( str(self._exception) ) )
raise self._exception
return self._returncode
class Stream(object):
def __init__( self, processor, name ):
self._queue = Queue.Queue()
self._processor = processor
self._name = name
def flush( self ):
pass
def write( self, text ):
logger.trace( "output_processor: Stream _queue.put [{}]".format( self._name ) )
self._queue.put( text )
def read( self, block ):
try:
logger.trace( "output_processor: Stream _queue.get [{}]".format( self._name ) )
text = self._queue.get( block )
if text:
for line in text.splitlines():
if self._processor:
line = self._processor( line )
if line:
print line
else:
print line
self._queue.task_done()
except Queue.Empty:
logger.trace( "output_processor: Stream Queue.Empty raised [{}]".format( self._name ) )
def join( self ):
if self._queue.empty():
logger.trace( "output_processor: Stream _queue.empty() - flush with None [{}]".format( self._name ) )
self._queue.put( None )
self._queue.join()
class Reader(object):
def __init__( self, stream, finished ):
self._stream = stream
self._finished = finished
def __call__( self ):
while not self._finished.is_set():
self._stream.read(True)
self._stream.read(False)
class Processor:
def __init__( self, scons_env ):
self.scons_env = scons_env
@classmethod
def install( cls, env ):
global _pspawn
_pspawn = env['PSPAWN']
output_processor = cls( env )
if platform.system() == "Windows":
env['SPAWN'] = output_processor.windows_spawn
else:
env['SPAWN'] = output_processor.posix_spawn
def posix_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
def windows_spawn( self, sh, escape, cmd, args, env ):
processor = SpawnedProcessor( self.scons_env )
stdout = Stream( processor, "stdout" )
stderr = Stream( processor, "stderr" )
pspawn = PSpawn( _pspawn, sh, escape, cmd, args, env, stdout, stderr )
pspawn_thread = threading.Thread( target=pspawn )
finished = threading.Event()
pspawn_thread.start()
stdout_thread = threading.Thread( target = Reader( stdout, finished ) )
stdout_thread.start()
stderr_thread = threading.Thread( target = Reader( stderr, finished ) )
stderr_thread.start()
pspawn_thread.join()
logger.trace( "output_processor: Processor - PSPAWN joined" )
finished.set()
stdout.join()
logger.trace( "output_processor: Processor - STDOUT stream joined" )
stdout_thread.join()
logger.trace( "output_processor: Processor - STDOUT thread joined" )
stderr.join()
logger.trace( "output_processor: Processor - STDERR stream joined" )
stderr_thread.join()
logger.trace( "output_processor: Processor - STDERR thread joined" )
returncode = pspawn.returncode()
summary = processor.summary( returncode )
if summary:
print summary
return returncode
class SpawnedProcessor(object):
def __init__( self, scons_env ):
self._processor = ToolchainProcessor(
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, toolchain, minimal_output, ignore_duplicates ):
self.toolchain = toolchain
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 = as_colour( meaning, element )
if match in highlights:
element = as_emphasised( element )
message += element
message = self.filtered_line( message + "\n", meaning )
if meaning == 'error':
if message:
message = as_highlighted( meaning, " = Error " + str(error_id) + " = ") + "\n" + message
else:
self.errors -= 1
elif meaning == 'warning':
if message:
message = as_highlighted( 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 += as_highlighted( 'summary', " === Process Terminated with status " + str(returncode) + " (Elapsed " + str(elapsed_time) + "s)" + " === ") + "\n"
if self.errors:
Summary += as_highlighted( 'error', " === Errors " + str(self.errors) + " === ")
if self.warnings:
Summary += as_highlighted( '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 DkRG!'„݇ ݇
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
import collections
# Scons
import SCons.Script
# Custom
import cuppa.modules.registration
import cuppa.build_platform
import cuppa.output_processor
import cuppa.recursive_glob
import cuppa.configure
import cuppa.options
import cuppa.version
#import cuppa.cpp.stdcpp
from cuppa.colourise import colouriser, as_emphasised, as_info, as_error, as_notice
from cuppa.log import initialise_logging, set_logging_level, reset_logging_format, logger
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' )
verbosity_choices = ( 'trace', 'debug', 'info', 'warn', 'error' )
add_option( '--verbosity', dest='verbosity', choices=verbosity_choices, nargs=1, action='store',
help='The The verbosity level that you wish to run cuppa at. Default level is info' )
# 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:
logger.warn( "Requested toolchain [{}] does not match any supported, skipping".format( as_info(toolchain) ) )
else:
available = fnmatch.filter( self._available, toolchain )
if not available:
logger.warn( "Requested toolchain [{}] does not match any available, skipping".format( as_info(toolchain) ) )
else:
toolchains.update( available )
if not toolchains:
logger.error( "None of the requested toolchains are available" )
parser.values.toolchains = list(toolchains)
# class ParseTargetArchsOption(object):
# def __init__( self, available_toolchains ):
# self._available = available_toolchains
# def __call__(self, option, opt, value, parser):
# target_archs = set()
# requested = value.split(',')
# for target_arch 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 CuppaEnvironment(collections.MutableMapping):
_tools = []
_options = {}
_cached_options = {}
_methods = {}
# Option Interface
@classmethod
def get_option( cls, option, default=None ):
if option in cls._cached_options:
return cls._cached_options[ option ]
value = SCons.Script.GetOption( option )
source = None
if value == None or value == '':
if cls._options['default_options'] and option in cls._options['default_options']:
value = cls._options['default_options'][ option ]
source = "in the sconstruct file"
elif default:
value = default
source = "using default"
else:
source = "on command-line"
if option in cls._options['configured_options']:
source = "using configure"
if value:
logger.debug( "option [{}] set {} as [{}]".format(
as_info( option ),
source,
as_info( str(value) ) )
)
cls._cached_options[option] = value
return value
@classmethod
def _get_option_method( cls, env, option, default=None ):
return cls.get_option( option, default )
# Environment Interface
@classmethod
def default_env( cls ):
if not hasattr( cls, '_default_env' ):
cls._default_env = SCons.Script.Environment( tools=['default'] + cls._tools )
return cls._default_env
@classmethod
def create_env( cls, **kwargs ):
tools = ['default'] + cls._tools
if 'tools' in kwargs:
tools = tools + kwargs['tools']
del kwargs['tools']
tools = SCons.Script.Flatten( tools )
env = SCons.Script.Environment(
tools = tools,
**kwargs
)
env['default_env'] = CuppaEnvironment.default_env()
for key, option in cls._options.iteritems():
env[key] = option
for name, method in cls._methods.iteritems():
env.AddMethod( method, name )
env.AddMethod( cls._get_option_method, "get_option" )
return env
@classmethod
def dump( cls ):
print str( cls._options )
print str( cls._methods )
@classmethod
def colouriser( cls ):
return colouriser
@classmethod
def add_tools( cls, tools ):
cls._tools.append( tools )
@classmethod
def tools( cls ):
return cls._tools
@classmethod
def add_method( cls, name, method ):
cls._methods[name] = method
@classmethod
def add_variant( cls, name, variant ):
if not 'variants' in cls._options:
cls._options['variants'] = {}
cls._options['variants'][name] = variant
@classmethod
def add_action( cls, name, action ):
if not 'actions' in cls._options:
cls._options['actions'] = {}
cls._options['actions'][name] = action
@classmethod
def add_supported_toolchain( cls, name ):
if not 'supported_toolchains' in cls._options:
cls._options['supported_toolchains'] = []
cls._options['supported_toolchains'].append( name )
@classmethod
def add_available_toolchain( cls, name, toolchain ):
if not 'toolchains' in cls._options:
cls._options['toolchains'] = {}
cls._options['toolchains'][name] = toolchain
@classmethod
def add_project_generator( cls, name, project_generator ):
if not 'project_generators' in cls._options:
cls._options['project_generators'] = {}
cls._options['project_generators'][name] = project_generator
@classmethod
def add_profile( cls, name, profile ):
if not 'profiles' in cls._options:
cls._options['profiles'] = {}
cls._options['profiles'][name] = profile
@classmethod
def add_dependency( cls, name, dependency ):
if not 'dependencies' in cls._options:
cls._options['dependencies'] = {}
cls._options['dependencies'][name] = dependency
# Dict Interface
def __getitem__( self, key ):
return self._options[key]
def __setitem__( self, key, value ):
self._options[key] = value
def __delitem__( self, key ):
del self._options[key]
del self._cached_options[key]
def __iter__( self ):
return iter( self._options )
def __len__( self ):
return len( self._options )
def __contains__( self, key ):
return key in self._options
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'
def add_platforms( self, env ):
platforms = self.platforms_key
env[platforms] = cuppa.build_platform.Platform.supported()
def add_project_generators( self, env ):
cuppa.modules.registration.add_to_env( self.project_generators_key, env )
def add_variants( self, env ):
variants = self.variants_key
cuppa.modules.registration.add_to_env( variants, env, env.add_variant, env.add_action )
cuppa.modules.registration.add_options( variants )
def colour_items( self, items, colour_func=as_notice ):
return "'{}'".format( "', '".join( colour_func( item ) for item in items ) )
def add_toolchains( self, env ):
toolchains = self.toolchains_key
cuppa.modules.registration.add_to_env( toolchains, env, env.add_available_toolchain, env.add_supported_toolchain )
logger.trace( "supported toolchains are [{}]".format(
self.colour_items( env["supported_toolchains"] )
) )
logger.info( "available toolchains are [{}]".format(
self.colour_items( sorted( env[toolchains].keys(), reverse=True ), as_info )
) )
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. A comma separate list with wildcards'
' may be provided. For example --toolchains=gcc*,clang37,clang36'
)
# TODO
# SCons.Script.AddOption(
# '--target-arch',
# type = 'string',
# nargs = 1,
# action = 'callback',
# callback = ParseTargetArchsOption( env[toolchains] ),
# help = 'The Target Archictectures you wish to generate executables for. You may'
# ' specify a number a comma separated list of architectures. You may also'
# ' restrict an acrhitecture to a specific toolchain by prepending it with a'
# ' toolchain name followed by a ":". Only valid architectures for each toolchain'
# ' will be built. Example --target-arch=64,vc100:amd64,x86 is valid.'
# )
def initialise_options( self, options, default_options, dependencies ):
options['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',
'parallel',
'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()
initialise_logging()
cuppa_env = CuppaEnvironment()
cuppa_env.add_tools( tools )
self.initialise_options( cuppa_env, default_options, dependencies )
cuppa_env['configured_options'] = {}
self._configure = cuppa.configure.Configure( cuppa_env, callback=configure_callback )
verbosity = cuppa_env.get_option( 'verbosity' )
if verbosity:
set_logging_level( verbosity )
cuppa_env['sconstruct_file'] = cuppa_env.get_option( 'file' )
if not cuppa_env['sconstruct_file']:
for path in [ 'SConstruct', 'Sconstruct', 'sconstruct' ]:
if os.path.exists( path ):
cuppa_env['sconstruct_file'] = path
cuppa_env['raw_output'] = cuppa_env.get_option( 'raw_output' ) and True or False
cuppa_env['standard_output'] = cuppa_env.get_option( 'standard_output' ) and True or False
if not cuppa_env['raw_output'] and not cuppa_env['standard_output']:
cuppa_env.colouriser().enable()
reset_logging_format()
logger.info( "using sconstruct file [{}]".format( as_notice( cuppa_env['sconstruct_file'] ) ) )
help = cuppa_env.get_option( 'help' ) and True or False
self._configure.load()
cuppa_env['minimal_output'] = cuppa_env.get_option( 'minimal_output' )
cuppa_env['ignore_duplicates'] = cuppa_env.get_option( 'ignore_duplicates' )
cuppa_env['working_dir'] = os.getcwd()
cuppa_env['launch_dir'] = os.path.relpath( SCons.Script.GetLaunchDir(), cuppa_env['working_dir'] )
cuppa_env['run_from_launch_dir'] = cuppa_env['launch_dir'] == "."
cuppa_env['launch_offset_dir'] = "."
if not cuppa_env['run_from_launch_dir']:
levels = len( cuppa_env['launch_dir'].split( os.path.sep ) )
cuppa_env['launch_offset_dir'] = os.path.sep.join( ['..' for i in range(levels)] )
cuppa_env['base_path'] = os.path.normpath( os.path.expanduser( base_path ) )
cuppa_env['branch_root'] = branch_root and os.path.normpath( os.path.expanduser( branch_root ) ) or base_path
cuppa_env['branch_dir'] = cuppa_env['branch_root'] and os.path.relpath( cuppa_env['base_path'], cuppa_env['branch_root'] ) or None
thirdparty = cuppa_env.get_option( 'thirdparty' )
if thirdparty:
thirdparty = os.path.normpath( os.path.expanduser( thirdparty ) )
cuppa_env['thirdparty'] = thirdparty
build_root = cuppa_env.get_option( 'build_root', default='_build' )
cuppa_env['build_root'] = os.path.normpath( os.path.expanduser( build_root ) )
download_root = cuppa_env.get_option( 'download_root', default='_cuppa' )
cuppa_env['download_root'] = os.path.normpath( os.path.expanduser( download_root ) )
cache_root = cuppa_env.get_option( 'cache_root', default='~/_cuppa/_cache' )
cuppa_env['cache_root'] = os.path.normpath( os.path.expanduser( cache_root ) )
if not os.path.exists( cuppa_env['cache_root'] ):
os.makedirs( cuppa_env['cache_root'] )
cuppa_env['default_projects'] = default_projects
cuppa_env['default_variants'] = default_variants and set( default_variants ) or set()
cuppa_env['default_dependencies'] = default_dependencies and default_dependencies or []
cuppa_env['BUILD_WITH'] = cuppa_env['default_dependencies']
cuppa_env['dependencies'] = {}
cuppa_env['default_profiles'] = default_profiles and default_profiles or []
cuppa_env['BUILD_PROFILE'] = cuppa_env['default_profiles']
cuppa_env['profiles'] = {}
test_runner = cuppa_env.get_option( 'runner', default=default_runner and default_runner or 'process' )
cuppa_env['default_runner'] = test_runner
cuppa_env['show_test_output'] = cuppa_env.get_option( 'show-test-output' ) and True or False
self.add_variants ( cuppa_env )
self.add_toolchains ( cuppa_env )
self.add_platforms ( cuppa_env )
cuppa_env['platform'] = cuppa.build_platform.Platform.current()
toolchains = cuppa_env.get_option( 'toolchains' )
cuppa_env[ 'target_architectures' ] = None
if not help and not self._configure.handle_conf_only():
default_toolchain = cuppa_env['platform'].default_toolchain()
if not toolchains:
toolchains = [ cuppa_env[self.toolchains_key][default_toolchain] ]
else:
toolchains = [ cuppa_env[self.toolchains_key][t] for t in toolchains ]
cuppa_env['active_toolchains'] = toolchains
def add_dependency( name, dependency ):
cuppa_env['dependencies'][name] = dependency
cuppa.modules.registration.get_options( "methods", cuppa_env )
if not help and not self._configure.handle_conf_only():
cuppa_env[self.project_generators_key] = {}
cuppa.modules.registration.add_to_env( "dependencies", cuppa_env, add_dependency )
cuppa.modules.registration.add_to_env( "profiles", cuppa_env )
cuppa.modules.registration.add_to_env( "methods", cuppa_env )
cuppa.modules.registration.add_to_env( "project_generators", cuppa_env )
for method_plugin in pkg_resources.iter_entry_points( group='cuppa.method.plugins', name=None ):
method_plugin.load().add_to_env( cuppa_env )
if dependencies:
for name, dependency in dependencies.iteritems():
dependency.add_to_env( cuppa_env, add_dependency )
# TODO - default_profile
if cuppa_env.get_option( 'dump' ):
cuppa_env.dump()
SCons.Script.Exit()
job_count = cuppa_env.get_option( 'num_jobs' )
parallel = cuppa_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"
cuppa_env['job_count'] = job_count
cuppa_env['parallel'] = parallel
if job_count>1:
logger.debug( "Running in {} with option [{}] set {} as [{}]".format(
as_emphasised("parallel mode"),
as_info( "jobs" ),
as_emphasised(parallel_mode),
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( cuppa_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( cuppa_env['configured_options'] ) )
print ""
print "cuppa: Nothing to be done. Exiting."
SCons.Script.Exit()
def _command_line_from_settings( self, settings ):
commands = []
for key, value in settings.iteritems():
command = as_emphasised( "--" + key )
if value != True and value != False:
if not isinstance( value, list ):
command += "=" + as_info( str(value) )
else:
command += "=" + as_info( ",".join( value ) )
commands.append( command )
commands.sort()
return " ".join( commands )
def get_active_actions_for_variant( self, cuppa_env, active_variants, variant ):
available_variants = cuppa_env[ self.variants_key ]
available_actions = cuppa_env[ self.actions_key ]
specified_actions = {}
for key, action in available_actions.items():
if cuppa_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_envs( self, toolchain, cuppa_env ):
variants = cuppa_env[ self.variants_key ]
target_architectures = cuppa_env[ 'target_architectures' ]
if not target_architectures:
target_architectures = [ None ]
active_variants = {}
for key, variant in variants.items():
if cuppa_env.get_option( variant.name() ):
active_variants[ variant.name() ] = variant
if not active_variants:
default_variants = cuppa_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 ]
build_envs = []
for key, variant in active_variants.items():
for target_arch in target_architectures:
env, target_arch = toolchain.make_env( cuppa_env, variant, target_arch )
if env:
build_envs.append( {
'variant': key,
'target_arch': target_arch,
'env': env } )
if not cuppa_env['raw_output']:
cuppa.output_processor.Processor.install( env )
env['toolchain'] = toolchain
env['variant'] = variant
env['target_arch'] = target_arch
env['variant_actions'] = self.get_active_actions_for_variant( cuppa_env, active_variants, variant )
return build_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 build( self, cuppa_env ):
projects = cuppa_env.get_option( 'projects' )
toolchains = cuppa_env['active_toolchains']
if projects == None:
projects = cuppa_env['default_projects']
if projects == None or not cuppa_env['run_from_launch_dir']:
sub_sconscripts = self.get_sub_sconscripts(
cuppa_env['launch_dir'],
[ cuppa_env['build_root'], cuppa_env['download_root'] ]
)
if sub_sconscripts:
projects = sub_sconscripts
logger.info( "Using sub-sconscripts [{}]".format( self.colour_items( projects ) ) )
elif projects != None:
logger.info( "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,
[ cuppa_env['build_root'], cuppa_env['download_root'] ]
)
if sub_sconscripts:
logger.info( "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:
build_envs = self.create_build_envs( toolchain, cuppa_env )
for build_env in build_envs:
for sconscript in sconscripts:
decider = cuppa_env.get_option( 'decider' )
if decider:
build_env['env'].Decider( decider )
self.call_project_sconscript_files( toolchain, build_env['variant'], build_env['target_arch'], build_env['env'], sconscript )
else:
logger.warn( "No projects to build. Nothing to be done" )
def call_project_sconscript_files( self, toolchain, variant, target_arch, 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 ):
logger.debug( "project exists and added to build [{}] using [{},{},{}]".format(
as_notice( sconscript_file ),
as_notice( toolchain.name() ),
as_notice( variant ),
as_notice( target_arch )
) )
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
# cloned_env = sconscript_env.Clone()
sconscript_env['sconscript_env'] = sconscript_env
sconscript_env['sconscript_build_dir'] = path_without_ext
sconscript_env['sconscript_toolchain_build_dir'] = os.path.join( path_without_ext, toolchain.name() )
sconscript_env['sconscript_dir'] = os.path.join( sconscript_env['base_path'], sconstruct_offset_path )
sconscript_env['build_dir'] = os.path.normpath( os.path.join( build_root, path_without_ext, toolchain.name(), variant, target_arch, 'working', '' ) )
sconscript_env['abs_build_dir'] = os.path.abspath( sconscript_env['build_dir'] )
sconscript_env['offset_dir'] = sconstruct_offset_path
sconscript_env['final_dir'] = '..' + os.path.sep + 'final' + os.path.sep
sconscript_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 ) )
sconscript_env['abs_final_dir'] = abs_final_dir( sconscript_env['abs_build_dir'], sconscript_env['final_dir'] )
sconscript_env.AppendUnique( INCPATH = [
sconscript_env['offset_dir']
] )
sconscript_exports = {
'env' : sconscript_env,
'sconscript_env' : sconscript_env,
'build_root' : build_root,
'build_dir' : sconscript_env['build_dir'],
'abs_build_dir' : sconscript_env['abs_build_dir'],
'final_dir' : sconscript_env['final_dir'],
'abs_final_dir' : sconscript_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:
logger.error( "Skipping non-existent project [{}]".format( 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 Ap=G Ñzeþ þ 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
try:
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('.','')
except:
print "Could not detect the version of libc installed. You might be missing some development libraries!"
return None
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 DkRGL4TJ J 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
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:
self._toolchain = 'vc'
return self._toolchain
def __getitem__( self, key ):
return self.values.get( key )
def _bit_depth( self, machine ):
machine = machine.lower()
if machine == "x86":
return '32'
elif machine == "amd64":
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 ö RGKPö~¯@ ¯@ & 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
from cuppa.log import logger
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:
logger.error( "Failed to create CodeBlocks project generator with error [{}]".format( as_error(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 )
logger.debug( "Including Paths Under = {}".format( as_notice( str( self._include_paths ) ) ) )
logger.debug( "Excluding Paths Starting = {}".format( as_notice( 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( sconscript, target[0], source )
elif progress == 'end':
self.on_sconscript_end( 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, sconscript, root_node, source ):
project = sconscript
tree_processor = ProcessNodes(
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, sconscript ):
self.write( 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 )
logger.debug( "Write workspace [{}]".format( as_notice( 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 ):
logger.debug( "Update project [{}] for [{}, {}]".format( as_notice( project ), as_notice( toolchain) , as_notice( 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, project ):
project_file = self._projects[project]['project_file']
directory = self._projects[project]['directory']
logger.debug( "Write [{}] for [{}]".format(
as_notice( self._projects[project]['project_file'] ),
as_notice( 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, base_path, files, allowed_paths, excluded_paths, ignored_types ):
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 ] )
# logger.trace( "str(file)=[{}], file.path=[{}], allowed=[{}], prefix=[{}]".format(
# as_notice( str(node) ),
# as_notice( node.path ),
# as_notice( str(allowed) ),
# as_notice( str(prefix) )
# ) )
if prefix != allowed:
return
# logger.trace( "str(file)=[{}], file.path=[{}], allowed=[{}], prefix=[{}]".format(
# as_notice( str(node) ),
# as_notice( node.path ),
# as_notice( str(allowed) ),
# as_notice( 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 {QGtZGN N 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, cuppa_env ):
cuppa_env.add_method( "Coverage", cls() )
PK {QG ¯ä‰ ‰ 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 __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_factory = env['dependencies'][name]
if not dependency_factory:
raise BuildWithException(
"The sconscript [{}] requires the dependency [{}] but it is not available."
.format( env['sconscript_file'], name )
)
env.AppendUnique( BUILD_WITH = name )
dependency = dependency_factory( env )
if dependency:
dependency( env, env['toolchain'], env['variant'].name() )
else:
raise BuildWithException(
"The sconscript [{}] requires the dependency [{}] but it cannot be created."
.format( env['sconscript_file'], name )
)
@classmethod
def add_to_env( cls, cuppa_env ):
cuppa_env.add_method( "BuildWith", cls() )
@classmethod
def init_env_for_variant( cls, sconscript_exports ):
env = sconscript_exports['env']
if env['default_dependencies']:
env.BuildWith( env['default_dependencies'] )
PK {QGLgü 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, cuppa_env ):
cuppa_env.add_method( "Using", cls( cuppa_env['dependencies'] ) )
PK {QGb%Þš 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, cuppa_env ):
cuppa_env.add_method( "Toolchain", cls( cuppa_env['toolchains'] ) )
PK {QGÞÍþL L ( 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, cuppa_env ):
cuppa_env.add_method( "RecursiveGlob", cls() )
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, cuppa_env ):
cuppa_env.add_method( "GlobFiles", cls() )
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 {QGÍpd d 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, cuppa_env ):
cuppa_env.add_method( "RemoveFlags", cls() )
PK {QG ¨» » cuppa/methods/target_from.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)
#-------------------------------------------------------------------------------
# TargetFrom
#-------------------------------------------------------------------------------
import os
class TargetFromMethod:
def __call__( self, env, source, final_dir=None ):
target = os.path.splitext( os.path.relpath( source.path, env['build_dir'] ) )[0]
return target
@classmethod
def add_to_env( cls, cuppa_env ):
cuppa_env.add_method( "TargetFrom", cls() )
PK DkRG‰h8K K 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, as_notice
from cuppa.log import logger
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:
logger.error( "[{}] not in allowed list {}".format( as_error( standard ), as_notice( 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, cuppa_env ):
cuppa_env.add_method( "StdCpp", cls() )
PK {QGæVf»ž ž 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, cuppa_env ):
cuppa_env.add_method( "Test", cls( cuppa_env['default_runner'] ) )
test_runners = set()
for toolchain in cuppa_env['active_toolchains']:
for test_runner in toolchain.test_runners():
test_runners.add( test_runner )
for test_runner in test_runners:
cuppa_env.add_method( "{}Test".format( test_runner.title() ), cls( test_runner ) )
PK {QGN‚ïu) ) 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, cuppa_env ):
cuppa_env.add_method( "BuildTest", cls( cuppa_env['default_runner'] ) )
test_runners = set()
for toolchain in cuppa_env['active_toolchains']:
for test_runner in toolchain.test_runners():
test_runners.add( test_runner )
for test_runner in test_runners:
cuppa_env.add_method( "Build{}Test".format( test_runner.title() ), cls( test_runner ) )
PK {QGÖ¯×7 7 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, cuppa_env ):
cuppa_env.add_method( "Compile", cls() )
PK {QG¦ îßC C 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, cuppa_env ):
cuppa_env.add_method( "Build", cls() )
PK {QG;v´‘¼ ¼ 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, cuppa_env ):
cuppa_env.add_method( "ReplaceFlags", cls() )
PK {QGÌúº¸Y Y 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, cuppa_env ):
cuppa_env.add_method( "CreateVersion", cls() )
PK {QG?Ä
Ž Ž ! 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, cuppa_env ):
cuppa_env.add_method( "MarkdownToHtml", cls() )
PK {QGÍx‡_9 9 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, cuppa_env ):
cuppa_env.add_method( "BuildStaticLib", cls() )
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, cuppa_env ):
cuppa_env.add_method( "BuildSharedLib", cls() )
PK {QG@]cÙµ µ 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 __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, cuppa_env ):
cuppa_env.add_method( "BuildProfile", cls() )
@classmethod
def init_env_for_variant( cls, sconscript_exports ):
env = sconscript_exports['env']
if env['default_profiles']:
env.BuildProfile( env['default_profiles'] )
PK {QG∱ê 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() )
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 {QG¡.6 6 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() )
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 {QG·5¯ 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() )
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 DkRG´*¨X X $ 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
import glob
# Cuppa Imports
import cuppa.location
import cuppa.output_processor
import cuppa.build_platform
from cuppa.colourise import as_info
from cuppa.log import logger
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"
_qt4_tool = None
@classmethod
def add_options( cls, add_option ):
pass
@classmethod
def add_to_env( cls, env, add_dependency ):
add_dependency( cls._name, cls.create )
@classmethod
def create( cls, env ):
try:
if not cls._qt4_tool:
cls._qt4_tool = cls.retrieve_tool( env )
return build_with_qt4( env )
except Qt4Exception:
logger.error( "Could not create dependency [{}]. Dependency not available.".format( cls._name ) )
return None
@classmethod
def retrieve_tool( cls, env ):
url = "hg+https://bitbucket.org/dirkbaechle/scons_qt4"
try:
return cuppa.location.Location( env, url, extra_sub_path = "qt4" )
except cuppa.location.LocationException:
logger.warn( "Could not retrieve scons_qt4 from [{}]".format( url ) )
return None
def __init__( self, env ):
self._version = "4"
if cuppa.build_platform.name() in ["Darwin", "Linux"]:
if cuppa.output_processor.command_available( "pkg-config" ):
if 'QT4DIR' not in env:
self._set_qt4_dir( env )
self._version = self._get_qt4_version()
elif cuppa.build_platform.name() == "Windows":
if 'QT4DIR' not in env:
paths = glob.glob( 'C:\\Qt\\4.*\\*' )
if len(paths):
paths.sort()
env['QT4DIR'] = paths[-1]
if 'QT4DIR' not in env:
logger.error( "could not detect QT4 installation" )
raise Qt4Exception( "could not detect QT4 installation." )
logger.debug( "Q4DIR detected as [{}]".format( as_info( env['QT4DIR'] ) ) )
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
logger.debug( "Q4DIR detected as [{}]".format( as_info( env['QT4DIR'] ) ) )
except:
logger.debug( "In _set_qt4_dir() failed to execute [{}]".format( command ) )
def _get_qt4_version( self ):
command = "pkg-config --modversion QtCore"
try:
return subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
except:
logger.debug( "In _get_qt4_version() failed to execute [{}]".format( command ) )
return None
def __call__( self, env, toolchain, variant ):
SCons.Script.Tool( 'qt4', toolpath=[ self._qt4_tool.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 )“QGüˆgèè1 è1 ' 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
import platform
import glob
# Cuppa Imports
import cuppa.location
import cuppa.output_processor
from cuppa.log import logger
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"
_location = None
@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 ):
add_dependency( cls._name, cls.create )
@classmethod
def create( cls, env ):
if not cls._location:
location = env.get_option( cls._name + "-location" )
if not location:
logger.error( "Dependency not available - no location specified" )
return None
try:
cls._location = cuppa.location.Location( env, location )
except cuppa.location.LocationException as error:
logger.error(
"Dependency not available - retrieving location failed with error [{}]."
.format( str(error) )
)
return None
return build_with_quince( env )
def __init__( self, env ):
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"
_location = None
@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 ):
add_dependency( cls._name, cls.create )
@classmethod
def create( cls, env ):
if not cls._location:
location = env.get_option( cls._name + "-location" )
if not location:
logger.error( "postgresql: Dependency not available - no location specified" )
return None
try:
cls._location = cuppa.location.Location( env, location )
except cuppa.location.LocationException as error:
logger.error(
"postgresql: Dependency not available - retrieving location failed with error [{}]."
.format( str(error) )
)
return None
return quince_postgresql( env )
def __init__( self, env ):
self._flags = {}
self._flags['INCPATH'] = [ os.path.join( self._location.local(), "include" ) ]
pg_config = "pg_config"
if platform.system() == "Windows":
pg_config = pg_config + ".exe"
if not cuppa.output_processor.command_available( pg_config ):
# try to find the Postgresql install
program_files = os.environ.get( "ProgramW6432" )
postgresql_base = os.path.join( program_files, "PostgreSQL" )
if os.path.exists( postgresql_base ):
paths = glob.glob( postgresql_base + '\\*' )
if len(paths):
paths.sort()
latest = paths[-1]
pg_config = '\"' + os.path.join( latest, "bin", pg_config ) + '\"'
if cuppa.output_processor.command_available( pg_config ):
command = "{pg_config} --includedir".format( pg_config = pg_config )
libpq_include = subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
self._flags['INCPATH'].append( libpq_include )
command = "{pg_config} --libdir".format( pg_config = pg_config )
libpq_libpath = subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
self._flags['LIBPATH'] = [ libpq_libpath ]
else:
logger.warn( "postgresql: pg_config not available so cannot determine LIBPATH for postgres libraries" )
self._flags['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"
_location = None
@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 ):
add_dependency( cls._name, cls.create )
@classmethod
def create( cls, env ):
if not cls._location:
location = env.get_option( cls._name + "-location" )
if not location:
logger.error( "sqlite: Dependency not available - no location specified" )
return None
try:
cls._location = cuppa.location.Location( env, location )
except cuppa.location.LocationException as error:
logger.error(
"sqlite: Dependency not available - retrieving location failed with error [{}]."
.format( str(error) )
)
return None
return quince_sqlite( env )
def __init__( self, env ):
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 q‚RG
÷2€‘˜ ‘˜ & 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 platform
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_info, as_emphasised, as_notice
from cuppa.log import logger
class BoostException(Exception):
def __init__(self, value):
self.parameter = value
def __str__(self):
return repr(self.parameter)
def determine_latest_boost_verion():
current_release = "1.59.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) )
logger.debug( "latest boost release detected as [{}]".format( as_info( current_release ) ) )
except Exception as e:
logger.warn( "cannot determine latest version of boost - [{}]. Assuming [{}].".format( str(e), current_release ) )
return current_release
class Boost(object):
_cached_boost_locations = {}
@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, cuppa_env, add_dependency ):
add_dependency( 'boost', cls.create )
@classmethod
def _boost_location_id( cls, env ):
location = env.get_option( 'boost-location' )
home = env.get_option( 'boost-home' )
version = env.get_option( 'boost-version' )
latest = env.get_option( 'boost-latest' )
thirdparty = env[ 'thirdparty' ]
patch_test = env.get_option( 'boost-patch-boost-test' )
base = None
if location:
base = None
elif home:
base = home
elif thirdparty and version:
base = thirdparty
elif version:
base = None
elif latest:
version = "latest"
return ( location, version, base, patch_test )
@classmethod
def _get_boost_location( cls, env, location, version, base, patched ):
logger.debug( "Identify boost using location = [{}], version = [{}], base = [{}], patched = [{}]".format(
as_info( str(location) ),
as_info( str(version) ),
as_info( str(base) ),
as_info( str(patched) )
) )
if not base and not version and not location:
raise BoostException("Cannot construct Boost Object. Invalid parameters")
boost_home = None
boost_location = None
extra_sub_path = 'clean'
if patched:
extra_sub_path = 'patched'
if location:
location = cls.location_from_boost_version( location )
if not location: # use version as a fallback in case both at specified
location = cls.location_from_boost_version( version )
boost_location = cuppa.location.Location( env, location, extra_sub_path=extra_sub_path, name_hint="boost" )
elif base: # Find boost locally
if not os.path.isabs( base ):
base = os.path.abspath( base )
if not version:
boost_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:
home = cls._home_from_path( location )
if home:
return home
return None
boost_home = exists_in( search_list )
if not boost_home:
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")
logger.debug( "Using boost found at [{}]".format( as_info( boost_home ) ) )
boost_location = cuppa.location.Location( env, boost_home, extra_sub_path=extra_sub_path )
else:
location = cls.location_from_boost_version( version )
boost_location = cuppa.location.Location( env, location, extra_sub_path=extra_sub_path )
if patched:
cls.apply_patch_if_needed( boost_location.local() )
return boost_location
@classmethod
def create( cls, env ):
boost_id = cls._boost_location_id( env )
if not boost_id in cls._cached_boost_locations:
logger.debug( "Adding boost [{}] to env".format( as_notice( str(boost_id) ) ) )
cls._cached_boost_locations[ boost_id ] = cls._get_boost_location( env, boost_id[0], boost_id[1], boost_id[2], boost_id[3] )
location = cls._cached_boost_locations[ boost_id ]
boost = None
try:
boost = cls( env, env[ 'platform' ], location )
except BoostException as e:
logger.error( "Could not create boost dependency - {}".format(e) )
return None
if not boost:
logger.error( "Could not create boost dependency" )
return None
build_always = env.get_option( 'boost-build-always' )
verbose_build = env.get_option( 'boost-verbose-build' )
verbose_config = env.get_option( 'boost-verbose-config' )
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"
)
return boost
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")
@classmethod
def _home_from_path( cls, path ):
if os.path.exists( path ) and os.path.isdir( path ):
return path
return None
@classmethod
def location_from_boost_version( cls, location ):
if location == "latest" or location == "current":
location = determine_latest_boost_verion()
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"
logger.debug( "Only boost version specified, retrieve from SourceForge if not already cached" )
extension = ".tar.gz"
if cuppa.build_platform.name() == "Windows":
extension = ".zip"
return "http://sourceforge.net/projects/boost/files/boost/{numeric_version}/boost_{string_version}{extension}/download".format(
numeric_version = version.translate( string.maketrans( '._', '..' ) ),
string_version = version.translate( string.maketrans( '._', '__' ) ),
extension = extension
)
return location
@classmethod
def patched_boost_test( cls, home ):
patch_applied_path = os.path.join( home, "cuppa_test_patch_applied.txt" )
return os.path.exists( patch_applied_path )
@classmethod
def apply_patch_if_needed( cls, 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 ):
logger.debug( "[{}] already applied".format( as_info( diff_file ) ) )
return
diff_path = os.path.join( os.path.split( __file__ )[0], "boost", diff_file )
command = "patch --batch -p1 --input={}".format( diff_path )
logger.info( "Applying [{}] using [{}] in [{}]".format(
as_info( diff_file ),
as_info( command ),
as_info( home )
) )
if subprocess.call( shlex.split( command ), cwd=home ) != 0:
logger.error( "Could not apply [{}]".format( diff_file ) )
with open( patch_applied_path, "w" ) as patch_applied_file:
pass
def __init__( self, cuppa_env, platform, location ):
self._location = location
self.values = {}
self.values['name'] = 'boost'
self.values['home'] = self._location.local()
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:
# TODO - nonsense code - need to fix
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:
logger.warn( "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']( env )
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:
logger.warn( "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']( env )
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 = os.path.join( self._location, 'tools', 'build' )
if self._version < 1.47:
build_script_path = os.path.join( build_script_path, 'src', 'v2', 'engine' )
elif self._version > 1.55:
build_script_path = os.path.join( build_script_path, 'src', 'engine' )
else:
build_script_path = os.path.join( build_script_path, 'v2', 'engine' )
bjam_build_script = './build.sh'
if platform.system() == "Windows":
bjam_build_script = os.path.join( build_script_path, 'build.bat' )
logger.debug( "Execute [{}] from [{}]".format(
bjam_build_script,
str(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:
logger.critical( "Could not determine bjam exe path" )
return 1
bjam_binary_path = os.path.join( build_script_path, bjam_exe_path )
shutil.copy( bjam_binary_path, target[0].path )
except OSError as error:
logger.critical( "Error building bjam [{}]".format( str( error.args ) ) )
return 1
return None
def toolset_name_from_toolchain( toolchain ):
toolset_name = toolchain.toolset_name()
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
elif toolset_name == "msvc":
return toolset_name
toolset = toolchain.cxx_version() and toolset_name + "-" + toolchain.cxx_version() or toolset_name
return toolset
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 ):
if abi_flag:
flag, value = abi_flag.split('=')
if value:
return value
return abi_flag
def stage_directory( toolchain, variant, target_arch, 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, target_arch )
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._target_arch = env['target_arch']
self._toolchain = env['toolchain']
self._job_count = env['job_count']
self._parallel = env['parallel']
def _toolset_name_from_toolchain( self, toolchain ):
toolset_name = toolchain.toolset_name()
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 _build_command( self, env, toolchain, libraries, variant, target_arch, 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 + '"'
address_model = ""
architecture = ""
windows_api = ""
if toolchain.family() == "cl":
if target_arch == "amd64":
address_model = "address-model=64"
elif target_arch == "arm":
address_model = "architecture=arm"
if toolchain.target_store() != "desktop":
windows_api = "windows-api=" + toolchain.target_store()
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 )
bjam = './bjam'
if platform.system() == "Windows":
# Use full path on Windows
bjam = os.path.join( self._location, 'bjam.exe' )
toolset = toolset_from_toolchain( toolchain )
command_line = "{bjam}{verbose} -j {jobs}{with_libraries} toolset={toolset} variant={variant} {address_model} {architecture} {windows_api} {build_flags} link={linktype} --build-dir=.{path_sep}{build_dir} stage --stagedir=.{path_sep}{stage_dir}".format(
bjam = bjam,
verbose = verbose,
jobs = jobs,
with_libraries = with_libraries,
toolset = toolset,
variant = variant,
address_model = address_model,
architecture = architecture,
windows_api = windows_api,
build_flags = build_flags,
linktype = linktype,
build_dir = build_dir,
stage_dir = stage_dir,
path_sep = os.path.sep
)
print command_line
if platform.system() == "Windows":
command_line = command_line.replace( "\\", "\\\\" )
command_line = command_line.replace( '"', '\\"' )
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._target_arch, self._toolchain.abi_flag(env) )
args = self._build_command( env, self._toolchain, self._libraries, self._variant, self._target_arch, 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._minimal_output = not self._verbose_build
ignore_duplicates = not self._verbose_build
self._toolchain_processor = ToolchainProcessor( 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( as_emphasised( '--boost-verbose-build' ) )
return summary
def library_tag( toolchain, boost_version, variant, threading ):
tag = "-{toolset_tag}{toolset_version}{threading}{abi_flag}-{boost_version}"
toolset_tag = toolchain.toolset_tag()
abi_flag = variant == "debug" and "-d" or ""
if cuppa.build_platform.name() == "Windows":
if toolset_tag == "gcc":
toolset_tag = "mgw"
elif toolset_tag == "vc":
abi_flag = variant == "debug" and "-gd" or ""
return tag.format(
toolset_tag = toolset_tag,
toolset_version = toolchain.short_version(),
threading = threading and "-mt" or "",
abi_flag = abi_flag,
boost_version = boost_version
)
def static_library_name( env, library, toolchain, boost_version, variant, threading ):
name = "{prefix}boost_{library}{tag}{suffix}"
tag = ""
prefix = env.subst('$LIBPREFIX')
if cuppa.build_platform.name() == "Windows":
tag = library_tag( toolchain, boost_version, variant, threading )
prefix = "lib"
return name.format(
prefix = prefix,
library = library,
tag = tag,
suffix = env.subst('$LIBSUFFIX')
)
def shared_library_name( env, library, toolchain, boost_version, variant, threading ):
name = "{prefix}boost_{library}{tag}{suffix}{version}"
tag = ""
version = ""
if cuppa.build_platform.name() == "Windows":
tag = library_tag( toolchain, boost_version, variant, threading )
elif cuppa.build_platform.name() == "Linux":
version = "." + boost_version
return name.format(
prefix = env.subst('$SHLIBPREFIX'),
library = library,
tag = tag,
suffix = env.subst('$SHLIBSUFFIX'),
version = 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._boost = boost
self._linktype = linktype
self._version = boost.numeric_version()
self._full_version = boost.full_version()
self._variant = variant_name( self._env['variant'].name() )
self._target_arch = env['target_arch']
self._toolchain = env['toolchain']
self._threading = True
def __call__( self, target, source, env ):
stage_dir = stage_directory( self._toolchain, self._variant, self._target_arch, self._toolchain.abi_flag(env) )
for library in self._libraries:
filename = None
if self._linktype == 'static':
filename = static_library_name( env, library, self._toolchain, self._boost.version(), self._variant, self._threading )
else:
filename = shared_library_name( env, library, self._toolchain, self._boost.version(), self._variant, self._threading )
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: adding toolset config [{}] to dummy toolset config [{}]".format( str(toolset_config_line.strip()), path )
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_exe = 'bjam'
if platform.system() == "Windows":
bjam_exe += ".exe"
bjam_target = os.path.join( self._boost.local(), bjam_exe )
bjam = env.Command( bjam_target, [], BuildBjam( self._boost ) )
env.NoClean( bjam )
built_libraries = env.BoostLibraryBuilder( target, source )
built_library_map = {}
for library in built_libraries:
# Extract the library name from the library filename.
# Possibly use regex instead?
name = os.path.split( str(library) )[1]
name = name.split( "." )[0]
name = name.split( "-" )[0]
name = "_".join( name.split( "_" )[1:] )
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 òkRG§E f $ 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
import glob
# Cuppa Imports
import cuppa.location
import cuppa.output_processor
import cuppa.build_platform
from cuppa.colourise import as_info
from cuppa.log import logger
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"
_qt5_tool = None
@classmethod
def add_options( cls, add_option ):
pass
@classmethod
def add_to_env( cls, cuppa_env, add_dependency ):
add_dependency( cls._name, cls.create )
@classmethod
def create( cls, env ):
try:
if not cls._qt5_tool:
cls._qt5_tool = cls.retrieve_tool( env )
return build_with_qt5( env )
except Qt5Exception:
logger.error( "Could not create dependency [{}]. Dependency not available.".format( cls._name ) )
return None
@classmethod
def retrieve_tool( cls, env ):
url = "hg+https://bitbucket.org/dirkbaechle/scons_qt5"
try:
return cuppa.location.Location( env, url, extra_sub_path = "qt5" )
except cuppa.location.LocationException:
logger.warn( "Could not retrieve scons_qt5 from [{}]".format( url ) )
return None
def __init__( self, env ):
self._version = "5"
if cuppa.build_platform.name() in ["Darwin", "Linux"]:
if cuppa.output_processor.command_available( "pkg-config" ):
if 'QT5DIR' not in env:
self._set_qt5_dir( env )
self._version = self._get_qt5_version()
elif cuppa.build_platform.name() == "Windows":
if 'QT5DIR' not in env:
paths = glob.glob( 'C:\\Qt\\5.*\\*' )
if len(paths):
paths.sort()
env['QT5DIR'] = paths[-1]
if 'QT5DIR' not in env:
logger.error( "Could not detect QT5 installation" )
raise Qt5Exception( "Could not detect QT5 installation." )
logger.debug( "Q5DIR detected as [{}]".format( as_info( env['QT5DIR'] ) ) )
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
except:
logger.debug( "In _set_qt5_dir() failed to execute [{}]".format( command ) )
def _get_qt5_version( self ):
command = "pkg-config --modversion Qt5Core"
try:
return subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ).strip()
except:
logger.debug( "In _get_qt5_version() failed to execute [{}]".format( command ) )
return None
def __call__( self, env, toolchain, variant ):
SCons.Script.Tool( 'qt5', toolpath=[ self._qt5_tool.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 •c×FC߈4 $ cuppa/dependencies/boost/__init__.py
PK Ö“üFÎH e3 3 . 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