configure

#!/usr/bin/env python

import subprocess, sys, os, platform, tempfile, shutil, shlex, re, copy


debug = False
profile = False
nogui = False
noshared = False
static = False
verbose = False
R_module = False
profile_name = None
sh_basis_def = None

for arg in sys.argv[1:]:
  if '-debug'.startswith (arg): debug = True
  elif '-profile'.startswith (arg): profile = True
  elif '-nogui'.startswith (arg): nogui = True
  elif '-noortho'.startswith (arg): sh_basis_def = '-DUSE_NON_ORTHONORMAL_SH_BASIS'
  elif '-noshared'.startswith (arg): noshared = True
  elif '-static'.startswith (arg): 
    static = True
    noshared = True
  elif '-verbose'.startswith (arg): verbose = True
  elif '-R'.startswith (arg): 
    R_module = True
    #noshared = True
    nogui = True
  elif arg[0] != '-':
    if profile_name != None: 
      print ('configure: too many names supplied')
      sys.exit (1)
    profile_name = arg
  else: 
    print ("""
usage: [ENV] ./configure [name] [-debug] [-profile] [-nogui] [-noshared]

In most cases, a simple invocation should work:

   $ ./configure

If a name is provided, the configuration will be written to a different file, 
which can then be used by the build script. For example:

   $ ./configure testing -debug

will generate the file 'config.testing', which can be used with the build
script as follows:

   $ ./build testing

Note that all intermediate files will be named according to the name of the
configuration to avoid conflict with any other configuration.


OPTIONS:

    -debug       enable debugging symbols.

    -profile     enable profiling.

    -nogui       disable GUI components.

    -noshared    disable shared library generation.

    -R           used to generate an R module (implies -noshared)

    -static      produce statically-linked executables.

    -verbose     enable more informative output.


ENVIRONMENT VARIABLES:

For non-standard setups, you may need to supply additional
information using environment variables. For example, to set
the compiler, use:
   $ CXX=/usr/local/bin/g++-4.1 ./configure

The following environment variables can be set:

CXX             The compiler command to use. The default is "g++" ("clang" on MacOSX)

CXX_ARGS        The arguments expected by the compiler. The default is:
                "-c CFLAGS SRC -o OBJECT"

LD              The linker command to use. The default is:
                "g++" ("clang++" on MacOSX)

LD_ARGS         The arguments expected by the linker. The default is:
                "LDFLAGS OBJECTS -o EXECUTABLE"

LDLIB_ARGS      The arguments expected by the linker for generating a shared library.
                The default is:
                "-shared LDLIB_FLAGS OBJECTS -o LIB"

ARCH            the specific CPU architecture to compile for. This variable 
                will be passed to the compiler using -march=$ARCH.
                The default is 'native'.

CFLAGS          Any additional flags to the compiler.

LDFLAGS         Any additional flags to the linker.

LDLIB_FLAGS     Any additional flags to the linker to generate a shared library.

GSL_CFLAGS      Any flags required to compile with the GSL.
                This may include in particular the path to the
                include files, if not in a standard location
                For example:
                $ GSL_CFLAGS="-I/usr/local/include" ./configure

GSL_LDFLAGS     Any flags required to link with the GSL.
                This may include in particular the path to the
                libraries, if not in a standard location
                For example:
                $ GSL_LDFLAGS="-L/usr/local/lib -lgsl -lgslcblas" ./configure

ZLIB_CFLAGS     Any flags required to compile with the zlib compression library.

ZLIB_LDFLAGS    Any flags required to link with the zlib compression library.

CBLAS_LDFLAGS   Any flags required to link with an alternate cblas library.

QMAKE           The command to run to invoke qmake. 

MOC             The command to invoke Qt's meta-object compile (default: moc)

RCC             The command to invoke Qt's resource compiler (default: rcc)

PATH            Set the path to use during the configure process.
                This may be useful to set the path to Qt's qmake.
                For example:
                $ PATH=/usr/local/bin:$PATH ./configure

                Note that this path will NOT be used during the build
                process itself.
""")
    sys.exit (0)
  

if not profile_name:
  profile_name = 'default'


global logfile, config_report
logfile = open (os.path.join (os.path.dirname(sys.argv[0]), 'configure.log'), 'wb')
config_report = ''


def log (message):
  global logfile
  logfile.write (message.encode (errors='ignore'))
  if (verbose): 
    sys.stdout.write (message)
    sys.stdout.flush()

