configure

#!/usr/bin/env python

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


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

for arg in sys.argv[1:]:
  if '-debug'.startswith (arg): debug = True
  elif '-dev'.startswith (arg): dev = True
  elif '-assert'.startswith (arg): asserts = 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] [-assert] [-profile] [-nogui] [-noshared]

In most cases, a simple invocation should work:

   $ ./configure

By default, this creates a target folder named 'release', and a 'config' file
within that folder. All intermediate files will be placed within the target
folder to avoid conflict with any other configurations. If a name is provided,
the configuration will be written to a different folder, which can then be used
by the build script. For example:

   $ ./configure testing -debug -assert

will generate the folder 'testing' and a config file with debugging symbols and
assertions enabled, which can be used with the build script as follows:

   $ ./build testing

By default, the build script will compile the 'release' folder.

Note that naming a target folder does *not* set any compiler flags. These are
modified by command-line options or environment variables. It is perfectly
valid to use non-standard options with a default ('release') target folder, or
standard options in a named target folder. For instance:

   $ ARCH=x86-84 ./configure -noshared

will produce a 'release' (the default name) target folder with non-default
compiler options, while:

   $ ./configure normal

will produce a target folder named 'normal' using default compiler settings.


OPTIONS:

    -debug       enable debugging symbols.

    -assert      enable all assert() and related checks.

    -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.

    -dev         enable the extended development build process


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++-5.5 ./configure

Alternatively:
   $ export CXX=/usr/local/bin/g++-5.5
   $ ./configure

Multiple environment variables can be set this way as needed. 
The following environment variables are available:

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 the same as CXX.

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.

EIGEN_CFLAGS    Any flags required to compile with Eigen3.
                This may include in particular the path to the
                include files, if not in a standard location
                For example:
                $ EIGEN_CFLAGS="-isystem /usr/local/include/eigen3" ./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.

QMAKE           The command to invoke Qt's qmake (default: 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 be stored in the config file and used
                during subsequent invocations of the build process. It only
                needs to be specified correctly at configure time.
