~ubuntu-branches/ubuntu/raring/flac/raring

« back to all changes in this revision

Viewing changes to install-sh

  • Committer: Bazaar Package Importer
  • Author(s): Joshua Kwan
  • Date: 2007-05-29 22:56:36 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070529225636-ljeff8xxip09qaap
Tags: 1.1.4-1
* New upstream release. closes: #405167, #411311
  - libOggFLAC and libOggFLAC++ have been merged into libFLAC, so
    remove their corresponding packages.
  - Because of the API changes required to effect the above, there has
    been yet another soname bump. libflac7 -> libflac8 and
    libflac++5 -> libflac++6. Emails have been dispatched to the
    maintainers of dependent packages.
* Some notes on patches that were removed:
  - 02_stdin_stdout, 06_manpage_mention_utf8_convert: merged upstream
  - 08_manpage_warnings: Upstream has changed the manpage so it defintely
    can't fit in in 80 cols, so just forget about it. We'll live.
  - 05_eof_warnings_are_errors: Upstream decided to add a -w option to
    flac to treat all warnings as errors. I am going to defer to that
    for now, but if people think it's stupid let me know and I'll port
    the patch forward.
  - 04_stack_smasher: was a backport from 1.1.3, so it's obsolete.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#!/bin/sh
 
2
#
2
3
# install - install a program, script, or datafile
3
 
 
4
 
scriptversion=2004-04-01.17
5
 
 
 
4
#
6
5
# This originates from X11R5 (mit/util/scripts/install.sh), which was
7
6
# later released in X11R6 (xc/config/util/install.sh) with the
8
7
# following copyright and license.
42
41
# from scratch.  It can only install one file at a time, a restriction
43
42
# shared with many OS's install programs.
44
43
 
 
44
 
45
45
# set DOITPROG to echo to test this script
46
46
 
47
47
# Don't use :- since 4.3BSD and earlier shells don't like it.
48
48
doit="${DOITPROG-}"
49
49
 
 
50
 
50
51
# put in absolute paths if you don't have them in your path; or use env. vars.
51
52
 
52
53
mvprog="${MVPROG-mv}"
58
59
rmprog="${RMPROG-rm}"
59
60
mkdirprog="${MKDIRPROG-mkdir}"
60
61
 
61
 
transformbasename=
62
 
transform_arg=
 
62
transformbasename=""
 
63
transform_arg=""
63
64
instcmd="$mvprog"
64
65
chmodcmd="$chmodprog 0755"
65
 
chowncmd=
66
 
chgrpcmd=
67
 
stripcmd=
 
66
chowncmd=""
 
67
chgrpcmd=""
 
68
stripcmd=""
68
69
rmcmd="$rmprog -f"
69
70
mvcmd="$mvprog"
70
 
src=
71
 
dst=
72
 
dir_arg=
73
 
 
74
 
usage="Usage: $0 [OPTION]... SRCFILE DSTFILE
75
 
   or: $0 [OPTION]... SRCFILES... DIRECTORY
76
 
   or: $0 -d DIRECTORIES...
77
 
 
78
 
In the first form, install SRCFILE to DSTFILE, removing SRCFILE by default.
79
 
In the second, create the directory path DIR.
80
 
 
81
 
Options:
82
 
-b=TRANSFORMBASENAME
83
 
-c         copy source (using $cpprog) instead of moving (using $mvprog).
84
 
-d         create directories instead of installing files.
85
 
-g GROUP   $chgrp installed files to GROUP.
86
 
-m MODE    $chmod installed files to MODE.
87
 
-o USER    $chown installed files to USER.
88
 
-s         strip installed files (using $stripprog).
89
 
-t=TRANSFORM
90
 
--help     display this help and exit.
91
 
--version  display version info and exit.
92
 
 
93
 
Environment variables override the default commands:
94
 
  CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG
95
 
"
96
 
 
97
 
while test -n "$1"; do
98
 
  case $1 in
