gac

#!/bin/sh
#############################################################################
##
#W  gac.sh                      GAP compiler                 Martin Schoenert
##
#H  @(#)$Id$
##
#Y  Copyright (C)  1997,  Lehrstuhl D fuer Mathematik,  RWTH Aachen,  Germany
##
##  gac [-c|-d] [-o <output>] {-f<option>} <input>...
##
##  'gac'  compiles the input files.   Input files  must be  GAP  source code
##  (suffix '.g' or '.gap'),  C source code (suffix '.c'),  or compiled  code
##  files (suffix '.o').
##
##  If  neither '-c'  nor '-d' is given,  then 'gac'  produces a  new kernel,
##  which contains the compiled code for all the input files.
##
##  If '-c' is given,  then 'gac' only compiles the input files to statically
##  loadable object files, which must be linked together to a new kernel.
##
##  If '-d' is given, then 'gac' only compiles the input files to dynamically
##  loadable object files, which can be loaded by a kernel at runtime.
##
##  The option '-o <output>' tells 'gac' to name the output file <output>.
##
##  The option  '-ffast-int-arith' tells  'gac' to emit  code for  arithmetic
##  operations, which works faster if both  operands are  small integers  and
##  slower otherwise.
##
##  The option '-ffast-plain-lists' tells 'gac' to emit code for list access,
##  which works faster if the list is a plain list and slower otherwise.
##
##  The option '-ffast-list-funcs' tells 'gac' to inline  the functions 'Add'
##  and 'Length' the code, which makes it a bit faster.
##
##  The option '-fno-check-types' tells 'gac' to  emit  no  error checks  for
##  list access, which makes it faster but may dump core if an error happens.
##
##  The option '-p <option>' tells 'gac' to pass the option  <option> to  the
##  C compiler.
##
gap_bin=`echo $0 | sed -e 's:/[^/]*$::'`
if [ "X${gap_bin}" = "X$0" ];  then
    gap_dir="../../";
    gap_compiler="./gap";
    gap_binary="./";
else
    gap_dir="${gap_bin}/../..";
    gap_compiler="${gap_bin}/gap";
    gap_binary="${gap_bin}";
fi
gap_options=""
gap_include="${gap_dir}/src"
stat_identifier="USER";

c_compiler="@CCOMPILER@"
c_options="@COPTIONS@"
c_dyn_options="@CDYNOPTIONS@"
c_linker="@CLINKER@"
c_dyn_linker="@CDYNLINKER@"
c_dyn_linking="@CDYNLINKING@"


#############################################################################
##
#F  gap_compile <output> <input> <module-name> <identifier>
##
gap_compile () {
    echo ${gap_compiler} ${gap_options} -C $1 $2 $3 $4
    ${gap_compiler} ${gap_options} -C "$1" "$2" "$3" "$4"
}


#############################################################################
##
#F  c_compile   <output> <input>
##
c_compile () {
    echo ${c_compiler} ${c_options} -o $1 -I ${gap_include} -c $2
    ${c_compiler} ${c_options} -o $1 -I ${gap_include} -c $2
}


#############################################################################
##
#F  c_compile_dyn <output> <input>
##
c_compile_dyn () {
    xxx=`basename $1 .so`
    tmp=/tmp/$$_${xxx}.o
    echo ${c_compiler} ${c_dyn_options} -o ${tmp} -I ${gap_include} -c $2
    ${c_compiler} ${c_dyn_options} -o ${tmp} -I ${gap_include} -c $2
    echo ${c_dyn_linker} ${c_dyn_linking} -o $1 ${tmp}
    ${c_dyn_linker} ${c_dyn_linking} -o $1 ${tmp}
    echo rm -f ${tmp}
    rm -f ${tmp}
}


#############################################################################
##
#F  c_link <output> <inputs_o>
##
c_link () {
    echo ${c_linker} -o $1 $2
    ${c_linker} -o $1 $2
}


#############################################################################
##
#F  clean_up
##
clean_up () {
    echo rm -f ${temps_c} ${temps_o}
    rm -f ${temps_c} ${temps_o}
}
trap "clean_up" 2 3


#############################################################################
##
##  parse the arguments
##
if [ $# = 0 ]; then
    echo "usage: $0 [-c|-d|-e] [-o <output>] [-l <gap_binary>] <input>..."
    exit 1
fi

comp_mode="comp_link"
output=""
inputs=""

while [ $# -gt 0 ]; do
    case $1 in

    -c|--compile)         comp_mode="comp_stat";;

    -d|--dynamic)         comp_mode="comp_dyna";;

    -C|--create-c)	  comp_mode="comp_to_c";;

    -o|--output)          shift; output="$1";;

    -ffast-int-arith)     if [ "X${gap_options}" = "X" ]; then
                              gap_options="-D FAST_INT_ARITH"
                          else
                              gap_options="${gap_options},FAST_INT_ARITH"
                          fi;;

    -ffast-plain-lists)   if [ "X${gap_options}" = "X" ]; then
                              gap_options="-D FAST_PLAIN_LISTS"
                          else
                              gap_options="${gap_options},FAST_PLAIN_LISTS"
                          fi;;

    -ffast-list-funcs)    if [ "X${gap_options}" = "X" ]; then
                              gap_options="-D FAST_LIST_FUNCS"
                          else
                              gap_options="${gap_options},FAST_LIST_FUNCS"
                          fi;;

    -fno-check-types)     if [ "X${gap_options}" = "X" ]; then
                              gap_options="-D NO_CHECK_TYPES"
                          else
                              gap_options="${gap_options},NO_CHECK_TYPES"
                          fi;;

    -fno-check-list-elms) if [ "X${gap_options}" = "X" ]; then
                              gap_options="-D NO_CHECK_LIST_ELMS"
                          else
                              gap_options="${gap_options},NO_CHECK_LIST_ELMS"
                          fi;;

    -f*)                  echo "$0: no such option '$1'"
                          exit 1;;

    -k|--gap-compiler)    shift; gap_compiler="$1";;

    -i|--gap-include)     shift; gap_include="$1";;

    -l|--gap-binary)      shift; gap_binary="$1";;

    -p)                   shift; c_options="${c_options} $1";;

    *.g|*.gap|*.gd|*.gi|*.c|*.o)
                          inputs="${inputs} $1";;

    *)                    echo "$0: cannot handle this argument '$1'"
                          exit 1;;

    esac
    shift
done

if [ "X${inputs}" = "X" ]; then
    echo "$0: no input files given"
    exit 1
fi


#############################################################################
##
##  compile and/or link
##
if [ ${comp_mode} = "comp_link" ]; then

    # loop over the input files
    for input in ${inputs}; do
        case $input in

        *.g) # compile '.g' source files
            name=`basename ${input} .g`
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            temps_o="${temps_o} /tmp/$$_${name}.o"
            c_compile /tmp/$$_${name}.o /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            names="${names} ${name}"
            objects="${objects} /tmp/$$_${name}.o";;

        *.gap) # compile '.gap' source files
            name=`basename ${input} .gap`
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            temps_o="${temps_o} /tmp/$$_${name}.o"            
            c_compile /tmp/$$_${name}.o /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            names="${names} ${name}"
            objects="${objects} /tmp/$$_${name}.o";;

        *.gd) # compile '.gd' source files
            name=`basename ${input} .gd`
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            temps_o="${temps_o} /tmp/$$_${name}.o"            
            c_compile /tmp/$$_${name}.o /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            names="${names} ${name}"
            objects="${objects} /tmp/$$_${name}.o";;

        *.gi) # compile '.gi' source files
            name=`basename ${input} .gi`
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            temps_o="${temps_o} /tmp/$$_${name}.o"            
            c_compile /tmp/$$_${name}.o /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            names="${names} ${name}"
            objects="${objects} /tmp/$$_${name}.o";;

        *.c) # compile '.c' source files
            name=`basename ${input} .c`
            temps_o="${temps_o} /tmp/$$_${name}.o"
            c_compile /tmp/$$_${name}.o ${input}
            names="${names} ${name}"
            objects="${objects} /tmp/$$_${name}.o";;

        *.o) # look over '.o' source files
            name=`basename ${input} .o`
            names="${names} ${name}"
            objects="${objects} ${input}";;

        esac
    done

    # make 'compstat.c' and compile it
    temps_c="${temps_c} /tmp/$$compstat.c"
    echo     "/* made by 'gac', can be thrown away */"   >  /tmp/$$compstat.c
    echo     "#include \"compiled.h\""                   >> /tmp/$$compstat.c
    for name in ${names}; do
        echo "extern StructCompInitInfo * Init__${name} ( void );" \
						         >> /tmp/$$compstat.c
    done
    echo     "CompInitFunc CompInitFuncs [] = {"         >> /tmp/$$compstat.c
    for name in ${names}; do
        echo "    Init__${name},"                        >> /tmp/$$compstat.c
    done
    echo "    0"                                         >> /tmp/$$compstat.c
    echo "};"                                            >> /tmp/$$compstat.c
    temps_o="/tmp/$$compstat.o ${temps_o}"
    c_compile /tmp/$$compstat.o /tmp/$$compstat.c
    echo rm -f /tmp/$$compstat.c
    rm -f /tmp/$$compstat.c
    objects="/tmp/$$compstat.o ${objects}"

    # link everything together
    if [ "X${output}" = "X" ]; then output="gacout"; fi
    for object in @OBJECTS@;  do
        objects="${gap_binary}/${object} ${objects}"
    done
    c_link ${output} "${objects}"
    echo rm -f ${temps_o}
    rm -f ${temps_o}


