DEP: Remove scons related files and code.

This removes files and code supporting scons builds. After this change
numpy will only support builds using distutils or bento. The removal of
scons has been discussed on the list several times and a decision has been
made that scons support is no longer needed. This was originally discussed
for numpy 1.7 and because the distutils and bento methods are still
available we are skipping the usual deprecation period.

1 files changed, 0 insertions, 531 deletions

diff --git a/numpy/core/SConscript b/numpy/core/SConscript
deleted file mode 100644
index 952544a25..000000000
--- a/numpy/core/SConscript
+++ /dev/null
@@ -1,531 +0,0 @@
-# Last Change: Sun Apr 26 05:00 PM 2009 J
-# vim:syntax=python
-import os
-import sys
-from os.path import join as pjoin, basename as pbasename, dirname as pdirname
-from copy import deepcopy
-
-from numscons import get_pythonlib_dir
-from numscons import GetNumpyEnvironment
-from numscons import CheckCBLAS
-from numscons import write_info
-
-from code_generators.numpy_api import \
-    multiarray_api as multiarray_api_dict, \
-    ufunc_api as ufunc_api_dict
-
-from setup_common import *
-from scons_support import CheckBrokenMathlib, define_no_smp, \
-    check_mlib, check_mlibs, is_npy_no_signal, CheckInline
-from scons_support import array_api_gen_bld, ufunc_api_gen_bld, template_bld, \
-                          umath_bld, CheckGCC4, check_api_version, \
-                          CheckLongDoubleRepresentation
-
-import SCons
-
-# Set to True to enable multiple file compilations (experimental)
-try:
-    os.environ['NPY_SEPARATE_COMPILATION']
-    ENABLE_SEPARATE_COMPILATION = True
-except KeyError:
-    ENABLE_SEPARATE_COMPILATION = False
-try:
-    os.environ['NPY_BYPASS_SINGLE_EXTENDED']
-    BYPASS_SINGLE_EXTENDED = True
-except KeyError:
-    BYPASS_SINGLE_EXTENDED = False
-
-env = GetNumpyEnvironment(ARGUMENTS)
-env.Append(CPPPATH = env["PYEXTCPPPATH"])
-if os.name == 'nt':
-    # NT needs the pythonlib to run any code importing Python.h, including
-    # simple code using only typedef and so on, so we need it for configuration
-    # checks
-    env.AppendUnique(LIBPATH = [get_pythonlib_dir()])
-
-# Check whether we have a mismatch between the set C API VERSION and the
-# actual C API VERSION
-check_api_version(C_API_VERSION)
-
-#=======================
-# Starting Configuration
-#=======================
-config = env.NumpyConfigure(custom_tests = {'CheckBrokenMathlib' : CheckBrokenMathlib,
-    'CheckCBLAS' : CheckCBLAS, 'CheckInline': CheckInline, 'CheckGCC4' : CheckGCC4,
-    'CheckLongDoubleRepresentation': CheckLongDoubleRepresentation},
-    config_h = pjoin('config.h'))
-
-# numpyconfig_sym will keep the values of some configuration variables, the one
-# needed for the public numpy API.
-
-# Convention: list of tuples (definition, value). value:
-# - 0: #undef definition
-# - 1: #define definition
-# - string: #define definition value
-numpyconfig_sym = []
-
-#---------------
-# Checking Types
-#---------------
-if not config.CheckHeader("Python.h"):
-    errmsg = []
-    for line in config.GetLastError():
-        errmsg.append("%s " % line)
-    print """
-Error: Python.h header cannot be compiled (or cannot be found).
-On linux, check that you have python-dev/python-devel packages. On windows,
-check that you have he platform SDK. You may also use unsupported cflags.
-Configuration error log says: \n\n%s""" % ''.join(errmsg)
-    Exit(-1)
-
-st = config.CheckHeader("endian.h")
-if st:
-    numpyconfig_sym.append(('DEFINE_NPY_HAVE_ENDIAN_H', '#define NPY_HAVE_ENDIAN_H 1'))
-else:
-    numpyconfig_sym.append(('DEFINE_NPY_HAVE_ENDIAN_H', ''))
-
-def check_type(type, include = None):
-    st = config.CheckTypeSize(type, includes = include)
-    type = type.replace(' ', '_')
-    if st:
-        numpyconfig_sym.append(('SIZEOF_%s' % type.upper(), '%d' % st))
-    else:
-        numpyconfig_sym.append(('SIZEOF_%s' % type.upper(), 0))
-
-for type in ('short', 'int', 'long'):
-    # SIZEOF_LONG defined on darwin
-    if type == "long":
-        if not config.CheckDeclaration("SIZEOF_LONG", includes="#include <Python.h>"):
-            check_type(type)
-        else:
-            numpyconfig_sym.append(('SIZEOF_LONG', 'SIZEOF_LONG'))
-    else:
-        check_type(type)
-
-for type in ('float', 'double', 'long double'):
-    sz = config.CheckTypeSize(type)
-    numpyconfig_sym.append(('SIZEOF_%s' % type2def(type), str(sz)))
-
-    # Compute size of corresponding complex type: used to check that our
-    # definition is binary compatible with C99 complex type (check done at
-    # build time in npy_common.h)
-    complex_def = "struct {%s __x; %s __y;}" % (type, type)
-    sz = config.CheckTypeSize(complex_def)
-    numpyconfig_sym.append(('SIZEOF_COMPLEX_%s' % type2def(type), str(sz)))
-
-if sys.platform != 'darwin':
-    tp = config.CheckLongDoubleRepresentation()
-    config.Define("HAVE_LDOUBLE_%s" % tp, 1,
-                  "Define for arch-specific long double representation")
-
-for type in ('Py_intptr_t',):
-    check_type(type, include = "#include <Python.h>\n")
-
-# We check declaration AND type because that's how distutils does it.
-if config.CheckDeclaration('PY_LONG_LONG', includes = '#include <Python.h>\n'):
-    st = config.CheckTypeSize('PY_LONG_LONG',
-                              includes = '#include <Python.h>\n')
-    assert not st == 0
-    numpyconfig_sym.append(('DEFINE_NPY_SIZEOF_LONGLONG',
-                            '#define NPY_SIZEOF_LONGLONG %d' % st))
-    numpyconfig_sym.append(('DEFINE_NPY_SIZEOF_PY_LONG_LONG',
-                            '#define NPY_SIZEOF_PY_LONG_LONG %d' % st))
-else:
-    numpyconfig_sym.append(('DEFINE_NPY_SIZEOF_LONGLONG', ''))
-    numpyconfig_sym.append(('DEFINE_NPY_SIZEOF_PY_LONG_LONG', ''))
-
-if not config.CheckDeclaration('CHAR_BIT', includes= '#include <Python.h>\n'):
-    raise RuntimeError(\
-"""Config wo CHAR_BIT is not supported with scons: please contact the
-maintainer (cdavid)""")
-
-#----------------------
-# Checking signal stuff
-#----------------------
-if is_npy_no_signal():
-    numpyconfig_sym.append(('DEFINE_NPY_NO_SIGNAL', '#define NPY_NO_SIGNAL\n'))
-    config.Define('__NPY_PRIVATE_NO_SIGNAL',
-                  comment = "define to 1 to disable SMP support ")
-else:
-    numpyconfig_sym.append(('DEFINE_NPY_NO_SIGNAL', ''))
-
-#---------------------
-# Checking SMP option
-#---------------------
-if define_no_smp():
-    nosmp = 1
-else:
-    nosmp = 0
-numpyconfig_sym.append(('NPY_NO_SMP', nosmp))
-
-#----------------------------------------------
-# Check whether we can use C99 printing formats
-#----------------------------------------------
-if config.CheckDeclaration(('PRIdPTR'), includes  = '#include <inttypes.h>'):
-    numpyconfig_sym.append(('DEFINE_NPY_USE_C99_FORMATS', '#define NPY_USE_C99_FORMATS 1'))
-else:
-    numpyconfig_sym.append(('DEFINE_NPY_USE_C99_FORMATS', ''))
-
-#----------------------
-# Checking the mathlib
-#----------------------
-mlibs = [[], ['m'], ['cpml']]
-mathlib = os.environ.get('MATHLIB')
-if mathlib:
-    mlibs.insert(0, mathlib)
-
-mlib = check_mlibs(config, mlibs)
-
-# XXX: this is ugly: mathlib has nothing to do in a public header file
-numpyconfig_sym.append(('MATHLIB', ','.join(mlib)))
-
-#----------------------------------
-# Checking the math funcs available
-#----------------------------------
-# Function to check:
-mfuncs = ('expl', 'expf', 'log1p', 'expm1', 'asinh', 'atanhf', 'atanhl',
-          'rint', 'trunc')
-
-# Set value to 1 for each defined function (in math lib)
-mfuncs_defined = dict([(f, 0) for f in mfuncs])
-
-# Check for mandatory funcs: we barf if a single one of those is not there
-if not config.CheckFuncsAtOnce(MANDATORY_FUNCS):
-    raise SystemError("One of the required function to build numpy is not"
-            " available (the list is %s)." % str(MANDATORY_FUNCS))
-
-# Standard functions which may not be available and for which we have a
-# replacement implementation
-#
-def check_funcs(funcs):
-    # Use check_funcs_once first, and if it does not work, test func per
-    # func. Return success only if all the functions are available
-    st = config.CheckFuncsAtOnce(funcs)
-    if not st:
-        # Global check failed, check func per func
-        for f in funcs:
-            st = config.CheckFunc(f, language = 'C')
-
-for f in OPTIONAL_STDFUNCS_MAYBE:
-    if config.CheckDeclaration(fname2def(f),
-                includes="#include <Python.h>\n#include <math.h>"):
-        OPTIONAL_STDFUNCS.remove(f)
-check_funcs(OPTIONAL_STDFUNCS)
-
-# C99 functions: float and long double versions
-if not BYPASS_SINGLE_EXTENDED:
-    check_funcs(C99_FUNCS_SINGLE)
-    check_funcs(C99_FUNCS_EXTENDED)
-
-# Normally, isnan and isinf are macro (C99), but some platforms only have
-# func, or both func and macro version. Check for macro only, and define
-# replacement ones if not found.
-# Note: including Python.h is necessary because it modifies some math.h
-# definitions
-for f in ["isnan", "isinf", "signbit", "isfinite"]:
-    includes = """\
-#include <Python.h>
-#include <math.h>
-"""
-    st = config.CheckDeclaration(f, includes=includes)
-    if st:
-        numpyconfig_sym.append(('DEFINE_NPY_HAVE_DECL_%s' % f.upper(),
-            '#define NPY_HAVE_DECL_%s' % f.upper()))
-    else:
-        numpyconfig_sym.append(('DEFINE_NPY_HAVE_DECL_%s' % f.upper(), ''))
-
-inline = config.CheckInline()
-config.Define('inline', inline)
-
-
-if ENABLE_SEPARATE_COMPILATION:
-    config.Define("ENABLE_SEPARATE_COMPILATION", 1)
-    numpyconfig_sym.append(('DEFINE_NPY_ENABLE_SEPARATE_COMPILATION', '#define NPY_ENABLE_SEPARATE_COMPILATION 1'))
-else:
-    numpyconfig_sym.append(('DEFINE_NPY_ENABLE_SEPARATE_COMPILATION', ''))
-
-#-----------------------------
-# Checking for complex support
-#-----------------------------
-if config.CheckHeader('complex.h'):
-    numpyconfig_sym.append(('DEFINE_NPY_USE_C99_COMPLEX', '#define NPY_USE_C99_COMPLEX 1'))
-
-    for t in C99_COMPLEX_TYPES:
-        st = config.CheckType(t, includes='#include <complex.h>')
-        if st:
-            numpyconfig_sym.append(('DEFINE_NPY_HAVE_%s' % type2def(t),
-                                    '#define NPY_HAVE_%s' % type2def(t)))
-        else:
-            numpyconfig_sym.append(('DEFINE_NPY_HAVE_%s' % type2def(t), ''))
-
-    def check_prec(prec):
-        flist = [f + prec for f in C99_COMPLEX_FUNCS]
-        st = config.CheckFuncsAtOnce(flist)
-        if not st:
-            # Global check failed, check func per func
-            for f in flist:
-                config.CheckFunc(f, language='C')
-
-    check_prec('')
-    check_prec('f')
-    check_prec('l')
-
-else:
-    numpyconfig_sym.append(('DEFINE_NPY_USE_C99_COMPLEX', ''))
-    for t in C99_COMPLEX_TYPES:
-        numpyconfig_sym.append(('DEFINE_NPY_HAVE_%s' % type2def(t), ''))
-
-def visibility_define():
-    if config.CheckGCC4():
-        return '__attribute__((visibility("hidden")))'
-    else:
-        return ''
-
-numpyconfig_sym.append(('VISIBILITY_HIDDEN', visibility_define()))
-
-# Add the C API/ABI versions
-numpyconfig_sym.append(('NPY_ABI_VERSION', '0x%.8X' % C_ABI_VERSION))
-numpyconfig_sym.append(('NPY_API_VERSION', '0x%.8X' % C_API_VERSION))
-
-# Check whether we need our own wide character support
-if not config.CheckDeclaration('Py_UNICODE_WIDE', includes='#include <Python.h>'):
-    PYTHON_HAS_UNICODE_WIDE = True
-else:
-    PYTHON_HAS_UNICODE_WIDE = False
-
-#-------------------------------------------------------
-# Define the function PyOS_ascii_strod if not available
-#-------------------------------------------------------
-if not config.CheckDeclaration('PyOS_ascii_strtod',
-                               includes = "#include <Python.h>"):
-    if config.CheckFunc('strtod'):
-        config.Define('PyOS_ascii_strtod', 'strtod',
-                      "Define to a function to use as a replacement for "\
-                      "PyOS_ascii_strtod if not available in python header")
-
-#------------------------------------
-# DISTUTILS Hack on AMD64 on windows
-#------------------------------------
-# XXX: this is ugly
-if sys.platform=='win32' or os.name=='nt':
-    from distutils.msvccompiler import get_build_architecture
-    a = get_build_architecture()
-    print 'BUILD_ARCHITECTURE: %r, os.name=%r, sys.platform=%r' % \
-          (a, os.name, sys.platform)
-    if a == 'AMD64':
-        distutils_use_sdk = 1
-        config.Define('DISTUTILS_USE_SDK', distutils_use_sdk,
-                      "define to 1 to disable SMP support ")
-
-    if a == "Intel":
-        config.Define('FORCE_NO_LONG_DOUBLE_FORMATTING', 1,
-                      "define to 1 to force long double format string to the" \
-                      " same as double (Lg -> g)")
-#--------------
-# Checking Blas
-#--------------
-if config.CheckCBLAS():
-    build_blasdot = 1
-else:
-    build_blasdot = 0
-
-config.config_h_text += """
-#ifndef _NPY_NPY_CONFIG_H_
-#error config.h should never be included directly, include npy_config.h instead
-#endif
-"""
-
-config.Finish()
-write_info(env)
-
-#==========
-#  Build
-#==========
-
-# List of headers which need to be "installed " into the build directory for
-# proper in-place build support
-generated_headers = []
-
-#---------------------------------------
-# Generate the public configuration file
-#---------------------------------------
-config_dict = {}
-# XXX: this is ugly, make the API for config.h and numpyconfig.h similar
-for key, value in numpyconfig_sym:
-    config_dict['@%s@' % key] = str(value)
-env['SUBST_DICT'] = config_dict
-
-include_dir = 'include/numpy'
-target = env.SubstInFile(pjoin(include_dir, '_numpyconfig.h'),
-        pjoin(include_dir, '_numpyconfig.h.in'))
-generated_headers.append(target[0])
-
-env['CONFIG_H_GEN'] = numpyconfig_sym
-
-#---------------------------
-# Builder for generated code
-#---------------------------
-env.Append(BUILDERS = {'GenerateMultiarrayApi' : array_api_gen_bld,
-                       'GenerateUfuncApi' : ufunc_api_gen_bld,
-                       'GenerateFromTemplate' : template_bld,
-                       'GenerateUmath' : umath_bld})
-
-#------------------------
-# Generate generated code
-#------------------------
-scalartypes_src = env.GenerateFromTemplate(
-    pjoin('src', 'multiarray', 'scalartypes.c.src'))
-umath_funcs_src = env.GenerateFromTemplate(pjoin('src', 'umath', 'funcs.inc.src'))
-umath_loops_src = env.GenerateFromTemplate(pjoin('src', 'umath', 'loops.c.src'))
-arraytypes_src = env.GenerateFromTemplate(
-    pjoin('src', 'multiarray', 'arraytypes.c.src'))
-nditer_src = env.GenerateFromTemplate(
-    pjoin('src', 'multiarray', 'nditer_templ.c.src'))
-lowlevel_strided_loops_src = env.GenerateFromTemplate(
-    pjoin('src', 'multiarray', 'lowlevel_strided_loops.c.src'))
-einsum_src = env.GenerateFromTemplate(pjoin('src', 'multiarray', 'einsum.c.src'))
-umath_tests_src = env.GenerateFromTemplate(pjoin('src', 'umath',
-    'umath_tests.c.src'))
-multiarray_tests_src = env.GenerateFromTemplate(pjoin('src', 'multiarray',
-    'multiarray_tests.c.src'))
-scalarmathmodule_src = env.GenerateFromTemplate(
-                            pjoin('src', 'scalarmathmodule.c.src'))
-
-umath = env.GenerateUmath('__umath_generated',
-                          pjoin('code_generators', 'generate_umath.py'))
-
-multiarray_api = env.GenerateMultiarrayApi('include/numpy/multiarray_api',
-                        [SCons.Node.Python.Value(d) for d in multiarray_api_dict])
-generated_headers.append(multiarray_api[0])
-
-ufunc_api = env.GenerateUfuncApi('include/numpy/ufunc_api',
-                        [SCons.Node.Python.Value(d) for d in ufunc_api_dict])
-generated_headers.append(ufunc_api[0])
-
-# include/numpy is added for compatibility reasons with distutils: this is
-# needed for __multiarray_api.c and __ufunc_api.c included from multiarray and
-# ufunc.
-env.Prepend(CPPPATH = ['src/private', 'include', '.', 'include/numpy'])
-
-# npymath core lib
-npymath_src = [env.GenerateFromTemplate(pjoin('src', 'npymath', 'npy_math.c.src')),
-               env.GenerateFromTemplate(pjoin('src', 'npymath', 'npy_math_complex.c.src')),
-               env.GenerateFromTemplate(pjoin('src', 'npymath', 'ieee754.c.src')),
-               pjoin('src', 'npymath', 'halffloat.c')]
-env.DistutilsInstalledStaticExtLibrary("npymath", npymath_src, install_dir='lib')
-env.Prepend(LIBS=["npymath"])
-env.Prepend(LIBPATH=["."])
-
-subst_dict = {'@prefix@': '$distutils_install_prefix',
-    '@pkgname@': 'numpy.core', '@sep@': os.path.sep}
-npymath_ini = env.SubstInFile(pjoin('lib', 'npy-pkg-config', 'npymath.ini'),
-    'npymath.ini.in', SUBST_DICT=subst_dict)
-
-subst_dict = {'@posix_mathlib@': " ".join(['-l%s' % l for l in mlib]),
-              '@msvc_mathlib@': " ".join(['%s.mlib' % l for l in mlib])}
-mlib_ini = env.SubstInFile(pjoin('lib', 'npy-pkg-config', 'mlib.ini'),
-    'mlib.ini.in', SUBST_DICT=subst_dict)
-env.Install('$distutils_installdir/lib/npy-pkg-config', mlib_ini)
-env.Install('$distutils_installdir/lib/npy-pkg-config', npymath_ini)
-
-# npysort core lib
-npysort_src = [env.GenerateFromTemplate(pjoin('src', 'npysort', 'quicksort.c.src')),
-               env.GenerateFromTemplate(pjoin('src', 'npysort', 'mergesort.c.src')),
-               env.GenerateFromTemplate(pjoin('src', 'npysort', 'heapsort.c.src'))]
-env.StaticExtLibrary("npysort", npysort_src)
-env.Prepend(LIBS=["npysort"])
-env.Prepend(LIBPATH=["."])
-
-#-----------------
-# Build multiarray
-#-----------------
-if ENABLE_SEPARATE_COMPILATION:
-    multiarray_src = [pjoin('src', 'multiarray', 'multiarraymodule.c'),
-        pjoin('src', 'multiarray', 'hashdescr.c'),
-        pjoin('src', 'multiarray', 'arrayobject.c'),
-        pjoin('src', 'multiarray', 'array_assign.c'),
-        pjoin('src', 'multiarray', 'array_assign_scalar.c'),
-        pjoin('src', 'multiarray', 'array_assign_array.c'),
-        pjoin('src', 'multiarray', 'datetime.c'),
-        pjoin('src', 'multiarray', 'datetime_strings.c'),
-        pjoin('src', 'multiarray', 'datetime_busday.c'),
-        pjoin('src', 'multiarray', 'datetime_busdaycal.c'),
-        pjoin('src', 'multiarray', 'numpyos.c'),
-        pjoin('src', 'multiarray', 'flagsobject.c'),
-        pjoin('src', 'multiarray', 'descriptor.c'),
-        pjoin('src', 'multiarray', 'iterators.c'),
-        pjoin('src', 'multiarray', 'mapping.c'),
-        pjoin('src', 'multiarray', 'number.c'),
-        pjoin('src', 'multiarray', 'getset.c'),
-        pjoin('src', 'multiarray', 'sequence.c'),
-        pjoin('src', 'multiarray', 'methods.c'),
-        pjoin('src', 'multiarray', 'ctors.c'),
-        pjoin('src', 'multiarray', 'convert_datatype.c'),
-        pjoin('src', 'multiarray', 'convert.c'),
-        pjoin('src', 'multiarray', 'shape.c'),
-        pjoin('src', 'multiarray', 'item_selection.c'),
-        pjoin('src', 'multiarray', 'calculation.c'),
-        pjoin('src', 'multiarray', 'common.c'),
-        pjoin('src', 'multiarray', 'refcount.c'),
-        pjoin('src', 'multiarray', 'conversion_utils.c'),
-        pjoin('src', 'multiarray', 'usertypes.c'),
-        pjoin('src', 'multiarray', 'buffer.c'),
-        pjoin('src', 'multiarray', 'numpymemoryview.c'),
-        pjoin('src', 'multiarray', 'scalarapi.c'),
-        pjoin('src', 'multiarray', 'nditer_api.c'),
-        pjoin('src', 'multiarray', 'nditer_constr.c'),
-        pjoin('src', 'multiarray', 'nditer_pywrap.c'),
-        pjoin('src', 'multiarray', 'dtype_transfer.c'),
-        pjoin("src", "multiarray", "ucsnarrow.c")]
-    multiarray_src.extend(arraytypes_src)
-    multiarray_src.extend(scalartypes_src)
-    multiarray_src.extend(lowlevel_strided_loops_src)
-    multiarray_src.extend(nditer_src)
-    multiarray_src.extend(einsum_src)
-else:
-    multiarray_src = [pjoin('src', 'multiarray', 'multiarraymodule_onefile.c')]
-multiarray = env.DistutilsPythonExtension('multiarray', source = multiarray_src)
-env.DistutilsPythonExtension('multiarray_tests', source=multiarray_tests_src)
-
-#-------------------
-# Build umath module
-#-------------------
-if ENABLE_SEPARATE_COMPILATION:
-    umathmodule_src.extend([pjoin('src', 'umath', 'ufunc_object.c')])
-    umathmodule_src.extend([pjoin('src', 'umath', 'ufunc_type_resolution.c')])
-    umathmodule_src.extend([pjoin('src', 'multiarray', 'reduction.c')]),
-    umathmodule_src.extend(umath_loops_src)
-else:
-    umathmodule_src = [pjoin('src', 'umath', 'umathmodule_onefile.c')]
-umathmodule = env.DistutilsPythonExtension('umath', source = umathmodule_src)
-
-#------------------------
-# Build scalarmath module
-#------------------------
-scalarmathmodule = env.DistutilsPythonExtension('scalarmath',
-                                            source = scalarmathmodule_src)
-
-#------------------------
-# Build scalarmath module
-#------------------------
-umath_tests = env.DistutilsPythonExtension('umath_tests',
-        source=umath_tests_src)
-
-#----------------------
-# Build _dotblas module
-#----------------------
-if build_blasdot:
-    dotblas_src = [pjoin('blasdot', i) for i in ['_dotblas.c']]
-    # because _dotblas does #include CBLAS_HEADER instead of #include
-    # "cblas.h", scons does not detect the dependency
-    # XXX: PythonExtension builder does not take the Depends on extension into
-    # account for some reason, so we first build the object, with forced
-    # dependency, and then builds the extension. This is more likely a bug in
-    # our PythonExtension builder, but I cannot see how to solve it.
-    dotblas_o = env.PythonObject('_dotblas', source = dotblas_src)
-    env.Depends(dotblas_o, pjoin("blasdot", "cblas.h"))
-    dotblas = env.DistutilsPythonExtension('_dotblas', dotblas_o)
-
-# "Install" the header in the build directory, so that in-place build works
-for h in generated_headers:
-    env.Install(pjoin('$distutils_installdir', include_dir), h)