Annotation of embedaddon/arping/compile, revision 1.1.1.1

1.1       misho       1: #! /bin/sh
                      2: # Wrapper for compilers which do not understand '-c -o'.
                      3: 
                      4: scriptversion=2018-03-07.03; # UTC
                      5: 
                      6: # Copyright (C) 1999-2018 Free Software Foundation, Inc.
                      7: # Written by Tom Tromey <tromey@cygnus.com>.
                      8: #
                      9: # This program is free software; you can redistribute it and/or modify
                     10: # it under the terms of the GNU General Public License as published by
                     11: # the Free Software Foundation; either version 2, or (at your option)
                     12: # any later version.
                     13: #
                     14: # This program is distributed in the hope that it will be useful,
                     15: # but WITHOUT ANY WARRANTY; without even the implied warranty of
                     16: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     17: # GNU General Public License for more details.
                     18: #
                     19: # You should have received a copy of the GNU General Public License
                     20: # along with this program.  If not, see <https://www.gnu.org/licenses/>.
                     21: 
                     22: # As a special exception to the GNU General Public License, if you
                     23: # distribute this file as part of a program that contains a
                     24: # configuration script generated by Autoconf, you may include it under
                     25: # the same distribution terms that you use for the rest of that program.
                     26: 
                     27: # This file is maintained in Automake, please report
                     28: # bugs to <bug-automake@gnu.org> or send patches to
                     29: # <automake-patches@gnu.org>.
                     30: 
                     31: nl='
                     32: '
                     33: 
                     34: # We need space, tab and new line, in precisely that order.  Quoting is
                     35: # there to prevent tools from complaining about whitespace usage.
                     36: IFS=" ""       $nl"
                     37: 
                     38: file_conv=
                     39: 
                     40: # func_file_conv build_file lazy
                     41: # Convert a $build file to $host form and store it in $file
                     42: # Currently only supports Windows hosts. If the determined conversion
                     43: # type is listed in (the comma separated) LAZY, no conversion will
                     44: # take place.
                     45: func_file_conv ()
                     46: {
                     47:   file=$1
                     48:   case $file in
                     49:     / | /[!/]*) # absolute file, and not a UNC file
                     50:       if test -z "$file_conv"; then
                     51:        # lazily determine how to convert abs files
                     52:        case `uname -s` in
                     53:          MINGW*)
                     54:            file_conv=mingw
                     55:            ;;
                     56:          CYGWIN*)
                     57:            file_conv=cygwin
                     58:            ;;
                     59:          *)
                     60:            file_conv=wine
                     61:            ;;
                     62:        esac
                     63:       fi
                     64:       case $file_conv/,$2, in
                     65:        *,$file_conv,*)
                     66:          ;;
                     67:        mingw/*)
                     68:          file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
                     69:          ;;
                     70:        cygwin/*)
                     71:          file=`cygpath -m "$file" || echo "$file"`
                     72:          ;;
                     73:        wine/*)
                     74:          file=`winepath -w "$file" || echo "$file"`
                     75:          ;;
                     76:       esac
                     77:       ;;
                     78:   esac
                     79: }
                     80: 
                     81: # func_cl_dashL linkdir
                     82: # Make cl look for libraries in LINKDIR
                     83: func_cl_dashL ()
                     84: {
                     85:   func_file_conv "$1"
                     86:   if test -z "$lib_path"; then
                     87:     lib_path=$file
                     88:   else
                     89:     lib_path="$lib_path;$file"
                     90:   fi
                     91:   linker_opts="$linker_opts -LIBPATH:$file"
                     92: }
                     93: 
                     94: # func_cl_dashl library
                     95: # Do a library search-path lookup for cl
                     96: func_cl_dashl ()
                     97: {
                     98:   lib=$1
                     99:   found=no
                    100:   save_IFS=$IFS
                    101:   IFS=';'
                    102:   for dir in $lib_path $LIB
                    103:   do
                    104:     IFS=$save_IFS
                    105:     if $shared && test -f "$dir/$lib.dll.lib"; then
                    106:       found=yes
                    107:       lib=$dir/$lib.dll.lib
                    108:       break
                    109:     fi
                    110:     if test -f "$dir/$lib.lib"; then
                    111:       found=yes
                    112:       lib=$dir/$lib.lib
                    113:       break
                    114:     fi
                    115:     if test -f "$dir/lib$lib.a"; then
                    116:       found=yes
                    117:       lib=$dir/lib$lib.a
                    118:       break
                    119:     fi
                    120:   done
                    121:   IFS=$save_IFS
                    122: 
                    123:   if test "$found" != yes; then
                    124:     lib=$lib.lib
                    125:   fi
                    126: }
                    127: 
                    128: # func_cl_wrapper cl arg...
                    129: # Adjust compile command to suit cl
                    130: func_cl_wrapper ()
                    131: {
                    132:   # Assume a capable shell
                    133:   lib_path=
                    134:   shared=:
                    135:   linker_opts=
                    136:   for arg
                    137:   do
                    138:     if test -n "$eat"; then
                    139:       eat=
                    140:     else
                    141:       case $1 in
                    142:        -o)
                    143:          # configure might choose to run compile as 'compile cc -o foo foo.c'.
                    144:          eat=1
                    145:          case $2 in
                    146:            *.o | *.[oO][bB][jJ])
                    147:              func_file_conv "$2"
                    148:              set x "$@" -Fo"$file"
                    149:              shift
                    150:              ;;
                    151:            *)
                    152:              func_file_conv "$2"
                    153:              set x "$@" -Fe"$file"
                    154:              shift
                    155:              ;;
                    156:          esac
                    157:          ;;
                    158:        -I)
                    159:          eat=1
                    160:          func_file_conv "$2" mingw
                    161:          set x "$@" -I"$file"
                    162:          shift
                    163:          ;;
                    164:        -I*)
                    165:          func_file_conv "${1#-I}" mingw
                    166:          set x "$@" -I"$file"
                    167:          shift
                    168:          ;;
                    169:        -l)
                    170:          eat=1
                    171:          func_cl_dashl "$2"
                    172:          set x "$@" "$lib"
                    173:          shift
                    174:          ;;
                    175:        -l*)
                    176:          func_cl_dashl "${1#-l}"
                    177:          set x "$@" "$lib"
                    178:          shift
                    179:          ;;
                    180:        -L)
                    181:          eat=1
                    182:          func_cl_dashL "$2"
                    183:          ;;
                    184:        -L*)
                    185:          func_cl_dashL "${1#-L}"
                    186:          ;;
                    187:        -static)
                    188:          shared=false
                    189:          ;;
                    190:        -Wl,*)
                    191:          arg=${1#-Wl,}
                    192:          save_ifs="$IFS"; IFS=','
                    193:          for flag in $arg; do
                    194:            IFS="$save_ifs"
                    195:            linker_opts="$linker_opts $flag"
                    196:          done
                    197:          IFS="$save_ifs"
                    198:          ;;
                    199:        -Xlinker)
                    200:          eat=1
                    201:          linker_opts="$linker_opts $2"
                    202:          ;;
                    203:        -*)
                    204:          set x "$@" "$1"
                    205:          shift
                    206:          ;;
                    207:        *.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
                    208:          func_file_conv "$1"
                    209:          set x "$@" -Tp"$file"
                    210:          shift
                    211:          ;;
                    212:        *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
                    213:          func_file_conv "$1" mingw
                    214:          set x "$@" "$file"
                    215:          shift
                    216:          ;;
                    217:        *)
                    218:          set x "$@" "$1"
                    219:          shift
                    220:          ;;
                    221:       esac
                    222:     fi
                    223:     shift
                    224:   done
                    225:   if test -n "$linker_opts"; then
                    226:     linker_opts="-link$linker_opts"
                    227:   fi
                    228:   exec "$@" $linker_opts
                    229:   exit 1
                    230: }
                    231: 
                    232: eat=
                    233: 
                    234: case $1 in
                    235:   '')
                    236:      echo "$0: No command.  Try '$0 --help' for more information." 1>&2
                    237:      exit 1;
                    238:      ;;
                    239:   -h | --h*)
                    240:     cat <<\EOF
                    241: Usage: compile [--help] [--version] PROGRAM [ARGS]
                    242: 
                    243: Wrapper for compilers which do not understand '-c -o'.
                    244: Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
                    245: arguments, and rename the output as expected.
                    246: 
                    247: If you are trying to build a whole package this is not the
                    248: right script to run: please start by reading the file 'INSTALL'.
                    249: 
                    250: Report bugs to <bug-automake@gnu.org>.
                    251: EOF
                    252:     exit $?
                    253:     ;;
                    254:   -v | --v*)
                    255:     echo "compile $scriptversion"
                    256:     exit $?
                    257:     ;;
                    258:   cl | *[/\\]cl | cl.exe | *[/\\]cl.exe | \
                    259:   icl | *[/\\]icl | icl.exe | *[/\\]icl.exe )
                    260:     func_cl_wrapper "$@"      # Doesn't return...
                    261:     ;;
                    262: esac
                    263: 
                    264: ofile=
                    265: cfile=
                    266: 
                    267: for arg
                    268: do
                    269:   if test -n "$eat"; then
                    270:     eat=
                    271:   else
                    272:     case $1 in
                    273:       -o)
                    274:        # configure might choose to run compile as 'compile cc -o foo foo.c'.
                    275:        # So we strip '-o arg' only if arg is an object.
                    276:        eat=1
                    277:        case $2 in
                    278:          *.o | *.obj)
                    279:            ofile=$2
                    280:            ;;
                    281:          *)
                    282:            set x "$@" -o "$2"
                    283:            shift
                    284:            ;;
                    285:        esac
                    286:        ;;
                    287:       *.c)
                    288:        cfile=$1
                    289:        set x "$@" "$1"
                    290:        shift
                    291:        ;;
                    292:       *)
                    293:        set x "$@" "$1"
                    294:        shift
                    295:        ;;
                    296:     esac
                    297:   fi
                    298:   shift
                    299: done
                    300: 
                    301: if test -z "$ofile" || test -z "$cfile"; then
                    302:   # If no '-o' option was seen then we might have been invoked from a
                    303:   # pattern rule where we don't need one.  That is ok -- this is a
                    304:   # normal compilation that the losing compiler can handle.  If no
                    305:   # '.c' file was seen then we are probably linking.  That is also
                    306:   # ok.
                    307:   exec "$@"
                    308: fi
                    309: 
                    310: # Name of file we expect compiler to create.
                    311: cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
                    312: 
                    313: # Create the lock directory.
                    314: # Note: use '[/\\:.-]' here to ensure that we don't use the same name
                    315: # that we are using for the .o file.  Also, base the name on the expected
                    316: # object file name, since that is what matters with a parallel build.
                    317: lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
                    318: while true; do
                    319:   if mkdir "$lockdir" >/dev/null 2>&1; then
                    320:     break
                    321:   fi
                    322:   sleep 1
                    323: done
                    324: # FIXME: race condition here if user kills between mkdir and trap.
                    325: trap "rmdir '$lockdir'; exit 1" 1 2 15
                    326: 
                    327: # Run the compile.
                    328: "$@"
                    329: ret=$?
                    330: 
                    331: if test -f "$cofile"; then
                    332:   test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
                    333: elif test -f "${cofile}bj"; then
                    334:   test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
                    335: fi
                    336: 
                    337: rmdir "$lockdir"
                    338: exit $ret
                    339: 
                    340: # Local Variables:
                    341: # mode: shell-script
                    342: # sh-indentation: 2
                    343: # eval: (add-hook 'before-save-hook 'time-stamp)
                    344: # time-stamp-start: "scriptversion="
                    345: # time-stamp-format: "%:y-%02m-%02d.%02H"
                    346: # time-stamp-time-zone: "UTC0"
                    347: # time-stamp-end: "; # UTC"
                    348: # End:

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>