#############################################################################
##
##  compile only
##
elif [ ${comp_mode} = "comp_stat" ]; then

    # loop over the input files
    for input in ${inputs}; do
        case $input in

        *.g) # compile '.g' source files
            name=`basename ${input} .g`
            if [ "X${output}" = "X" ]; then output=${name}.o; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            c_compile ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.gap) # compile '.gap' source files
            name=`basename ${input} .gap`
            if [ "X${output}" = "X" ]; then output=${name}.o; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            c_compile ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.gd) # compile '.gd' source files
            name=`basename ${input} .gd`
            if [ "X${output}" = "X" ]; then output=${name}.o; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            c_compile ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.gi) # compile '.gi' source files
            name=`basename ${input} .gi`
            if [ "X${output}" = "X" ]; then output=${name}.o; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
            c_compile ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.c) # compile '.c' source files
            name=`basename ${input} .c`
            if [ "X${output}" = "X" ]; then output=${name}.o; fi
            c_compile ${output} ${input}
            output="";;

        esac
    done


#############################################################################
##
##  compile dynamically loaded
##
elif [ ${comp_mode} = "comp_dyna" ]; then

    # loop over the input files
    for input in ${inputs}; do
        case $input in

        *.g) # compile '.g' source files
            name=`basename ${input} .g`
            if [ "X${output}" = "X" ]; then output=${name}.so; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_Dynamic" ${input}
            c_compile_dyn ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.gap) # compile '.gap' source files
            name=`basename ${input} .gap`
            if [ "X${output}" = "X" ]; then output=${name}.so; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_Dynamic" ${input}
            c_compile_dyn ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.gd) # compile '.gd' source files
            name=`basename ${input} .gd`
            if [ "X${output}" = "X" ]; then output=${name}.so; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_Dynamic" ${input}
            c_compile_dyn ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.gi) # compile '.gi' source files
            name=`basename ${input} .gi`
            if [ "X${output}" = "X" ]; then output=${name}.so; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_Dynamic" ${input}
            c_compile_dyn ${output} /tmp/$$_${name}.c
            echo rm -f /tmp/$$_${name}.c
            rm -f /tmp/$$_${name}.c
            output="";;

        *.c) # compile '.c' source files
            name=`basename ${input} .c`
            if [ "X${output}" = "X" ]; then output=${name}.so; fi
            c_compile_dyn ${output} ${input}
            output="";;

        esac
    done


#############################################################################
##
##  compile to c only
##
elif [ ${comp_mode} = "comp_to_c" ]; then

    # loop over the input files
    for input in ${inputs}; do
        case $input in

        *.g) # compile '.g' source files
            name=`basename ${input} .g`
            if [ "X${output}" = "X" ]; then output=${name}.c; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
	    mv /tmp/$$_${name}.c ${output}
            output="";;

        *.gap) # compile '.gap' source files
            name=`basename ${input} .gap`
            if [ "X${output}" = "X" ]; then output=${name}.c; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
	    mv /tmp/$$_${name}.c ${output}
            output="";;

        *.gd) # compile '.gd' source files
            name=`basename ${input} .gd`
            if [ "X${output}" = "X" ]; then output=${name}.c; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
	    mv /tmp/$$_${name}.c ${output}
            output="";;

        *.gi) # compile '.gi' source files
            name=`basename ${input} .gi`
            if [ "X${output}" = "X" ]; then output=${name}.c; fi
            temps_c="${temps_c} /tmp/$$_${name}.c"
            gap_compile /tmp/$$_${name}.c ${input} "Init_${name}" ${input}
	    mv /tmp/$$_${name}.c ${output}
            output="";;

        *.c) # compile '.c' source files
	    echo "cannot compile '${input}' to C"
            output="";;

        esac
    done

fi