99
 
    -b=*) transformbasename=`echo $1 | sed 's/-b=//'`
100
 
        shift
101
 
        continue;;
102
 
 
103
 
    -c) instcmd=$cpprog
104
 
        shift
105
 
        continue;;
106
 
 
107
 
    -d) dir_arg=true
108
 
        shift
109
 
        continue;;
110
 
 
111
 
    -g) chgrpcmd="$chgrpprog $2"
112
 
        shift
113
 
        shift
114
 
        continue;;
115
 
 
116
 
    --help) echo "$usage"; exit 0;;
117
 
 
118
 
    -m) chmodcmd="$chmodprog $2"
119
 
        shift
120
 
        shift
121
 
        continue;;
122
 
 
123
 
    -o) chowncmd="$chownprog $2"
124
 
        shift
125
 
        shift
126
 
        continue;;
127
 
 
128
 
    -s) stripcmd=$stripprog
129
 
        shift
130
 
        continue;;
131
 
 
132
 
    -t=*) transformarg=`echo $1 | sed 's/-t=//'`
133
 
        shift
134
 
        continue;;
135
 
 
136
 
    --version) echo "$0 $scriptversion"; exit 0;;
137
 
 
138
 
    *)  # When -d is used, all remaining arguments are directories to create.
139
 
        test -n "$dir_arg" && break
140
 
        # Otherwise, the last argument is the destination.  Remove it from $@.
141
 
        for arg
142
 
        do
143
 
          if test -n "$dstarg"; then
144
 
            # $@ is not empty: it contains at least $arg.
145
 
            set fnord "$@" "$dstarg"
146
 
            shift # fnord
147
 
          fi
148
 
          shift # arg
149
 
          dstarg=$arg
150
 
        done
151
 
        break;;
152
 
  esac
153
 
done
154
 
 
155
 
if test -z "$1"; then
156
 
  if test -z "$dir_arg"; then
157
 
    echo "$0: no input file specified." >&2
158
 
    exit 1
159
 
  fi
160
 
  # It's OK to call `install-sh -d' without argument.
161
 
  # This can happen when creating conditional directories.
162
 
  exit 0
163
 
fi
164
 
 
165
 
for src
166
 
do
167
 
  # Protect names starting with `-'.
168
 
  case $src in
169
 
    -*) src=./$src ;;
170
 
  esac
171
 
 
172
 
  if test -n "$dir_arg"; then
173
 
    dst=$src
174
 
    src=
175
 
 
176
 
    if test -d "$dst"; then
177
 
      instcmd=:
178
 
      chmodcmd=
179
 
    else
180
 
      instcmd=$mkdirprog
181
 
    fi
182
 
  else
183
 
    # Waiting for this to be detected by the "$instcmd $src $dsttmp" command
184
 
    # might cause directories to be created, which would be especially bad
185
 
    # if $src (and thus $dsttmp) contains '*'.
186
 
    if test ! -f "$src" && test ! -d "$src"; then
187
 
      echo "$0: $src does not exist." >&2
188
 
      exit 1
189
 
    fi
190
 
 
191
 
    if test -z "$dstarg"; then
192
 
      echo "$0: no destination specified." >&2
193
 
      exit 1
194
 
    fi
195
 
 
196
 
    dst=$dstarg
197
 
    # Protect names starting with `-'.
198
 
    case $dst in
199
 
      -*) dst=./$dst ;;
 
71
src=""
 
72
dst=""
 
73
dir_arg=""
 
74
 
 
75
while [ x"$1" != x ]; do
 
76
    case $1 in
 
77
        -c) instcmd=$cpprog
 
78
            shift
 
79
            continue;;
 
80
 
 
81
        -d) dir_arg=true
 
82
            shift
 
83
            continue;;
 
84
 
 
85
        -m) chmodcmd="$chmodprog $2"
 
86
            shift
 
87
            shift
 
88
            continue;;
 
89
 
 
90
        -o) chowncmd="$chownprog $2"
 