def report (message):
  global config_report, logfile
  config_report += message
  sys.stdout.write (message)
  sys.stdout.flush()
  logfile.write (('\nREPORT: ' + message.rstrip() + '\n').encode (errors='ignore'))

def error (message):
  global logfile
  logfile.write (('\nERROR: ' + message.rstrip() + '\n\n').encode (errors='ignore'))
  sys.stderr.write ('\nERROR: ' + message.rstrip() + '\n\n')
  sys.exit (1)


report ("""
MRtrix build type requested: """)
if profile: report ('profiling')
elif debug: report ('debug')
else: report ('release')
if nogui: report (' [command-line only]')
report ('\n\n')




global cpp, cpp_cmd, ld, ld_args, ld_cmd

cxx = [ 'g++' ]
cxx_args = '-c CFLAGS SRC -o OBJECT'.split()
cpp_flags = [ '-std=c++11' ]

ld_args = 'OBJECTS LDFLAGS -o EXECUTABLE'.split()
ld_flags = [ ]

if static:
  ld_flags += [ '-static', '-Wl,-u,pthread_cancel,-u,pthread_cond_broadcast,-u,pthread_cond_destroy,-u,pthread_cond_signal,-u,pthread_cond_wait,-u,pthread_create,-u,pthread_detach,-u,pthread_cond_signal,-u,pthread_equal,-u,pthread_join,-u,pthread_mutex_lock,-u,pthread_mutex_unlock,-u,pthread_once,-u,pthread_setcancelstate' ] 

ld_lib_args = 'OBJECTS LDLIB_FLAGS -o LIB'.split()
ld_lib_flags = [ ]

zlib_cflags = []
zlib_ldflags = [ '-lz' ]

gsl_cflags = []
gsl_ldflags = [ '-lgsl', '-lgslcblas' ]


class TempFile:
  def __init__ (self, suffix):
    self.fid = None
    self.name = None
    [ fid, self.name ] = tempfile.mkstemp (suffix)
    self.fid = os.fdopen (fid, 'w')

  def __enter__ (self):
    return self

  def __exit__(self, type, value, traceback):      
    try:
      os.unlink (self.name)
    except OSError as error:
      log ('error deleting temporary file "' + self.name + '": ' + error.strerror)
    except:
      raise
  


class DeleteAfter:
  def __init__ (self, name):
    self.name = name

  def __enter__ (self):
    return self

  def __exit__(self, exception_type, value, traceback):
    try:
      os.unlink (self.name)
    except OSError as error:
      log ('error deleting temporary file "' + self.name + '": ' + error.strerror)
    except:
      raise
    
    
class TempDir:
  def __init__ (self):
    self.name = tempfile.mkdtemp ();

  def __enter__ (self):
    return self

  def __exit__(self, type, value, traceback):
    try:
      for entry in os.listdir (self.name):
        fname = os.path.join (self.name, entry)
        if os.path.isdir (fname):
          os.rmdir (fname)
        else:
          os.unlink (fname)
      os.rmdir (self.name)
       
    except OSError as error:
      log ('error deleting temporary folder "' + self.name + '": ' + error.strerror)
    except:
      raise



class QMakeError (Exception): pass
class QMOCError (Exception): pass
class CompileError (Exception): pass
class LinkError (Exception): pass
class RuntimeError (Exception): pass

def commit (name, variable):
  cache.write (name + ' = ')
  if type (variable) == type([]): 
    cache.write ('[')
    if len(variable): cache.write(' \'' + '\', \''.join (variable) + '\' ')
    cache.write (']\n')
  else: cache.write ('\'' + variable + '\'\n')



def fillin (template, keyvalue):
  cmd = []
  for item in template:
    if item in keyvalue: 
      if type(keyvalue[item]) == type ([]): cmd += keyvalue[item]
      else: cmd += [ keyvalue[item] ]
    else: cmd += [ item ]
  return cmd



def execute (cmd, exception, raise_on_non_zero_exit_code = True, cwd = None):
  log ('EXEC <<\nCMD: ' + ' '.join(cmd) + '\n')
  try: 
    process = subprocess.Popen (cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)
    ( stdout, stderr ) = process.communicate()

    log ('EXIT: ' + str(process.returncode) + '\n')
    stdout = stdout.decode(errors='ignore').rstrip()
    if len (stdout): log ('STDOUT:\n' + stdout + '\n')
    stderr = stderr.decode(errors='ignore').rstrip()
    if len (stderr): log ('STDERR:\n' + stderr + '\n')
    log ('>>\n\n')
  
  except OSError as error: 
    log ('error invoking command "' + cmd[0] + '": ' + error.strerror + '\n>>\n\n')
    raise exception
  except:
    print ('Unexpected error:', str(sys.exc_info()))
    raise
  else:
    if raise_on_non_zero_exit_code and process.returncode != 0: 
      raise exception (stderr)


  return (process.returncode, stdout, stderr)

  

