Add m-esr52 at 52.6.0

1 files changed, 780 insertions, 0 deletions

diff --git a/build/moz.configure/init.configure b/build/moz.configure/init.configure
new file mode 100644
index 000000000..2123bebc9
--- /dev/null
+++ b/build/moz.configure/init.configure
@@ -0,0 +1,780 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+include('util.configure')
+include('checks.configure')
+
+option(env='DIST', nargs=1, help='DIST directory')
+
+# Do not allow objdir == srcdir builds.
+# ==============================================================
+@depends('--help', 'DIST')
+@imports(_from='os.path', _import='exists')
+def check_build_environment(help, dist):
+    topobjdir = os.path.realpath(os.path.abspath('.'))
+    topsrcdir = os.path.realpath(os.path.abspath(
+        os.path.join(os.path.dirname(__file__), '..', '..')))
+
+    if dist:
+        dist = normsep(dist[0])
+    else:
+        dist = os.path.join(topobjdir, 'dist')
+
+    result = namespace(
+        topsrcdir=topsrcdir,
+        topobjdir=topobjdir,
+        dist=dist,
+    )
+
+    if help:
+        return result
+
+    if topsrcdir == topobjdir:
+        die('  ***\n'
+            '  * Building directly in the main source directory is not allowed.\n'
+            '  *\n'
+            '  * To build, you must run configure from a separate directory\n'
+            '  * (referred to as an object directory).\n'
+            '  *\n'
+            '  * If you are building with a mozconfig, you will need to change your\n'
+            '  * mozconfig to point to a different object directory.\n'
+            '  ***'
+        )
+
+    # Check for a couple representative files in the source tree
+    conflict_files = [
+        '*         %s' % f for f in ('Makefile', 'config/autoconf.mk')
+        if exists(os.path.join(topsrcdir, f))
+    ]
+    if conflict_files:
+        die('  ***\n'
+            '  *   Your source tree contains these files:\n'
+            '  %s\n'
+            '  *   This indicates that you previously built in the source tree.\n'
+            '  *   A source tree build can confuse the separate objdir build.\n'
+            '  *\n'
+            '  *   To clean up the source tree:\n'
+            '  *     1. cd %s\n'
+            '  *     2. gmake distclean\n'
+            '  ***'
+            % ('\n  '.join(conflict_files), topsrcdir)
+        )
+
+    return result
+
+set_config('TOPSRCDIR', delayed_getattr(check_build_environment, 'topsrcdir'))
+set_config('TOPOBJDIR', delayed_getattr(check_build_environment, 'topobjdir'))
+set_config('MOZ_BUILD_ROOT', delayed_getattr(check_build_environment,
+                                             'topobjdir'))
+set_config('DIST', delayed_getattr(check_build_environment, 'dist'))
+
+
+option(env='MOZ_AUTOMATION', help='Enable options for automated builds')
+set_config('MOZ_AUTOMATION', depends_if('MOZ_AUTOMATION')(lambda x: True))
+
+
+option(env='OLD_CONFIGURE', nargs=1, help='Path to the old configure script')
+
+option(env='MOZ_CURRENT_PROJECT', nargs=1, help='Current build project')
+option(env='MOZCONFIG', nargs=1, help='Mozconfig location')
+
+# Read user mozconfig
+# ==============================================================
+# Note: the dependency on --help is only there to always read the mozconfig,
+# even when --help is passed. Without this dependency, the function wouldn't
+# be called when --help is passed, and the mozconfig wouldn't be read.
+@depends('MOZ_CURRENT_PROJECT', 'MOZCONFIG', 'OLD_CONFIGURE',
+         check_build_environment, '--help')
+@imports(_from='mozbuild.mozconfig', _import='MozconfigLoader')
+def mozconfig(current_project, mozconfig, old_configure, build_env, help):
+    if not old_configure:
+        die('The OLD_CONFIGURE environment variable must be set')
+
+    # Don't read the mozconfig for the js configure (yay backwards
+    # compatibility)
+    # While the long term goal is that js and top-level use the same configure
+    # and the same overall setup, including the possibility to use mozconfigs,
+    # figuring out what we want to do wrt mozconfig vs. command line and
+    # environment variable is not a clear-cut case, and it's more important to
+    # fix the immediate problem mozconfig causes to js developers by
+    # "temporarily" returning to the previous behavior of not loading the
+    # mozconfig for the js configure.
+    # Separately to the immediate problem for js developers, there is also the
+    # need to not load a mozconfig when running js configure as a subconfigure.
+    # Unfortunately, there is no direct way to tell whether the running
+    # configure is the js configure. The indirect way is to look at the
+    # OLD_CONFIGURE path, which points to js/src/old-configure.
+    # I expect we'll have figured things out for mozconfigs well before
+    # old-configure dies.
+    if os.path.dirname(os.path.abspath(old_configure[0])).endswith('/js/src'):
+        return {'path': None}
+
+    loader = MozconfigLoader(build_env.topsrcdir)
+    current_project = current_project[0] if current_project else None
+    mozconfig = mozconfig[0] if mozconfig else None
+    mozconfig = loader.find_mozconfig(env={'MOZCONFIG': mozconfig})
+    mozconfig = loader.read_mozconfig(mozconfig, moz_build_app=current_project)
+
+    return mozconfig
+
+set_config('MOZCONFIG', depends(mozconfig)(lambda m: m['path']))
+
+
+option(env='PYTHON', nargs=1, help='Python interpreter')
+
+# Setup python virtualenv
+# ==============================================================
+@depends('PYTHON', check_build_environment, mozconfig, '--help')
+@imports('os')
+@imports('sys')
+@imports('subprocess')
+@imports(_from='mozbuild.configure.util', _import='LineIO')
+@imports(_from='mozbuild.virtualenv', _import='VirtualenvManager')
+@imports(_from='mozbuild.virtualenv', _import='verify_python_version')
+@imports('distutils.sysconfig')
+def virtualenv_python(env_python, build_env, mozconfig, help):
+    if help:
+        return
+
+    python = env_python[0] if env_python else None
+
+    # Ideally we'd rely on the mozconfig injection from mozconfig_options,
+    # but we'd rather avoid the verbosity when we need to reexecute with
+    # a different python.
+    if mozconfig['path']:
+        if 'PYTHON' in mozconfig['env']['added']:
+            python = mozconfig['env']['added']['PYTHON']
+        elif 'PYTHON' in mozconfig['env']['modified']:
+            python = mozconfig['env']['modified']['PYTHON'][1]
+        elif 'PYTHON' in mozconfig['vars']['added']:
+            python = mozconfig['vars']['added']['PYTHON']
+        elif 'PYTHON' in mozconfig['vars']['modified']:
+            python = mozconfig['vars']['modified']['PYTHON'][1]
+
+    with LineIO(lambda l: log.error(l)) as out:
+        verify_python_version(out)
+    topsrcdir, topobjdir = build_env.topsrcdir, build_env.topobjdir
+    if topobjdir.endswith('/js/src'):
+        topobjdir = topobjdir[:-7]
+
+    with LineIO(lambda l: log.info(l)) as out:
+        manager = VirtualenvManager(
+            topsrcdir, topobjdir,
+            os.path.join(topobjdir, '_virtualenv'), out,
+            os.path.join(topsrcdir, 'build', 'virtualenv_packages.txt'))
+
+    if python:
+        # If we're not in the virtualenv, we need the which module for
+        # find_program.
+        if normsep(sys.executable) != normsep(manager.python_path):
+            sys.path.append(os.path.join(topsrcdir, 'python', 'which'))
+        found_python = find_program(python)
+        if not found_python:
+            die('The PYTHON environment variable does not contain '
+                'a valid path. Cannot find %s', python)
+        python = found_python
+    else:
+        python = sys.executable
+
+    if not manager.up_to_date(python):
+        log.info('Creating Python environment')
+        manager.build(python)
+
+    python = normsep(manager.python_path)
+
+    if python != normsep(sys.executable):
+        log.info('Reexecuting in the virtualenv')
+        if env_python:
+            del os.environ['PYTHON']
+        # One would prefer to use os.execl, but that's completely borked on
+        # Windows.
+        sys.exit(subprocess.call([python] + sys.argv))
+
+    # We are now in the virtualenv
+    if not distutils.sysconfig.get_python_lib():
+        die('Could not determine python site packages directory')
+
+    return python
+
+set_config('PYTHON', virtualenv_python)
+add_old_configure_assignment('PYTHON', virtualenv_python)
+
+# Inject mozconfig options
+# ==============================================================
+# All options defined above this point can't be injected in mozconfig_options
+# below, so collect them.
+@template
+def early_options():
+    @dependable
+    @imports('__sandbox__')
+    def early_options():
+        return set(
+            option.env
+            for option in __sandbox__._options.itervalues()
+            if option.env
+        )
+    return early_options
+
+early_options = early_options()
+
+@depends(mozconfig, '--help')
+# This gives access to the sandbox. Don't copy this blindly.
+@imports('__sandbox__')
+@imports('os')
+def mozconfig_options(mozconfig, help):
+    if mozconfig['path']:
+        helper = __sandbox__._helper
+        log.info('Adding configure options from %s' % mozconfig['path'])
+        for arg in mozconfig['configure_args']:
+            log.info('  %s' % arg)
+            # We could be using imply_option() here, but it has other
+            # contraints that don't really apply to the command-line
+            # emulation that mozconfig provides.
+            helper.add(arg, origin='mozconfig', args=helper._args)
+
+        def add(key, value):
+            if key.isupper():
+                arg = '%s=%s' % (key, value)
+                log.info('  %s' % arg)
+                helper.add(arg, origin='mozconfig', args=helper._args)
+
+        for key, value in mozconfig['env']['added'].iteritems():
+            add(key, value)
+            os.environ[key] = value
+        for key, (_, value) in mozconfig['env']['modified'].iteritems():
+            add(key, value)
+            os.environ[key] = value
+        for key, value in mozconfig['vars']['added'].iteritems():
+            # mozconfig_loader adds _IS_SET variables that are irrelevant
+            if not key.endswith('_IS_SET'):
+                add(key, value)
+        for key, (_, value) in mozconfig['vars']['modified'].iteritems():
+            add(key, value)
+
+
+# Mozilla-Build
+# ==============================================================
+option(env='MOZILLABUILD', nargs=1,
+       help='Path to Mozilla Build (Windows-only)')
+
+option(env='CONFIG_SHELL', nargs=1, help='Path to a POSIX shell')
+
+# It feels dirty replicating this from python/mozbuild/mozbuild/mozconfig.py,
+# but the end goal being that the configure script would go away...
+@depends('CONFIG_SHELL', 'MOZILLABUILD')
+@checking('for a shell')
+@imports('sys')
+def shell(value, mozillabuild):
+    if value:
+        return find_program(value[0])
+    shell = 'sh'
+    if mozillabuild:
+        shell = mozillabuild[0] + '/msys/bin/sh'
+    if sys.platform == 'win32':
+        shell = shell + '.exe'
+    return find_program(shell)
+
+
+# Host and target systems
+# ==============================================================
+option('--host', nargs=1, help='Define the system type performing the build')
+
+option('--target', nargs=1,
+       help='Define the system type where the resulting executables will be '
+            'used')
+
+@imports(_from='mozbuild.configure.constants', _import='CPU')
+@imports(_from='mozbuild.configure.constants', _import='CPU_bitness')
+@imports(_from='mozbuild.configure.constants', _import='Endianness')
+@imports(_from='mozbuild.configure.constants', _import='Kernel')
+@imports(_from='mozbuild.configure.constants', _import='OS')
+def split_triplet(triplet):
+    # The standard triplet is defined as
+    #   CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+    # There is also a quartet form:
+    #   CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+    # But we can consider the "KERNEL-OPERATING_SYSTEM" as one.
+    cpu, manufacturer, os = triplet.split('-', 2)
+
+    # Autoconf uses config.sub to validate and canonicalize those triplets,
+    # but the granularity of its results has never been satisfying to our
+    # use, so we've had our own, different, canonicalization. We've also
+    # historically not been very consistent with how we use the canonicalized
+    # values. Hopefully, this will help us make things better.
+    # The tests are inherited from our decades-old autoconf-based configure,
+    # which can probably be improved/cleaned up because they are based on a
+    # mix of uname and config.guess output, while we now only use the latter,
+    # which presumably has a cleaner and leaner output. Let's refine later.
+    os = os.replace('/', '_')
+    if 'android' in os:
+        canonical_os = 'Android'
+        canonical_kernel = 'Linux'
+    elif os.startswith('linux'):
+        canonical_os = 'GNU'
+        canonical_kernel = 'Linux'
+    elif os.startswith('kfreebsd') and os.endswith('-gnu'):
+        canonical_os = 'GNU'
+        canonical_kernel = 'kFreeBSD'
+    elif os.startswith('gnu'):
+        canonical_os = canonical_kernel = 'GNU'
+    elif os.startswith('mingw'):
+        canonical_os = canonical_kernel = 'WINNT'
+    elif os.startswith('darwin'):
+        canonical_kernel = 'Darwin'
+        canonical_os = 'OSX'
+    elif os.startswith('ios'):
+        canonical_kernel = 'Darwin'
+        canonical_os = 'iOS'
+    elif os.startswith('dragonfly'):
+        canonical_os = canonical_kernel = 'DragonFly'
+    elif os.startswith('freebsd'):
+        canonical_os = canonical_kernel = 'FreeBSD'
+    elif os.startswith('netbsd'):
+        canonical_os = canonical_kernel = 'NetBSD'
+    elif os.startswith('openbsd'):
+        canonical_os = canonical_kernel = 'OpenBSD'
+    else:
+        die('Unknown OS: %s' % os)
+
+    # The CPU granularity is probably not enough. Moving more things from
+    # old-configure will tell us if we need more
+    if cpu.endswith('86') or (cpu.startswith('i') and '86' in cpu):
+        canonical_cpu = 'x86'
+        endianness = 'little'
+    elif cpu in ('x86_64', 'ia64'):
+        canonical_cpu = cpu
+        endianness = 'little'
+    elif cpu in ('s390', 's390x'):
+        canonical_cpu = cpu
+        endianness = 'big'
+    elif cpu in ('powerpc64', 'ppc64', 'powerpc64le', 'ppc64le'):
+        canonical_cpu = 'ppc64'
+        endianness = 'little' if 'le' in cpu else 'big'
+    elif cpu in ('powerpc', 'ppc', 'rs6000') or cpu.startswith('powerpc'):
+        canonical_cpu = 'ppc'
+        endianness = 'big'
+    elif cpu in ('Alpha', 'alpha', 'ALPHA'):
+        canonical_cpu = 'Alpha'
+        endianness = 'little'
+    elif cpu.startswith('hppa') or cpu == 'parisc':
+        canonical_cpu = 'hppa'
+        endianness = 'big'
+    elif cpu.startswith('sparc64'):
+        canonical_cpu = 'sparc64'
+        endianness = 'big'
+    elif cpu.startswith('sparc') or cpu == 'sun4u':
+        canonical_cpu = 'sparc'
+        endianness = 'big'
+    elif cpu.startswith('arm'):
+        canonical_cpu = 'arm'
+        endianness = 'big' if cpu.startswith(('armeb', 'armbe')) else 'little'
+    elif cpu in ('mips', 'mipsel'):
+        canonical_cpu = 'mips32'
+        endianness = 'little' if 'el' in cpu else 'big'
+    elif cpu in ('mips64', 'mips64el'):
+        canonical_cpu = 'mips64'
+        endianness = 'little' if 'el' in cpu else 'big'
+    elif cpu.startswith('aarch64'):
+        canonical_cpu = 'aarch64'
+        endianness = 'little'
+    else:
+        die('Unknown CPU type: %s' % cpu)
+
+    return namespace(
+        alias=triplet,
+        cpu=CPU(canonical_cpu),
+        bitness=CPU_bitness[canonical_cpu],
+        kernel=Kernel(canonical_kernel),
+        os=OS(canonical_os),
+        endianness=Endianness(endianness),
+        raw_cpu=cpu,
+        raw_os=os,
+        # Toolchains, most notably for cross compilation may use cpu-os
+        # prefixes.
+        toolchain='%s-%s' % (cpu, os),
+    )
+
+
+@imports('subprocess')
+def config_sub(shell, triplet):
+    config_sub = os.path.join(os.path.dirname(__file__), '..',
+                              'autoconf', 'config.sub')
+    return subprocess.check_output([shell, config_sub, triplet]).strip()
+
+
+@depends('--host', shell)
+@checking('for host system type', lambda h: h.alias)
+@imports('subprocess')
+def host(value, shell):
+    if not value:
+        config_guess = os.path.join(os.path.dirname(__file__), '..',
+                                    'autoconf', 'config.guess')
+        host = subprocess.check_output([shell, config_guess]).strip()
+    else:
+        host = value[0]
+
+    return split_triplet(config_sub(shell, host))
+
+
+@depends('--target', host, shell)
+@checking('for target system type', lambda t: t.alias)
+def target(value, host, shell):
+    if not value:
+        return host
+    return split_triplet(config_sub(shell, value[0]))
+
+
+@depends(host, target)
+@checking('whether cross compiling')
+def cross_compiling(host, target):
+    return host != target
+
+set_config('CROSS_COMPILE', cross_compiling)
+set_define('CROSS_COMPILE', cross_compiling)
+add_old_configure_assignment('CROSS_COMPILE', cross_compiling)
+
+
+@depends(target)
+def have_64_bit(target):
+    if target.bitness == 64:
+        return True
+
+set_config('HAVE_64BIT_BUILD', have_64_bit)
+set_define('HAVE_64BIT_BUILD', have_64_bit)
+add_old_configure_assignment('HAVE_64BIT_BUILD', have_64_bit)
+
+
+# Autoconf needs these set
+@depends(host)
+def host_for_old_configure(host):
+    return '--host=%s' % host.alias
+
+add_old_configure_arg(host_for_old_configure)
+
+@depends(host, target)
+def target_for_old_configure(host, target):
+    target_alias = target.alias
+    # old-configure does plenty of tests against $target and $target_os
+    # and expects darwin for iOS, so make it happy.
+    if target.os == 'iOS':
+        target_alias = target_alias.replace('-ios', '-darwin')
+    return '--target=%s' % target_alias
+
+add_old_configure_arg(target_for_old_configure)
+
+
+# These variables are for compatibility with the current moz.builds and
+# old-configure. Eventually, we'll want to canonicalize better.
+@depends(target)
+def target_variables(target):
+    if target.kernel == 'kFreeBSD':
+        os_target = 'GNU/kFreeBSD'
+        os_arch = 'GNU_kFreeBSD'
+    elif target.kernel == 'Darwin' or (target.kernel == 'Linux' and
+                                       target.os == 'GNU'):
+        os_target = target.kernel
+        os_arch = target.kernel
+    else:
+        os_target = target.os
+        os_arch = target.kernel
+
+    if target.kernel == 'Darwin' and target.cpu == 'x86':
+        os_test = 'i386'
+    else:
+        os_test = target.raw_cpu
+
+    return namespace(
+        OS_TARGET=os_target,
+        OS_ARCH=os_arch,
+        OS_TEST=os_test,
+        INTEL_ARCHITECTURE=target.cpu in ('x86', 'x86_64') or None,
+    )
+
+set_config('OS_TARGET', delayed_getattr(target_variables, 'OS_TARGET'))
+add_old_configure_assignment('OS_TARGET',
+                             delayed_getattr(target_variables, 'OS_TARGET'))
+set_config('OS_ARCH', delayed_getattr(target_variables, 'OS_ARCH'))
+add_old_configure_assignment('OS_ARCH',
+                             delayed_getattr(target_variables, 'OS_ARCH'))
+set_config('OS_TEST', delayed_getattr(target_variables, 'OS_TEST'))
+add_old_configure_assignment('OS_TEST',
+                             delayed_getattr(target_variables, 'OS_TEST'))
+set_config('CPU_ARCH', delayed_getattr(target, 'cpu'))
+add_old_configure_assignment('CPU_ARCH', delayed_getattr(target, 'cpu'))
+set_config('INTEL_ARCHITECTURE', delayed_getattr(target_variables,
+                                                 'INTEL_ARCHITECTURE'))
+set_config('TARGET_CPU', delayed_getattr(target, 'raw_cpu'))
+set_config('TARGET_OS', delayed_getattr(target, 'raw_os'))
+
+
+@depends(host)
+def host_variables(host):
+    if host.kernel == 'kFreeBSD':
+        os_arch = 'GNU_kFreeBSD'
+    else:
+        os_arch = host.kernel
+    return namespace(
+        HOST_OS_ARCH=os_arch,
+    )
+
+set_config('HOST_OS_ARCH', delayed_getattr(host_variables, 'HOST_OS_ARCH'))
+add_old_configure_assignment('HOST_OS_ARCH',
+                             delayed_getattr(host_variables, 'HOST_OS_ARCH'))
+
+@depends(target)
+def target_is_windows(target):
+    if target.kernel == 'WINNT':
+        return True
+
+set_define('_WINDOWS', target_is_windows)
+set_define('WIN32', target_is_windows)
+set_define('XP_WIN', target_is_windows)
+set_define('XP_WIN32', target_is_windows)
+
+@depends(target)
+def target_is_unix(target):
+    if target.kernel != 'WINNT':
+        return True
+
+set_define('XP_UNIX', target_is_unix)
+
+@depends(target)
+def target_is_darwin(target):
+    if target.kernel == 'Darwin':
+        return True
+
+set_define('XP_DARWIN', target_is_darwin)
+
+@depends(target)
+def target_is_ios(target):
+    if target.kernel == 'Darwin' and target.os == 'iOS':
+        return True
+
+set_define('XP_IOS', target_is_ios)
+
+@depends(target)
+def target_is_osx(target):
+    if target.kernel == 'Darwin' and target.os == 'OSX':
+        return True
+
+set_define('XP_MACOSX', target_is_osx)
+
+@depends(target)
+def target_is_linux(target):
+    if target.kernel == 'Linux':
+        return True
+
+set_define('XP_LINUX', target_is_linux)
+
+# The application/project to build
+# ==============================================================
+option('--enable-application', nargs=1, env='MOZ_BUILD_APP',
+       help='Application to build. Same as --enable-project.')
+
+@depends('--enable-application', '--help')
+def application(app, help):
+    if app:
+        return app
+
+imply_option('--enable-project', application)
+
+
+@depends(check_build_environment, '--help')
+def default_project(build_env, help):
+    if build_env.topobjdir.endswith('/js/src'):
+        return 'js'
+    return 'browser'
+
+option('--enable-project', nargs=1, default=default_project,
+       help='Project to build')
+
+option('--with-external-source-dir', env='EXTERNAL_SOURCE_DIR', nargs=1,
+       help='External directory containing additional build files')
+
+@depends('--enable-project', '--with-external-source-dir',
+         check_build_environment, '--help')
+@imports(_from='os.path', _import='exists')
+def include_project_configure(project, external_source_dir, build_env, help):
+    if not project:
+        die('--enable-project is required.')
+
+    base_dir = build_env.topsrcdir
+    if external_source_dir:
+        base_dir = os.path.join(base_dir, external_source_dir[0])
+
+    path = os.path.join(base_dir, project[0], 'moz.configure')
+    if not exists(path):
+        die('Cannot find project %s', project[0])
+    return path
+
+@depends('--with-external-source-dir')
+def external_source_dir(value):
+    if value:
+        return value[0]
+
+set_config('EXTERNAL_SOURCE_DIR', external_source_dir)
+add_old_configure_assignment('EXTERNAL_SOURCE_DIR', external_source_dir)
+
+
+@depends(include_project_configure, check_build_environment, '--help')
+def build_project(include_project_configure, build_env, help):
+    ret = os.path.dirname(os.path.relpath(include_project_configure,
+                                          build_env.topsrcdir))
+    return ret
+
+set_config('MOZ_BUILD_APP', build_project)
+set_define('MOZ_BUILD_APP', build_project)
+add_old_configure_assignment('MOZ_BUILD_APP', build_project)
+
+
+# set RELEASE_OR_BETA and NIGHTLY_BUILD variables depending on the cycle we're in
+# The logic works like this:
+# - if we have "a1" in GRE_MILESTONE, we're building Nightly (define NIGHTLY_BUILD)
+# - otherwise, if we have "a" in GRE_MILESTONE, we're building Nightly or Aurora
+# - otherwise, we're building Release/Beta (define RELEASE_OR_BETA)
+@depends(check_build_environment, '--help')
+@imports(_from='__builtin__', _import='open')
+def milestone(build_env, _):
+    milestone_path = os.path.join(build_env.topsrcdir,
+                                  'config',
+                                  'milestone.txt')
+    with open(milestone_path, 'r') as fh:
+        milestone = fh.read().splitlines()[-1]
+
+    is_nightly = is_release_or_beta = None
+
+    if 'a1' in milestone:
+        is_nightly = True
+    elif 'a' not in milestone:
+        is_release_or_beta = True
+
+    return namespace(version=milestone,
+                     is_nightly=is_nightly,
+                     is_release_or_beta=is_release_or_beta)
+
+set_config('GRE_MILESTONE', delayed_getattr(milestone, 'version'))
+set_config('NIGHTLY_BUILD', delayed_getattr(milestone, 'is_nightly'))
+set_define('NIGHTLY_BUILD', delayed_getattr(milestone, 'is_nightly'))
+add_old_configure_assignment('NIGHTLY_BUILD',
+                             delayed_getattr(milestone, 'is_nightly'))
+set_config('RELEASE_OR_BETA', delayed_getattr(milestone, 'is_release_or_beta'))
+set_define('RELEASE_OR_BETA', delayed_getattr(milestone, 'is_release_or_beta'))
+add_old_configure_assignment('RELEASE_OR_BETA',
+                             delayed_getattr(milestone, 'is_release_or_beta'))
+
+# The app update channel is 'default' when not supplied. The value is used in
+# the application's confvars.sh (and is made available to a project specific
+# moz.configure).
+option('--enable-update-channel',
+       nargs=1,
+       help='Select application update channel',
+       default='default')
+
+@depends('--enable-update-channel')
+def update_channel(channel):
+    if channel[0] == '':
+        return 'default'
+    return channel[0].lower()
+
+set_config('MOZ_UPDATE_CHANNEL', update_channel)
+set_define('MOZ_UPDATE_CHANNEL', update_channel)
+add_old_configure_assignment('MOZ_UPDATE_CHANNEL', update_channel)
+
+
+# A template providing a shorthand for setting a variable. The created
+# option will only be settable with imply_option.
+# It is expected that a project-specific moz.configure will call imply_option
+# to set a value other than the default.
+# If required, the set_as_define and set_for_old_configure arguments
+# will additionally cause the variable to be set using set_define and
+# add_old_configure_assignment. util.configure would be an appropriate place for
+# this, but it uses add_old_configure_assignment, which is defined in this file.
+@template
+def project_flag(env=None, set_for_old_configure=False,
+                 set_as_define=False, **kwargs):
+
+    if not env:
+        configure_error("A project_flag must be passed a variable name to set.")
+
+    opt = option(env=env, possible_origins=('implied',), **kwargs)
+
+    @depends(opt.option)
+    def option_implementation(value):
+        if value:
+            if len(value):
+                return value
+            return bool(value)
+
+    set_config(env, option_implementation)
+    if set_as_define:
+        set_define(env, option_implementation)
+    if set_for_old_configure:
+        add_old_configure_assignment(env, option_implementation)
+
+# milestone.is_nightly corresponds to cases NIGHTLY_BUILD is set.
+@depends(milestone, '--help')
+def enabled_in_nightly(milestone, _):
+    return milestone.is_nightly
+
+# Set the MOZ_CONFIGURE_OPTIONS variable with all the options that
+# were passed somehow (environment, command line, mozconfig)
+@depends(mozconfig_options)
+@imports(_from='mozbuild.shellutil', _import='quote')
+@imports('__sandbox__')
+def all_configure_options(_):
+    result = []
+    previous = None
+    for option in __sandbox__._options.itervalues():
+        # __sandbox__._options contains items for both option.name and
+        # option.env. But it's also an OrderedDict, meaning both are
+        # consecutive.
+        # Also ignore OLD_CONFIGURE and MOZCONFIG because they're not
+        # interesting.
+        if option == previous or option.env in ('OLD_CONFIGURE', 'MOZCONFIG'):
+            continue
+        previous = option
+        value = __sandbox__._value_for(option)
+        # We only want options that were explicitly given on the command
+        # line, the environment, or mozconfig, and that differ from the
+        # defaults.
+        if (value is not None and value.origin not in ('default', 'implied') and
+                value != option.default):
+            result.append(__sandbox__._raw_options[option])
+        # We however always include options that are sent to old configure
+        # because we don't know their actual defaults. (Keep the conditions
+        # separate for ease of understanding and ease of removal)
+        elif (option.help == 'Help missing for old configure options' and
+                option in __sandbox__._raw_options):
+            result.append(__sandbox__._raw_options[option])
+
+    return quote(*result)
+
+set_config('MOZ_CONFIGURE_OPTIONS', all_configure_options)
+
+
+# This is temporary until js/src/configure and configure are merged.
+# Use instead of option() in js/moz.configure and more generally, for
+# options that are shared between configure and js/src/configure.
+@template
+def js_option(*args, **kwargs):
+    opt = option(*args, **kwargs)
+
+    @depends(opt.option, build_project)
+    def js_option(value, build_project):
+        if build_project != 'js':
+            return value.format(opt.option)
+
+    add_old_configure_arg(js_option)
+
+
+# Bug 1278542: This function is a workaround to resolve
+# |android_ndk_include|'s dependency on 'gonkdir.' The
+# actual implementation is located in b2g/moz.configure.
+# Remove this function as soon as 'android_ndk_include'
+# depends on 'target.'
+@depends('--help')
+def gonkdir(_):
+    return None