""")
    sys.exit (0)


if not profile_name:
  profile_name = 'release'


try:
  os.makedirs (profile_name)
except OSError:
  if not os.path.isdir (profile_name):
    raise


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 asserts: report (' with asserts')
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 = [ ]

eigen_cflags = []

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


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



# error handling helpers:

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

def compiler_hint (cmd, flags_var, flags, args_var=None, args=None):
  ret='''

  Set the '''+ flags_var + ''' environment variable to inform 'configure' of the path to the
  ''' + cmd + ''' on your system, as follows:
    $ export ''' + flags_var + '=' + flags + '''
    $./configure
  (amend with the actual path to the ''' + cmd + ''' on your system)
'''
  if args_var is not None:
    ret += '''
  If you are using a ''' + cmd + ' other than gcc, you can also set the ' + args_var + '''
  environment variable to specify how your ''' + cmd + ''' expects different arguments
  to be presented on the command line, for instance as follows:
    $ export ''' + args_var + '=' + args + '''
    $ ./configure
'''
  return ret
 
def compiler_flags_hint (name, var, flags):
  return '''

  Set the ''' + var + ''' environment variable to inform 'configure' of
  the flags it must provide to the compiler in order to compile
  programs that use ''' + name + ''' functionality; this may include the path to
  the ''' + name + ''' include files, as well as any required flags.
  For example:
    $ export ''' + var + '=' + flags + '''
    $./configure
  (amend with the actual path to the ''' + name + ''' include files on your system)
'''
 
def linker_flags_hint (name, var, flags):
  return '''

  Set the ''' + var + ''' environment variable to inform 'configure' of
  the flags it must provide to the linker in order to link
  programs that use ''' + name + ''' functionality; this may include the path to
  the ''' + name + ''' libraries, as well as any required flags.
  For example:
    $ export ''' + var + '=' + flags + '''
    $./configure
  (amend with the actual path to the ''' + name + ''' library file on your system)
'''

configure_log_hint='''

  See the file 'configure.log' for details. If this doesn't help and you need
  further assistance, please post on the MRtrix3 community forum
  (http://community.mrtrix.org/), and make sure to include the full contents of
  the 'configure.log' file.
'''

qt_path_hint='''

  Make sure your PATH environment variable includes the location of the correct 
  version of this command, for example:
    $ export PATH=/opt/qt5/bin:$PATH
    $./configure
  (amend with the actual path to the Qt executables on your system)
'''

def qt_exec_hint (name):
  return '''

  If your PATH already includes the correct location, but there are several
  versions of the command available, use the ''' + name.upper() + ''' environment variable to inform
  'configure' of the correct version, for example:
    $ export '''+ name.upper() + '=' + name + '''-qt5
    $./configure
  (amend with the actual name of (or full path to) Qt's ''' + name + ''' on your system)
'''




# other helper functions:

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', '-Wa,-mbig-obj' ]
  exe_suffix = '.exe'
  lib_prefix = ''
  lib_suffix = '.dll'
  ld_flags += [ '-pthread', '-Wl,--allow-multiple-definition' ]
  ld_lib_flags += [ '-pthread', '-shared' ]
  runpath = ''
elif system == 'darwin':
  if 'MACOSX_DEPLOYMENT_TARGET' in os.environ and 'QMAKE_MACOSX_DEPLOYMENT_TARGET' in os.environ:
    if not os.environ['QMAKE_MACOSX_DEPLOYMENT_TARGET'] == os.environ['MACOSX_DEPLOYMENT_TARGET']:
      error ('environment variables QMAKE_MACOSX_DEPLOYMENT_TARGET and MACOSX_DEPLOYMENT_TARGET differ')
    macosx_version = os.environ['MACOSX_DEPLOYMENT_TARGET']
  elif 'QMAKE_MACOSX_DEPLOYMENT_TARGET' in os.environ:
    macosx_version = os.environ['QMAKE_MACOSX_DEPLOYMENT_TARGET']
  elif 'MACOSX_DEPLOYMENT_TARGET' in os.environ:
    macosx_version = os.environ['MACOSX_DEPLOYMENT_TARGET']
  else:
    macosx_version =  ('.'.join(execute([ 'sw_vers', '-productVersion' ], RuntimeError)[1].split('.')[:2]))
  report ('OS X deployment target: ' +  macosx_version + '\n')
  cxx = [ 'clang++' ]
  cpp_flags += [ '-DMRTRIX_MACOSX', '-fPIC', '-mmacosx-version-min='+macosx_version ]
  ld_flags += [ '-mmacosx-version-min='+macosx_version ]
  ld_lib_flags += [ '-dynamiclib', '-install_name', '@rpath/LIBNAME', '-mmacosx-version-min='+macosx_version ]
  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!

  MRtrix3 was unable to find an appropriate C++11 compiler.''' + compiler_hint ('compiler', 'CXX', '/usr/bin/g++-5.5') + configure_log_hint)

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!

  MRtrix3 was unable to compile a simple C++ program.''' + compiler_hint ('compiler', 'CXX', '/usr/bin/g++-5.5', 'CXX_ARGS', '"-c CFLAGS SRC -o OBJECT"') + configure_log_hint)
except (LinkError, RuntimeError):
  error ('''linking error!

  MRtrix3 was unable to find an appropriate C++ linker.''' + compiler_hint ('linker', 'LD', '/usr/bin/g++-5.5', 'LD_ARGS', '"LDFLAGS OBJECTS -o EXECUTABLE"') + configure_log_hint)
except:
  error (' unexpected exception!' + configure_log_hint)







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!' + configure_log_hint)




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 ('''error compiling zlib application!

  MRtrix3 was unable to compile a test program involving zlib.''' + compiler_flags_hint ('zlib', 'ZLIB_CFLAGS', '"-isystem /usr/local/include"'))
except LinkError:
  error ('''linker error!

  MRtrix3 was unable to link a test program involving zlib.''' + linker_flags_hint ('zlib', 'ZLIB_LDFLAGS', '"-L/usr/local/lib -lz"'))
except RuntimeError:
  error ('''runtime error!

 Unable to configure zlib''' + configure_log_hint)
except:
  error ('unexpected exception!' + configure_log_hint)

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





# Eigen3 flags:

report('Checking for Eigen 3 library: ')
if 'EIGEN_CFLAGS' in os.environ.keys():
  eigen_cflags = shlex.split (os.environ['EIGEN_CFLAGS'])
else:
  try:
    eigen_cflags = []
    for entry in shlex.split (execute ([ 'pkg-config', '--cflags', 'eigen3' ], RuntimeError)[1]):
      if entry.startswith ('-I'):
        eigen_cflags += [ '-isystem', entry[2:] ]
      else:
        eigen_cflags += [ entry ]
  except:
    log('error running on pkg-config --cflags eigen3\n\n')

try:
  eigen_version = compile ('''
#include <Eigen/Core>
#include <iostream>

int main (int argc, char* argv[]) {
  std::cout << EIGEN_WORLD_VERSION << "." << EIGEN_MAJOR_VERSION << "." << EIGEN_MINOR_VERSION << "\\n";
  return 0;
}
''', cpp_flags + eigen_cflags, ld_flags)

  cpp_flags += eigen_cflags
  report (eigen_version + '\n')
except CompileError:
  error (''' error compiling Eigen application!

  MRtrix3 was unable to compile a test program involving Eigen3.''' + compiler_flags_hint ('Eigen3', 'EIGEN_CFLAGS', '"-isystem /usr/include/eigen3"'))
except ( LinkError, RuntimeError ) as e:
  error (''' error linking Eigen application!

  This shouldn't happen!''' + configure_log_hint)
except:
  error ('unexpected exception!' + configure_log_hint)






# 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!' + configure_log_hint)
      except:
        error ('unexpected exception!' + configure_log_hint)
      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!

  MRtrix3 was unable to employ the linker program for shared library generation.''' + compiler_hint ('shared library linker', 'LDLIB_FLAGS', '"-L/usr/local/lib"', 'LDLIB_ARGS', '"-shared LDLIB_FLAGS OBJECTS -o LIB"'))
        except:
          error ('unexpected exception!' + configure_log_hint)

        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:
      raise VersionError
  except VersionError:
    error (''' Qt moc version is too old!

  The version number reported by the Qt moc command is too old.''' + qt_path_hint + qt_exec_hint ('moc'))
  except OSError:
    error (''' Qt moc not found!

  MRtrix3 was unable to locate the Qt meta-object compiler 'moc'.''' + qt_path_hint)
  except:
    error ('unexpected exception!' + configure_log_hint)

  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:
      raise VersionError
  except VersionError:
    error (''' Qt qmake version is too old!

  The version number reported by the Qt qmake command is too old.''' + qt_path_hint + qt_exec_hint ('qmake'))
  except OSError:
    error (''' Qt qmake not found!

  MRtrix3 was unable to locate the Qt command 'qmake'.''' + qt_path_hint)
  except:
    error ('unexpected exception!' + configure_log_hint)
  
  
  
  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:
      raise VersionError
  except VersionError:
    error (''' Qt rcc version is too old!

  The version number reported by the Qt rcc command is too old.''' + qt_path_hint + qt_exec_hint ('rcc'))
  except OSError:
    error (''' Qt rcc not found!

  MRtrix3 was unable to locate the Qt command 'rcc'.''' + qt_path_hint)
  except:
    error ('unexpected exception!' + configure_log_hint)




  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'
      if system == "darwin":
        file += 'QMAKE_MACOSX_DEPLOYMENT_TARGET = '+macosx_version + '\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.':
          entry = entry.replace('\"','').replace("'",'')
          if entry.startswith('-I'):
            qt_cflags += [ '-isystem', entry[2:] ]
          else:
            qt_cflags += [ entry ]

      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' ]
      execute (cmd, QMOCError, cwd=qt_dir.name) #process = subprocess.Popen (cmd, cwd=qt_dir.name, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

      cmd = cxx + [ '-c' ] + cpp_flags + qt_cflags + [ 'qt.cpp', '-o', 'qt.o' ]
      execute (cmd, CompileError, cwd=qt_dir.name)

      cmd = cxx + [ '-c' ] + cpp_flags + qt_cflags + [ 'qt_moc.cpp', '-o', 'qt_moc.o' ]
      execute (cmd, CompileError, cwd=qt_dir.name)

      cmd = cxx + ld_flags + [ 'qt_moc.o', 'qt.o', '-o', 'qt' ] + qt_ldflags
      execute (cmd, LinkError, cwd=qt_dir.name)

      cmd = [ os.path.join(qt_dir.name, 'qt') ]
      ret = execute (cmd, RuntimeError)
      report (ret[1])


  except QMakeError:
    error ('error invoking Qt qmake!' + configure_log_hint)
  except QMOCError:
    error ('error invoking Qt moc!' + configure_log_hint)
  except LinkError:
    error ('error linking Qt application!' + configure_log_hint)
  except CompileError:
    error ('error compiling Qt application!' + configure_log_hint)
  except RuntimeError:
    error ('error running Qt application!' + configure_log_hint)
  except OSError as e:
    error ('unexpected error: ' + str(e) + configure_log_hint)
  except:
    error ('unexpected exception!' + configure_log_hint)





  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 = [ '-isystem', '/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!

  MRtrix3 encountered an error when testing compilation of MRtrix as an R module.''' + compiler_hint ('R', 'R_CFLAGS', '"-isystem /usr/local/include/R"'))
  except LinkError:
    error ('''linker error!'

  MRtrix3 encountered an error when testing linking of MRtrix as an R module.''' + linker_flags_hint ('R', 'R_LDFLAGS', '"-L/usr/local/R/lib -lR"'))
  except RuntimeError:
    error ('error running command!' + configure_log_hint)
  except: 
    error ('unexpected exception!' + configure_log_hint)

  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' ]
  ld_flags += [ '-g', '-pg' ]
  ld_lib_flags += [ '-g', '-pg' ]
elif debug:
  if os.path.basename(cxx[0]).startswith('g++'):
    cpp_flags += [ '-Og' ]
  else:
    cpp_flags += [ '-O0' ]
  cpp_flags += [ '-g' ]
  ld_flags += [ '-g' ]
  ld_lib_flags += [ '-g' ]
else:
  cpp_flags += [ '-O2' ]

if asserts:
  cpp_flags += [ '-D_GLIBCXX_DEBUG=1', '-D_GLIBCXX_DEBUG_PEDANTIC=1' ]
elif not debug:
  cpp_flags += [ '-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]), profile_name, 'config')

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 ('eigen_cflags', eigen_cflags)

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')

if dev:
  cache.write('bash_completion = True\ncommand_doc = True\n')

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