Subversion Repositories tendra.SVN

#!/bin/sh

#

#   

#   This TenDRA(r) Computer Program is subject to Copyright

#   owned by the United Kingdom Secretary of State for Defence

#   acting through the Defence Evaluation and Research Agency

#   (DERA).  It is made available to Recipients with a

#   royalty-free licence for its use, reproduction, transfer

#   to other parties and amendment for any purpose not excluding

#   product development provided that any such use et cetera

#   shall be deemed to be acceptance of the following conditions:-

#   

#       (1) Its Recipients shall ensure that this Notice is

#       reproduced upon any copies or amended versions of it;

#   

#       (2) Any amended version of it shall be clearly marked to

#       show both the nature of and the organisation responsible

#   

#       (3) Its onward transfer from a recipient to another

#       party shall be deemed to be that party's acceptance of

#       these conditions;

#   

#       (4) DERA gives no warranty or assurance as to its

#       quality or suitability for any purpose and DERA accepts

#       no liability whatsoever in relation to any use to which

#       it may be put.

#

#

#

# These directories are used to configure where the release is to be

# installed:

#

#	BASE_DIR	gives the directory in which the source has been

#			installed (i.e. the directory containing this script).

#

#	PUBLIC_BIN	gives the directory in which the public executables

#			(tcc, tchk and tspec) are to be installed.  If

#			PUBLIC_BIN is left blank then the public executables

#			will be installed in the private executables

#			directory.

#

#	INSTALL_DIR	gives the directory in which the configuration files,

#			include files, private executables, libraries etc.

#			are to be installed.

#

#	COMMON_DIR	gives the sub-directory of INSTALL_DIR in which the

#			target independent components are to be installed.

#

#	MACH_DIR	gives the sub-directory of INSTALL_DIR in which the

#			target dependent components are to be installed.

#

#	MAN_DIR		gives the directory in which the manual pages are

#

#	WORK_DIR	gives the working directory in which binary object

#			files etc. created during the build process will

#			be stored.

#

#	TMP_DIR		gives a temporary directory, used both by this

#			script and by tcc (so make sure that there is

#			plenty of free space).

#

BASE_DIR=/usr/local/src/TenDRA-4.1.2

PUBLIC_BIN=/usr/local/bin

COMMON_DIR=${INSTALL_DIR}/lib

MACH_DIR=${INSTALL_DIR}/machines

MAN_DIR=/usr/local/man

WORK_DIR=${BASE_DIR}/work

TEMP_DIR=/var/tmp

#

#

# These flags control which components of the release should be installed.

#

# If BUILD_UPDATE is true then the public executables and their configuration

# files will be installed (this has to be done on every target platform).

#

# If BUILD_MACHINE is true then all the other target dependent components

# will be installed (this also has to be done on every target platform).

#

# If BUILD_COMMON is true then the target independent components will be

# installed (this only has to be done once, indeed if the release is being

# built simultaneously on several platforms then the builds can conflict

# with each other, so start the quickest machine off first to install

# the complete release, and get the other machines to only install the

#

# BUILD_OK is set to false if an error occurs.

#

# COMMENT controls whether or not this script prints comments as it goes

# along.

#

BUILD_UPDATE=true

BUILD_COMMON=true

BUILD_OK=true

COMMENT=echo

#

# COMPILER INFORMATION

#

# These variables give information on the compiler to be used to install

# the release.  CC gives the compiler. CCOPTS and LIBOPTS give any target

# specific options required by the build, and are set by this script.  It

# is recommended that any extra flags which the user requires are made

# part of the definition of CC, so CC="gcc -O" would install using gcc

# in optimising mode.  TCCOPTS controls the extra configuration options

# required when bootstrapping the system using tcc.  It should be set to:

#

#	TCCOPTS=			for tcc,

#	TCCOPTS="TCCOPTS="		for other compilers.

#

# To install the bootstrapped compiler, install first using cc or gcc.

# Then remove the work directory (WORK_DIR), change the compiler to tcc,

# and install again.  Bootstrapping is recommended (all our testing is

# on the bootstrapped compiler).

#

#

# STRIP may be set to "strip" in order to ensure that the installed

# executables are stripped.

#

# RANLIB is used on those platforms on which system libraries need to be