def compile (source, compiler_flags = [], linker_flags = []):
  global cpp, ld
  with TempFile ('.cpp') as F:
    log ('\nCOMPILE ' + F.name + ':\n---\n' + source + '\n---\n')
    F.fid.write (source)
    F.fid.flush()
    F.fid.close()
    with DeleteAfter (F.name[:-4] + '.o') as obj:
      cmd = fillin (cpp, {
        'CFLAGS': compiler_flags,
        'SRC': F.name,
        'OBJECT': obj.name })
      execute (cmd, CompileError)
      
      with DeleteAfter ('a.out') as out:
        cmd = fillin (ld, {
          'LDFLAGS': linker_flags,
          'OBJECTS': obj.name,
          'EXECUTABLE': out.name })
        execute (cmd, LinkError)

        ret = execute ([ './'+out.name ], RuntimeError)

  return ret[1]


def compare_version (needed, observed):
  needed = [ float(n) for n in needed.split()[0].split('.') ]
  observed = [ float(n) for n in observed.split()[0].split('.') ]
  for n in zip (needed, observed):
    if n[0] > n[1]:
      return False
  return True








# OS-dependent variables:

obj_suffix = '.o'
exe_suffix = ''
lib_prefix = 'lib'

system = platform.system().lower()
if system.startswith('mingw') or system.startswith('msys'):
  system = 'windows'
report ('Detecting OS: ' + system + '\n')
if system == 'linux':
  cpp_flags += [ '-pthread', '-fPIC' ]
  lib_suffix = '.so'
  ld_flags += [ '-pthread' ]
  ld_lib_flags += [ '-pthread', '-shared' ]
  runpath = '-Wl,-rpath,$ORIGIN/'
elif system == 'windows':
  cpp_flags += [ '-pthread', '-DMRTRIX_WINDOWS', '-mms-bitfields' ]
  exe_suffix = '.exe'
  lib_prefix = ''
  lib_suffix = '.dll'
  ld_flags += [ '-pthread', '-Wl,--allow-multiple-definition' ]
  ld_lib_flags += [ '-pthread', '-shared' ]
  runpath = ''
elif system == 'darwin':
  cxx = [ 'clang++' ]
  cpp_flags += [ '-DMRTRIX_MACOSX', '-fPIC' ]
  ld_lib_flags += [ '-dynamiclib', '-install_name', '@rpath/LIBNAME' ]
  runpath = '-Wl,-rpath,@loader_path/'
  lib_suffix = '.dylib'




if 'ARCH' in os.environ.keys(): 
  march = os.environ['ARCH']
  report ('Machine architecture set by ARCH environment variable to: ' + march + '\n')
  cpp_flags += [ '-march='+march ]
else:
  if system != 'darwin':
    cpp_flags += [ '-march=native' ]




# set CPP compiler:

if 'CXX' in os.environ.keys(): cxx = shlex.split (os.environ['CXX'])
if 'CXX_ARGS' in os.environ.keys(): cxx_args = shlex.split (os.environ['CXX_ARGS'])
ld = copy.copy(cxx)
if 'LD' in os.environ.keys(): ld = shlex.split (os.environ['LD'])
if 'LD_ARGS' in os.environ.keys(): ld_args = shlex.split (os.environ['LD_ARGS'])
if 'LDLIB_ARGS' in os.environ.keys(): ld_lib_args = shlex.split (os.environ['LDLIB_ARGS'])

cpp = cxx + cxx_args
ld_lib = ld + ld_lib_args
ld += ld_args




# CPP flags:

if 'CFLAGS' in os.environ.keys(): cpp_flags += shlex.split (os.environ['CFLAGS'])
if 'LDFLAGS' in os.environ.keys(): ld_flags + shlex.split (os.environ['LDFLAGS'])
ld_lib_flags += ld_flags
if 'LDLIB_FLAGS' in os.environ.keys(): ld_lib_flags + shlex.split (os.environ['LDLIB_FLAGS'])



report ('Checking for C++11 compliant compiler [' + cpp[0] + ']: ')
try: 
  compiler_version = execute ([ cpp[0], '-dumpversion' ], CompileError)[1]
  if len(compiler_version) == 0: report ('(no version information)')
  else: report (compiler_version)
except:
  error ('''compiler not found!

Use CXX environment variable to set path to compiler, as follows:
     CXX=/usr/bin/g++-4.2 ./configure''')

try:
  compile ('''
struct Base {
    Base (int);
};
struct Derived : Base {
    using Base::Base;
};

int main() { 
  Derived D (int); // check for contructor inheritance
  return (0); 
}
''', cpp_flags, ld_flags)
  report (' - tested ok\n')
except CompileError:
  error ('''compiler test failed!

Use CXX environment variable to set path to compiler, as follows:
     CXX=/usr/bin/g++-4.2 ./configure

You can also use the CXX_ARGS to set the arguments expected by the 
compiler, in case this differs from gcc, as follows:

     CXX_ARGS="-c CFLAGS SRC -o OBJECT" ./configure''')
except (LinkError, RuntimeError):
  error ('''linking error!

Use LD environment variable to set path to compiler, as follows:
     LD=/usr/bin/g++-4.2 ./configure''')
except:
  raise






report ('Detecting pointer size: ')
try:
  pointer_size = int (compile ('''
#include <iostream>
int main() { 
  std::cout << sizeof(void*); 
  return (0);
}
''', cpp_flags, ld_flags))
  report (str(8*pointer_size) + ' bit\n')
  if pointer_size == 8: cpp_flags += [ '-DMRTRIX_WORD64' ]
  elif pointer_size != 4: 
    error ('unexpected pointer size!')
except:
  error ('unable to determine pointer size!')




report ('Detecting byte order: ')
if sys.byteorder == 'big':
  report ('big-endian\n')
  cpp_flags += [ '-DMRTRIX_BYTE_ORDER_IS_BIG_ENDIAN' ]
else:
  report ('little-endian\n')







report ('Checking for variable-length array support: ')
try:
  compile ('''

int main(int argc, char* argv[]) { 
  int x[argc];
  return 0; 
}
''', cpp_flags, ld_flags)
  report ('yes\n')
except:
  report ('no\n')
  cpp_flags += [ '-DMRTRIX_NO_VLA' ]



report ('Checking for non-POD variable-length array support: ')
try:
  compile ('''
#include <string>

class X {
  int x;
  double y;
  std::string s;
};

int main(int argc, char* argv[]) { 
  X x[argc];
  return 0; 
}
''', cpp_flags, ld_flags)
  report ('yes\n')
except:
  report ('no\n')
  cpp_flags += [ '-DMRTRIX_NO_NON_POD_VLA' ]




# zlib:

report ('Checking for zlib compression library: ')

if 'ZLIB_CFLAGS' in os.environ.keys(): zlib_cflags = shlex.split (os.environ['ZLIB_CFLAGS'])
if 'ZLIB_LDFLAGS' in os.environ.keys(): zlib_ldflags = shlex.split (os.environ['ZLIB_LDFLAGS'])

try:
  zlib_version = compile ('''
#include <iostream>
#include <zlib.h>

int main() { 
  std::cout << zlibVersion(); 
  return (0);
}
''', cpp_flags + zlib_cflags, ld_flags + zlib_ldflags)
  report (zlib_version + '\n')
except CompileError:
  error ('''compiler error!

Use the ZLIB_CFLAGS environment variable to set the path to
the zlib include files and to set any required flags
For example:
     ZLIB_CFLAGS="-I/usr/local/include" ./configure''')
except LinkError:
  error ('''linker error!

Use the ZLIB_LDFLAGS environment variable to set the path to
the zlib libraries and to set the library to use
For example:
     ZLIB_LDFLAGS="-L/usr/local/lib -lz" ./configure''')
except RuntimeError:
  error ('''runtime error!

There is something wrong with your zlib implementation!''')
except:
  error ('zlib implementation not found!')

cpp_flags += zlib_cflags
ld_flags += zlib_ldflags
ld_lib_flags += zlib_ldflags







# GSL flags:

report ('Checking for GNU Scientific Library: ')
if 'GSL_CFLAGS' in os.environ.keys(): 
  gsl_cflags = shlex.split (os.environ['GSL_CFLAGS'])
else:
  try: 
    gsl_cflags = shlex.split (execute ([ 'gsl-config', '--cflags' ], RuntimeError)[1])
    gsl_cflags = [ c for c in gsl_cflags if c is not 0 ]
  except:
    log ('gsl-config not in PATH - assuming defaults for GSL_CFLAGS\n\n')
    