91
            shift
 
92
            shift
 
93
            continue;;
 
94
 
 
95
        -g) chgrpcmd="$chgrpprog $2"
 
96
            shift
 
97
            shift
 
98
            continue;;
 
99
 
 
100
        -s) stripcmd=$stripprog
 
101
            shift
 
102
            continue;;
 
103
 
 
104
        -t=*) transformarg=`echo $1 | sed 's/-t=//'`
 
105
            shift
 
106
            continue;;
 
107
 
 
108
        -b=*) transformbasename=`echo $1 | sed 's/-b=//'`
 
109
            shift
 
110
            continue;;
 
111
 
 
112
        *)  if [ x"$src" = x ]
 
113
            then
 
114
                src=$1
 
115
            else
 
116
                # this colon is to work around a 386BSD /bin/sh bug
 
117
                :
 
118
                dst=$1
 
119
            fi
 
120
            shift
 
121
            continue;;
200
122
    esac
201
 
 
202
 
    # If destination is a directory, append the input filename; won't work
203
 
    # if double slashes aren't ignored.
204
 
    if test -d "$dst"; then
205
 
      dst=$dst/`basename "$src"`
206
 
    fi
207
 
  fi
208
 
 
209
 
  # This sed command emulates the dirname command.
210
 
  dstdir=`echo "$dst" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
211
 
 
212
 
  # Make sure that the destination directory exists.
213
 
 
214
 
  # Skip lots of stat calls in the usual case.
215
 
  if test ! -d "$dstdir"; then
216
 
    defaultIFS='
217
 
         '
218
 
    IFS="${IFS-$defaultIFS}"
219
 
 
220
 
    oIFS=$IFS
221
 
    # Some sh's can't handle IFS=/ for some reason.
222
 
    IFS='%'
223
 
    set - `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'`
224
 
    IFS=$oIFS
225
 
 
226
 
    pathcomp=
227
 
 
228
 
    while test $# -ne 0 ; do
229
 
      pathcomp=$pathcomp$1
230
 
      shift
231
 
      if test ! -d "$pathcomp"; then
232
 
        $mkdirprog "$pathcomp" || lasterr=$?
233
 
        # mkdir can fail with a `File exist' error in case several
234
 
        # install-sh are creating the directory concurrently.  This
235
 
        # is OK.
236
 
        test ! -d "$pathcomp" && { (exit ${lasterr-1}); exit; }
237
 
      fi
238
 
      pathcomp=$pathcomp/
239
 
    done
240
 
  fi
241
 
 
242
 
  if test -n "$dir_arg"; then
243
 
    $doit $instcmd "$dst" \