# ranlib-ed.

#

# EXEC_SUFFIX is used on those platforms where executable names need to

# have a particular suffix, for example it may be set to ".exe".

#

CC=cc

CCOPTS=

LIBOPTS=

SYS_INCLUDES="-I/usr/include"

STRIP=:

RANLIB=ranlib

EXEC_SUFFIX=

#

#

# The easiest way of configuring this installation script is by direct

# editing, however these command line options may be used to make minor

# alterations.

#

do

    case ${ARG} in

    -cc)		CC=cc ; TCCOPTS="TCCOPTS=" ;;

    -gcc)		CC=gcc ; TCCOPTS="TCCOPTS=" ;;

    -tcc)		CC=tcc ; TCCOPTS="" ;;

    -g)			CC="${CC} -g" ;;

    -O)			CC="${CC} -O" ;;

    -exe)		EXEC_SUFFIX=".exe" ;;

    -quiet)		COMMENT=":" ;;

    -strip)		STRIP=strip ;;

    -target)		BUILD_COMMON=false ;;

    -update)		BUILD_COMMON=false ; BUILD_MACHINE=false ;;

    *)			${COMMENT} "Unknown option, ${ARG}" ;;

    esac

done

#

#

# The copyright notice is printed.  This also checks for the most common

#

if [ ! -f ${BASE_DIR}/COPYRIGHT ]

then

fi

#

# FIND HOST TYPE

#

#

TUNAME=${TEMP_DIR}/tuname_$$${EXEC_SUFFIX}

MACH_HEADER=${TEMP_DIR}/mach_$$.h

SRC=${BASE_DIR}/src/utilities/tuname

cd ${TEMP_DIR} || exit 1

make -f ${SRC}/Makefile CC="${CC}" ${TCCOPTS}\

    BASE=${BASE_DIR} NAME=${TUNAME} all

if [ -f ${TUNAME} ]

then

    MACH_OS=`${TUNAME} -s`

    MACH_VERS=`${TUNAME} -r`

    MACH_CPU=`${TUNAME} -m`

    MACH_EXEC=`${TUNAME} -e`

    ${TUNAME} -D > ${MACH_HEADER}

    rm -f ${TUNAME}

    then

	exit 1

    fi

else

    exit 1

fi

${COMMENT}

#

# FIND MACHINE DEPENDENT FLAGS

#

# The target specific options required to build the system on the various

#

MACH_OPTS=${BASE_DIR}/src/build/${MACH_OS}.opt

then

    . ${MACH_OPTS}

fi

#

# CREATE DIRECTORIES

#

# All the directories required for the installation are created.  The PATH

# is also set to pick up the private and public executables during

#

MACH_BASE=${MACH_DIR}/${MACH_OS}/${MACH_VERS}/${MACH_CPU}

if [ "X${PUBLIC_BIN}X" = "XX" ]

then

fi

PATH=${MACH_BASE}/bin:${PUBLIC_BIN}:/usr/ccs/bin:${PATH}

export PATH

if ${BUILD_UPDATE}

then

    CREATE_DIRS="${MACH_DIR}\

		 ${MACH_DIR}/${MACH_OS}/${MACH_VERS}\

		 ${MACH_BASE}\

		 ${MACH_BASE}/bin\

		 ${MACH_BASE}/env\

		 ${MACH_BASE}/lib\

		 ${MACH_BASE}/lib/sys\

		 ${PUBLIC_BIN}"

else

    CREATE_DIRS=

fi

then

else

fi

if ${BUILD_COMMON}

then

		 ${COMMON_DIR}\

		 ${MAN_DIR}\

else

    COMMON_DIRS=

fi

for DIR in ${COMMON_DIRS} ${CREATE_DIRS} ${MACH_DIRS}

do

    if [ ! -d ${DIR} ]

    then

	${COMMENT} creating ${DIR} ...

	mkdir ${DIR} || exit 1

    fi

done

${COMMENT}

#

# BUILD PROGRAMS

#

# The various program executables are now built.  The list of executables

# is stored in the PROGRAMS file.  Note that each executable has its own

# Makefile which can be used to install the executable in isolation, or

# during development work.

#

MACH_SED=${TEMP_DIR}/mach$$.sed