if 'GSL_LDFLAGS' in os.environ.keys(): 
  gsl_ldflags = shlex.split (os.environ['GSL_LDFLAGS'])
else:
  try: 
    gsl_ldflags = shlex.split (execute ([ 'gsl-config', '--libs' ], RuntimeError)[1])
    gsl_ldflags = [ c for c in gsl_ldflags if c is not 0 ]
  except:
    log ('gsl-config not in PATH - assuming defaults for GSL_LDFLAGS\n\n')
    

try:
  gsl_version = compile ('''
#include <iostream>
#include <gsl/gsl_version.h>
#include <gsl/gsl_matrix.h>

int main() { 
  std::cout << gsl_version; 
  gsl_matrix* M = gsl_matrix_alloc (3,3); 
  return (M->size1 != 3);
}
''', cpp_flags + gsl_cflags, ld_flags + gsl_ldflags)
  report (gsl_version + '\n')
except CompileError:
  error ('''compiler error!

Use the GSL_CFLAGS environment variable to set the path to the GSL include files'
For example:'
     GSL_CFLAGS=-I/usr/local/include ./configure''')
except LinkError:
  error ('''linker error!'

Use the GSL_LDFLAGS environment variable to set the path to the GSL libraries'
and include any required libraries'
For example:'
     GSL_LDFLAGS="-L/usr/local/lib -lgsl -lgslcblas" ./configure''')

ld_lib_flags += gsl_ldflags

report ('Checking whether GSL compiles with -DHAVE_INLINE: ')
try:
  gsl_version = compile ('''
#include <gsl/gsl_matrix.h>
int main() { 
  gsl_matrix* M = gsl_matrix_alloc (3,3); 
  gsl_matrix_set(M,0,0,3.14); 
  return (gsl_matrix_get(M,0,0) != 3.14); 
}''', cpp_flags + gsl_cflags + [ '-DHAVE_INLINE' ], ld_flags + gsl_ldflags)
  gsl_cflags += [ '-DHAVE_INLINE' ]
  report ('yes\n')
except:
  report ('no\n')




# check for alternate cblas libraries:

if 'CBLAS_LDFLAGS' in os.environ.keys(): 
  cblas_ldflags = shlex.split (os.environ['CBLAS_LDFLAGS'])
  flags = gsl_ldflags[:]
  flags.remove ('-lgslcblas')
  flags += cblas_ldflags;
  report ('Checking whether GSL compiles with alternate C BLAS libraries ("' + ' '.join(cblas_ldflags) + '"): ')
  try:
    compile ('''
#include <iostream>
#include <gsl/gsl_version.h>
#include <gsl/gsl_matrix.h>

int main() { 
  std::cout << gsl_version; 
  gsl_matrix* M = gsl_matrix_alloc (3,3); 
  return (M->size1 != 3);
}
''', cpp_flags + gsl_cflags, ld_flags + flags)
    report ('yes\n')
    gsl_ldflags = flags
  except:
    error ('''Error compiling and/or linking with alternative C BLAS libraries provided!
Check whether the information provided by the CBLAS_LDFLAGS environment
variable is correct.''')







# shared library generation:
if not noshared:
  report ('Checking shared library generation: ')

  with TempFile ('.cpp') as F:
    F.fid.write ('int bogus() { return (1); }')
    F.fid.flush()
    F.fid.close()
    with DeleteAfter (F.name[:-4] + '.o') as obj:
      cmd = fillin (cpp, {
        'CFLAGS': cpp_flags,
        'SRC': F.name,
        'OBJECT': obj.name })
      try: execute (cmd, CompileError)
      except CompileError:
        error ('''compiler not found!

  an unexpected error occurred''')
      except:
        raise
  
      with DeleteAfter (lib_prefix + 'test' + lib_suffix) as lib:
        cmd = fillin (ld_lib, {
          'LDLIB_FLAGS': ld_lib_flags,
          'OBJECTS': obj.name,
          'LIB': lib.name })
        try: execute (cmd, LinkError)
        except LinkError: 
          error ('''linker not found!

  Use the LDLIB_ARGS environment variable to set the command-line
  for shared library generation''')
        except:
          raise

        report ('yes\n')



#the following regex will be reused so keep it outside of the get_qt_version func
version_regex = re.compile(r'\d+\.\d+(\.\d+)+') #: :type version_regex: re.compile
def get_qt_version(cmd_list, raise_on_non_zero_exit_code):
  out = execute (cmd_list, raise_on_non_zero_exit_code, False)
  stdouterr = ' '.join(out[1:]).replace(r'\n',' ').replace(r'\r','')
  version_found = version_regex.search(stdouterr)
  if version_found: return version_found.group()
  else: raise raise_on_non_zero_exit_code('Version not Found')


