summaryrefslogtreecommitdiffstats
path: root/waflib/Scripting.py
diff options
context:
space:
mode:
authorDavid Robillard <d@drobilla.net>2019-04-21 23:05:06 +0200
committerDavid Robillard <d@drobilla.net>2019-04-21 23:05:06 +0200
commit202873cf9bfdeb669365a6d76e54ad657c550fe2 (patch)
tree79db4dee998f1ef093c3e81f1d0ea708901ab96c /waflib/Scripting.py
parentde6492738adf1794bf5fa39c1fe1ebbd167727ac (diff)
downloadsratom-202873cf9bfdeb669365a6d76e54ad657c550fe2.tar.gz
sratom-202873cf9bfdeb669365a6d76e54ad657c550fe2.tar.bz2
sratom-202873cf9bfdeb669365a6d76e54ad657c550fe2.zip
Switch to using a submodule for autowaf
Diffstat (limited to 'waflib/Scripting.py')
m---------waflib0
-rw-r--r--waflib/Scripting.py620
2 files changed, 0 insertions, 620 deletions
diff --git a/waflib b/waflib
new file mode 160000
+Subproject 2314e236ca6e7d94a26c3c17091da0f25f5867f
diff --git a/waflib/Scripting.py b/waflib/Scripting.py
deleted file mode 100644
index ae17a8b..0000000
--- a/waflib/Scripting.py
+++ /dev/null
@@ -1,620 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-# Thomas Nagy, 2005-2018 (ita)
-
-"Module called for configuring, compiling and installing targets"
-
-from __future__ import with_statement
-
-import os, shlex, shutil, traceback, errno, sys, stat
-from waflib import Utils, Configure, Logs, Options, ConfigSet, Context, Errors, Build, Node
-
-build_dir_override = None
-
-no_climb_commands = ['configure']
-
-default_cmd = "build"
-
-def waf_entry_point(current_directory, version, wafdir):
- """
- This is the main entry point, all Waf execution starts here.
-
- :param current_directory: absolute path representing the current directory
- :type current_directory: string
- :param version: version number
- :type version: string
- :param wafdir: absolute path representing the directory of the waf library
- :type wafdir: string
- """
- Logs.init_log()
-
- if Context.WAFVERSION != version:
- Logs.error('Waf script %r and library %r do not match (directory %r)', version, Context.WAFVERSION, wafdir)
- sys.exit(1)
-
- # Store current directory before any chdir
- Context.waf_dir = wafdir
- Context.run_dir = Context.launch_dir = current_directory
- start_dir = current_directory
- no_climb = os.environ.get('NOCLIMB')
-
- if len(sys.argv) > 1:
- # os.path.join handles absolute paths
- # if sys.argv[1] is not an absolute path, then it is relative to the current working directory
- potential_wscript = os.path.join(current_directory, sys.argv[1])
- if os.path.basename(potential_wscript) == Context.WSCRIPT_FILE and os.path.isfile(potential_wscript):
- # need to explicitly normalize the path, as it may contain extra '/.'
- path = os.path.normpath(os.path.dirname(potential_wscript))
- start_dir = os.path.abspath(path)
- no_climb = True
- sys.argv.pop(1)
-
- ctx = Context.create_context('options')
- (options, commands, env) = ctx.parse_cmd_args(allow_unknown=True)
- if options.top:
- start_dir = Context.run_dir = Context.top_dir = options.top
- no_climb = True
- if options.out:
- Context.out_dir = options.out
-
- # if 'configure' is in the commands, do not search any further
- if not no_climb:
- for k in no_climb_commands:
- for y in commands:
- if y.startswith(k):
- no_climb = True
- break
-
- # try to find a lock file (if the project was configured)
- # at the same time, store the first wscript file seen
- cur = start_dir
- while cur:
- try:
- lst = os.listdir(cur)
- except OSError:
- lst = []
- Logs.error('Directory %r is unreadable!', cur)
- if Options.lockfile in lst:
- env = ConfigSet.ConfigSet()
- try:
- env.load(os.path.join(cur, Options.lockfile))
- ino = os.stat(cur)[stat.ST_INO]
- except EnvironmentError:
- pass
- else:
- # check if the folder was not moved
- for x in (env.run_dir, env.top_dir, env.out_dir):
- if not x:
- continue
- if Utils.is_win32:
- if cur == x:
- load = True
- break
- else:
- # if the filesystem features symlinks, compare the inode numbers
- try:
- ino2 = os.stat(x)[stat.ST_INO]
- except OSError:
- pass
- else:
- if ino == ino2:
- load = True
- break
- else:
- Logs.warn('invalid lock file in %s', cur)
- load = False
-
- if load:
- Context.run_dir = env.run_dir
- Context.top_dir = env.top_dir
- Context.out_dir = env.out_dir
- break
-
- if not Context.run_dir:
- if Context.WSCRIPT_FILE in lst:
- Context.run_dir = cur
-
- next = os.path.dirname(cur)
- if next == cur:
- break
- cur = next
-
- if no_climb:
- break
-
- wscript = os.path.normpath(os.path.join(Context.run_dir, Context.WSCRIPT_FILE))
- if not os.path.exists(wscript):
- if options.whelp:
- Logs.warn('These are the generic options (no wscript/project found)')
- ctx.parser.print_help()
- sys.exit(0)
- Logs.error('Waf: Run from a folder containing a %r file (or try -h for the generic options)', Context.WSCRIPT_FILE)
- sys.exit(1)
-
- try:
- os.chdir(Context.run_dir)
- except OSError:
- Logs.error('Waf: The folder %r is unreadable', Context.run_dir)
- sys.exit(1)
-
- try:
- set_main_module(wscript)
- except Errors.WafError as e:
- Logs.pprint('RED', e.verbose_msg)
- Logs.error(str(e))
- sys.exit(1)
- except Exception as e:
- Logs.error('Waf: The wscript in %r is unreadable', Context.run_dir)
- traceback.print_exc(file=sys.stdout)
- sys.exit(2)
-
- if options.profile:
- import cProfile, pstats
- cProfile.runctx('from waflib import Scripting; Scripting.run_commands()', {}, {}, 'profi.txt')
- p = pstats.Stats('profi.txt')
- p.sort_stats('time').print_stats(75) # or 'cumulative'
- else:
- try:
- try:
- run_commands()
- except:
- if options.pdb:
- import pdb
- type, value, tb = sys.exc_info()
- traceback.print_exc()
- pdb.post_mortem(tb)
- else:
- raise
- except Errors.WafError as e:
- if Logs.verbose > 1:
- Logs.pprint('RED', e.verbose_msg)
- Logs.error(e.msg)
- sys.exit(1)
- except SystemExit:
- raise
- except Exception as e:
- traceback.print_exc(file=sys.stdout)
- sys.exit(2)
- except KeyboardInterrupt:
- Logs.pprint('RED', 'Interrupted')
- sys.exit(68)
-
-def set_main_module(file_path):
- """
- Read the main wscript file into :py:const:`waflib.Context.Context.g_module` and
- bind default functions such as ``init``, ``dist``, ``distclean`` if not defined.
- Called by :py:func:`waflib.Scripting.waf_entry_point` during the initialization.
-
- :param file_path: absolute path representing the top-level wscript file
- :type file_path: string
- """
- Context.g_module = Context.load_module(file_path)
- Context.g_module.root_path = file_path
-
- # note: to register the module globally, use the following:
- # sys.modules['wscript_main'] = g_module
-
- def set_def(obj):
- name = obj.__name__
- if not name in Context.g_module.__dict__:
- setattr(Context.g_module, name, obj)
- for k in (dist, distclean, distcheck):
- set_def(k)
- # add dummy init and shutdown functions if they're not defined
- if not 'init' in Context.g_module.__dict__:
- Context.g_module.init = Utils.nada
- if not 'shutdown' in Context.g_module.__dict__:
- Context.g_module.shutdown = Utils.nada
- if not 'options' in Context.g_module.__dict__:
- Context.g_module.options = Utils.nada
-
-def parse_options():
- """
- Parses the command-line options and initialize the logging system.
- Called by :py:func:`waflib.Scripting.waf_entry_point` during the initialization.
- """
- ctx = Context.create_context('options')
- ctx.execute()
- if not Options.commands:
- if isinstance(default_cmd, list):
- Options.commands.extend(default_cmd)
- else:
- Options.commands.append(default_cmd)
- if Options.options.whelp:
- ctx.parser.print_help()
- sys.exit(0)
-
-def run_command(cmd_name):
- """
- Executes a single Waf command. Called by :py:func:`waflib.Scripting.run_commands`.
-
- :param cmd_name: command to execute, like ``build``
- :type cmd_name: string
- """
- ctx = Context.create_context(cmd_name)
- ctx.log_timer = Utils.Timer()
- ctx.options = Options.options # provided for convenience
- ctx.cmd = cmd_name
- try:
- ctx.execute()
- finally:
- # Issue 1374
- ctx.finalize()
- return ctx
-
-def run_commands():
- """
- Execute the Waf commands that were given on the command-line, and the other options
- Called by :py:func:`waflib.Scripting.waf_entry_point` during the initialization, and executed
- after :py:func:`waflib.Scripting.parse_options`.
- """
- parse_options()
- run_command('init')
- while Options.commands:
- cmd_name = Options.commands.pop(0)
- ctx = run_command(cmd_name)
- Logs.info('%r finished successfully (%s)', cmd_name, ctx.log_timer)
- run_command('shutdown')
-
-###########################################################################################
-
-def distclean_dir(dirname):
- """
- Distclean function called in the particular case when::
-
- top == out
-
- :param dirname: absolute path of the folder to clean
- :type dirname: string
- """
- for (root, dirs, files) in os.walk(dirname):
- for f in files:
- if f.endswith(('.o', '.moc', '.exe')):
- fname = os.path.join(root, f)
- try:
- os.remove(fname)
- except OSError:
- Logs.warn('Could not remove %r', fname)
-
- for x in (Context.DBFILE, 'config.log'):
- try:
- os.remove(x)
- except OSError:
- pass
-
- try:
- shutil.rmtree(Build.CACHE_DIR)
- except OSError:
- pass
-
-def distclean(ctx):
- '''removes build folders and data'''
-
- def remove_and_log(k, fun):
- try:
- fun(k)
- except EnvironmentError as e:
- if e.errno != errno.ENOENT:
- Logs.warn('Could not remove %r', k)
-
- # remove waf cache folders on the top-level
- if not Options.commands:
- for k in os.listdir('.'):
- for x in '.waf-2 waf-2 .waf3-2 waf3-2'.split():
- if k.startswith(x):
- remove_and_log(k, shutil.rmtree)
-
- # remove a build folder, if any
- cur = '.'
- if ctx.options.no_lock_in_top:
- cur = ctx.options.out
-
- try:
- lst = os.listdir(cur)
- except OSError:
- Logs.warn('Could not read %r', cur)
- return
-
- if Options.lockfile in lst:
- f = os.path.join(cur, Options.lockfile)
- try:
- env = ConfigSet.ConfigSet(f)
- except EnvironmentError:
- Logs.warn('Could not read %r', f)
- return
-
- if not env.out_dir or not env.top_dir:
- Logs.warn('Invalid lock file %r', f)
- return
-
- if env.out_dir == env.top_dir:
- distclean_dir(env.out_dir)
- else:
- remove_and_log(env.out_dir, shutil.rmtree)
-
- for k in (env.out_dir, env.top_dir, env.run_dir):
- p = os.path.join(k, Options.lockfile)
- remove_and_log(p, os.remove)
-
-class Dist(Context.Context):
- '''creates an archive containing the project source code'''
- cmd = 'dist'
- fun = 'dist'
- algo = 'tar.bz2'
- ext_algo = {}
-
- def execute(self):
- """
- See :py:func:`waflib.Context.Context.execute`
- """
- self.recurse([os.path.dirname(Context.g_module.root_path)])
- self.archive()
-
- def archive(self):
- """
- Creates the source archive.
- """
- import tarfile
-
- arch_name = self.get_arch_name()
-
- try:
- self.base_path
- except AttributeError:
- self.base_path = self.path
-
- node = self.base_path.make_node(arch_name)
- try:
- node.delete()
- except OSError:
- pass
-
- files = self.get_files()
-
- if self.algo.startswith('tar.'):
- tar = tarfile.open(node.abspath(), 'w:' + self.algo.replace('tar.', ''))
-
- for x in files:
- self.add_tar_file(x, tar)
- tar.close()
- elif self.algo == 'zip':
- import zipfile
- zip = zipfile.ZipFile(node.abspath(), 'w', compression=zipfile.ZIP_DEFLATED)
-
- for x in files:
- archive_name = self.get_base_name() + '/' + x.path_from(self.base_path)
- zip.write(x.abspath(), archive_name, zipfile.ZIP_DEFLATED)
- zip.close()
- else:
- self.fatal('Valid algo types are tar.bz2, tar.gz, tar.xz or zip')
-
- try:
- from hashlib import sha256
- except ImportError:
- digest = ''
- else:
- digest = ' (sha256=%r)' % sha256(node.read(flags='rb')).hexdigest()
-
- Logs.info('New archive created: %s%s', self.arch_name, digest)
-
- def get_tar_path(self, node):
- """
- Return the path to use for a node in the tar archive, the purpose of this
- is to let subclases resolve symbolic links or to change file names
-
- :return: absolute path
- :rtype: string
- """
- return node.abspath()
-
- def add_tar_file(self, x, tar):
- """
- Adds a file to the tar archive. Symlinks are not verified.
-
- :param x: file path
- :param tar: tar file object
- """
- p = self.get_tar_path(x)
- tinfo = tar.gettarinfo(name=p, arcname=self.get_tar_prefix() + '/' + x.path_from(self.base_path))
- tinfo.uid = 0
- tinfo.gid = 0
- tinfo.uname = 'root'
- tinfo.gname = 'root'
-
- if os.path.isfile(p):
- with open(p, 'rb') as f:
- tar.addfile(tinfo, fileobj=f)
- else:
- tar.addfile(tinfo)
-
- def get_tar_prefix(self):
- """
- Returns the base path for files added into the archive tar file
-
- :rtype: string
- """
- try:
- return self.tar_prefix
- except AttributeError:
- return self.get_base_name()
-
- def get_arch_name(self):
- """
- Returns the archive file name.
- Set the attribute *arch_name* to change the default value::
-
- def dist(ctx):
- ctx.arch_name = 'ctx.tar.bz2'
-
- :rtype: string
- """
- try:
- self.arch_name
- except AttributeError:
- self.arch_name = self.get_base_name() + '.' + self.ext_algo.get(self.algo, self.algo)
- return self.arch_name
-
- def get_base_name(self):
- """
- Returns the default name of the main directory in the archive, which is set to *appname-version*.
- Set the attribute *base_name* to change the default value::
-
- def dist(ctx):
- ctx.base_name = 'files'
-
- :rtype: string
- """
- try:
- self.base_name
- except AttributeError:
- appname = getattr(Context.g_module, Context.APPNAME, 'noname')
- version = getattr(Context.g_module, Context.VERSION, '1.0')
- self.base_name = appname + '-' + version
- return self.base_name
-
- def get_excl(self):
- """
- Returns the patterns to exclude for finding the files in the top-level directory.
- Set the attribute *excl* to change the default value::
-
- def dist(ctx):
- ctx.excl = 'build **/*.o **/*.class'
-
- :rtype: string
- """
- try:
- return self.excl
- except AttributeError:
- self.excl = Node.exclude_regs + ' **/waf-2.* **/.waf-2.* **/waf3-2.* **/.waf3-2.* **/*~ **/*.rej **/*.orig **/*.pyc **/*.pyo **/*.bak **/*.swp **/.lock-w*'
- if Context.out_dir:
- nd = self.root.find_node(Context.out_dir)
- if nd:
- self.excl += ' ' + nd.path_from(self.base_path)
- return self.excl
-
- def get_files(self):
- """
- Files to package are searched automatically by :py:func:`waflib.Node.Node.ant_glob`.
- Set *files* to prevent this behaviour::
-
- def dist(ctx):
- ctx.files = ctx.path.find_node('wscript')
-
- Files are also searched from the directory 'base_path', to change it, set::
-
- def dist(ctx):
- ctx.base_path = path
-
- :rtype: list of :py:class:`waflib.Node.Node`
- """
- try:
- files = self.files
- except AttributeError:
- files = self.base_path.ant_glob('**/*', excl=self.get_excl())
- return files
-
-def dist(ctx):
- '''makes a tarball for redistributing the sources'''
- pass
-
-class DistCheck(Dist):
- """creates an archive with dist, then tries to build it"""
- fun = 'distcheck'
- cmd = 'distcheck'
-
- def execute(self):
- """
- See :py:func:`waflib.Context.Context.execute`
- """
- self.recurse([os.path.dirname(Context.g_module.root_path)])
- self.archive()
- self.check()
-
- def make_distcheck_cmd(self, tmpdir):
- cfg = []
- if Options.options.distcheck_args:
- cfg = shlex.split(Options.options.distcheck_args)
- else:
- cfg = [x for x in sys.argv if x.startswith('-')]
- cmd = [sys.executable, sys.argv[0], 'configure', 'build', 'install', 'uninstall', '--destdir=' + tmpdir] + cfg
- return cmd
-
- def check(self):
- """
- Creates the archive, uncompresses it and tries to build the project
- """
- import tempfile, tarfile
-
- with tarfile.open(self.get_arch_name()) as t:
- for x in t:
- t.extract(x)
-
- instdir = tempfile.mkdtemp('.inst', self.get_base_name())
- cmd = self.make_distcheck_cmd(instdir)
- ret = Utils.subprocess.Popen(cmd, cwd=self.get_base_name()).wait()
- if ret:
- raise Errors.WafError('distcheck failed with code %r' % ret)
-
- if os.path.exists(instdir):
- raise Errors.WafError('distcheck succeeded, but files were left in %s' % instdir)
-
- shutil.rmtree(self.get_base_name())
-
-
-def distcheck(ctx):
- '''checks if the project compiles (tarball from 'dist')'''
- pass
-
-def autoconfigure(execute_method):
- """
- Decorator that enables context commands to run *configure* as needed.
- """
- def execute(self):
- """
- Wraps :py:func:`waflib.Context.Context.execute` on the context class
- """
- if not Configure.autoconfig:
- return execute_method(self)
-
- env = ConfigSet.ConfigSet()
- do_config = False
- try:
- env.load(os.path.join(Context.top_dir, Options.lockfile))
- except EnvironmentError:
- Logs.warn('Configuring the project')
- do_config = True
- else:
- if env.run_dir != Context.run_dir:
- do_config = True
- else:
- h = 0
- for f in env.files:
- try:
- h = Utils.h_list((h, Utils.readf(f, 'rb')))
- except EnvironmentError:
- do_config = True
- break
- else:
- do_config = h != env.hash
-
- if do_config:
- cmd = env.config_cmd or 'configure'
- if Configure.autoconfig == 'clobber':
- tmp = Options.options.__dict__
- launch_dir_tmp = Context.launch_dir
- if env.options:
- Options.options.__dict__ = env.options
- Context.launch_dir = env.launch_dir
- try:
- run_command(cmd)
- finally:
- Options.options.__dict__ = tmp
- Context.launch_dir = launch_dir_tmp
- else:
- run_command(cmd)
- run_command(self.cmd)
- else:
- return execute_method(self)
- return execute
-Build.BuildContext.execute = autoconfigure(Build.BuildContext.execute)
-