cat > ${MACH_SED} << EOF

1,\$s/MACH_OS/${MACH_OS}/g

1,\$s/MACH_CPU/${MACH_CPU}/g

EOF

for PROG in `sed -f ${MACH_SED} ${BASE_DIR}/src/build/PROGRAMS`

do

    NAME=`echo ${PROG} | sed -e 's/:.*//'`

    SRC=${BASE_DIR}/src/`echo ${PROG} | sed -e 's/.*://'`

    #

    # Build program

    #

    if ${BUILD_MACHINE}

    then

	${COMMENT} building ${NAME} ...

	if [ ! -d ${MACH_WORK}/${NAME} ]

	then

	    ${COMMENT} creating ${MACH_WORK}/${NAME} ...

	    mkdir ${MACH_WORK}/${NAME} || exit 1

	fi

	cd ${MACH_WORK}/${NAME} || exit 1

	EXEC=${MACH_BASE}/bin/${NAME}${EXEC_SUFFIX}

	make -f ${SRC}/Makefile CC="${CC} ${CCOPTS}" ${TCCOPTS}\

	    BASE=${BASE_DIR} NAME=${EXEC} all || BUILD_OK=false

	if [ -f ${EXEC} ]

	then

	    ${STRIP} ${EXEC}

	else

	    ${COMMENT} compilation failed ...

	    BUILD_OK=false

	fi

	${COMMENT}

    fi

    #

    # Copy manual pages

    #

    if ${BUILD_COMMON}

    then

	for SUFFIX in 1 5

	do

	    for MANPAGE in ${SRC}/*.${SUFFIX}

	    do

		if [ -f ${MANPAGE} ]

		then

		    NEWPAGE=${MAN_DIR}/man${SUFFIX}/`basename ${MANPAGE}`

		    rm -f ${NEWPAGE}

		    cp ${MANPAGE} ${NEWPAGE}

		fi

	    done

	done

    fi

done

rm -f ${MACH_SED}

#

# BUILD DYNAMIC LINKER

#

# On some platforms a dynamic linker is required to handle the TDF

# initial_value construct (used by C++'s non-constant initialisation etc.).

# This is built at this stage.

#

if ${BUILD_MACHINE}

then

    ${COMMENT} building machine dependent components ...

    SRC=${BASE_DIR}/src/lib/machines/${MACH_OS}/${MACH_CPU}/src

    if [ -f ${SRC}/Makefile ]

    then

	make -f ${SRC}/Makefile CC="${CC} ${CCOPTS}" ${TCCOPTS}\

	    BASE=${BASE_DIR} pre || BUILD_OK=false

	${COMMENT}

    fi

fi

#

# INSTALL ENVIRONMENTS

#

# The user interfaces to the TenDRA compiler, tcc and tchk, use configuration

# files called environments to configure them to the particular details of

# the platform on which they are installed (including where the private

# executables, libraries etc. are to be found).  If the release is moved

# then only the environments need to be re-installed, by setting BUILD_UPDATE

# to true, but BUILD_COMMON and BUILD_MACHINE to false.

#

if ${BUILD_UPDATE}

then

    ${COMMENT} installing tcc environments ...

    ENV_SED=${TEMP_DIR}/env$$.sed

    cat > ${ENV_SED} << EOF

1,\$s%-MACH-%${MACH_OS}/${MACH_CPU}%g

1,\$s%-MACHDIR-%${MACH_BASE}%g

1,\$s%-BINDIR-%${MACH_BASE}/bin%g

1,\$s%-ENVDIR-%${MACH_BASE}/env%g

1,\$s%-LIBDIR-%${MACH_BASE}/lib%g

1,\$s%-INCLDIR-%${COMMON_DIR}/include%g

1,\$s%-STARTUPDIR-%${COMMON_DIR}/startup%g

1,\$s%-TMPDIR-%${TEMP_DIR}%g

EOF

    cd ${MACH_BASE}/env || exit 1

    SRC=${BASE_DIR}/src/lib/env

    ENVIRON_DIRS="${SRC}/common\

		  ${SRC}/${MACH_OS}/common/common\

		  ${SRC}/${MACH_OS}/common/${MACH_CPU}\

		  ${SRC}/${MACH_OS}/${MACH_EXEC}/common\

		  ${SRC}/${MACH_OS}/${MACH_EXEC}/${MACH_CPU}\

		  ${SRC}/${MACH_OS}/${MACH_VERS}/common\

		  ${SRC}/${MACH_OS}/${MACH_VERS}/${MACH_CPU}"

    for DIR in ${ENVIRON_DIRS}

    do

	then

	    for ENVFILE in ${DIR}/*

	    do

		if [ -f ${ENVFILE} ]

		then

		    NEWFILE=`basename ${ENVFILE}`

		    ${COMMENT} ${ENVFILE} '->' ${NEWFILE}

		    rm -f ${NEWFILE}

		    sed -f ${ENV_SED} ${ENVFILE} > ${NEWFILE}

		fi

	    done

	fi

    done

    ${COMMENT} default.extra '>>' default

    rm -f default.new

    cat default default.extra > default.new

    rm -f default

    rm -f ${ENV_SED}

    ${COMMENT}

fi

#

# INSTALL WRAPPER FUNCTIONS

#

# The public executables are actually wrapper scripts which call the

# actual programs from the private executables directory with the appropriate

# configuration options.

#

if ${BUILD_UPDATE}

then

    ${COMMENT} installing tcc ...

    rm -f ${PUBLIC_BIN}/tcc

    cat > ${PUBLIC_BIN}/tcc << EOF

#!/bin/sh

exec ${MACH_BASE}/bin/tcc1${EXEC_SUFFIX} -Y${MACH_BASE}/env/default \${@+"\$@"}

EOF

    chmod +x ${PUBLIC_BIN}/tcc

    ${COMMENT}

    ${COMMENT} installing tchk ...

    rm -f ${PUBLIC_BIN}/tchk

    cat > ${PUBLIC_BIN}/tchk << EOF

#!/bin/sh

exec ${MACH_BASE}/bin/tcc1${EXEC_SUFFIX} -Y${MACH_BASE}/env/default -ch \${@+"\$@"}

EOF

    chmod +x ${PUBLIC_BIN}/tchk

    ${COMMENT}

    ${COMMENT} installing tspec ...

    rm -f ${PUBLIC_BIN}/tspec

    cat > ${PUBLIC_BIN}/tspec << EOF

#!/bin/sh

TSPEC_INPUT=${BASE_DIR}/src/lib/apis

TSPEC_INCL_OUTPUT=${COMMON_DIR}/include

TSPEC_SRC_OUTPUT=${COMMON_DIR}/building

export TSPEC_INPUT TSPEC_INCL_OUTPUT TSPEC_SRC_OUTPUT

exec ${MACH_BASE}/bin/tspec1${EXEC_SUFFIX} \${@+"\$@"}

EOF

    chmod +x ${PUBLIC_BIN}/tspec

    ${COMMENT}

fi

#

# INSTALL START-UP FILES

#

# The machine independent compiler configuration files are installed

# (cp -r would do as well as tar, but not all machines support it).

#

if ${BUILD_COMMON}

then

    ${COMMENT} installing start-up files ...

    cd ${BASE_DIR}/src/lib || exit 1

    rm -f ${MACH_WORK}/startup.tar

    tar cvf ${MACH_WORK}/startup.tar startup

    cd ${COMMON_DIR} || exit 1

    rm -rf startup

    tar xvf ${MACH_WORK}/startup.tar

    rm -f ${MACH_WORK}/startup.tar

    ${COMMENT}

fi

#

# INSTALL API DESCRIPTIONS

#

# The TenDRA API descriptions for the various supported APIs are installed

# using the tspec executable built above.  The list of APIs is given in a

# separate file, APIS.

#

if ${BUILD_COMMON}

then

    for API in `cat ${BASE_DIR}/src/build/APIS`

    do

	${COMMENT} installing API ${API} ...

	${PUBLIC_BIN}/tspec -w -v ${API}

	${COMMENT} all done

	${COMMENT}

    done

fi

#

# INSTALL MACHINE DEPENDENT HEADERS

#

# The machine dependent include files and configuration files are now

# installed.  These are used in particular during TDF API library building

# and when the compiler is configured to use the system headers.

#

if ${BUILD_MACHINE}

then

    ${COMMENT} installing machine dependent headers ...

    SRC=${BASE_DIR}/src/lib/machines/${MACH_OS}/${MACH_CPU}

    if [ -d ${SRC} ]

    then

	cd ${SRC} || exit 1

	rm -f ${MACH_WORK}/machine.tar

	tar cvf ${MACH_WORK}/machine.tar include startup

	cd ${MACH_BASE} || exit 1

	rm -rf include

	rm -rf startup

	tar xvf ${MACH_WORK}/machine.tar

	rm -f ${MACH_WORK}/machine.tar

	cp ${MACH_HEADER} startup/machine.h

    fi

    ${COMMENT}

fi

rm -f ${MACH_HEADER}

#

# BUILD MACHINE DEPENDENT COMPONENTS

#

# Any machine dependent libraries etc. are now built.  This includes the

# basic TDF token definitions which describe the machine to the compiler.

#

if ${BUILD_MACHINE}

then

    ${COMMENT} building machine dependent components ...

    SRC=${BASE_DIR}/src/lib/machines/${MACH_OS}/${MACH_CPU}/src

    if [ -f ${SRC}/Makefile ]

    then

	cd ${MACH_BASE}/lib/sys || exit 1

	make -f ${SRC}/Makefile CC="${CC} ${CCOPTS}" ${TCCOPTS}\

	    BASE=${BASE_DIR} all || BUILD_OK=false

    fi

    ${COMMENT}

fi

#

# BUILD API LIBRARIES

#

# And now the tricky bit.  The TDF API libraries are built from the TenDRA

# API descriptions and the implementation of the API as described in the

# system headers.

#

# Although this has been tested to the operating system versions listed

# in the supported platforms section of the release notes, it is possible

# that it may fail for other operating system versions.  Provided the

# ansi library builds, you have enough to play with, but to get other

# libraries through, you may need to modify the machine dependent include

# and start-up files in src/lib/machines/<os>/<cpu>, using the existing

# files as a template.  If you get really stuck; you've read all the

# documentation, and looked at all what I've done in similar circumstances,

# you can email me (Rob) at the address on the web page, but make this a

# last resort - I do have other things to do.

#

# Note that each library is built twice, firstly without diagnostic

# information and secondly with.  Really only the ones with diagnostics

# are required (the diagnostic information is ignored if not needed),

# but building both is traditional.

#

DIAG_MSG=

DIAG_CC=tcc

for LIBDIR in lib lib/diag

do

    #

    # Build basic token definitions

    #

    if ${BUILD_MACHINE}

    then

	${COMMENT} building basic C token definitions${DIAG_MSG} ...

	if [ ! -d ${MACH_WORK}/${LIBDIR} ]

	then

	    ${COMMENT} creating ${MACH_WORK}/${LIBDIR} ...

	    mkdir ${MACH_WORK}/${LIBDIR} || exit 1

	fi

	for API in `cat ${BASE_DIR}/src/build/APIS` ansi cpp

	do

	    API_NAME=`echo ${API} | sed -e 's%/%_%g'`

	    if [ ! -d ${MACH_WORK}/${LIBDIR}/${API_NAME} ]

	    then

		${COMMENT} creating ${MACH_WORK}/${LIBDIR}/${API_NAME} ...

		mkdir ${MACH_WORK}/${LIBDIR}/${API_NAME} || exit 1

	    fi

	done

	SRC=${BASE_DIR}/src/lib/machines/${MACH_OS}/${MACH_CPU}/tokens

	if [ -d ${SRC} ]

	then

	    cd ${MACH_WORK}/${LIBDIR}/ansi || exit 1

	    make -f ${SRC}/Makefile TCC="${DIAG_CC}" BASE=${BASE_DIR}\

		basic || BUILD_OK=false

	fi

	${COMMENT}

	SRC=${BASE_DIR}/src/lib/cpp/tokens

	if [ -d ${SRC} ]

	then

	    ${COMMENT} building basic C++ token definitions${DIAG_MSG} ...

	    cd ${MACH_WORK}/${LIBDIR}/cpp || exit 1

	    make -f ${SRC}/Makefile TCC="${DIAG_CC}" BASE=${BASE_DIR}\

		all || BUILD_OK=false

	    ${COMMENT}

	fi

    fi

    #

    # Build API token libraries

    #

    if ${BUILD_MACHINE}

    then

	cd ${MACH_WORK}/${LIBDIR} || exit 1

	for API in `cat ${BASE_DIR}/src/build/APIS`

	do

	    API_NAME=`echo ${API} | sed -e 's%/%_%g'`

	    SRC=${COMMON_DIR}/building/${API}.api

	    if [ -d ${SRC} ]

	    then

		${COMMENT} building ${API} API token library${DIAG_MSG} ...

		rm -f ${API_NAME}/Makefile

		cat > ${API_NAME}/Makefile << EOF

BASE=${MACH_BASE}

LIB=\${BASE}/${LIBDIR}/${API_NAME}.tl

SRC=${COMMON_DIR}/building

STARTUP=\${BASE}/startup

WORK=.

TLIB=tld -mc

TDI=${DIAG_CC} -Fj -Ybuilding -Y32bit -I\${BASE}/include ${SYS_INCLUDES}

TDP=echo

EOF

		cat ${SRC}/Makefile >> ${API_NAME}/Makefile

		if [ -f ${MACH_BASE}/startup/${API_NAME}.h ]

		then

		    make -f ${API_NAME}/Makefile all || BUILD_OK=false

		else

		    ${COMMENT} skipped

		fi

		${COMMENT}

	    fi

	done

    fi

    #

    # Build TDF standard token library

    #

    if ${BUILD_MACHINE}

    then

	SRC=${BASE_DIR}/src/lib/machines/${MACH_OS}/${MACH_CPU}/tokens

	if [ -d ${SRC} ]

	then

	    ${COMMENT} building TDF standard token library${DIAG_MSG} ...

	    LIB=${MACH_BASE}/${LIBDIR}/target_tok.tl

	    cd ${MACH_WORK}/${LIBDIR}/ansi || exit 1

	    make -f ${SRC}/Makefile LIB=${LIB} TCC="${DIAG_CC}"\

		BASE=${BASE_DIR} all || BUILD_OK=false

	    ${COMMENT}

	fi

    fi

    #

    # Now build with diagnostics

    #

    DIAG_MSG=" (with diagnostics)"

    DIAG_CC="tcc -g"

done

#

# BUILD SUPPORT LIBRARIES

#

# The support libraries are now built.  The list of libraries to be built

# is stored in a separate file, LIBRARIES.  It bears repeating that the

# C++ support library only contains the minimum language support features.

#

if ${BUILD_MACHINE}

then

    SRC=${BASE_DIR}/src/lib/machines/common/src

    if [ -f ${SRC}/Makefile ]

    then

	${COMMENT} building crtp_n.o ...

	cd ${MACH_BASE}/lib/sys || exit 1

	make -f ${SRC}/Makefile BASE=${BASE_DIR} all || BUILD_OK=false

	${COMMENT}

    fi

    for PROG in `cat ${BASE_DIR}/src/build/LIBRARIES`

    do

	NAME=`echo ${PROG} | sed -e 's/:.*//'`

	SRC=${BASE_DIR}/src/`echo ${PROG} | sed -e 's/.*://'`

	if [ -f ${SRC}/Makefile ]

	then

	    ${COMMENT} building ${NAME} ...

	    if [ ! -d ${MACH_WORK}/${NAME} ]

	    then

		${COMMENT} creating ${MACH_WORK}/${NAME} ...

		mkdir ${MACH_WORK}/${NAME} || exit 1

	    fi

	    cd ${MACH_WORK}/${NAME} || exit 1

	    LIB=${MACH_BASE}/lib/sys/lib${NAME}.a

	    make -f ${SRC}/Makefile BASE=${BASE_DIR} NAME=${LIB}\

		MACHOPTS="${LIBOPTS}" RANLIB="${RANLIB}" all || BUILD_OK=false

	    if [ ! -f ${LIB} ]

	    then

		${COMMENT} compilation failed ...

		BUILD_OK=false

	    fi

	    ${COMMENT}

	fi

    done

fi

#

# END OF INSTALLATION SCRIPT

#

# Phew!

#

if ${BUILD_OK}

then

    ${COMMENT} installation completed successfully

else

    ${COMMENT} installation completed with errors

fi

exit 0