moc = ''
rcc = ''
qt_cflags = []
qt_ldflags = []


if not nogui:

  report ('Checking for Qt moc: ')
  moc = 'moc' 
  if 'MOC' in os.environ.keys(): 
    moc = os.environ['MOC']
  try:
    moc_version = get_qt_version([ moc, '-v' ], OSError)
    report (moc + ' (version ' + moc_version + ')\n')
    if int (moc_version.split('.')[0]) < 4:
      error (''' Qt moc version is too old!

  Use the MOC environment variable to specify the Qt meta-object compiler, 
  or set PATH to ensure the correct version is listed first''')
  except OSError:
    error (''' Qt moc not found!

  Use the MOC environment variable to specify the Qt meta-object compiler,
  or set PATH to include its location''')
  except:
    raise
  
    

  report ('Checking for Qt qmake: ')
  qmake = 'qmake' 
  if 'QMAKE' in os.environ.keys(): 
    qmake = os.environ['QMAKE'] 
  try:
    qmake_version = get_qt_version([ qmake, '-v' ], OSError)
    report (qmake + ' (version ' + qmake_version + ')\n')
    if int (qmake_version.split('.')[0]) < 4:
      error (''' Qt qmake not found!

  Use the QMAKE environment variable to specify the Qt qmake executable,
  or set PATH to ensure the correct version is listed first''')
  except OSError:
    error (''' Qt qmake not found!

  Use the QMAKE environment variable to specify the Qt qmake executable,
  or set PATH to include its location''')
  except:
    raise
  
  
  
  report ('Checking for Qt rcc: ')
  rcc = 'rcc' 
   
  if 'RCC' in os.environ.keys(): 
    rcc = os.environ['RCC'] 
  try:
    rcc_version = get_qt_version([ rcc, '-v' ], OSError)
    report (rcc + ' (version ' + rcc_version + ')\n')
    if int (rcc_version.split('.')[0]) < 4:
      error (''' Qt rcc not found!

  Use the RCC environment variable to specify the Qt rcc executable,
  or set PATH to ensure the correct version is listed first''')
  except OSError:
    error (''' Qt rcc not found!

  Use the RCC environment variable to specify the Qt rcc executable,
  or set PATH to include its location''')
  except:
    raise
  
    


  report ('Checking for Qt: ')

  try:
    with TempDir() as qt_dir:
      file = '''#include <QObject>

class Foo: public QObject {
  Q_OBJECT;
  public:
    Foo();
    ~Foo();
  public slots:
    void setValue(int value);
  signals:
    void valueChanged (int newValue);
  private:
    int value_;
};
'''
      log ('\nsource file "qt.h":\n---\n' + file + '---\n')
  
      f=open (os.path.join (qt_dir.name, 'qt.h'), 'w')
      f.write (file)
      f.close();

      file = '''#include <iostream>
#include "qt.h"

Foo::Foo() : value_ (42) { connect (this, SIGNAL(valueChanged(int)), this, SLOT(setValue(int))); }

Foo::~Foo() { std::cout << qVersion() << "\\n"; }

void Foo::setValue (int value) { value_ = value; }

int main() { Foo f; }
'''

      log ('\nsource file "qt.cpp":\n---\n' + file + '---\n')
      f=open (os.path.join (qt_dir.name, 'qt.cpp'), 'w')
      f.write (file)
      f.close();

      file = 'CONFIG += c++11'
      if debug: file += ' debug'
      file += '\nQT += core gui opengl svg\n'
      file += 'HEADERS += qt.h\nSOURCES += qt.cpp\n'

      log ('\nproject file "qt.pro":\n---\n' + file + '---\n')
      f=open (os.path.join (qt_dir.name, 'qt.pro'), 'w')
      f.write (file)
      f.close();

      qmake_cmd = [ qmake ]

      try: 
         (retcode, stdout, stderr) = execute (qmake_cmd, QMakeError, raise_on_non_zero_exit_code = False, cwd=qt_dir.name)
         if retcode != 0:
           error ('''qmake returned with error:

''' + stderr)
      except QMakeError as E:
        error ('''error issuing qmake command!

  Use the QMAKE environment variable to set the correct qmake command for use with Qt''')
      except:
        raise


      qt_defines = [] 
      qt_includes = []
      qt_cflags = []
      qt_libs = []
      qt_ldflags = []
      qt_makefile = 'Makefile'
      if system == 'windows':
        qt_makefile = 'Makefile.Release'
      for line in open (os.path.join (qt_dir.name, qt_makefile)):
        line = line.strip()
        if line.startswith ('DEFINES'):
          qt_defines = shlex.split (line[line.find('=')+1:].strip())
        elif line.startswith ('CXXFLAGS'):
          qt_cflags = shlex.split (line[line.find('=')+1:].strip())
        elif line.startswith ('INCPATH'):
          qt_includes = shlex.split (line[line.find('=')+1:].strip())
        elif line.startswith ('LIBS'):
          qt_libs = shlex.split (line[line.find('=')+1:].strip())
        elif line.startswith ('LFLAGS'):
          qt_ldflags = shlex.split (line[line.find('=')+1:].strip())

      for index, entry in enumerate(qt_includes):
        if entry[2:].startswith('..'):
          qt_includes[index] = '-I' + os.path.abspath(qt_dir.name + '/' + entry[2:])
      
      qt = qt_cflags + qt_defines + qt_includes
      qt_cflags = []
      for entry in qt:
        if entry[0] != '$' and not entry == '-I.': qt_cflags += [ entry.replace('\"','').replace("'",'') ]

      qt = qt_ldflags + qt_libs
      qt_ldflags = []
      for entry in qt:
        if entry[0] != '$': qt_ldflags += [ entry.replace('\"','').replace("'",'') ]
  
      cmd = [ moc, 'qt.h', '-o', 'qt_moc.cpp' ]
      log ('\nexecuting "' + ' ' .join(cmd) + '"...\n')
      try: process = subprocess.Popen (cmd, cwd=qt_dir.name, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      except OSError: raise QMOCError
      if process.wait() != 0: raise QMOCError

      cmd = cxx + [ '-c' ] + cpp_flags + qt_cflags + [ 'qt.cpp', '-o', 'qt.o' ]
      log ('\nexecuting "' + ' ' .join(cmd) + '"...\n')
      try: process = subprocess.Popen (cmd, cwd=qt_dir.name, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      except OSError: raise CompileError('oserror')
      except: raise
      retcode = process.wait()
      if retcode != 0: raise CompileError('process not terminated properly (exit code = %s)'%str(retcode))

      cmd = cxx + [ '-c' ] + cpp_flags + qt_cflags + [ 'qt_moc.cpp', '-o', 'qt_moc.o' ]
      log ('\nexecuting "' + ' ' .join(cmd) + '"...\n')
      try: process = subprocess.Popen (cmd , cwd=qt_dir.name, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      except OSError: raise CompileError('oserror')
      except: raise
      if process.wait() != 0: raise CompileError('process not terminated properly')

      cmd = cxx + ld_flags + [ 'qt_moc.o', 'qt.o', '-o', 'qt' ] + qt_ldflags
      log ('\nexecuting "' + ' ' .join(cmd) + '"...\n')
      try: process = subprocess.Popen (cmd , cwd=qt_dir.name, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      except OSError: raise LinkError('oserror')
      except: raise
      if process.wait() != 0: raise LinkError('process not terminated properly')

      cmd = os.path.join(qt_dir.name, 'qt')
      log ('\nexecuting "' + cmd + '"...\n')
      process = subprocess.Popen (cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      if process.wait() != 0: raise LinkError('process not terminated properly')
      report (process.stdout.read().decode(errors='ignore').strip() + '\n')

    
  except QMakeError:
    error ('''error invoking Qt qmake!

  Use the QMAKE environment variable to set the correct qmake command for use with Qt''')
  except QMOCError:
    error ('''error invoking Qt moc!

use the MOC environment variable to specify the Qt moc command''')
  except LinkError:
    error ('''error linking Qt application!

Are all necessary (static or shared) Qt libraries installed?''')
  except QMOCError:
    error ('''error invoking Qt moc!

use the MOC environment variable to specify the Qt moc command''')
  except CompileError as e:
    error ('error compiling Qt application! ' + str(e))
  except OSError as e:
    error ('Unexpected error! Unable to configure Qt environment: ' + str(e))
  except:
    raise





  if system == "darwin":
    if '-Wall' in qt_cflags: qt_cflags.remove ('-Wall')
    if '-W' in qt_cflags: qt_cflags.remove ('-W')



# output R module:
if R_module:

  report ('Checking for R library: ')
  R_cflags = [ '-I/usr/include/R' ]
  if 'R_CFLAGS' in os.environ.keys(): 
    R_cflags = shlex.split (os.environ['R_CFLAGS'])
  else:
    try: 
      R_cflags = shlex.split (execute ([ 'pkg-config', '--cflags', 'libR' ], RuntimeError)[1])
    except:
      log ('error running pkg-config --libs libR - assuming defaults for R_CFLAGS\n\n')
      
  R_ldflags = [ '-L/usr/lib/R/lib', '-lR' ]
  if 'R_LDFLAGS' in os.environ.keys(): 
    R_ldflags = shlex.split (os.environ['R_LDFLAGS'])
  else:
    try: 
      R_ldflags = shlex.split (execute ([ 'pkg-config', '--libs', 'libR' ], RuntimeError)[1])
    except:
      log ('error running pkg-config --libs libR - assuming defaults for R_LDFLAGS\n\n')
    

  try:
    R_version = compile ('''
  #include <R.h>
  #include <Rversion.h>
  #include <iostream>
  
  int main() { 
    std::cout << R_MAJOR << "." << R_MINOR << " (r" << R_SVN_REVISION << ")\\n";
    return 0;
  }
  ''', cpp_flags + R_cflags, ld_flags + R_ldflags)
    report (R_version + '\n')
  except CompileError:
    error ('''compiler error!
  
  Use the R_CFLAGS environment variable to set the path to the R include files'
  For example:'
       R_CFLAGS=-I/usr/local/include/R ./configure''')
  except LinkError:
    error ('''linker error!'
  
  Use the R_LDFLAGS environment variable to set the path to the R library'
  and include any required libraries'
  For example:'
       R_LDFLAGS="-L/usr/local/R/lib -lR" ./configure''')
  except RuntimeError:
    error ('''error running command - check configure.log for details''')
  except: 
    raise
  
  cpp_flags += R_cflags + [ '-DMRTRIX_AS_R_LIBRARY' ]
  ld_lib_flags += R_ldflags
    
  ld_flags = ld_lib_flags
  exe_suffix = lib_suffix




# add debugging or profiling flags if requested:

cpp_flags += [ '-Wall' ]

if profile:
  cpp_flags += [ '-g', '-pg', '-DNDEBUG' ]
  ld_flags += [ '-g', '-pg' ]
  ld_lib_flags += [ '-g', '-pg' ]
elif debug:
  cpp_flags += [ '-O0', '-g', '-D_GLIBCXX_DEBUG=1', '-D_GLIBCXX_DEBUG_PEDANTIC=1' ]
  ld_flags += [ '-g' ]
  ld_lib_flags += [ '-g' ]
else:
  cpp_flags += [ '-O2', '-DNDEBUG' ]



#
# set macro for non-orthonormal SH basis if requested:
if sh_basis_def is not None:
  cpp_flags += [ sh_basis_def ]


# write out configuration:

cache_filename = os.path.join (os.path.dirname(sys.argv[0]), 'config.' + profile_name)

sys.stdout.write ('\nwriting configuration to file \'' + cache_filename + '\': ')

cache = open (cache_filename, 'w')

cache.write ("""#!/usr/bin/python
#
# autogenerated by MRtrix configure script
#
# configure output:
""")
for line in config_report.splitlines():
  cache.write ('# ' + line + '\n')
cache.write ('\n\n')

path = os.environ['PATH']
if path.endswith ('\\'):
  path = path[:-1]
cache.write ("PATH = r'" + path + "'\n")

commit ('obj_suffix', obj_suffix)
commit ('exe_suffix', exe_suffix)
commit ('lib_prefix', lib_prefix)
commit ('lib_suffix', lib_suffix)
commit ('cpp', cpp);
commit ('cpp_flags', cpp_flags);
commit ('ld', ld);
commit ('ld_flags', ld_flags);
commit ('runpath', runpath);
cache.write ('ld_enabled = ')
if noshared:
  cache.write ('False\n')
else:
  cache.write ('True\n')
  commit ('ld_lib', ld_lib);
  commit ('ld_lib_flags', ld_lib_flags);
commit ('gsl_cflags', gsl_cflags)
commit ('gsl_ldflags', gsl_ldflags)

commit ('moc', moc)
commit ('rcc', rcc)
commit ('qt_cflags', qt_cflags)
commit ('qt_ldflags', qt_ldflags)
cache.write ('nogui = ')
if nogui:
  cache.write ('True\n')
else:
  cache.write ('False\n')

cache.close()
sys.stdout.write ('ok\n\n')