EasyBuild support for GAMESS-US

GAMESS-US-20100325-r2-ictce-3.2.1.015.u4.eb

name='GAMESS-US'
version='20100325-r2'

homepage='http://www.msg.ameslab.gov/gamess/'
description="""The General Atomic and Molecular Electronic Structure System (GAMESS)
is a general ab initio quantum chemistry package."""

toolkit={'name':'ictce','version':'3.2.1.015.u4'}
toolkitopts={'usempi':True}

sources=['%s-%s.tar.gz'%(name.lower().split('-')[0],version)]

# the two following values can be set optionally
# if not set, default values are: maxcpus=8 and maxnodes=128
#maxcpus=8
#maxnodes=128

gamess_us.py

import os, shutil, re, glob, fileinput, sys
from distutils.version import LooseVersion
from easybuild.apps.Application import Application
from easybuild.buildsoft.fileTools import runrun, runqanda, convertName, unpack

class GAMESS_US(Application):
    def __init__(self,*args,**kwargs):
        """constructor, overwritten from Application to add extra attributes"""
        Application.__init__(self, args,kwargs)
      
        self.cfg.update({'maxcpus':[None,"(default: None)"],
                         'maxnodes':[None,"(default: None)"],
                         })
        

    def configure(self):
        pass

    def make(self):
        # 1) compiling the source code activator
        actvtecode = os.path.join(self.builddir, 'gamess', 'tools', 'actvte.code')
        try:
            f = open(actvtecode, 'r')
            origcontent = f.readlines()
            f.close()
        except Exception, err:
            self.log.error("Can't read from file %s: %s" % (actvtecode, err))

        unxreg = re.compile(r"^\*UNX", re.M)

        actvtef = os.path.join(self.builddir, 'gamess', 'tools', 'actvte.f')
        try:
            f = open(actvtef, 'w')
            for line in origcontent:
                newline = unxreg.sub('    ', line) + '\n'
                f.write(newline)
            f.close()
        except Exception, err:
            self.log.error("Can't write to file %s: %s" % (actvtef, err))

        try:
            cmd = "ifort -o tools/actvte.x tools/actvte.f"
            runrun(cmd, logall=True, simple=True)
        except Exception, err:
            self.log.error("Something went wrong during compilation of %s" % actvtef)

        # 2) creating the install.info file
        # timestamp
        import datetime
        timestamp = datetime.datetime.now()

        # machinetype
        import platform
        machine = platform.machine()
        system = platform.system()
        if machine == 'x86_64' and system == 'Linux':
            machinetype = "linux64"
        else:
            self.log.error("Unanticipated target machine: %s-%s. You should probably extend the easybuild functionality" % (machine, system))

        # compiler and mathematical library (and message passing model) setup
        fortrancompiler = os.environ['F77']
        self.log.info("The %s fortran compiler will be used for compilation" % fortrancompiler)
        if fortrancompiler[:3] == 'mpi': 
            shortcomp = fortrancompiler[3:]
        else: 
            shortcomp = fortrancompiler
        fortranverno = os.environ['SOFTVERSION%s' % shortcomp.upper()].split('.')[0]
        self.log.info("Version %s of this fortran compiler will be used for compilation" % fortranverno)
        if self.tk.name in ['ictce', 'ismkl']:
            mathlib = 'mkl'
            # old ictce toolkits (3.1.x, 3.2.x)
            #mathlibpath = os.path.join(os.environ['SOFTROOTIMKL'],'lib',mkllibversion)
            # new ictce toolkits (4.0.x)
            mathlibpath = os.path.join(os.environ['SOFTROOTIMKL'], 'mkl', 'lib', 'intel64')
            mklverno = os.environ['SOFTVERSIONIMKL'].split('.')[0]
            commtype = 'mpi'
            if self.tk.name == 'ictce':
                mpilib = 'impi'
                mpilibpath = os.environ['SOFTROOTIMPI']
            elif self.tk.name == 'ismkl':
                mpilib = 'mpich2'
                mpilibpath = os.environ['SOFTROOTMPICH2']
            else:
                self.log.error("Don't know which MPI lib is included in %s toolkit" % self.tk.name)
        else:
            self.log.error("Unanticipated toolkit: %s. You should probably extend the easybuild functionality" % (self.tk.name))

        text = """#!/bin/csh
#   compilation configuration for GAMESS
#   generated with easybuild
#   generated at %(timestamp)s
setenv GMS_PATH            %(builddir)s
#         machine type
setenv GMS_TARGET          %(machinetype)s
#         FORTRAN compiler setup
setenv GMS_FORTRAN         %(fortrancompiler)s
setenv GMS_IFORT_VERNO     %(fortranverno)s
#         mathematical library setup
setenv GMS_MATHLIB         %(mathlib)s
setenv GMS_MATHLIB_PATH    %(mathlibpath)s
setenv GMS_MKL_VERNO       %(mklverno)s
#         parallel message passing model setup
setenv GMS_DDI_COMM        %(commtype)s
setenv GMS_MPI_LIB         %(mpilib)s
setenv GMS_MPI_PATH        %(mpilibpath)s
"""
        installinfo = text % {'timestamp':timestamp,
                            'builddir':os.path.join(self.builddir, 'gamess'),
                            'machinetype':machinetype,
                            'fortrancompiler':fortrancompiler, 'fortranverno':fortranverno,
                            'mathlib':mathlib, 'mathlibpath':mathlibpath, 'mklverno':mklverno,
                            'commtype':commtype, 'mpilib':mpilib, 'mpilibpath':mpilibpath}

        installinfofile = "install.info"
        self.log.info("The install.info script used for this build has the following content:\n%s" % installinfo)
        try:
            f = open(installinfofile, 'w')
            f.write(installinfo)
            f.close()
        except Exception, err:
            self.log.error("Can't write to file %s: %s" % (installinfofile, err))

        # 3) adapting and executing the compddi file
        maxcpusreg = re.compile(r"^set MAXCPUS.*$", re.M)
        if self.getCfg("maxcpus"): 
            maxcpusrepl = "set MAXCPUS = %s\n" % self.getCfg("maxcpus")

        maxnodesreg = re.compile(r"^set MAXNODES.*$", re.M)
        if self.getCfg("maxnodes"): 
            maxnodesrepl = "set MAXNODES = %s\n" % self.getCfg("maxnodes")

        ccreg = re.compile(r"'gcc'")
        if self.tk.name in ['ictce', 'ismkl']: 
            ccrepl = "'%s'" % os.getenv('MPICC')

        ffreg = re.compile(r"ifort")
        if fortrancompiler == 'mpiifort': 
            ffrepl = "mpiifort"

        compddi = os.path.join(self.builddir, 'gamess', 'ddi', 'compddi')
        try:
            f = open(compddi, 'r')
            origcontent = f.read()
            f.close()
        except Exception, err:
            self.log.error("Can't read from file %s: %s" % (compddi, err))

        try:
            os.remove(compddi)
        except Exception, err:
            self.log.error("It is not possible to remove the old version of %s" % compddi)

        try:
            f = open(compddi, 'w')
            if self.tk.name in ['ictce', 'ismkl']: origcontent = ccreg.sub(ccrepl, origcontent)
            if self.getCfg("maxcpus"): 
                origcontent = maxcpusreg.sub(maxcpusrepl, origcontent)
            if self.getCfg("maxnodes"): 
                origcontent = maxnodesreg.sub(maxnodesrepl, origcontent)
            if fortrancompiler == 'mpiifort': origcontent = ffreg.sub(ffrepl, origcontent)
            f.write(origcontent)
            f.close()
            self.log.info("New version of file %s successfully written" % compddi)
        except Exception, err:
            self.log.error("Can't write to file %s: %s" % (compddi, err))

        try:
            os.chmod(compddi, 0755)
            self.log.info("The script %s has been made executable" % compddi)
        except:
            self.log.error('Something went wrong while trying to make %s executable.' % compddi)

        try:
            cmd = "%s" % compddi
            runrun(cmd, logall=True, simple=True)
        except Exception, err:
            self.log.error("Something went wrong during compilation of %s" % compddi)

        newlib = os.path.join(self.builddir, 'gamess', 'ddi', 'libddi.a')
        if not os.path.isfile(newlib):
            self.log.error("the libddi.a library (%s) was never built" % compddi)
        else: self.log.info("the libddi.a library (%s) was successfully built." % compddi)

        # 4) Compiling all of the GAMESS source code
        compall = os.path.join(self.builddir, 'gamess', 'compall')
        comp = os.path.join(self.builddir, 'gamess', 'comp')
        try:
            f = open(comp, 'r')
            origcontent = f.read()
            f.close()
        except Exception, err:
            self.log.error("Can't read from file %s: %s" % (comp, err))

        try:
            os.remove(comp)
        except Exception, err:
            self.log.error("It is not possible to remove the old version of %s" % comp)

        try:
            f = open(comp, 'w')
            if fortrancompiler == 'mpiifort': origcontent = ffreg.sub(ffrepl, origcontent)
            f.write(origcontent)
            f.close()
            self.log.info("New version of file %s successfully written" % comp)
        except Exception, err:
            self.log.error("Can't write to file %s: %s" % (comp, err))

        try:
            os.chmod(comp, 0755)
            self.log.info("The script %s has been made executable" % comp)
        except:
            self.log.error('Something went wrong while trying to make %s executable.' % comp)

        try:
            cmd = "%s" % compall
            runrun(cmd, logall=True, simple=True)
        except Exception, err:
            self.log.error("Something went wrong during compilation of %s" % compall)

        # 5) Link an executable form of GAMESS
        lked = os.path.join(self.builddir, 'gamess', 'lked')
        try:
            f = open(lked, 'r')
            origcontent = f.read()
            f.close()
        except Exception, err:
            self.log.error("Can't read from file %s: %s" % (lked, err))

        try:
            os.remove(lked)
        except Exception, err:
            self.log.error("It is not possible to remove the old version of %s" % lked)

        try:
            f = open(lked, 'w')
            if fortrancompiler == 'mpiifort': origcontent = ffreg.sub(ffrepl, origcontent)
            f.write(origcontent)
            f.close()
            self.log.info("New version of file %s successfully written" % lked)
        except Exception, err:
            self.log.error("Can't write to file %s: %s" % (lked, err))

        try:
            os.chmod(lked, 0755)
            self.log.info("The script %s has been made executable" % lked)
        except:
            self.log.error('Something went wrong while trying to make %s executable.' % lked)

        try:
            cmd = "%s gamess mpi" % lked
            runrun(cmd, logall=True, simple=True)
        except Exception, err:
            self.log.error("Something went wrong during compilation of %s" % lked)

        executable = os.path.join(self.builddir, 'gamess', 'gamess.mpi.x')
        if not os.path.isfile(executable):
            self.log.error("the executable (%s) was never built" % executable)

    def makeInstall(self):
        try:
            shutil.copytree(os.path.join(self.builddir, 'gamess', 'tests'), os.path.join(self.installdir, 'tests'))
            shutil.copytree(os.path.join(self.builddir, 'gamess', 'graphics'), os.path.join(self.installdir, 'graphics'))
            mcpdatadir = os.path.join(self.builddir, 'gamess', 'mcpdata')
            if os.path.isdir(mcpdatadir):
                shutil.copytree(mcpdatadir, os.path.join(self.installdir, 'mcpdata'))
            auxdatadir = os.path.join(self.builddir, 'gamess', 'auxdata')
            if os.path.isdir(auxdatadir):
                shutil.copytree(auxdatadir, os.path.join(self.installdir, 'auxdata'))
            shutil.copytree(os.path.join(self.builddir, 'gamess', 'qmnuc'), os.path.join(self.installdir, 'qmnuc'))
            shutil.copytree(os.path.join(self.builddir, 'gamess', 'misc'), os.path.join(self.installdir, 'misc'))
            shutil.copytree(os.path.join(self.builddir, 'gamess', 'tools'), os.path.join(self.installdir, 'tools'))
        except Exception, err:
            self.log.error("Something went wrong during dir copying to installdir: %s" % err)

        try:
            dst = os.path.join(self.installdir, 'bin')
            os.mkdir(dst)
            shutil.copy2(os.path.join(self.builddir, 'gamess', 'gamess.mpi.x'), dst)
        except:
            self.log.error("Copying gamess.mpi.x executable to installation dir %s failed." % dst)

    def makeModuleReq(self):
        txt = """
setenv GAMESSUSROOT $root\n
prepend-path PATH $root/bin\n
"""
        return txt

Updated easyblock, contains some OS X specific hardcodings:

##
# Copyright 2009-2014 Ghent University
#
# This file is part of EasyBuild,
# originally created by the HPC team of Ghent University (http://ugent.be/hpc/en),
# with support of Ghent University (http://ugent.be/hpc),
# the Flemish Supercomputer Centre (VSC) (https://vscentrum.be/nl/en),
# the Hercules foundation (http://www.herculesstichting.be/in_English)
# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
#
# http://github.com/hpcugent/easybuild
#
# EasyBuild is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation v2.
#
# EasyBuild is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with EasyBuild.  If not, see <http://www.gnu.org/licenses/>.
##
"""
EasyBuild support for building and installing GAMESS-US, implemented as an easyblock

@author: Stijn De Weirdt (Ghent University)
@author: Dries Verdegem (Ghent University)
@author: Kenneth Hoste (Ghent University)
@author: Pieter De Baets (Ghent University)
@author: Jens Timmerman (Ghent University)
@author: Toon Willems (Ghent University)
"""
import fileinput
import os
import re
import shutil
import sys

from easybuild.framework.easyblock import EasyBlock
from easybuild.framework.easyconfig import CUSTOM, MANDATORY
from easybuild.tools.filetools import mkdir
from easybuild.tools.modules import get_software_root, get_software_version
from easybuild.tools.run import run_cmd
from easybuild.tools.systemtools import get_avail_core_count, get_platform_name
from easybuild.tools import toolchain


class EB_GAMESS_minus_US(EasyBlock):
    """Support for building/installing GAMESS-US."""

    @staticmethod
    def extra_options():
        """Define custom easyconfig parameters for GAMESS-US."""
        extra_vars = {
            'ddi_comm': ['mpi', "DDI communication layer to use", CUSTOM],
            'maxcpus': [None, "Maximum number of cores per node", MANDATORY],
            'maxnodes': [None, "Maximum number of nodes", MANDATORY],
        }
        return EasyBlock.extra_options(extra_vars)

    def configure_step(self):
        """Custom configure procedure for GAMESS-US."""

        # copy, edit and build the source code activator
        actvtecode = os.path.join(self.cfg['start_dir'], 'tools', 'actvte.code')
        actvtef = os.path.join(self.cfg['start_dir'], 'tools', 'actvte.f')
        try:
            shutil.copy2(actvtecode, actvtef)
            for line in fileinput.input(actvtef, inplace=1, backup='.orig'):
                # uncomment lines by replacing '*UNX' with 4 spaces
                line = re.sub(r"^\*UNX", ' '*4, line)
                sys.stdout.write(line)
        except (IOError, OSError), err:
            self.log.error("Failed to create %s: %s" % (actvtef, err))

        try:
            cmd = "%s -o tools/actvte.x tools/actvte.f" % os.environ['F77']
            run_cmd(cmd, log_all=True, simple=True)
        except Exception, err:
            self.log.error("Something went wrong during compilation of %s" % actvtef)

        # creating the install.info file
        platform_name = get_platform_name()
        x86_64_linux_re = re.compile('^x86_64-.*-linux$')
        if x86_64_linux_re.match(platform_name) or platform_name == 'x86_64-apple-darwin':  # FIXME
            machinetype = "linux64"
        else:
            self.log.error("Build target %s currently unsupported" % platform_name)

        # compiler config
        comp_fam = self.toolchain.comp_family()
        fortran_comp, fortran_ver = None, None
        if comp_fam == toolchain.INTELCOMP:
            fortran_comp = 'ifort'
            fortran_ver = get_software_version('ifort')
        elif comp_fam == toolchain.GCC:
            fortran_comp = 'gfortran'
            fortran_ver = '.'.join(get_software_version('GCC').split('.')[:2])
        else:
            self.log.error("Compiler family %s currently unsupported." % comp_fam)

        # math library config
        known_mathlibs = ['imkl', 'OpenBLAS', 'ATLAS', 'ACML']
        mathlib, mathlib_ver, mathlib_path = None, None, None
        for mathlib in known_mathlibs:
            mathlib_ver = get_software_version(mathlib)
            if mathlib_ver is not None:
                mathlib_path = os.environ['LAPACK_LIB_DIR'].split(os.pathsep)[0]
                break
        if mathlib_ver is None:
            self.log.error("None of the know math libraries (%s) available, giving up." % known_mathlibs)
        if mathlib == 'imkl':
            mathlib = 'mkl'
        elif mathlib == 'OpenBLAS':
            mathlib = 'blas'  # FIXME, only for old GAMESS-US versions?

        # MPI library config
        known_mpilibs = ['impi', 'OpenMPI', 'MVAPICH2', 'MPICH2']
        mpilib, mpilib_path = None, None
        for mpilib in known_mpilibs:
            mpilib_path = get_software_root(mpilib)
            if mpilib_path is not None:
                break
        if mpilib_path is None:
            self.log.error("None of the known MPI libraries (%s) available, giving up." % known_mpilibs)

        # verify selected DDI communication layer
        known_ddi_comms = ['mpi', 'mixed', 'shmem', 'sockets']
        if not self.cfg['ddi_comm'] in known_ddi_comms:
            tup = (known_ddi_comms, self.cfg['ddi_comm'])
            self.log.error("Unsupported DDI communication layer specified (known: %s): %s" % tup)

        install_info = {
            'GMS_BUILD_DIR': self.cfg['start_dir'],
            'GMS_PATH': self.cfg['start_dir'],
            'GMS_TARGET': machinetype,
            'GMS_FORTRAN': os.environ['F77'],
            'GMS_%s_VERNO' % fortran_comp.upper(): fortran_ver,
            'GMS_MATHLIB': mathlib.lower(),
            'GMS_MATHLIB_PATH': mathlib_path,
            'GMS_DDI_COMM': self.cfg['ddi_comm'],
            'GMS_MPI_LIB': mpilib.lower(),
            'GMS_MPI_PATH': mpilib_path,
        }
        if mathlib == 'mkl':
            install_info.update({'GMS_MKL_VERNO': mathlib_ver})

        install_info_lines = [
            "#!/bin/csh",
            "# Build configuration from GAMESS-US",
            "# generated by EasyBuild",
        ]
        for key, val in sorted(install_info.items()):
            setenv = "setenv %s\t\t%s" % (key, val)
            install_info_lines.append("setenv %s\t\t%s" % (key, val))
        install_info_txt = '\n'.join(install_info_lines) + '\n'  # each line *must* end with newline in a csh script

        install_info_fp = "install.info"
        tup = (install_info_fp, install_info_txt)
        self.log.info("The %s script used for this build has the following content:\n%s" % tup)
        try:
            f = open(install_info_fp, 'w')
            f.write(install_info_txt)
            f.close()
        except IOError, err:
            self.log.error("Failed to create %s: %s" % (install_info_fp, err))

        # adapt and execute the compddi file
        compddi = os.path.join(self.cfg['start_dir'], 'ddi', 'compddi')
        try:
            maxcpus_re = re.compile(r"^set MAXCPUS.*", re.M)
            set_maxcpus = "set MAXCPUS = %s" % self.cfg['maxcpus']
            maxnodes_re = re.compile(r"^set MAXNODES.*", re.M)
            set_maxnodes = "set MAXNODES = %s" % self.cfg['maxnodes']
            cc_re = re.compile(r"set CC = \S*")
            set_cc = "set CC = '%s'" % os.environ['MPICC']
            f77_re = re.compile(r"case %s\s*:" % os.environ['F77_SEQ'])
            case_f77 = "case %s:" % os.environ['F77']
            for line in fileinput.input(compddi, inplace=1, backup='.orig'):
                # set MAXCPUS/MAXNODES as configured
                line = maxcpus_re.sub(set_maxcpus, line)
                line = maxnodes_re.sub(set_maxnodes, line)
                # adjust hardcoded settings for C compiler
                line = cc_re.sub(set_cc, line)
                # make sure switch statements also work when $F77 is an MPI compiler wrapper
                if os.environ['F77'].startswith('mpi'):
                    line = f77_re.sub(case_f77, line)
                sys.stdout.write(line)
        except IOError, err:
            self.log.error("Failed to patch %s: %s" % (compddi, err))

        run_cmd(compddi, log_all=True, simple=True)

        # make sure the libddi.a library is present
        libddi = os.path.join(self.cfg['start_dir'], 'ddi', 'libddi.a')
        if not os.path.isfile(libddi):
            self.log.error("The libddi.a library (%s) was never built" % libddi)
        else:
            self.log.info("The libddi.a library (%s) was successfully built." % libddi)

    def build_step(self):
        """Custom build procedure for GAMESS-US."""
        # patch comp/lked scripts if required (if $F77 is an MPI command wrapper)
        comp = os.path.join(self.cfg['start_dir'], 'comp')
        lked = os.path.join(self.cfg['start_dir'], 'lked')
        if os.environ['F77'].startswith('mpi'):
            f77_re = re.compile(r"case %s\s*:" % os.environ['F77_SEQ'])
            case_f77 = "case %s:" % os.environ['F77']
            for line in fileinput.input(comp, inplace=1, backup='.orig'):
                line = f77_re.sub(case_f77, line)
                sys.stdout.write(line)
            for line in fileinput.input(lked, inplace=1, backup='.orig'):
                line = f77_re.sub(case_f77, line)
                sys.stdout.write(line)

        compall = os.path.join(self.cfg['start_dir'], 'compall')
        run_cmd(compall, log_all=True, simple=True)

        cmd = "%s gamess mpi" % lked
        run_cmd(cmd, log_all=True, simple=True)

        # sanity check for gamess executable
        executable = os.path.join(self.builddir, 'gamess', 'gamess.%s.x' % self.cfg['ddi_comm'])
        if not os.path.isfile(executable):
            self.log.error("the executable (%s) was never built" % executable)

    def install_step(self):
        """Custom install procedure for GAMESS-US (copy files/directories to install dir)."""
        try:
            for subdir in ['auxdata', 'graphics', 'mcpdata', 'misc', 'qmnuc', 'tests', 'tools']:
                srcpath = os.path.join(self.cfg['start_dir'], subdir)
                if os.path.exists(srcpath):
                    shutil.copytree(srcpath, os.path.join(self.installdir, subdir))
                bindir = os.path.join(self.installdir, 'bin')
                mkdir(bindir)
                shutil.copy2(os.path.join(self.cfg['start_dir'], 'gamess.%s.x' % self.cfg['ddi_comm']), bindir)
        except OSError, err:
            self.log.error("Failed to install GAMESS-US by copying files/directories: %s" % err)

    def make_module_extra(self):
        """Define GAMESS-US specific variables in generated module file, i.e. $GAMESSUSROOT."""
        txt = super(EB_GAMESS_minus_US, self).make_module_extra()
        txt += self.moduleGenerator.set_environment('GAMESSUSROOT', '$root')
        return txt

easyconfig + TMP patch:

name = 'GAMESS-US'
version = '20130501-R1'

homepage = 'http://www.msg.ameslab.gov/gamess/'
description = """The General Atomic and Molecular Electronic Structure System (GAMESS)
 is a general ab initio quantum chemistry package."""

toolchain = {'name': 'goolf', 'version': '1.5.14-no-OFED'}
toolchainopts = {'usempi': True, 'optarch': False}

# manually download via http://www.msg.chem.iastate.edu/gamess/download.html (requires registration)
sources = ['gamess-%(version)s.tar.gz']
patches = ['gamess_TMP.patch']

maxcpus = 4
maxnodes = 1

moduleclass = 'chem'

--- gamess/compall.orig 2014-06-11 18:37:54.000000000 +0200
+++ gamess/compall  2014-06-11 18:40:44.000000000 +0200
@@ -97,7 +97,7 @@
 #      Debian uses the -m flag, since its -p replies "unknown"
 #      Gentoo uses the -m flag, since its -p gives an unusable multiword reply
 if ($TARGET == linux64) then
-   set chip=(`uname -p`)
+   set chip=(`uname -m`)
    if (${#chip} > 1) set chip=unknown
    if ($chip == unknown) set chip=`uname -m`
    if ($chip == x86_64) set extraflags='-DLINUX64 -m64'
--- gamess/comp.orig    2014-06-11 21:26:28.000000000 +0200
+++ gamess/comp 2014-06-11 21:26:03.000000000 +0200
@@ -1806,6 +1804,8 @@
             breaksw
          case 4.6:
          case 4.7:
+         case 4.8:
+         case 4.9:
             set EXTRAOPT="$EXTRAOPT -fno-whole-file"
             breaksw
          default:
--- gamess/source/zunix.c.orig  2014-06-12 08:52:56.000000000 +0200
+++ gamess/source/zunix.c   2014-06-12 08:53:05.000000000 +0200
@@ -443,7 +443,7 @@
 #ifdef LINUX64

 #include <stdlib.h>
-#include <malloc.h>
+#include <malloc/malloc.h>

 #define FORTINT long