Annotation of embedaddon/pcre/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=2012-10-14.11; # UTC
                      5: 
                      6: # Copyright (C) 1999-2013 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 <http://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:     func_cl_wrapper "$@"      # Doesn't return...
                    260:     ;;
                    261: esac
                    262: 
                    263: ofile=
                    264: cfile=
                    265: 
                    266: for arg
                    267: do
                    268:   if test -n "$eat"; then
                    269:     eat=
                    270:   else
                    271:     case $1 in
                    272:       -o)
                    273:        # configure might choose to run compile as 'compile cc -o foo foo.c'.
                    274:        # So we strip '-o arg' only if arg is an object.
                    275:        eat=1
                    276:        case $2 in
                    277:          *.o | *.obj)
                    278:            ofile=$2
                    279:            ;;
                    280:          *)
                    281:            set x "$@" -o "$2"
                    282:            shift
                    283:            ;;
                    284:        esac
                    285:        ;;
                    286:       *.c)
                    287:        cfile=$1
                    288:        set x "$@" "$1"
                    289:        shift
                    290:        ;;
                    291:       *)
                    292:        set x "$@" "$1"
                    293:        shift
                    294:        ;;
                    295:     esac
                    296:   fi
                    297:   shift
                    298: done
                    299: 
                    300: if test -z "$ofile" || test -z "$cfile"; then
                    301:   # If no '-o' option was seen then we might have been invoked from a
                    302:   # pattern rule where we don't need one.  That is ok -- this is a
                    303:   # normal compilation that the losing compiler can handle.  If no
                    304:   # '.c' file was seen then we are probably linking.  That is also
                    305:   # ok.
                    306:   exec "$@"
                    307: fi
                    308: 
                    309: # Name of file we expect compiler to create.
                    310: cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
                    311: 
                    312: # Create the lock directory.
                    313: # Note: use '[/\\:.-]' here to ensure that we don't use the same name
                    314: # that we are using for the .o file.  Also, base the name on the expected
                    315: # object file name, since that is what matters with a parallel build.
                    316: lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
                    317: while true; do
                    318:   if mkdir "$lockdir" >/dev/null 2>&1; then
                    319:     break
                    320:   fi
                    321:   sleep 1
                    322: done
                    323: # FIXME: race condition here if user kills between mkdir and trap.
                    324: trap "rmdir '$lockdir'; exit 1" 1 2 15
                    325: 
                    326: # Run the compile.
                    327: "$@"
                    328: ret=$?
                    329: 
                    330: if test -f "$cofile"; then
                    331:   test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
                    332: elif test -f "${cofile}bj"; then
                    333:   test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
                    334: fi
                    335: 
                    336: rmdir "$lockdir"
                    337: exit $ret
                    338: 
                    339: # Local Variables:
                    340: # mode: shell-script
                    341: # sh-indentation: 2
                    342: # eval: (add-hook 'write-file-hooks 'time-stamp)
                    343: # time-stamp-start: "scriptversion="
                    344: # time-stamp-format: "%:y-%02m-%02d.%02H"
                    345: # time-stamp-time-zone: "UTC"
                    346: # time-stamp-end: "; # UTC"
                    347: # End:

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