244
 
      && { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \
245
 
      && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \
246
 
      && { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \
247
 
      && { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; }
248
 
 
249
 
  else
250
 
    # If we're going to rename the final executable, determine the name now.
251
 
    if test -z "$transformarg"; then
252
 
      dstfile=`basename "$dst"`
253
 
    else
254
 
      dstfile=`basename "$dst" $transformbasename \
255
 
               | sed $transformarg`$transformbasename
256
 
    fi
257
 
 
258
 
    # don't allow the sed command to completely eliminate the filename.
259
 
    test -z "$dstfile" && dstfile=`basename "$dst"`
260
 
 
261
 
    # Make a couple of temp file names in the proper directory.
262
 
    dsttmp=$dstdir/_inst.$$_
263
 
    rmtmp=$dstdir/_rm.$$_
264
 
 
265
 
    # Trap to clean up those temp files at exit.
266
 
    trap 'status=$?; rm -f "$dsttmp" "$rmtmp" && exit $status' 0
267
 
    trap '(exit $?); exit' 1 2 13 15
268
 
 
269
 
    # Move or copy the file name to the temp name
270
 
    $doit $instcmd "$src" "$dsttmp" &&
271
 
 
272
 
    # and set any options; do chmod last to preserve setuid bits.
273
 
    #
274
 
    # If any of these fail, we abort the whole thing.  If we want to
275
 
    # ignore errors from any of these, just make sure not to ignore
276
 
    # errors from the above "$doit $instcmd $src $dsttmp" command.
277
 
    #
278
 
    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \
279
 
      && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \
280
 
      && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \
281
 
      && { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } &&
282
 
 
283
 
    # Now rename the file to the real destination.
284
 
    { $doit $mvcmd -f "$dsttmp" "$dstdir/$dstfile" 2>/dev/null \
285
 
      || {
286
 
           # The rename failed, perhaps because mv can't rename something else
287
 
           # to itself, or perhaps because mv is so ancient that it does not
288
 
           # support -f.
289
 
 
290
 
           # Now remove or move aside any old file at destination location.
291
 
           # We try this two ways since rm can't unlink itself on some
292
 
           # systems and the destination file might be busy for other
293
 
           # reasons.  In this case, the final cleanup might fail but the new
294
 
           # file should still install successfully.
295
 
           {
296
 
             if test -f "$dstdir/$dstfile"; then
297
 
               $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \
298
 
               || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \
299
 
               || {
300
 
                 echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2
301
 
                 (exit 1); exit
302
 
               }
303
 
             else
304
 
               :
305
 
             fi
306
 
           } &&
307
 
 
308
 
           # Now rename the file to the real destination.
309
 
           $doit $mvcmd "$dsttmp" "$dstdir/$dstfile"
310
 
         }
311
 
    }
312
 
  fi || { (exit 1); exit; }
313
 
done
 
123
done
 
124
 
 
125
if [ x"$src" = x ]
 
126
then
 
127
        echo "$0: no input file specified" >&2
 
128
        exit 1
 
129
else
 
130
        :
 
131
fi
 
132
 
 
133
if [ x"$dir_arg" != x ]; then
 
134
        dst=$src
 
135
        src=""
 
136
 
 
137
        if [ -d "$dst" ]; then
 
138
                instcmd=:
 
139
                chmodcmd=""
 
140
        else
 
141
                instcmd=$mkdirprog
 
142
        fi
 
143
else
 
144
 
 
145
# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
 
146
# might cause directories to be created, which would be especially bad
 
147
# if $src (and thus $dsttmp) contains '*'.
 
148
 
 
149
        if [ -f "$src" ] || [ -d "$src" ]
 
150
        then
 
151
                :
 
152
        else
 
153
                echo "$0: $src does not exist" >&2
 
154
                exit 1
 
155
        fi
 
156
 
 
157
        if [ x"$dst" = x ]
 
158
        then
 
159
                echo "$0: no destination specified" >&2
 
160
                exit 1
 
161
        else
 
162
                :
 
163
        fi
 
164
 
 
165
# If destination is a directory, append the input filename; if your system
 
166
# does not like double slashes in filenames, you may need to add some logic
 
167
 
 
168
        if [ -d "$dst" ]
 
169
        then
 
170
                dst=$dst/`basename "$src"`
 
171
        else
 
172
                :
 
173
        fi
 
174
fi
 
175
 
 
176
## this sed command emulates the dirname command
 
177
dstdir=`echo "$dst" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
 
178
 
 
179
# Make sure that the destination directory exists.
 
180
#  this part is taken from Noah Friedman's mkinstalldirs script
 
181
 
 
182
# Skip lots of stat calls in the usual case.
 
183
if [ ! -d "$dstdir" ]; then
 
184
defaultIFS='
 
185
        '
 
186
IFS="${IFS-$defaultIFS}"
 
187
 
 
188
oIFS=$IFS
 
189
# Some sh's can't handle IFS=/ for some reason.
 
190
IFS='%'
 
191
set - `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'`
 
192
IFS=$oIFS
 
193
 
 
194
pathcomp=''
 
195
 
 
196
while [ $# -ne 0 ] ; do
 
197
        pathcomp=$pathcomp$1
 
198
        shift
 
199
 
 
200
        if [ ! -d "$pathcomp" ] ;
 
201
        then
 
202
                $mkdirprog "$pathcomp"
 
203
        else
 
204
                :
 
205
        fi
 
206
 
 
207
        pathcomp=$pathcomp/
 
208
done
 
209
fi
 
210
 
 
211
if [ x"$dir_arg" != x ]
 
212
then
 
213
        $doit $instcmd "$dst" &&
 
214
 
 
215
        if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dst"; else : ; fi &&
 
216
        if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dst"; else : ; fi &&
 
217
        if [ x"$stripcmd" != x ]; then $doit $stripcmd "$dst"; else : ; fi &&
 
218
        if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dst"; else : ; fi
 
219
else
 
220
 
 
221
# If we're going to rename the final executable, determine the name now.
 
222
 
 
223
        if [ x"$transformarg" = x ]
 
224
        then
 
225
                dstfile=`basename "$dst"`
 
226
        else
 
227
                dstfile=`basename "$dst" $transformbasename |
 
228
                        sed $transformarg`$transformbasename
 
229
        fi
 
230
 
 
231
# don't allow the sed command to completely eliminate the filename
 
232
 
 
233
        if [ x"$dstfile" = x ]
 
234
        then
 
235
                dstfile=`basename "$dst"`
 
236
        else
 
237
                :
 
238
        fi
 
239
 
 
240
# Make a couple of temp file names in the proper directory.
 
241
 
 
242
        dsttmp=$dstdir/_inst.$$_
 
243
        rmtmp=$dstdir/_rm.$$_
 
244
 
 
245
# Trap to clean up temp files at exit.
 
246
 
 
247
        trap 'status=$?; rm -f "$dsttmp" "$rmtmp" && exit $status' 0
 
248
        trap '(exit $?); exit' 1 2 13 15
 
249
 
 
250
# Move or copy the file name to the temp name
 
251
 
 
252
        $doit $instcmd "$src" "$dsttmp" &&
 
253
 
 
254
# and set any options; do chmod last to preserve setuid bits
 
255
 
 
256
# If any of these fail, we abort the whole thing.  If we want to
 
257
# ignore errors from any of these, just make sure not to ignore
 
258
# errors from the above "$doit $instcmd $src $dsttmp" command.
 
259
 
 
260
        if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dsttmp"; else :;fi &&
 
261
        if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dsttmp"; else :;fi &&
 
262
        if [ x"$stripcmd" != x ]; then $doit $stripcmd "$dsttmp"; else :;fi &&
 
263
        if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dsttmp"; else :;fi &&
 
264
 
 
265
# Now remove or move aside any old file at destination location.  We try this
 
266
# two ways since rm can't unlink itself on some systems and the destination
 
267
# file might be busy for other reasons.  In this case, the final cleanup
 
268
# might fail but the new file should still install successfully.
 
269
 
 
270
{
 
271
        if [ -f "$dstdir/$dstfile" ]
 
272
        then
 
273
                $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null ||
 
274
                $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null ||
 
275
                {
 
276
                  echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2
 
277
                  (exit 1); exit
 
278
                }
 
279
        else
 
280
                :
 
281
        fi
 
282
} &&
 
283
 
 
284
# Now rename the file to the real destination.
 
285
 
 
286
        $doit $mvcmd "$dsttmp" "$dstdir/$dstfile"
 
287
 
 
288
fi &&
314
289
 
315
290
# The final little trick to "correctly" pass the exit status to the exit trap.
 
291
 
316
292
{
317
 
  (exit 0); exit
 
293
        (exit 0); exit
318
294
}
319
 
 
320
 
# Local variables:
321
 
# eval: (add-hook 'write-file-hooks 'time-stamp)
322
 
# time-stamp-start: "scriptversion="
323
 
# time-stamp-format: "%:y-%02m-%02d.%02H"
324
 
# time-stamp-end: "$"
325
 
# End: