path: root/mac/make-package

#!/bin/sh

#### make-package: create a Mac OS X package for use by the installer.
#### The installer will place the Emacs OSX application in
#### /Application/Emacs and the rest of emacs in the usual unix places
#### under /usr/local or some other location if specified as the first
#### argument. The disc image will be in the file EmacsInstaller.dmg.
####
#### Upon installation, this will leave two versions of emacs on the
#### computer, 20.7 and 21.1.
####
#### Examples:
#### ./make-package
####     Will create an installer that will place the emacs support
####     files inside /usr/local.
#### ./make-package /usr
####     Will create an installer that will place the emacs support
####     files inside /usr.  This will replace the default version of
####     emacs included with Mac OS X.

# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
#
# This file is part of GNU Emacs.
#
# GNU Emacs 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; either version 3, or (at your option)
# any later version.
#
# GNU Emacs 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 GNU Emacs; see the file COPYING.  If not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
# Boston, MA 02110-1301, USA.
#
# Contributed by Steven Tamm (steventamm@mac.com).

progname="$0"

srcdir="`pwd`/.."
builddir=${srcdir}

## Default location to place it is /usr/local
prefix=/usr/local
appsdir=/Applications
emapp=Emacs.app
with_config=yes
with_app=yes
with_x=no
comp_diskimage=no
self_contained=no
app_symlink=no
full_dist=yes
compressed_dist=no
build_in_place=no
keep_directory=no

ac_prev=
display_usage=false;
config_options=;
while test $# != 0
do
  if test -n "$ac_prev"; then
     eval "$ac_prev=\$1"
     ac_prev=
     continue
  fi
  case $1 in
    -help | --help | --hel | --he | -h)
       display_usage=yes ;;
    -p | -prefix | --p | --prefix)
       ac_prev=prefix ;;
    -p=* | -prefix=* | --p=* | --prefix=*)
       prefix=`expr "x$1" : 'x[^=]*=\(.*\)'` ;;
    --build-in-place | --build-in-place )
       build_in_place=yes ;;
    --build-dir | -build-dir | --builddir | -build-dir)
       build_in_place=no
       ac_prev=builddir;;
    --build-dir=* | -build-dir=* | -builddir=* | --builddir=*)
       build_in_place=no
       builddir=`expr "x$1" : 'x[^=]*=\(.*\)'`;;
    -no-configure | -no-conf | --no-configure | --no-conf | --without-config)
       with_config=no ;;
    -no-app | --no-app | -without-app | --without-app)
       with_app=no ;;
    -without-x | --without-x)
       with_x=no ;;
    -with-x | --with-x)
       with_x=yes
       with_app=no ;;
    --without-full-dist | -without-full-dist | -no-full-dist | -no-full)
       full_dist=no ;;
    --compressed-dist)
       compressed_dist=yes ;;
    --self-contained | -self-contained | --with-self-contained-app | -sc)
       self_contained=yes ;;
    -app-symlink | --app-symlink | -symlink | --symlink | --asl)
       app_symlink=yes ;;
    --keep-dir)
       keep_directory=yes ;;
    -C,* | -c,*)
       config_options="$config_options `expr "x$1" : 'x[^,]*,\(.*\)'`" ;;
    -M,* | -m,*)
       make_options="$make_options `expr "x$1" : 'x[^,]*,\(.*\)'`" ;;
    *)
       display_usage=yes ;;
  esac
  shift
done

if test "$with_x" = "no"; then
   config_options="--without-x $config_options"
fi

if test "$display_usage" = "yes"; then
  cat <<EOF
\`make-package' generates a Mac OS X installer package from an Emacs
distribution.  By default, this first runs ./configure on the emacs
directory.  Then make install to create the emacs distribution.
Then some mac-specific commands to generate the required information
for the mac package.  The installer will, by default, create a
Carbon application called Emacs in the ${appsdir} directory, with the
shared emacs files in /usr/local

Usage: $0 [OPTION]

Options:
  -h, --help              display this help and exit
      --prefix=DIR        Set install location for the Mac OS X package
                          of the emacs related file.  By default /usr/local
      --no-conf           Do not run the configure script before running
                          make install.
      --without-app       Do not create the Emacs application bundle
      --with-x            Setup the install to use X Windows for its
                          windowed display, instead of carbon.  Implies
                          --without-app.
      --without-full-dist Do not include all the .el files in the distribution.
                          This is discouraged except if disk space is critical.
      --compressed-dist   Compress .el and info files in the distribution.
      --app-symlink       Have the Emacs.app executable be a symlink
                          to the install in [prefix]/bin/emacs and have
                          the emacs executable link to emacs-${version}
      --self-contained    Create an Emacs.app that is self-contained;
                          prefix will be ignored and all files installed
                          inside the application
      --build-in-place    Build the application in the source directory
                          instead of a temporary directory.
      --build-dir=DIR     Build the application in the specified directory
                          instead of a temporary directory.  Mutually exclusive
                          with --build-in-place.
  -C,option               Pass option to configure
  -M,option               Pass option to make
EOF
  exit 0
fi

### Exit if a command fails.
#set -e

### Print out each line we read, for debugging's sake.
#set -v

LANGUAGE=C
LC_ALL=C
LC_MESSAGES=
LANG=
export LANGUAGE LC_ALL LC_MESSAGES LANG

## Don't restrict access to any files.
umask 0

### Make sure we're running in the right place.
if [ -f Emacs.pkg ]; then
  echo "${progname}: Package Emacs.pkg already exists.
Perhaps a previous invocation of \`${progname}' failed to clean up after
itself.  Move or delete Emacs.pkg and try again." >&2
  exit 1
fi

if test $with_app == "yes" && [ ! -f ${emapp}/Contents/PkgInfo ]; then
  echo "${progname}: Can't find \`${emapp}/Contents/PkgInfo'" >&2
  echo "${progname} must be run in the \`mac' directory of the Emacs" >&2
  echo "distribution tree.  cd to that directory and try again." >&2
  exit 1
fi

### Check whether file ../lisp/version.el exists.
if [ ! -f ../lisp/version.el ]; then
  echo "${progname}: Can't find \`../lisp/version.el'" >&2
  exit 1
fi

### Find out which version of Emacs this is.
shortversion=`grep 'defconst[	 ]*emacs-version' ../lisp/version.el \
	 | sed -e 's/^.*"\([0-9][0-9]*\.[0-9][0-9]*\).*$/\1/'`
version=`grep 'defconst[	 ]*emacs-version' ../lisp/version.el \
	 | sed -e 's/^[^"]*"\([^"]*\)".*$/\1/'`
if [ ! "${version}" ]; then
  echo "${progname}: can't find current Emacs version in \`./lisp/version.el'" >&2
  exit 1
fi

echo Version numbers are $version and $shortversion

### Make sure we don't already have a directory  emacs-${version}.

emacsname="emacs-${version}${new_extension}"

if [ -d ${emacsname} ]
then
  echo Directory "${emacsname}" already exists >&2
  exit 1
fi

### Make sure the subdirectory is available.
tempparent="make-package.tmp.$$"
if [ -d ${tempparent} ]; then
  echo "${progname}: staging directory \`${tempparent}' already exists.
Perhaps a previous invocation of \`${progname}' failed to clean up after
itself.  Check that directories whose names are of the form
\`make-dist.tmp.NNNNN' don't contain any important information, remove
them, and try again." >&2
  exit 1
fi

if [ -d /Volumes/Emacs ]; then
  echo "${progname}: Already have an Emacs disc image mounted.  Please
eject that disc image and try again." >&2
  exit 1
fi

tempparentfull="`pwd`/${tempparent}"
tempparentdist=${tempparentfull}/dist

if test "$build_in_place" = "no"; then
    case ${builddir} in
      ${srcdir})
        tempbuild="make-package.build.$$"
	builddir="`pwd`/${tempbuild}"
	removable_build_dir=${builddir}
	mkdir -p ${builddir}
	;;
      [\\/]* | ?:[\\/]* ) #Absolutepath.
        mkdir -p ${builddir}
        ;;
      *)
	mkdir -p ${builddir}
	builddir=`cd $builddir && pwd`
	;;
    esac
fi
# Location of install package
packagedir=${builddir}/mac/Emacs.pkg

echo Building in directory ${builddir}
echo Installing into directory ${tempparentfull} >&2

### This trap ensures that the staging directory will be cleaned up even
### when the script is interrupted in mid-career.
trap "echo 'Interrupted...cleaning up the staging directory'; rm -rf ${tempparent} ${removable_build_dir} ${packagedir}; exit 1" 1 2 15

# Run configure in the new tempparent directory
if test "$with_config" = "yes"; then
    (cd ${builddir}; ${srcdir}/configure ${config_options} --prefix=${prefix})
fi

installprefix=${tempparentfull}${prefix}
if test "$self_contained" = "yes"; then
    # If selfcontained, the local directory is Resources directory
    installprefix=$tempparentfull/$appsdir/$emapp/Contents/Resources
fi


make_options="prefix=${installprefix} $make_options"

if test "$with_app" = "yes"; then
    make_options="carbon_appdir=${tempparentfull}/Applications $make_options"
fi

## Make bootstrap if .elc files are missing from distribution
if [ ! -f ${srcdir}/lisp/abbrev.elc ]; then
   echo "Required .elc files missing; making bootstrap..."
   if ! (cd ${builddir}; make bootstrap $make_options); then
      echo "Make bootstrap failed...  Aborting make-package."
      exit 2
   fi
fi

if ! (cd ${builddir}; make install $make_options); then
   echo "Make failed... Aborting make-package."
   exit 1
fi

if test "$full_dist" == "no"; then
    echo "Removing unneeded .el files"
    sharedir=$installprefix/share/emacs/$version
    find $sharedir/lisp $sharedir/leim -name "*.elc" -print | sed 's|\(.*\)\.elc$|/bin/rm -f \1.el|' | /bin/sh -s
fi

if test "$compressed_dist" == "yes" -a "$full_dist" == "yes"; then
    echo "Compressing .el files"
    sharedir=$installprefix/share/emacs/$version
    find $sharedir/lisp $sharedir/leim -name "*.elc" -print | sed 's|\(.*\)\.elc$|/usr/bin/gzip -9 \1.el|' | /bin/sh -s
    echo "Compressing info files"
    find $installprefix/info -type f ! -name dir -print | sed 's|\(.*\)$|/usr/bin/gzip -9 \1|' | /bin/sh -s
fi

if test "$with_app" == "yes"; then
  echo "Creating Emacs.app application"
  tempappdir=${tempparentfull}${appsdir}
  tempemapp=${tempappdir}/${emapp}/Contents/MacOS/Emacs
  ## Delete any CVS files
  find ${tempappdir} -name "CVS" -type d -exec rm -rf {} \;

  ## Have application be a symlink to ${prefix}/bin/emacs
  if test "$app_symlink" == "yes"; then
    echo "Creating application symlink"
    rm ${tempemapp}
    ln -s ${prefix}/bin/${emacsname} ${tempemapp}
  fi
fi

compver=`uname -p`-apple-darwin`uname -r`
 
if test "$self_contained" = "yes"; then
    # Move shared files down to Resources directory
    mv $installprefix/share/emacs/$version/* $installprefix
    mv $installprefix/share/info $installprefix
    mv $installprefix/share/man $installprefix
    rm -rf $installprefix/share
    # These directories might remain in Resources
    mv $installprefix/bin $installprefix/../MacOS/bin
    mv $installprefix/libexec/emacs/$version/$compver $installprefix/../MacOS/libexec
    # Make the application binary a hard link
    rm $installprefix/../MacOS/Emacs
    ln $installprefix/../MacOS/bin/emacs $installprefix/../MacOS/Emacs
fi


# Remove unnecessary .el files
#if test "$full_dist" = no; then
#fi

echo "Creating Package Info file"

mkdir -p ${packagedir}
mkdir ${packagedir}/Contents
mkdir ${packagedir}/Contents/Resources
mkdir ${packagedir}/Contents/Resources/English.lproj
echo -n 'pmkrpkg1' > ${packagedir}/Contents/PkgInfo

# Create ReadMe and License files
cp ${srcdir}/COPYING ${packagedir}/Contents/Resources/License.txt
cp ${srcdir}/mac/README ${packagedir}/Contents/Resources/ReadMe.txt

infofile=${packagedir}/Contents/Resources/English.lproj/Emacs.info

echo 'Title GNU Emacs' > ${infofile}
echo "Version ${version}" >> ${infofile}
echo "Description Install GNU Emacs ${version} as a command-line app and a Mac OS Application" >> ${infofile}
echo 'DefaultLocation /' >> ${infofile}
echo 'DeleteWarning' >> ${infofile}
echo 'NeedsAuthorization YES' >> ${infofile}
echo 'Required NO' >> ${infofile}
echo 'Relocatable NO' >> ${infofile}
echo 'RequiresReboot NO' >> ${infofile}
echo 'UseUserMask NO' >> ${infofile}
echo 'OverwritePermissions NO' >> ${infofile}
echo 'InstallFat NO' >> ${infofile}

### Set the install directory to install files as root...
### Not sure if this is a good diea
# echo "Setting owner to root"
# chown -Rh 0 ${tempparentfull}

echo "Creating pax file"
(cd ${tempparentfull}; pax -w -f ${packagedir}/Contents/Resources/Emacs.pax .)
echo "Compressing pax file"
gzip ${packagedir}/Contents/Resources/Emacs.pax

echo "Creating bom file"
mkbom ${tempparentfull} ${packagedir}/Contents/Resources/Emacs.bom

echo "Generating sizes file"
sizesfile=${packagedir}/Contents/Resources/Emacs.sizes

numFiles=`du -a ${tempparent} | wc -l`
installedSize=`du -s ${tempparent} | cut -f1`
compressedSize=`du -s ${packagedir} | cut -f1`

echo "NumFiles ${numFiles}" > ${sizesfile}
echo "InstalledSize ${installedSize}" >> ${sizesfile}
echo "CompressedSize ${compressedSize}" >> ${sizesfile}
cat ${sizesfile}

echo "Creating Disc Image"
## From hdiutil man page, a sector is 512k.  Allocate an extra 5% for
## directories and partition tables.
sectorsAlloced=`echo 2.1*${compressedSize}|bc`
hdiutil create -ov ${builddir}/mac/EmacsRW -sectors ${sectorsAlloced}
## Need to format the disc image before mounting
mountLoc=`hdid -nomount ${builddir}/mac/EmacsRW.dmg | grep HFS | cut -f1`
/sbin/newfs_hfs -v Emacs ${mountLoc}
hdiutil eject ${mountLoc}
echo "Copying Package to Disc Image"
hdid ${builddir}/mac/EmacsRW.dmg

if test "$keep_directory" = "no"; then
    rm -rf ${tempparentfull}
else
    mv ${tempparentfull} ${emacsname}
fi

if [ ! -d /Volumes/Emacs ]; then
  echo "Could not create disc image.  The Emacs installer package (Emacs.pkg)
in this directory should be correct.  Please use the Disc Copy program to
create a disc image." >&2
  exit 0
fi

cp -R ${packagedir} /Volumes/Emacs

## Converting Disk Image to read-only
echo 'Converting Disc Image to read-only'
hdiutil eject ${mountLoc}
hdiutil resize ${builddir}/mac/EmacsRW.dmg -sectors min
if test "$comp_diskimage" = "yes"; then
    hdiutil convert ${builddir}/mac/EmacsRW.dmg -format UDZO -imagekey zlib-level=2 -o ${srcdir}/mac/EmacsInstaller.dmg
else
    hdiutil convert ${builddir}/mac/EmacsRW.dmg -format UDRO -o ${srcdir}/mac/EmacsInstaller.dmg
fi
rm ${builddir}/mac/EmacsRW.dmg

echo "Cleaning up the staging directory"
rm -rf ${builddir}/mac/Emacs.pkg ${removable_build_dir}

# arch-tag: 1b631d0d-9fde-4f71-80c0-33e0e5815515
### make-package ends here