Extend Musicbrainz multi-artist support
[abcde.git] / abcde
diff --git a/abcde b/abcde
index 8a873fe..384954a 100755 (executable)
--- a/abcde
+++ b/abcde
@@ -2,8 +2,8 @@
 # Copyright (c) 1998-2001 Robert Woodcock <rcw@debian.org>
 # Copyright (c) 2003-2006 Jesus Climent <jesus.climent@hispalinux.es>
 # Copyright (c) 2009-2012 Colin Tuckley <colint@debian.org>
-# Copyright (c) 2012-     Steve McIntyre <93sam@@debian.org>
-# Copyright (c) 2015-2016 Andrew Strong <andrew.david.strong@gmail.com>
+# Copyright (c) 2012-2018 Steve McIntyre <93sam@@debian.org>
+# Copyright (c) 2015-2017 Andrew Strong <andrew.david.strong@gmail.com>
 # This code is hereby licensed for public consumption under either the
 # GNU GPL v2 or greater, or Larry Wall's Artistic license - your choice.
 #
@@ -20,8 +20,9 @@ echo "Usage: abcde [options] [tracks]"
 echo "Options:"
 echo "-1     Encode the whole CD in a single file"
 echo "-a <action1[,action2]...>"
-echo "       Actions to perform:"
-echo "       cddb,read,getalbumart,embedalbumart,normalize,encode,tag,move,replaygain,playlist,clean"
+echo "       Actions to perform, comma separated:"
+echo "       (cddb,read,getalbumart,embedalbumart,normalize,encode,"
+echo "       tag,move,replaygain,playlist,clean)"
 #echo "-A     Experimental actions (retag, transcode)"
 echo "-b     Enable batch normalization"
 echo "-B     Embed albumart (this also activates getalbumart)"
@@ -48,10 +49,13 @@ echo "-m     Modify playlist to include CRLF endings, to comply with some player
 echo "-n     No lookup. Don't query CDDB, just create and use template"
 echo "-N     Noninteractive. Never prompt for anything"
 echo "-o <type1[,type2]...>"
-echo "       Output file type(s) (vorbis,mp3,flac,spx,mpc,wav,m4a,opus,mka,wv,ape,mp2,tta,aiff). Defaults to vorbis"
+echo "       Output file type(s), comma separated"
+echo "       (vorbis,mp3,flac,spx,mpc,wav,m4a,opus,mka,wv,ape,mp2,tta,aiff)."
+echo "       Defaults to vorbis"
 echo "-p     Pad track numbers with 0's (if less than 10 tracks)"
 echo "-P     Use UNIX pipes to read+encode without wav files"
-echo "-Q     Select CDDBMETHOD method(s) from the command line. Choose from any/all of musicbrainz,cddb,cdtext. Defaults to musicbrainz".
+echo "-Q     CD lookup method(s), comma separated"
+echo "       (musicbrainz,cddb,cdtext). Defaults to musicbrainz".
 echo "-r <host1[,host2]...>"
 echo "       Also encode on these remote hosts"
 echo "-s <field>"
@@ -97,21 +101,21 @@ log ()
 f_seq_row ()
 {
        i=$1
-       while [ $i -ne `expr $2 + 1` ]
+       while [ $i -le $2 ]
        do
                echo $i
-               i=`expr $i + 1`
+               i=$(( $i + 1 ))
        done
 }
 
 f_seq_line ()
 {
        i=$1
-       if echo $i | grep "[[:digit:]]" > /dev/null 2>&1 ; then
-               while [ $i -ne `expr $2 + 1` ]
+       if echo "$i" | grep "[[:digit:]]" > /dev/null 2>&1 ; then
+               while [ $i -le $2 ]
                do
-                       printf $i" "
-                       i=`expr $i + 1`
+                       printf "%d " "$i"
+                       i=$(( $i + 1 ))
                done
                echo
        else
@@ -123,26 +127,26 @@ f_seq_line ()
 # Functions to replace the need of awk {print $1} and {print $NF}
 get_first()
 {
-if [ X"$1" = "X" ]; then
-       for first in `cat`; do
-               break
-       done
-else
-       first=$1
-fi
-echo $first
+       if [ X"$1" = "X" ]; then
+               for first in $(cat); do
+                       break
+               done
+       else
+               first=$1
+       fi
+       echo "$first"
 }
 
 get_last()
 {
-if [ X"$1" = "X" ]; then
-       for stdin in `cat`; do
-               last=$stdin
-       done
-else
-       for last in $@ ; do :; done
-fi
-echo $last
+       if [ X"$1" = "X" ]; then
+               for stdin in $(cat); do
+                       last=$stdin
+               done
+       else
+               for last in $@ ; do :; done
+       fi
+       echo "$last"
 }
 
 # checkstatus [blurb]
@@ -153,7 +157,7 @@ checkstatus ()
 {
        # Take the last line in the status file if there's multiple matches
        PATTERN="^$1(=.*)?$"
-       BLURB=$(grep -E $PATTERN "${ABCDETEMPDIR}/status" | tail -n 1)
+       BLURB=$(grep -E "$PATTERN" "${ABCDETEMPDIR}/status" | tail -n 1)
 
        if [ -z "$BLURB" ]; then
                # No matches found
@@ -161,8 +165,8 @@ checkstatus ()
        else
                # Matches found
                # See if there's a = in it
-               if [ "$(echo $BLURB | grep -c =)" != "0" ]; then
-                       echo "$(echo $BLURB | cut -f2- -d=)"
+               if ( echo "$BLURB" | grep -q '=' ); then
+                       echo "$BLURB" | cut -f2- -d=
                fi
                return 0
        fi
@@ -180,7 +184,7 @@ checkwarnings ()
        fi
        # Take the last line in the status file if there's multiple matches
        PATTERN="^$1(:.*)?$"
-       BLURB="$(grep -E $PATTERN "${ABCDETEMPDIR}/warnings" | tail -n 1)"
+       BLURB=$(grep -E "$PATTERN" "${ABCDETEMPDIR}/warnings" | tail -n 1)
 
        if [ -z "$BLURB" ]; then
                # negative, we did not have a negative...
@@ -203,7 +207,7 @@ checkerrors ()
        fi
        # Take the last line in the status file if there's multiple matches
        PATTERN="^$1(:.*)?$"
-       BLURB="$(grep -E $PATTERN "${ABCDETEMPDIR}/errors" | tail -n 1)"
+       BLURB=$(grep -E "$PATTERN" "${ABCDETEMPDIR}/errors" | tail -n 1)
 
        if [ -z "$BLURB" ]; then
                # negative, we did not have a negative...
@@ -215,26 +219,36 @@ checkerrors ()
 }
 
 # page [file]
-# Finds the right pager in the system to display a file
+# Display a file. If it's too long to fit the current terminal size,
+# find the right pager in the system and use it
 page ()
 {
        PAGEFILE="$1"
-       # Use the debian sensible-pager wrapper to pick the pager
-       # user has requested via their $PAGER environment variable
-       if [ -x "/usr/bin/sensible-pager" ]; then
-               /usr/bin/sensible-pager "$PAGEFILE"
-       elif [ -x "$PAGER" ]; then
-               # That failed, try to load the preferred editor, starting
-               # with their PAGER variable
-               $PAGER "$PAGEFILE"
-               # If that fails, check for less
-       elif [ -x /usr/bin/less ]; then
-               /usr/bin/less -f "$PAGEFILE"
-               # more should be on all UNIX systems
-       elif [ -x /bin/more ]; then
-               /bin/more "$PAGEFILE"
+       local NUM_LINES=$(wc -l < "$PAGEFILE")
+
+       # Is the text long enough to need a pager?
+       if [ "$NUM_LINES" -ge $LINES ]; then
+               # Yes!
+               # Use the debian sensible-pager wrapper to pick the pager user
+               # has requested via their $PAGER environment variable
+               if [ -x "/usr/bin/sensible-pager" ]; then
+                       /usr/bin/sensible-pager "$PAGEFILE"
+               elif [ -x "$PAGER" ]; then
+                       # That failed, try to load the preferred pager, starting
+                       # with their PAGER variable
+                       $PAGER "$PAGEFILE"
+                       # If that fails, check for less
+               elif [ -x /usr/bin/less ]; then
+                       /usr/bin/less -f "$PAGEFILE"
+                       # more should be on all UNIX systems
+               elif [ -x /bin/more ]; then
+                       /bin/more "$PAGEFILE"
+               else
+                       # No bananas, just cat the thing
+                       cat "$PAGEFILE" >&2
+               fi
        else
-               # No bananas, just cat the thing
+               # No, just cat the thing
                cat "$PAGEFILE" >&2
        fi
 }
@@ -253,7 +267,7 @@ run_command ()
        else
                # Special case for SMP, since
                # encoder output is never displayed, don't mute echos
-               if [ -z "$BLURB" -a "$MAXPROCS" != "1" ]; then
+               if [ -z "$BLURB" ] && [ "$MAXPROCS" != "1" ]; then
                        "$@" >&2
                        RETURN=$?
                else
@@ -281,7 +295,7 @@ run_command ()
                return $RETURN # Do not pass go, do not update the status file
        fi
        if [ "$BLURB" ]; then
-               echo $BLURB >> "${ABCDETEMPDIR}/status"
+               echo "$BLURB" >> "${ABCDETEMPDIR}/status"
        fi
 }
 
@@ -331,17 +345,18 @@ relpath ()
                ;;
        esac
 
-       echo $TO
+       echo "$TO"
 }
 
 new_checkexec ()
 {
        if [ ! "$@" = "" ]; then
                # Cut off any command-line option we added in
-               X=$(echo $@ | cut -d' ' -f2)
-               if [ "$(which $X 2>/dev/null)" = "" ]; then
+               X=$(echo "$@" | cut -d' ' -f2)
+               WHICH=$(which "$X" 2>/dev/null)
+               if [ -z "$WHICH" ]; then
                        return 1
-               elif [ ! -x $(which $X 2>/dev/null) ]; then
+               elif [ ! -x "$WHICH" ]; then
                        return 2
                fi
        fi
@@ -352,10 +367,11 @@ checkexec ()
 {
        if [ ! "$@" = "" ]; then
                # Cut off any command-line option we added in
-               X=$(echo $@ | cut -d' ' -f2)
+               X=$(echo "$@" | cut -d' ' -f2)
                # Test for built-in abcde.function
-               [ "$X" != "${X#abcde.}" ] && type $X >/dev/null 2>&1 && return
-               if [ "$(which $X 2>/dev/null)" = "" ]; then
+               [ "$X" != "${X#abcde.}" ] && type "$X" >/dev/null 2>&1 && return
+               WHICH=$(which "$X" 2>/dev/null)
+               if [ -z "$WHICH" ]; then
                        log error "$X is not in your path." >&2
                        log info  "Define the full path to the executable if it exists on your system." >&2
                        if [ -e /etc/debian_version ] ; then
@@ -370,7 +386,7 @@ checkexec ()
                                log info "Hint: sudo apt-get install $MISSING_PACKAGE" >&2
                        fi
                        exit 1
-               elif [ ! -x "$(which $X 2>/dev/null)" ]; then
+               elif [ ! -x "$WHICH" ]; then
                        log error "$X is not executable." >&2
                        exit 1
                fi
@@ -387,27 +403,26 @@ diffentries ()
        shift
        local CDDBDIFFCHOICE="$@"
        if [ ! X"$DIFF" = "X" ]; then
-               PARSECHOICE1=$(echo $CDDBDIFFCHOICE | cut -d"," -f1 | xargs printf %d 2>/dev/null)
-               PARSECHOICE2=$(echo $CDDBDIFFCHOICE | cut -d"," -f2 | xargs printf %d 2>/dev/null)
-               if [ $PARSECHOICE1 -lt 1 ] || [ $PARSECHOICE1 -gt $CDDBDIFFCHOICES ] || \
-                  [ $PARSECHOICE2 -lt 1 ] || [ $PARSECHOICE2 -gt $CDDBDIFFCHOICES ] || \
-                  [ $PARSECHOICE1 -eq $PARSECHOICE2 ]; then
-                       echo "Invalid diff range. Please select two comma-separated numbers between 1 and $CDDBDIFFCHOICES" >&2
+               PARSECHOICE1=$(echo "$CDDBDIFFCHOICE" | cut -d"," -f1 | xargs printf %d 2>/dev/null)
+               PARSECHOICE2=$(echo "$CDDBDIFFCHOICE" | cut -d"," -f2 | xargs printf %d 2>/dev/null)
+               if [ "$PARSECHOICE1" -lt 1 ] || [ "$PARSECHOICE1" -gt "$CDDBDIFFCHOICES" ] || \
+                  [ "$PARSECHOICE2" -lt 1 ] || [ "$PARSECHOICE2" -gt "$CDDBDIFFCHOICES" ] || \
+                  [ "$PARSECHOICE1" -eq "$PARSECHOICE2" ]; then
+                       echo "Invalid diff range." >&2
+                       echo "Please select two comma-separated numbers between 1 and $CDDBDIFFCHOICES" >&2
                else
                        # We parse the 2 choices to diff, store them in temporary files and diff them.
-                       for PARSECHOICE in $(echo $CDDBDIFFCHOICE | tr , \ ); do
+                       for PARSECHOICE in $(echo "$CDDBDIFFCHOICE" | tr , \ ); do
                                do_cddbparse "${ABCDETEMPDIR}/$FILENAME.$PARSECHOICE" > "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE"
                        done
                        echo "Showing diff between choices $PARSECHOICE1 and $PARSECHOICE2..." > "${ABCDETEMPDIR}/$FILENAME.diff"
-                       $DIFF $DIFFOPTS "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE1" "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE2" >> "${ABCDETEMPDIR}/$FILENAME.diff"
-                       if [ $(cat "${ABCDETEMPDIR}/$FILENAME.diff" | wc -l) -ge $LINES ]; then
-                               page "${ABCDETEMPDIR}/$FILENAME.diff"
-                       else
-                               cat "${ABCDETEMPDIR}/$FILENAME.diff" >&2
-                       fi
+                       $DIFF $DIFFOPTS "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE1" \
+                                 "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE2" >> "${ABCDETEMPDIR}/$FILENAME.diff"
+                       page "${ABCDETEMPDIR}/$FILENAME.diff"
                fi
        else
-               echo "The diff program was not found in your path. Please choose a number between 0 and $CDDBDIFFCHOICES." >&2
+               echo "The diff program was not found in your path." >&2
+               echo "Please choose a number between 0 and $CDDBDIFFCHOICES." >&2
        fi
 }
 
@@ -417,13 +432,13 @@ getcddbinfo()
 {
        case $1 in
        TRACKNAME1)
-               TRACKNAME="$(grep -a ^TTITLE$CDDBTRACKNUM= "$CDDBDATA" | head -n 1 | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
+               TRACKNAME="$(grep -a "^TTITLE$CDDBTRACKNUM=" "$CDDBDATA" | head -n 1 | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
                ;;
        TRACKNAME)
-               TRACKNAME="$(grep -a ^TTITLE$CDDBTRACKNUM= "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
+               TRACKNAME="$(grep -a "^TTITLE$CDDBTRACKNUM=" "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
                ;;
        TRACK-INFO)
-               grep -a ^EXTT$CDDBTRACKNUM= "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\\n/\n/g'
+               grep -a "^EXTT$CDDBTRACKNUM=" "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\\n/\n/g'
                ;;
        esac
 }
@@ -434,10 +449,10 @@ gettracknum()
 {
        if [ -n "$STARTTRACKNUMBER" ] ; then
                # Get the trackpadding from the current track, also trim whitespace for MacOSX
-               CURRENTTRACKPADDING=$(echo -n $UTRACKNUM | wc -c | tr -d ' ')
-               TRACKNUM=$( printf %0.${CURRENTTRACKPADDING}d $(expr ${UTRACKNUM} + ${STARTTRACKNUMBER} - $FIRSTTRACK ))
+               CURRENTTRACKPADDING=$(echo -n "$UTRACKNUM" | wc -c | tr -d ' ')
+               TRACKNUM=$( printf %0."${CURRENTTRACKPADDING}"d $(("${UTRACKNUM}" + "${STARTTRACKNUMBER}" - "${FIRSTTRACK}")))
        else
-               TRACKNUM=${UTRACKNUM}
+               TRACKNUM="${UTRACKNUM}"
        fi
 }
 
@@ -474,7 +489,7 @@ makeids ()
        CDDBCKSUM=0
 
        COOKEDOFFSETS=""
-       for OFFSET in $(echo $OFFSETS)
+       for OFFSET in $OFFSETS
        do
                COOKEDOFFSETS="${COOKEDOFFSETS} $(($OFFSET + $LEADIN))"
 
@@ -488,7 +503,7 @@ makeids ()
 
        COOKEDOFFSETS="${COOKEDOFFSETS:1}"  # eat the leading space
 
-       PREGAP=$(($(echo $OFFSETS | cut -f1 -d' ')))
+       PREGAP=$(echo $OFFSETS | cut -f1 -d' ')
        TOTALTIME=$(( (($LEADOUT + $LEADIN + $PREGAP) / $CDFRAMES) - (($LEADIN + $PREGAP) / $CDFRAMES)))
 
        vvecho "makeids: PREGAP $PREGAP, LEADIN $LEADIN, LEADOUT $LEADOUT"
@@ -504,6 +519,11 @@ makeids ()
                *musicbrainz*)
                        # FIXME: don't assume the first track is 1
                        MBDISCID=$($MUSICBRAINZ --command calcid --discinfo 1 $TRACKS $LEADIN $(($PREGAP + $LEADOUT)) $OFFSETS)
+                       error=$?
+                       if [ $error != 0 ]; then
+                               log error "$MUSICBRAINZ failed to run; ABORT"
+                               exit $error
+                       fi
                        MBTRACKINFO="${MBDISCID} $((TRACKS)) ${COOKEDOFFSETS} $((($LEADOUT + $LEADIN + $IDMAGICNUM) / $CDFRAMES))"
                        ;;
        esac
@@ -513,7 +533,7 @@ do_replaygain()
 {
        if checkstatus replaygain; then :; else
                run_command "" echo "Adding replaygain information..."
-               for TMPOUTPUT in $( echo $OUTPUTTYPE | tr , \ )
+               for TMPOUTPUT in $( echo "$OUTPUTTYPE" | tr , \ )
                do
                        case $TMPOUTPUT in
                                vorbis|ogg)
@@ -533,7 +553,7 @@ do_replaygain()
                        REPLAYINDEX=0
                        for UTRACKNUM in $TRACKQUEUE
                        do
-                               CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+                               CDDBTRACKNUM=$(expr "$UTRACKNUM" - 1) # Unpad
                                getcddbinfo TRACKNAME
                                splitvarious
                                TRACKFILE="$(mungetrackname "$TRACKNAME")"
@@ -560,26 +580,25 @@ do_replaygain()
                        done
                        case "$OUTPUT" in
                                flac)
-                                       run_command replaygain-flac nice $ENCNICE $METAFLAC $FLACGAINOPTS "${OUTPUTFILES[@]}"
-                                       #run_command replaygain-flac true
+                                       run_command "replaygain-flac" nice $ENCNICE $METAFLAC $FLACGAINOPTS "${OUTPUTFILES[@]}"
                                        ;;
                                vorbis|ogg)
-                                       run_command replaygain-vorbis nice $ENCNICE $VORBISGAIN $VORBISGAINOPTS "${OUTPUTFILES[@]}"
+                                       run_command "replaygain-vorbis" nice $ENCNICE $VORBISGAIN $VORBISGAINOPTS "${OUTPUTFILES[@]}"
                                        ;;
                                mp3)
-                                       run_command replaygain-mp3 nice $ENCNICE $MP3GAIN $MP3GAINOPTS "${OUTPUTFILES[@]}"
+                                       run_command "replaygain-mp3" nice $ENCNICE $MP3GAIN $MP3GAINOPTS "${OUTPUTFILES[@]}"
                                        ;;
                                mpc)
-                                       run_command replaygain-mpc nice $ENCNICE $MPCGAIN "${OUTPUTFILES[@]}"
+                                       run_command "replaygain-mpc" nice $ENCNICE $MPCGAIN "${OUTPUTFILES[@]}"
                                        ;;
                                wv)
-                                       run_command replaygain-wv nice $ENCNICE $WVGAIN $WVGAINOPTS "${OUTPUTFILES[@]}"
+                                       run_command "replaygain-wv" nice $ENCNICE $WVGAIN $WVGAINOPTS "${OUTPUTFILES[@]}"
                                        ;;
                                *);;
                        esac
                done
                if checkerrors "replaygain-.{3,6}"; then :; else
-                       run_command replaygain true
+                       run_command "replaygain" true
                fi
        fi
 }
@@ -639,7 +658,7 @@ splitvarious ()
 }
 
 do_getgenreid () {
-       local genre=$(echo "${@}" | tr '[A-Z]' '[a-z]')
+       local genre=$(echo "${@}" | tr 'A-Z' 'a-z')
        local id=""
        case ${genre} in
                "blues")                 id=0 ;;
@@ -804,18 +823,18 @@ return 0
 # COMMENT, DALBUM, DARTIST, CDYEAR, CDGENRE
 do_tag ()
 {
-       COMMENTOUTPUT="$(eval echo ${COMMENT})"
+       COMMENTOUTPUT="$(eval echo "${COMMENT}")"
        if [ -z "$COMMENTOUTPUT" ]; then
                COMMENTOUTPUT="$(getcddbinfo TRACK-INFO)"
        fi
-       CDDBDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
-       run_command '' echo "Tagging track $1 of $TRACKS: $TRACKNAME..."
+       CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+       run_command "" echo "Tagging track $1 of $TRACKS: $TRACKNAME..."
        # If we want to start the tracks with a given number, we need to modify the
        # TRACKNUM value before evaluation
        if [ -n "$STARTTRACKNUMBERTAG" ] ; then
                gettracknum
        fi
-       for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+       for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
        do
                case "$OUTPUT" in
                mp3)
@@ -829,7 +848,7 @@ do_tag ()
 
                        case "$ID3SYNTAX" in
                                id3)
-                                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+                                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
                                                $TAGGER $TAGGEROPTS -c "$COMMENTOUTPUT" \
                                                -A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
                                                -y "$CDYEAR" -g "$GENREID" \
@@ -839,7 +858,7 @@ do_tag ()
                                id3v2)
                                        # FIXME # track numbers in mp3 come with 1/10, so we cannot
                                        # happily substitute them with $TRACKNUM
-                                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+                                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
                                                $TAGGER $TAGGEROPTS -c "$COMMENTOUTPUT" \
                                                -A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
                                                -y "$CDYEAR" -g "$GENREID" \
@@ -850,7 +869,7 @@ do_tag ()
                                id3tag)
                                        # FIXME # track numbers in mp3 come with 1/10, so we cannot
                                        # happily substitute them with $TRACKNUM
-                                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+                                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
                                                $TAGGER $TAGGEROPTS -c "$COMMENTOUTPUT" \
                                                -A "$DALBUM" -a "$TRACKARTIST" -s "$TRACKNAME" \
                                                -y "$CDYEAR" -g "$GENREID" \
@@ -878,7 +897,7 @@ do_tag ()
                                                        ${COMMENTOUTPUT:+--comment "$COMMENTOUTPUT"} \
                                                        );;
                                        esac
-                                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE $TAGGER $TAGGEROPTS \
+                                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE $TAGGER $TAGGEROPTS \
                                                -A "$DALBUM" \
                                                -a "$TRACKARTIST" -t "$TRACKNAME" \
                                                -G "$GENREID" -n "${TRACKNUM:-$1}" \
@@ -896,8 +915,10 @@ do_tag ()
                        case "$OGGENCODERSYNTAX" in
                                vorbize|oggenc)
                                        # vorbiscomment can't do in-place modification, mv the file first
-                                       if [ -f "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" -a ! -f "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" ]; then
-                                               mv "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER"
+                                       if [ -f "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" ] && \
+                                                  [ ! -f "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" ]; then
+                                               mv "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" \
+                                                  "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER"
                                        fi
                                        (
                                        # These are from
@@ -912,7 +933,7 @@ do_tag ()
                                        if [ -n "$CDGENRE" ]; then
                                                echo GENRE="$CDGENRE"
                                        fi
-                                       echo TRACKNUMBER=${TRACKNUM:-$1}
+                                       echo TRACKNUMBER="${TRACKNUM:-$1}"
                                        # TRACKTOTAL is not in the proposed, minimal list of standard field names from
                                        # xiph.org: https://www.xiph.org/vorbis/doc/v-comment.html but is in common usage
                                        # and read by mediainfo, ffprobe, vlc, Aqualung, ogg123, Foobar. And now abcde :)
@@ -921,34 +942,36 @@ do_tag ()
                                        if [ -n "$DISCNUMBER" ]; then
                                                echo DISCNUMBER="$DISCNUMBER"
                                        fi
-                                       echo CDDB=$CDDBDISCID
+                                       echo CDDB="${CDDBDISCID}"
                                        if [ "$(eval echo ${COMMENT})" != "" ]; then
                                                case "$COMMENTOUTPUT" in
                                                        *=*) echo "$COMMENTOUTPUT";;
                                                        *)   echo COMMENT="$COMMENTOUTPUT";;
                                                esac
                                        fi
-                                       ) | run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+                                       ) | run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
                                                $VORBISCOMMENT $VORBISCOMMENTOPTS -w \
-                                               "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER"
+                                               "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" \
+                                               "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER"
                                        # Doublecheck that the commented file was created
                                        # successfully before wiping the original
                                        if [ -f "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" ]; then
                                                rm -f "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER"
                                        else
-                                               mv "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER"
+                                               mv "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" \
+                                                  "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER"
                                        fi
                                        ;;
                        esac
                        ;;
                opus)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                mka)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                aiff)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                flac)
                        (
@@ -970,86 +993,94 @@ do_tag ()
                        if [ -n "$DISCNUMBER" ]; then
                                echo DISCNUMBER="$DISCNUMBER"
                        fi
-                       echo CDDB="$CDDBDISCID"
-                       if [ "$(eval echo ${COMMENT})" != "" ]; then
+                       echo CDDB="${CDDBDISCID}"
+                       if [ -n "$(eval echo "${COMMENT}")" ]; then
                                case "$COMMENTOUTPUT" in
                                        *=*) echo "$COMMENTOUTPUT";;
                                        *)   echo COMMENT="$COMMENTOUTPUT";;
                                esac
                        fi
-                       ) | run_command tagtrack-$OUTPUT-$1 nice $ENCNICE $METAFLAC $METAFLACOPTS ${IMPORTCUESHEET:+--import-cuesheet-from="${ABCDETEMPDIR}/$CUEFILE"} \
-                       --import-tags-from=- "${ABCDETEMPDIR}/track$1.$FLACOUTPUTCONTAINER"
+                       ) | run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE $METAFLAC $METAFLACOPTS \
+                                                       ${IMPORTCUESHEET:+--import-cuesheet-from="${ABCDETEMPDIR}/$CUEFILE"} \
+                                                       --import-tags-from=- "${ABCDETEMPDIR}/track$1.$FLACOUTPUTCONTAINER"
                        ;;
                spx)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                mpc)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                wv)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                ape)
                        # This tagging syntax is suitable for Robert Muth's application 'apetag', the Monkey's Audio 
                        # Console port (mac) used for encoding does not have the ability to tag.
-                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$APETAG" -i "${ABCDETEMPDIR}/track$1.ape" -m overwrite \
-                       -p artist="$TRACKARTIST" -p album="$DALBUM" -p title="$TRACKNAME" -p track=${TRACKNUM:-$1} \
-                       -p year="$CDYEAR" -p genre="$CDGENRE" ${COMMENTOUTPUT:+-p comment="$COMMENTOUTPUT"} 
+                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$APETAG" -i "${ABCDETEMPDIR}/track$1.ape" -m overwrite \
+                                               -p artist="$TRACKARTIST" -p album="$DALBUM" -p title="$TRACKNAME" -p track="${TRACKNUM:-$1}" \
+                                               -p year="$CDYEAR" -p genre="$CDGENRE" ${COMMENTOUTPUT:+-p comment="$COMMENTOUTPUT"} 
                        ;;
                mp2)
                        # Using Mutagen's mid3v2 for tagging with id3v2.4.0. Interesting enough vlc, MPlayer and XMMS ignore
                        # these tags but they are read by Audacious, Xine, Aqualung, mediainfo, ffplay, ffprobe. FFmpeg does
                        # not currently tag mp2 audio so twolame and FFmpeg will both use mid3v2...
-                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
-                       -y "$CDYEAR" -g "$CDGENRE" -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} \
-                       "${ABCDETEMPDIR}/track$1.mp2"
+                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" \
+                                               -a "$TRACKARTIST" -t "$TRACKNAME" -y "$CDYEAR" -g "$CDGENRE" \
+                                               -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} \
+                                               ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} \
+                                               "${ABCDETEMPDIR}/track$1.mp2"
                        ;;
                aac)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                m4a)
                        case "$AACENCODERSYNTAX" in
                                fdkaac)
                                        # We will use inline tagging...
-                                       run_command tagtrack-$OUTPUT-$1 true
+                                       run_command "tagtrack-$OUTPUT-$1" true
                                        ;;
                                neroAacEnc)
                                        # Tag post encode with neroAacTag...
-                                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$NEROAACTAG" "${ABCDETEMPDIR}/track$1.m4a" \
-                                       -meta:artist="$TRACKARTIST" -meta:album="$DALBUM" -meta:title="$TRACKNAME" -meta:track=${TRACKNUM:-$1} \
-                                       -meta:year="$CDYEAR" -meta:genre="$CDGENRE" -meta:comment="$COMMENT"
+                                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$NEROAACTAG" \
+                                                               "${ABCDETEMPDIR}/track$1.m4a" \
+                                                               -meta:artist="$TRACKARTIST" -meta:album="$DALBUM" \
+                                                               -meta:title="$TRACKNAME" -meta:track="${TRACKNUM:-$1}" \
+                                                               -meta:year="$CDYEAR" -meta:genre="$CDGENRE" -meta:comment="$COMMENT"
                                        ;;
                                faac)
-                                       run_command tagtrack-$OUTPUT-$1 true   
+                                       run_command "tagtrack-$OUTPUT-$1" true
                                        ;;
                                qaac)
-                                       run_command tagtrack-$OUTPUT-$1 true   
+                                       run_command "tagtrack-$OUTPUT-$1" true
                                        ;;
                                fhgaacenc)
                                        # Tag post encode with AtomicParsley. Note that previous problems with seg fault when using
                                        # 'overWrite' cannot be reproduced with newer versions: https://bitbucket.org/wez/atomicparsley
-                                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$ATOMICPARSLEY" "${ABCDETEMPDIR}/track$1.m4a" \
-                                       --artist="$TRACKARTIST" --album="$DALBUM" --title="$TRACKNAME" --tracknum=${TRACKNUM:-$1} \
-                                       --year="$CDYEAR" --genre="$CDGENRE" --comment="$COMMENT" $ATOMICPARSLEYOPTS --overWrite
+                                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$ATOMICPARSLEY" \
+                                                               "${ABCDETEMPDIR}/track$1.m4a" --artist="$TRACKARTIST" --album="$DALBUM" \
+                                                               --title="$TRACKNAME" --tracknum="${TRACKNUM:-$1}" \
+                                                               --year="$CDYEAR" --genre="$CDGENRE" --comment="$COMMENT" \
+                                                               $ATOMICPARSLEYOPTS --overWrite
                                        ;;
                                ffmpeg)
-                                       run_command tagtrack-$OUTPUT-$1 true   
+                                       run_command "tagtrack-$OUTPUT-$1" true
                                ;;
                        esac
                        ;;
                tta)
                        # We use mid3v2 tagging for True Audio:
-                       run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
-                       -y "$CDYEAR" -g "$CDGENRE" -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} \
-                       "${ABCDETEMPDIR}/track$1.tta"
+                       run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" \
+                                               -a "$TRACKARTIST" -t "$TRACKNAME" -y "$CDYEAR" -g "$CDGENRE" \
+                                               -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} \
+                                               ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} "${ABCDETEMPDIR}/track$1.tta"
                        ;;
                wav)
-                       run_command tagtrack-$OUTPUT-$1 true
+                       run_command "tagtrack-$OUTPUT-$1" true
                        ;;
                esac
        done
        if checkerrors "tagtrack-(.{3,6})-$1"; then :; else
-               run_command tagtrack-$1 true
+               run_command "tagtrack-$1" true
        fi
 }
 
@@ -1061,30 +1092,29 @@ do_nogap_encode ()
        # The commands here don't go through run_command because they're never
        # supposed to be silenced
        echo "Encoding gapless MP3 tracks: $TRACKQUEUE"
-       for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+       for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
        do
                case "$OUTPUT" in
                mp3)
                        case "$MP3ENCODERSYNTAX" in
                        lame)
                                (
-                               cd "${ABCDETEMPDIR}"
-                               TRACKFILES=
-                               for UTRACKNUM in $TRACKQUEUE
-                               do
-                                       TRACKFILES="$TRACKFILES track$UTRACKNUM.wav"
-                               done
-                               nice $ENCNICE $MP3ENCODER $MP3ENCODEROPTS --nogap $TRACKFILES
-                               RETURN=$?
-                               if [ "$RETURN" != "0" ]; then
-                                       echo "nogap-encode: $ENCODER returned code $RETURN" >> "${ABCDETEMPDIR}/errors"
-                               else
-                                       for UTRACKNUM in $TRACKQUEUE
+                                       cd "${ABCDETEMPDIR}"
+                                       TRACKFILES=
+                                       for THISTRACKNUM in $TRACKQUEUE
                                        do
-                                               run_command encodetrack-$OUTPUT-$UTRACKNUM true
-                                               #run_command encodetrack-$UTRACKNUM true
+                                               TRACKFILES="$TRACKFILES track$THISTRACKNUM.wav"
                                        done
-                               fi
+                                       nice $ENCNICE $MP3ENCODER $MP3ENCODEROPTS --nogap $TRACKFILES
+                                       RETURN=$?
+                                       if [ "$RETURN" != "0" ]; then
+                                               echo "nogap-encode: $MP3ENCODER returned code $RETURN" >> "${ABCDETEMPDIR}/errors"
+                                       else
+                                               for THISTRACKNUM in $TRACKQUEUE
+                                               do
+                                                       run_command "encodetrack-$OUTPUT-$THISTRACKNUM" true
+                                               done
+                                       fi
                                )
                                ;;
                        esac
@@ -1153,8 +1183,8 @@ do_encode ()
                IN="${ABCDETEMPDIR}/track$1.wav"
        fi
        # We need IN to proceed, if we are not using pipes.
-       if [ -s "$IN" -o X"$USEPIPES" = "Xy" ] ; then
-               for TMPOUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+       if [ -s "$IN" ] || [ X"$USEPIPES" = "Xy" ] ; then
+               for TMPOUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
                do
                        case "$TMPOUTPUT" in
                                vorbis|ogg)
@@ -1177,7 +1207,7 @@ do_encode ()
                                        ;;
                        esac
                        OUT="${ABCDETEMPDIR}/track$1.$OUTPUT"
-                       if [ "$NOGAP" = "y" ] && checkstatus encodetrack-$OUTPUT-$1 ; then
+                       if [ "$NOGAP" = "y" ] && checkstatus "encodetrack-$OUTPUT-$1" ; then
                                continue
                        fi
                        if [ X"$USEPIPES" = "Xy" ]; then
@@ -1190,7 +1220,7 @@ do_encode ()
                                # bit the reading process.
                                EFFECTIVE_NICE=$READNICE
                        else
-                               run_command '' echo "Encoding track $1 of $TRACKS: $TRACKNAME..."
+                               run_command "" echo "Encoding track $1 of $TRACKS: $TRACKNAME..."
                                RUN_COMMAND="run_command encodetrack-$OUTPUT-$1"
                                EFFECTIVE_NICE=$ENCNICE
                        fi
@@ -1230,9 +1260,10 @@ do_encode ()
                                        opusenc)
                                        # Tag the file at encode time, as it can't be done after encoding.
                                                if [ "$DOTAG" = "y" ]; then
-                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $OPUSENCODER $OPUSENCODEROPTS --artist "$TRACKARTIST" \
-                                                       --album "$DALBUM" --title "$TRACKNAME" --genre "$CDGENRE" --date "$CDYEAR" --comment TRACKNUMBER="$1" \
-                                                       ${COMMENT:+--comment COMMENT="$COMMENT"} "$IN" "$OUT"
+                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $OPUSENCODER $OPUSENCODEROPTS \
+                                                                                --artist "$TRACKARTIST" --album "$DALBUM" --title "$TRACKNAME" \
+                                                                                --genre "$CDGENRE" --date "$CDYEAR" --comment TRACKNUMBER="$1" \
+                                                                                ${COMMENT:+--comment COMMENT="$COMMENT"} "$IN" "$OUT"
                                                else
                                                        $RUN_COMMAND nice $EFFECTIVE_NICE $OPUSENCODER $OPUSENCODEROPTS "$IN" "$OUT"
                                                fi
@@ -1248,9 +1279,11 @@ do_encode ()
                                case "$MKAENCODERSYNTAX" in
                                ffmpeg)
                                        if [ "$DOTAG" = "y" ]; then
-                                               $RUN_COMMAND nice $EFFECTIVE_NICE $MKAENCODER -i "$IN" $MKAENCODEROPTS -metadata artist="$TRACKARTIST" \
-                                               -metadata album="$DALBUM" -metadata title="$TRACKNAME" -metadata track=${TRACKNUM:-$1} -metadata date="$CDYEAR" \
-                                               -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT"
+                                               $RUN_COMMAND nice $EFFECTIVE_NICE $MKAENCODER -i "$IN" $MKAENCODEROPTS \
+                                                                        -metadata artist="$TRACKARTIST" -metadata album="$DALBUM" \
+                                                                        -metadata title="$TRACKNAME" -metadata track="${TRACKNUM:-$1}" \
+                                                                        -metadata date="$CDYEAR" -metadata genre="$CDGENRE" \
+                                                                        -metadata comment="$COMMENT" "$OUT"
                                        else
                                                $RUN_COMMAND nice $EFFECTIVE_NICE $MKAENCODER -i "$IN" $MKAENCODEROPTS "$OUT"
                                        fi
@@ -1261,9 +1294,11 @@ do_encode ()
                                case "$AIFFENCODERSYNTAX" in
                                ffmpeg)
                                        if [ "$DOTAG" = "y" ]; then
-                                               $RUN_COMMAND nice $EFFECTIVE_NICE $AIFFENCODER -i "$IN" $AIFFENCODEROPTS -metadata artist="$TRACKARTIST" \
-                                               -metadata album="$DALBUM" -metadata title="$TRACKNAME" -metadata track=${TRACKNUM:-$1} -metadata date="$CDYEAR" \
-                                               -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT"
+                                               $RUN_COMMAND nice $EFFECTIVE_NICE $AIFFENCODER -i "$IN" $AIFFENCODEROPTS \
+                                                                        -metadata artist="$TRACKARTIST" -metadata album="$DALBUM" \
+                                                                        -metadata title="$TRACKNAME" -metadata track="${TRACKNUM:-$1}" \
+                                                                        -metadata date="$CDYEAR" -metadata genre="$CDGENRE" \
+                                                                        -metadata comment="$COMMENT" "$OUT"
                                        else
                                                $RUN_COMMAND nice $EFFECTIVE_NICE $AIFFENCODER -i "$IN" $AIFFENCODEROPTS "$OUT"
                                        fi
@@ -1285,7 +1320,7 @@ do_encode ()
                                esac
                                ;;
                        spx)
-                               if [ "$(eval echo ${COMMENT})" != "" ]; then
+                               if [ -n "$(eval echo "${COMMENT}")" ]; then
                                        case "$COMMENT" in
                                                *=*) ;;
                                                *)   COMMENT="COMMENT=$COMMENT" ;;
@@ -1293,8 +1328,9 @@ do_encode ()
                                fi
                                # Tag the file at encode time, as it can't be done after encoding.
                                if [ "$DOTAG" = "y" ]; then
-                                       $RUN_COMMAND nice $EFFECTIVE_NICE $SPEEXENCODER $SPEEXENCODEROPTS --author "$TRACKARTIST" --title "$TRACKNAME" \
-                                       ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
+                                       $RUN_COMMAND nice $EFFECTIVE_NICE $SPEEXENCODER $SPEEXENCODEROPTS \
+                                                                --author "$TRACKARTIST" --title "$TRACKNAME" \
+                                                                ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
                                else
                                        $RUN_COMMAND nice $EFFECTIVE_NICE $SPEEXENCODER $SPEEXENCODEROPTS "$IN" "$OUT"
                                fi
@@ -1302,8 +1338,10 @@ do_encode ()
                        mpc)
                                # Tag the file inline at encode time.
                                if [ "$DOTAG" = "y" ]; then
-                                       $RUN_COMMAND nice $EFFECTIVE_NICE $MPCENCODER $MPCENCODEROPTS --artist "$TRACKARTIST" --album "$DALBUM" \
-                                       --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" --year "$CDYEAR" ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
+                                       $RUN_COMMAND nice $EFFECTIVE_NICE $MPCENCODER $MPCENCODEROPTS \
+                                                                --artist "$TRACKARTIST" --album "$DALBUM" \
+                                                                --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" \
+                                                                --year "$CDYEAR" ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
                                else
                                        $RUN_COMMAND nice $EFFECTIVE_NICE $MPCENCODER $MPCENCODEROPTS "$IN" "$OUT"
                                fi
@@ -1323,17 +1361,21 @@ do_encode ()
                        case "$WVENCODERSYNTAX" in
                                wavpack)
                                        if [ "$DOTAG" = "y" ]; then
-                                               $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER $WVENCODEROPTS -w Artist="$TRACKARTIST" -w Album="$DALBUM" \
-                                               -w Title="$TRACKNAME" -w Track="$1" -w Genre="$CDGENRE" -w Year="$CDYEAR" ${COMMENT:+-w Comment="$COMMENT"} "$IN" -o "$OUT"
+                                               $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER $WVENCODEROPTS \
+                                                                        -w Artist="$TRACKARTIST" -w Album="$DALBUM" \
+                                                                        -w Title="$TRACKNAME" -w Track="$1" -w Genre="$CDGENRE" \
+                                                                        -w Year="$CDYEAR" ${COMMENT:+-w Comment="$COMMENT"} "$IN" -o "$OUT"
                                        else
                                                $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER $WVENCODEROPTS "$IN" -o "$OUT"
                                        fi
                                ;;
                                ffmpeg)
                                        if [ "$DOTAG" = "y" ]; then
-                                               $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER -i "$IN" $WVENCODEROPTS -metadata artist="$TRACKARTIST" \
-                                               -metadata album="$DALBUM" -metadata title="$TRACKNAME" -metadata track=${TRACKNUM:-$1} -metadata date="$CDYEAR" \
-                                               -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT" 
+                                               $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER -i "$IN" $WVENCODEROPTS \
+                                                                        -metadata artist="$TRACKARTIST" \
+                                                                        -metadata album="$DALBUM" -metadata title="$TRACKNAME" \
+                                                                        -metadata track="${TRACKNUM:-$1}" -metadata date="$CDYEAR" \
+                                                                        -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT" 
                                        else 
                                                $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER -i "$IN" $WVENCODEROPTS "$OUT"
                                        fi
@@ -1346,11 +1388,11 @@ do_encode ()
                        mp2)
                                case "$MP2ENCODERSYNTAX" in
                                        twolame)
-                                       $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER $MP2ENCODEROPTS "$IN" "$OUT"
-                                       ;;
+                                               $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER $MP2ENCODEROPTS "$IN" "$OUT"
+                                               ;;
                                        ffmpeg)
-                                       $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER -i "$IN" $MP2ENCODEROPTS "$OUT" 
-                                       ;;
+                                               $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER -i "$IN" $MP2ENCODEROPTS "$OUT" 
+                                               ;;
                                esac
                                ;;
                        aac)
@@ -1362,8 +1404,10 @@ do_encode ()
                                case "$AACENCODERSYNTAX" in
                                        faac)
                                                if [ "$DOTAG" = "y" ]; then
-                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS  --artist "$TRACKARTIST" --album "$DALBUM" \
-                                                       --title "$TRACKNAME" --track ${TRACKNUM:-$1} --year "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
+                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS  \
+                                                                                --artist "$TRACKARTIST" --album "$DALBUM" \
+                                                                                --title "$TRACKNAME" --track "${TRACKNUM:-$1}" \
+                                                                                --year "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
                                                else 
                                                        $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS -o "$OUT" "$IN"   
                                                fi
@@ -1373,16 +1417,20 @@ do_encode ()
                                                ;;
                                        fdkaac)      
                                                if [ "$DOTAG" = "y" ]; then
-                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS --artist "$TRACKARTIST" --album "$DALBUM" \
-                                                       --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" --date "$CDYEAR" --comment "$COMMENT" "$IN" -o "$OUT"
+                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS \
+                                                                                --artist "$TRACKARTIST" --album "$DALBUM" \
+                                                                                --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" \
+                                                                                --date "$CDYEAR" --comment "$COMMENT" "$IN" -o "$OUT"
                                                else
                                                        $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS "$IN" -o "$OUT"
                                                fi
                                                ;;
                                        qaac)
                                                if [ "$DOTAG" = "y" ]; then
-                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $WINE $AACENCODER $AACENCODEROPTS  --artist "$TRACKARTIST" --album "$DALBUM" \
-                                                       --title "$TRACKNAME" --track ${TRACKNUM:-$1} --date "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
+                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $WINE $AACENCODER $AACENCODEROPTS \
+                                                                                --artist "$TRACKARTIST" --album "$DALBUM" \
+                                                                                --title "$TRACKNAME" --track "${TRACKNUM:-$1}" \
+                                                                                --date "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
                                                else 
                                                        $RUN_COMMAND nice $EFFECTIVE_NICE $WINE $AACENCODER $AACENCODEROPTS -o "$OUT" "$IN"
                                                fi
@@ -1392,9 +1440,11 @@ do_encode ()
                                                ;;
                                        ffmpeg)
                                                if [ "$DOTAG" = "y" ]; then
-                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER -i "$IN" $AACENCODEROPTS -metadata artist="$TRACKARTIST" \
-                                                       -metadata album="$DALBUM" -metadata title="$TRACKNAME" -metadata track=${TRACKNUM:-$1} -metadata date="$CDYEAR" \
-                                                       -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT" 
+                                                       $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER -i "$IN" \
+                                                                                $AACENCODEROPTS -metadata artist="$TRACKARTIST" \
+                                                                                -metadata album="$DALBUM" -metadata title="$TRACKNAME" \
+                                                                                -metadata track="${TRACKNUM:-$1}" -metadata date="$CDYEAR" \
+                                                                                -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT" 
                                                else 
                                                        $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER -i "$IN"  $AACENCODEROPTS "$OUT"
                                                fi
@@ -1412,7 +1462,7 @@ do_encode ()
                done
                # Only remove .wav if the encoding succeeded
                if checkerrors "encodetrack-(.{3,6})-$1"; then :; else
-                       run_command encodetrack-$1 true
+                       run_command "encodetrack-$1" true
                        if [ ! "$KEEPWAVS" = "y" ] ; then
                                if [ ! "$KEEPWAVS" = "move" ] ; then
                                        rm -f "$IN"
@@ -1422,13 +1472,14 @@ do_encode ()
        else
                run_command "" echo "HEH! The file we were about to encode disappeared:"
                run_command "" echo ">> $IN"
-               run_command encodetrack-$1 false
+               run_command "encodetrack-$1" false
        fi
 }
 
 # do_preprocess [tracknumber]
 # variables used:
-# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX, OUTPUTTYPE, ENCODEROPTS, DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
+# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX,
+# OUTPUTTYPE, ENCODEROPTS, DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
 #do_preprocess ()
 #{
 #      IN="${ABCDETEMPDIR}/track$1.wav"
@@ -1437,39 +1488,40 @@ do_encode ()
 #              for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
 #              do
 #                      #OUT="${ABCDETEMPDIR}/track$1.$OUTPUT"
-#                      run_command '' echo "Pre-processing track $1 of $TRACKS..."
+#                      run_command "" echo "Pre-processing track $1 of $TRACKS..."
 #                      case "$POSTPROCESSFORMAT" in
 #                      all|wav*)
-#                              run_command preprocess-$OUTPUT-$1 nice $PRENICE $WAV_PRE $IF $OF ;;
+#                              run_command "preprocess-$OUTPUT-$1" nice $PRENICE $WAV_PRE $IF $OF ;;
 #                      mp3)
-#                              run_command preprocess-$OUTPUT-$1 nice $PRENICE $MP3_PRE $IF $OF ;;
+#                              run_command "preprocess-$OUTPUT-$1" nice $PRENICE $MP3_PRE $IF $OF ;;
 #                      ogg)
-#                              run_command preprocess-$OUTPUT-$1 nice $PRENICE $OGG_PRE $IF $OF ;;
+#                              run_command "preprocess-$OUTPUT-$1" nice $PRENICE $OGG_PRE $IF $OF ;;
 #                      flac)
-#                              run_command preprocess-$OUTPUT-$1 nice $PRENICE $FLAC_PRE $IF $OF ;;
+#                              run_command "preprocess-$OUTPUT-$1" nice $PRENICE $FLAC_PRE $IF $OF ;;
 #                      spx)
-#                              run_command preprocess-$OUTPUT-$1 nice $PRENICE $SPX_PRE $IF $OF ;;
+#                              run_command "preprocess-$OUTPUT-$1" nice $PRENICE $SPX_PRE $IF $OF ;;
 #                      esac
 #              done
 #              # Only remove .wav if the encoding succeeded
 #              if checkerrors "preprocess-(.{3,4})-$1"; then
-#                      run_command preprocess-$1 false
+#                      run_command "preprocess-$1" false
 #              else
-#                      run_command preprocess-$1 true
+#                      run_command "preprocess-$1" true
 #              fi
 #      else
 #              if [ "$(checkstatus encode-output)" = "loud" ]; then
 #                      echo "HEH! The file we were about to pre-process disappeared:"
 #                      echo ">> $IN"
 #              fi
-#              run_command preprocess-$1 false
+#              run_command "preprocess-$1" false
 #      fi
 #}
 
 
 # do_postprocess [tracknumber]
 # variables used:
-# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX, OUTPUTTYPE, ENCODEROPTS, DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
+# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX, OUTPUTTYPE, ENCODEROPTS, 
+# DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
 #do_postprocess ()
 #{
 #      for POSTPROCESSFORMAT in $(echo $POSTPROCESSFORMATS | tr , \ )
@@ -1478,29 +1530,29 @@ do_encode ()
 #              # We need IN to proceed.
 #              if [ -s "$IN" ] ; then
 #                      #OUT="${ABCDETEMPDIR}/track$1.$OUTPUT"
-#                      run_command '' echo "Post-processing track $1 of $TRACKS..."
+#                      run_command "" echo "Post-processing track $1 of $TRACKS..."
 #                      case "$POSTPROCESSFORMAT" in
 #                              mp3)
-#                                      run_command postprocess-$OUTPUT-$1 nice $POSTNICE $MP3_POST $IF $OF ;;
+#                                      run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $MP3_POST $IF $OF ;;
 #                              ogg)
-#                                      run_command postprocess-$OUTPUT-$1 nice $POSTNICE $OGG_POST $IF $OF ;;
+#                                      run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $OGG_POST $IF $OF ;;
 #                              flac)
-#                                      run_command postprocess-$OUTPUT-$1 nice $POSTNICE $FLAC_POST $IF $OF ;;
+#                                      run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $FLAC_POST $IF $OF ;;
 #                              spx)
-#                                      run_command postprocess-$OUTPUT-$1 nice $POSTNICE $SPX_POST $IF $OF ;;
+#                                      run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $SPX_POST $IF $OF ;;
 #                      esac
 #                      # Only remove .wav if the encoding succeeded
 #                      if checkerrors "postprocess-(.{3,4})-$1"; then
-#                              run_command postprocess-$1 false
+#                              run_command "postprocess-$1" false
 #                      else
-#                              run_command postprocess-$1 true
+#                              run_command "postprocess-$1" true
 #                      fi
 #              else
 #                      if [ "$(checkstatus encode-output)" = "loud" ]; then
 #                              echo "HEH! The file we were about to post-process disappeared:"
 #                              echo ">> $IN"
 #                      fi
-#                      run_command postprocess-$1 false
+#                      run_command "postprocess-$1" false
 #              fi
 #      done
 #}
@@ -1527,7 +1579,7 @@ do_batch_gain ()
        TRACKFILES=
        for UTRACKNUM in $TRACKQUEUE
        do
-               MP3FILES="$TRACKFILES track$UTRACKNUM.mp3"
+               TRACKFILES="$TRACKFILES track$UTRACKNUM.mp3"
        done
        # FIXME # Hard-coded batch option!
        $NORMALIZER -b $NORMALIZEROPTS $TRACKFILES
@@ -1579,14 +1631,14 @@ do_normalize ()
 {
        IN="${ABCDETEMPDIR}/track$1.wav"
        if [ -e "$IN" ] ; then
-               run_command '' echo "Normalizing track $1 of $TRACKS: $TRACKNAME..."
-               run_command normalizetrack-$1 $NORMALIZER $NORMALIZEROPTS "$IN"
+               run_command "" echo "Normalizing track $1 of $TRACKS: $TRACKNAME..."
+               run_command "normalizetrack-$1" $NORMALIZER $NORMALIZEROPTS "$IN"
        else
                if [ "$(checkstatus encode-output)" = "loud" ]; then
                        echo "HEH! The file we were about to normalize disappeared:"
                        echo ">> $IN"
                fi
-               run_command normalizetrack-$1 false "File $IN was not found"
+               run_command "normalizetrack-$1" false "File $IN was not found"
        fi
 }
 
@@ -1597,7 +1649,7 @@ do_normalize ()
 # TRACKNUM, TRACKNAME, TRACKARTIST, DALBUM, OUTPUTFORMAT, CDGENRE, CDYEAR
 do_move ()
 {
-       for TMPOUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+       for TMPOUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
        do
                # For now, set OUTPUT as TMPOUTPUT, and then change it once we have
                # defined the OUTPUTFILE:
@@ -1660,27 +1712,27 @@ do_move ()
                                        else
                                                # mkdir -p shouldn't return an error if the directory already exists
                                                mkdir -p "$OUTPUTFILEDIR"
-                                               run_command movetrack-$1 mv "${ABCDETEMPDIR}/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
-                                               if checkstatus movetrack-output-$OUTPUT; then :; else
-                                                       run_command movetrack-output-$OUTPUT true
+                                               run_command "movetrack-$1" mv "${ABCDETEMPDIR}/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
+                                               if checkstatus "movetrack-output-$OUTPUT"; then :; else
+                                                       run_command "movetrack-output-$OUTPUT" true
                                                fi
                                        fi
                                        ;;
                                *)
                                        # mkdir -p shouldn't return an error if the directory already exists
                                        mkdir -p "$OUTPUTFILEDIR"
-                                       run_command movetrack-$1 mv "${ABCDETEMPDIR}/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
-                                       if checkstatus movetrack-output-$OUTPUT; then :; else
-                                               run_command movetrack-output-$OUTPUT true
+                                       run_command "movetrack-$1" mv "${ABCDETEMPDIR}/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
+                                       if checkstatus "movetrack-output-$OUTPUT"; then :; else
+                                               run_command "movetrack-output-$OUTPUT" true
                                        fi
                                        ;;
                        esac
                        # Lets move the cue file
                        if CUEFILE=$(checkstatus cuefile) >/dev/null ; then
                                if [ -r "${ABCDETEMPDIR}/$CUEFILE" ]; then
-                                       if checkstatus movecue-$OUTPUT; then :; else
+                                       if checkstatus "movecue-$OUTPUT"; then :; else
                                                # Silence the Copying output since it overlaps with encoding processes...
-                                               #run_command '' vecho "Copying cue file to its destination directory..."
+                                               #run_command "" vecho "Copying cue file to its destination directory..."
                                                if checkstatus onetrack >/dev/null ; then
                                                        case $OUTPUT in
                                                                wav)
@@ -1688,22 +1740,22 @@ do_move ()
                                                                                # We dont have the dir, since it was not created before.
                                                                                :
                                                                        else
-                                                                               run_command movecue-$OUTPUT cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
+                                                                               run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
                                                                        fi
                                                                        ;;
                                                                # NOTE: Creating a cue file with the 3-char-extension files is to comply with
                                                                # http://brianvictor.tripod.com/mp3cue.htm#details
                                                                [a-z0-9][a-z0-9][a-z0-9])
-                                                                       run_command movecue-$OUTPUT cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
+                                                                       run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
                                                                        ;;
                                                                *)
-                                                                       run_command movecue-$OUTPUT cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT.cue"
+                                                                       run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT.cue"
                                                                        ;;
                                                        esac
                                                else
-                                                       run_command movecue-$OUTPUT cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTFILEDIR/$CUEFILE"
+                                                       run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTFILEDIR/$CUEFILE"
                                                fi
-                                               echo movecue-$OUTPUT >> "${ABCDETEMPDIR}/status"
+                                               echo "movecue-$OUTPUT" >> "${ABCDETEMPDIR}/status"
                                        fi
                                fi
                        fi
@@ -1718,7 +1770,7 @@ do_move ()
 # VARIOUSARTISTS, OUTPUTDIR
 do_playlist ()
 {
-       for TMPOUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+       for TMPOUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
        do
                case $TMPOUTPUT in
                        vorbis|ogg)
@@ -1770,17 +1822,17 @@ do_playlist ()
                                ERASEPLAYLIST=e
                        fi
                        # Once we erase the playlist, we use append to create the new one.
-                       [ "$ERASEPLAYLIST" = "e" -o "$ERASEPLAYLIST" = "E" ] && rm -f "$OUTPUTDIR/$PLAYLISTFILE" && ERASEPLAYLIST=a
+                       [ "$ERASEPLAYLIST" = "e" ] || [ "$ERASEPLAYLIST" = "E" ] && rm -f "$OUTPUTDIR/$PLAYLISTFILE" && ERASEPLAYLIST=a
                else
                        # The playlist does not exist, so we can safelly use append to create the new list
                        ERASEPLAYLIST=a
                fi
-               if [ "$ERASEPLAYLIST" = "a" -o "$ERASEPLAYLIST" = "A" ]; then
+               if [ "$ERASEPLAYLIST" = "a" ] || [ "$ERASEPLAYLIST" = "A" ]; then
                        touch "$OUTPUTDIR/$PLAYLISTFILE"
                        for UTRACKNUM in $TRACKQUEUE
                        do
                                # Shares some code with do_move since the filenames have to match
-                               CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+                               CDDBTRACKNUM=$(expr $UTRACKNUM - 1) # Unpad
                                getcddbinfo TRACKNAME
                                splitvarious
                                TRACKFILE="$(mungetrackname "$TRACKNAME")"
@@ -1796,13 +1848,13 @@ do_playlist ()
                                fi
                                if [ "$VARIOUSARTISTS" = "y" ]; then
                                        if [ "$VAPLAYLISTDATAPREFIX" ] ; then
-                                               echo ${VAPLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT >> "$OUTPUTDIR/$PLAYLISTFILE"
+                                               echo "${VAPLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
                                        else
                                                relpath "$PLAYLISTFILE", "$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
                                        fi
                                else
                                        if [ "$PLAYLISTDATAPREFIX" ]; then
-                                               echo ${PLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT >> "$OUTPUTDIR/$PLAYLISTFILE"
+                                               echo "${PLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
                                        else
                                                relpath "$PLAYLISTFILE", "$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
                                        fi
@@ -1830,24 +1882,24 @@ abcde.cue2discid () {
        cddb_sum () {
                val=$1
                ret=0
-               while [ $val -gt 0 ] ; do
-                       ret=$(( $ret + ( $val % 10) ))
-                       val=$(( $val / 10 ))
+               while [ "$val" -gt 0 ] ; do
+                       ret=$(( "$ret" + ( "$val" % 10) ))
+                       val=$(( "$val" / 10 ))
                done
-               echo $ret
+               echo "$ret"
        }
 
        msf2lba () {
                OIFS="$IFS"
                IFS=":"
-               set -- $1
+               set -- "$1"
                IFS="$OIFS"
                local first second third
-               first=$(expr ${1} + 0 )
-               second=$(expr ${2} + 0 )
-               third=$(expr ${3} + 0 )
+               first=$(( $1 + 0 ))
+               second=$(( $2 + 0 ))
+               third=$(( $3 + 0 ))
 
-               echo $(( ((($first * 60) + $second) * 75) + $third ))
+               echo $(( ((("$first" * 60) + "$second") * 75) + "$third" ))
        }
 
        OFFSET=150
@@ -1858,26 +1910,26 @@ abcde.cue2discid () {
        N=0
 
        while read line ; do
-               set -- $line
+               set -- "$line"
                case "$1" in
                TRACK)  i=$(( i + 1 ))
                        ;;
                INDEX)  if [ "$2" -eq 1 ] ; then
-                               LBA=$(msf2lba $3)
-                               START=$(( $LBA + $PREGAP + $OFFSET ))
+                               LBA=$(msf2lba "$3")
+                               START=$(( "$LBA" + "$PREGAP" + "$OFFSET" ))
                                eval TRACK$i=$START
-                               X=$(cddb_sum $(( $START / 75 )) )
-                               N=$(( $N + $X ))
+                               X=$(cddb_sum $(( "$START" / 75 )) )
+                               N=$(( "$N" + "$X" ))
                        fi
                        ;;
-               PREGAP) PREGAP=$(msf2lba $2)
+               PREGAP) PREGAP=$(msf2lba "$2")
                        ;;
                REM)    case "$2" in
                        FLAC__lead-out)
-                               LEADOUT=$(( $4 / 588 ))
+                               LEADOUT=$(( "$4" / 588 ))
                                ;;
                        FLAC__lead-in)
-                               LEADIN=$(( $3 / 588 ))
+                               LEADIN=$(( "$3" / 588 ))
                                ;;
                        esac
                        ;;
@@ -1886,16 +1938,16 @@ abcde.cue2discid () {
        done
 
        TRACKS=$i
-       LEADOUT=$(( $LEADOUT + $LEADIN ))
+       LEADOUT=$(( "$LEADOUT" + "$LEADIN" ))
 
-       LENGTH=$(( $LEADOUT/75 - $TRACK1/75 ))
-       CDDBDISCID=$(( ( $N % 255 ) * 2**24 | $LENGTH * 2**8 | $TRACKS ))
-       printf "%08x %i" $CDDBDISCID $TRACKS
+       LENGTH=$(( "$LEADOUT"/75 - "$TRACK1"/75 ))
+       CDDBDISCID=$(( ( "$N" % 255 ) * 2**24 | "$LENGTH" * 2**8 | "$TRACKS" ))
+       printf "%08x %i" "${CDDBDISCID}" "$TRACKS"
 
        j=1
-       while [ $j -le $TRACKS ] ; do
+       while [ $j -le "$TRACKS" ] ; do
                eval echo -n "\" \$TRACK$j\""
-               j=$((j+1))
+               j=$(( $j + 1))
        done
        echo " $(( $LEADOUT / 75 ))"
 }
@@ -1953,34 +2005,34 @@ abcde.mkcue () {
                CUEWAVFILE="dummy.wav"
        fi
 
-       set -- $CDDBTRACKINFO
+       set -- "$CDDBTRACKINFO"
 
-       DISCID=$1
-       TRACKS=$2
+       DISCID="$1"
+       TRACKS="$2"
        shift 2
 
-       echo REM DISCID $DISCID
+       echo "REM DISCID $DISCID"
        echo FILE \""$CUEWAVFILE"\" WAVE
 
-       if [ $1 -ne 150 ] && [ $MODE = "PREGAP" ] ; then
-               OFFSET=$1
+       if [ "$1" -ne 150 ] && [ "$MODE" = "PREGAP" ] ; then
+               OFFSET="$1"
        else
-               OFFSET=150
+               OFFSET="150"
        fi
 
        i=1
        while [ $i -le "$TRACKS" ] ; do
                LBA=$(( $1 - $OFFSET ))
                printf "  TRACK %02i AUDIO\n" $i
-               if [ $i -eq 1 -a $1 -ne 150 ] ; then
-                       if [ $MODE = PREGAP ] ; then
-                               echomsf "    PREGAP " $(($OFFSET-150))
+               if [ "$i" -eq 1 ] && [ "$1" -ne 150 ] ; then
+                       if [ "$MODE" = PREGAP ] ; then
+                               echomsf "    PREGAP " $(($"OFFSET" - 150))
                        else
                                echo    "    INDEX 00 00:00:00"
                        fi
                fi
-               echomsf "    INDEX 01 " $LBA
-               i=$(($i+1))
+               echomsf "    INDEX 01 " "$LBA"
+               i=$(( $i + 1))
                shift
        done
 }
@@ -1989,11 +2041,11 @@ abcde.mkcue () {
 # This is essentially the start of things
 do_discid ()
 {
-       if [ -z "$CDDBDISCID" ]; then
+       if [ -z "${CDDBDISCID}" ]; then
                vecho -n "Getting CD track info... "
                # In OSX, unmount the disc before a query
                if [ "$OSFLAVOUR" = "OSX" ]; then
-                       diskutil unmount ${CDROM#/dev/}
+                       diskutil unmount "${CDROM#/dev/}"
                fi
                case "$CDROMREADERSYNTAX" in
                        flac)
@@ -2032,10 +2084,10 @@ do_discid ()
                                fi
                                ;;
                        cdparanoia|debug)
-                               CDPARANOIAOUTPUT="$( $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -Q --verbose 2>&1 )"
+                               CDPARANOIAOUTPUT="$( $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -Q --verbose 2>&1 )"
                                RET=$?
                                if [ ! "$RET" = "0" ];then
-                                       log warning "something went wrong while querying the CD... Maybe a DATA CD?"
+                                       log warning "something went wrong while querying the CD... Maybe a DATA CD or the CD is not loaded?"
                                fi
 
                                TRACKS="$(echo "$CDPARANOIAOUTPUT" | grep -E '^[[:space:]]+[[:digit:]]' | tail -n 1 | get_first | tr -d "." | tr '\n' ' ')"
@@ -2052,11 +2104,19 @@ do_discid ()
                                # consistency. Also calculate the
                                # musicbrainz discid if we need it.
                                CDDBTRACKINFO=$($CDDISCID "$CDROM")
-                               CDDBDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
-                               case $CDDBMETHOD in
+                               if [ "$CDDISCID_NEEDS_PAUSE"x = "y"x ]; then
+                                       sleep 6
+                               fi
+                               CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+                               case "$CDDBMETHOD" in
                                        *musicbrainz*)
                                                MBTRACKINFO=$($MUSICBRAINZ --command id --device "$CDROM")
-                                               MBDISCID=$(echo $MBTRACKINFO | cut -d' ' -f1)
+                                               error=$?
+                                               if [ $error != 0 ]; then
+                                                       log error "$MUSICBRAINZ failed to run; ABORT"
+                                                       exit $error
+                                               fi
+                                               MBDISCID=$(echo "$MBTRACKINFO" | cut -d' ' -f1)
                                                ;;
                                esac
                esac
@@ -2073,12 +2133,12 @@ do_discid ()
                fi
                # In OSX, remount the disc again
                if [ "$OSFLAVOUR" = "OSX" ]; then
-                       diskutil mount ${CDROM#/dev/}
+                       diskutil mount "${CDROM#/dev/}"
                fi
                WEHAVEACD=y
-               CDDBDISCID=$(echo $CDDBTRACKINFO | cut -f1 -d' ')
+               CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -f1 -d' ')
        else
-               CDDBTRACKINFO=$(cat "$WAVOUTPUTDIR/abcde.$CDDBDISCID/cddbdiscid")
+               CDDBTRACKINFO=$(cat "$WAVOUTPUTDIR/abcde.${CDDBDISCID}/cddbdiscid")
        fi
 
        # Get a full enumeration of tracks, sort it, and put it in the TRACKQUEUE.
@@ -2093,14 +2153,14 @@ do_discid ()
                TRACKNUMPADDING=2
        fi
 
-       ABCDETEMPDIR="$WAVOUTPUTDIR/abcde.$(echo $CDDBTRACKINFO | cut -f1 -d' ')"
+       ABCDETEMPDIR="$WAVOUTPUTDIR/abcde.$(echo "$CDDBTRACKINFO" | cut -f1 -d' ')"
        if [ -z "$TRACKQUEUE" ]; then
                if [ ! "$STRIPDATATRACKS" = "n" ]; then
                        case "$CDROMREADERSYNTAX" in
                                cdparanoia|libcdio|debug)
                                        if [ "$WEHAVEACD" = "y" ]; then
                                                vecho "Querying the CD for audio tracks..."
-                                               CDPARANOIAOUTPUT="$( $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -Q --verbose 2>&1 )"
+                                               CDPARANOIAOUTPUT="$( $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -Q --verbose 2>&1 )"
                                                RET=$?
                                                if [ ! "$RET" = "0" ];then
                                                        log warning "something went wrong while querying the CD... Maybe a DATA CD?"
@@ -2110,18 +2170,18 @@ do_discid ()
                                        else
                                                # Previous versions of abcde would store the tracks on a file, instead of the status record.
                                                if [ -f "${ABCDETEMPDIR}/cdparanoia-audio-tracks" ]; then
-                                                       echo cdparanoia-audio-tracks=$( cat "${ABCDETEMPDIR}/cdparanoia-audio-tracks" ) >> "${ABCDETEMPDIR}/status"
+                                                       echo "cdparanoia-audio-tracks=$( cat "${ABCDETEMPDIR}/cdparanoia-audio-tracks" )" >> "${ABCDETEMPDIR}/status"
                                                        rm -f "${ABCDETEMPDIR}/cdparanoia-audio-tracks"
                                                fi
                                                if [ -f "${ABCDETEMPDIR}/status" ] && TRACKS=$(checkstatus cdparanoia-audio-tracks); then :; else
-                                                       TRACKS=$(echo $CDDBTRACKINFO | cut -f2 -d' ')
+                                                       TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ')
                                                fi
                                        fi
                                        ;;
-                               *)      TRACKS=$(echo $CDDBTRACKINFO | cut -f2 -d' ') ;;
+                               *)      TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ') ;;
                        esac
                else
-                       TRACKS=$(echo $CDDBTRACKINFO | cut -f2 -d' ')
+                       TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ')
                fi
                if echo "$TRACKS" | grep "[[:digit:]]" > /dev/null 2>&1 ;then :;else
                        log info "The disc does not contain any tracks. Giving up..."
@@ -2129,32 +2189,34 @@ do_discid ()
                fi
                echo -n "Grabbing entire CD - tracks: "
                if [ ! "$PADTRACKS" = "y" ] ; then
-                       TRACKNUMPADDING=$(echo -n $TRACKS | wc -c | tr -d ' ')
+                       TRACKNUMPADDING=$(echo -n "$TRACKS" | wc -c | tr -d ' ')
                fi
+
                TRACKS=$(printf "%0.${TRACKNUMPADDING}d" $TRACKS)
                X=0
                while [ "$X" -ne "$TRACKS" ]
                do
-                       X=$(printf "%0.${TRACKNUMPADDING}d" $(expr $X + 1))
-                       TRACKQUEUE=$(echo $TRACKQUEUE $X)
+                       PT=$(printf "%0.${TRACKNUMPADDING}d" $(($X + 1)))
+                       TRACKQUEUE="$TRACKQUEUE $PT"
+                       X=$(($X + 1))
                done
-               echo $TRACKQUEUE
+               echo "$TRACKQUEUE"
        else
-               TRACKS=$(echo $CDDBTRACKINFO | cut -f2 -d' ')
+               TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ')
                # User-supplied track queue.
                # Weed out non-numbers, whitespace, then sort and weed out duplicates
-               TRACKQUEUE=$(echo $TRACKQUEUE | sed 's-[^0-9 ]--g' | tr ' ' '\n' | grep -v ^$ | sort -n | uniq | tr '\n' ' ' | sed 's- $--g')
+               TRACKQUEUE=$(echo "$TRACKQUEUE" | sed 's-[^0-9 ]--g' | tr ' ' '\n' | grep -v ^$ | sort -n | uniq | tr '\n' ' ' | sed 's- $--g')
                # Once cleaned, obtain the highest value in the trackqueue for number padding
                for LASTTRACK in $TRACKQUEUE; do :; done
                if [ ! "$PADTRACKS" = "y" ] ; then
-                       TRACKNUMPADDING=$(echo -n $LASTTRACK | wc -c | tr -d ' ')
+                       TRACKNUMPADDING=$(echo -n "$LASTTRACK" | wc -c | tr -d ' ')
                fi
                # Now we normalize the trackqueue
                for TRACK in $TRACKQUEUE ; do
-                       TRACKNUM=$(printf %0.${TRACKNUMPADDING}d $(expr ${TRACK} + 0 ))
-                       PADTRACKQUEUE=$(echo $PADTRACKQUEUE $TRACKNUM)
+                       TRACKNUM=$(printf "%0.${TRACKNUMPADDING}d" $(($TRACK + 0)))
+                       PADTRACKQUEUE="$PADTRACKQUEUE $TRACKNUM"
                done
-               TRACKQUEUE=$PADTRACKQUEUE
+               TRACKQUEUE="$PADTRACKQUEUE"
                echo Grabbing tracks: "$TRACKQUEUE"
        fi
 
@@ -2231,21 +2293,21 @@ do_discid ()
                # Store the abcde version in the status file.
                echo "abcde-version=$VERSION" >> "${ABCDETEMPDIR}/status"
        fi
-       if [ X"$DOCUE" = "Xy" -a X"$WEHAVEACD" = "Xy" ]; then
+       if [ X"$DOCUE" = "Xy" ] && [ X"$WEHAVEACD" = "Xy" ]; then
                if checkstatus cuefile > /dev/null 2>&1 ; then :; else
                        CUEFILE=cue-$(echo "$CDDBTRACKINFO" | cut -f1 -d' ').txt
                        vecho "Creating cue file..."
-                       case $CDROMREADERSYNTAX in
+                       case "$CDROMREADERSYNTAX" in
                                flac)
                                        if $METAFLAC --export-cuesheet-to=- "$CDROM" > "${ABCDETEMPDIR}/$CUEFILE"; then
-                                               echo cuefile=$CUEFILE >> "${ABCDETEMPDIR}/status"
+                                               echo "cuefile=$CUEFILE" >> "${ABCDETEMPDIR}/status"
                                        else
                                                log warning "the input flac file does not contain a cuesheet."
                                        fi
                                        ;;
                                *)
                                        if $CUEREADER $CUEREADEROPTS > "${ABCDETEMPDIR}/$CUEFILE"; then
-                                               echo cuefile=$CUEFILE >> "${ABCDETEMPDIR}/status"
+                                               echo "cuefile=$CUEFILE" >> "${ABCDETEMPDIR}/status"
                                        else
                                                log warning "reading the CUE sheet is still considered experimental"
                                                log warning "and there was a problem with the CD reading. abcde will continue,"
@@ -2258,13 +2320,13 @@ do_discid ()
        # If we got the CDPARANOIA status and it is not recorded, save it now
        if [ -n "$CDPARANOIAAUDIOTRACKS" ]; then
                if checkstatus cdparanoia-audio-tracks > /dev/null 2>&1; then :; else
-                       echo cdparanoia-audio-tracks=$CDPARANOIAAUDIOTRACKS >> "${ABCDETEMPDIR}/status"
+                       echo "cdparanoia-audio-tracks=$CDPARANOIAAUDIOTRACKS" >> "${ABCDETEMPDIR}/status"
                fi
        fi
 
        # Create the discid files
        echo "$CDDBTRACKINFO" > "${ABCDETEMPDIR}/cddbdiscid"
-       case $CDDBMETHOD in
+       case "$CDDBMETHOD" in
                *musicbrainz*)
                        echo "$MBTRACKINFO" > "${ABCDETEMPDIR}/mbdiscid"
                        ;;
@@ -2296,7 +2358,7 @@ do_cleancue()
 #                              echo "$line" >> "$CUEFILE_OUT"
 #                              if echo "$line" | grep "^[[:space:]]*TRACK" > /dev/null 2>&1 ; then
                                        eval track="\$TRACK$n"
-                                       n=$(expr $n + 1)
+                                       n=$(( $n + 1 ))
                                        echo "    TITLE \"$track\"" >> "$CUEFILE_OUT"
                                # When making a single-track rip, put the
                                # actual file name into the file declaration
@@ -2354,7 +2416,7 @@ do_cddbparse ()
        if [ ! "$ONETRACK" = "y" ]; then
                for TRACK in $(f_seq_row 1 $TRACKS)
                do
-                       echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "${CDDBPARSEFILE}" | cut -f2- -d= | tr -d \\r\\n)"
+                       echo "$TRACK": "$(grep -a ^TTITLE$(($TRACK - 1))= "${CDDBPARSEFILE}" | cut -f2- -d= | tr -d \\r\\n)"
                done
        fi
 }
@@ -2366,11 +2428,11 @@ do_localcddb_read ()
        if checkstatus cddb-readcomplete && checkstatus cddb-choice >/dev/null; then :; else
 
                CDDBLOCALSTATUS="notfound"
-               CDDBDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
+               CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
                USELOCALRESP="y"
 
                if [ "$CDDBLOCALRECURSIVE" = "y" ]; then
-                       CDDBLOCALRESULTS="$(find ${CDDBLOCALDIR} -name "${CDDBDISCID}" -type f 2> /dev/null)"
+                       CDDBLOCALRESULTS="$(find "${CDDBLOCALDIR}" -name "${CDDBDISCID}" -type f 2> /dev/null)"
                        if [ ! "${CDDBLOCALRESULTS}" = "" ]; then
                                if   (( $(echo "${CDDBLOCALRESULTS}" | wc -l) == 1 )); then
                                        CDDBLOCALFILE="${CDDBLOCALRESULTS}"
@@ -2394,7 +2456,7 @@ do_localcddb_read ()
                                echo "Processing multiple matching CDDB entries..." > "${ABCDETEMPDIR}/cddblocalchoices"
                                X=0
                                echo "$CDDBLOCALRESULTS" | while read RESULT ; do
-                                       X=$(expr $X + 1)
+                                       X=$(( $X + 1 ))
                                        # List out disc title/author and contents
                                        CDDBLOCALREAD="${ABCDETEMPDIR}/cddblocalread.$X"
                                        cat "$RESULT" > "${CDDBLOCALREAD}"
@@ -2406,18 +2468,14 @@ do_localcddb_read ()
                                                if [ ! "$INTERACTIVE" = "y" ]; then break ; fi
                                        } >> "${ABCDETEMPDIR}/cddblocalchoices"
                                done
-                               if [ $(cat "${ABCDETEMPDIR}/cddblocalchoices" | wc -l) -ge $LINES ] && [ "$INTERACTIVE" = "y" ]; then
-                                       page "${ABCDETEMPDIR}/cddblocalchoices"
-                               else
-                                       # It's all going to fit in one page, cat it
-                                       cat "${ABCDETEMPDIR}/cddblocalchoices" >&2
-                               fi
+                               page "${ABCDETEMPDIR}/cddblocalchoices"
                                CDDBLOCALCHOICES=$( echo "$CDDBLOCALRESULTS" | wc -l )
                                # Setting the choice to an impossible integer to avoid errors in the numeric comparisons
                                CDDBLOCALCHOICENUM=-1
                                if [ "$INTERACTIVE" = "y" ]; then
-                                       while [ $CDDBLOCALCHOICENUM -lt 0 ] || [ $CDDBLOCALCHOICENUM -gt $CDDBLOCALCHOICES ]; do
-                                               echo -n "Locally cached CDDB entries found. Which one would you like to use (0 for none)? [0-$CDDBLOCALCHOICES]: " >&2
+                                       while [ "$CDDBLOCALCHOICENUM" -lt 0 ] || [ "$CDDBLOCALCHOICENUM" -gt "$CDDBLOCALCHOICES" ]; do
+                                               echo "Locally cached CDDB entries found." >&2
+                                               echo -n "Which one would you like to use (0 for none)? [0-$CDDBLOCALCHOICES]: " >&2
                                                read CDDBLOCALCHOICE
                                                [ x"$CDDBLOCALCHOICE" = "x" ] && CDDBLOCALCHOICE="1"
                                                # FIXME # Introduce diff's
@@ -2426,15 +2484,12 @@ do_localcddb_read ()
                                                elif echo $CDDBLOCALCHOICE | grep -E "[[:space:]]*[[:digit:]]+[[:space:]]*" > /dev/null 2>&1 ; then
                                                        # Make sure we get a valid choice
                                                        CDDBLOCALCHOICENUM=$(echo $CDDBLOCALCHOICE | xargs printf %d 2>/dev/null)
-                                                       if [ $CDDBLOCALCHOICENUM -lt 0 ] || [ $CDDBLOCALCHOICENUM -gt $CDDBLOCALCHOICES ]; then
+                                                       if [ "$CDDBLOCALCHOICENUM" -lt 0 ] || [ "$CDDBLOCALCHOICENUM" -gt "$CDDBLOCALCHOICES" ]; then
                                                                echo "Invalid selection. Please choose a number between 0 and $CDDBLOCALCHOICES." >&2
                                                        fi
                                                fi
                                        done
                                else
-                                       ### FIXME ###
-                                       #echo "Selected ..."
-                                       CDDBLOCALRESP=y
                                        CDDBLOCALCHOICENUM=1
                                fi
                                if [ ! "$CDDBLOCALCHOICENUM" = "0" ]; then
@@ -2506,16 +2561,15 @@ do_cdtext_read ()
        fi
 
        vecho "Obtaining CD-Text results..."
-       CDTDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
        local SOURCE_WORKDIR="${ABCDETEMPDIR}/data-cdtext"
        mkdir -p "${SOURCE_WORKDIR}"
 
        if [ "$OSFLAVOUR" = "OSX" ] ; then
                # Hei, we have to unmount the device before running anything like cdda2wav/icedax in OSX
-               diskutil unmount ${CDROM#/dev/}
+               diskutil unmount "${CDROM#/dev/}"
                # Also, in OSX the cdrom device for cdda2wav/icedax changes...
                CDDA2WAVCDROM="IODVDServices"
-       elif [ "$OSFLAVOUR" = "FBSD" ] ; then
+       elif [ "$OSFLAVOUR" = "FBSD" ] || [ "$OSFLAVOUR" = "IRIX" ]; then
                CDDA2WAVCDROM="$CDROMID"
        else
                if [ "$CDROMID" = "" ]; then
@@ -2528,7 +2582,7 @@ do_cdtext_read ()
        # Do we have CD-Text on the disc (and can the drive read it?)
        (
                cd "${SOURCE_WORKDIR}" && rm -f audio.* audio_*
-               ${CDTEXT_READER} -J -v titles -D ${CDDA2WAVCDROM} > "${SOURCE_WORKDIR}/cd-text" 2>&1
+               ${CDTEXT_READER} -J -v titles -D "${CDDA2WAVCDROM}" > "${SOURCE_WORKDIR}/cd-text" 2>&1
        )
        grep -a -q '^CD-Text: detected' "${SOURCE_WORKDIR}/cd-text"
        ERRORCODE=$?
@@ -2539,13 +2593,13 @@ do_cdtext_read ()
 
        NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
        # Make an empty template
-       $CDDBTOOL template $(cat "${ABCDETEMPDIR}/cddbdiscid") > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
-       echo cddb-read-${NUM_CDDB_MATCHES}-complete >> "${ABCDETEMPDIR}/status"
+       $CDDBTOOL template "$(cat "${ABCDETEMPDIR}/cddbdiscid")" > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
+       echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
        rm -f "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
 
        # XXX FIXME - this is a hack and should be replaced by proper
        # character set tracking for the CDDB data we have.
-       if test "$CDDBPROTO" -ge 6 ; then
+       if [ "$CDDBPROTO" -ge 6 ]; then
                # convert to Unicode
                iconv -f iso-8859-1 -t utf-8 <"${SOURCE_WORKDIR}/audio.cddb" >"${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
        else
@@ -2555,15 +2609,15 @@ do_cdtext_read ()
                cp -p "${SOURCE_WORKDIR}/audio.cddb" "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
        fi
 
-       CDDBDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
+       CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
        ATITLE=$(grep -a -e '^DTITLE=' "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}" | cut -c8- | tr -d \\r\\n)
-       echo "CD-Text" > ${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}
-       echo "none $CDDBDISCID ${ATITLE}" >> "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+       echo "CD-Text" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
+       echo "none ${CDDBDISCID} ${ATITLE}" >> "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
 
        ( cd "${SOURCE_WORKDIR}" && rm -f audio_* audio.* )
        for file in ${SOURCE_WORKDIR}/cddbread.* ${SOURCE_WORKDIR}/cddbquery.* ${SOURCE_WORKDIR}/datasource.*; do
-               if [ -f $file ]; then
-                       cp $file "${ABCDETEMPDIR}"
+               if [ -f "$file" ]; then
+                       cp "$file" "${ABCDETEMPDIR}"
                fi
        done
        echo "cdtext-readcomplete" >> "${ABCDETEMPDIR}/status"
@@ -2582,11 +2636,16 @@ do_musicbrainz_read ()
                vecho "Obtaining Musicbrainz results..."
                # If MB is to be used, interpret the query results and read all
                # the available entries.
-               CDDBDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
-               MBDISCID=$(echo $MBTRACKINFO | cut -d' ' -f1)
+               CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+               MBDISCID=$(echo "$MBTRACKINFO" | cut -d' ' -f1)
                local SOURCE_WORKDIR="${ABCDETEMPDIR}/data-musicbrainz"
                mkdir -p "${SOURCE_WORKDIR}"
-               ${MUSICBRAINZ} --command data --discid "$MBDISCID" --workdir "${SOURCE_WORKDIR}" --start ${NUM_CDDB_MATCHES}
+               ${MUSICBRAINZ} --command data --discid "${MBDISCID}" --workdir "${SOURCE_WORKDIR}" --start ${NUM_CDDB_MATCHES}
+               error=$?
+               if [ $error != 0 ]; then
+                       log error "$MUSICBRAINZ failed to run; ABORT"
+                       exit $error
+               fi
 
                # Check for no matches.
                # The helper script will write disc matches out to
@@ -2595,12 +2654,12 @@ do_musicbrainz_read ()
                if [ "$NUM_RESPONSES" -gt 0 ] ; then
                        # One or more exact matches
                        i=1
-                       while [ $i -le $NUM_RESPONSES ]; do
+                       while [ $i -le "$NUM_RESPONSES" ]; do
                                NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
                                i=$(($i + 1))
                                echo cddb-read-${NUM_CDDB_MATCHES}-complete >> "${ABCDETEMPDIR}/status"
                                ATITLE=$(grep -a -e '^DTITLE=' "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}" | cut -c8- | tr -d \\r\\n)
-                               echo "none $CDDBDISCID ${ATITLE}" >> "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+                               echo "none ${CDDBDISCID} ${ATITLE}" >> "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
                                echo "Musicbrainz" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
                                cp -f "${SOURCE_WORKDIR}/"*."${NUM_CDDB_MATCHES}" "${ABCDETEMPDIR}"
                        done
@@ -2626,22 +2685,22 @@ do_cddb_read ()
                        echo 503 > "${SOURCE_WORKDIR}/cddbstat"
                else
                        rc=1
-                       CDDBUSER=$(echo $HELLOINFO | cut -f1 -d'@')
-                       CDDBHOST=$(echo $HELLOINFO | cut -f2- -d'@')
-                       while test $rc -eq 1 -a $CDDBPROTO -ge 3; do
+                       CDDBUSER=$(echo "$HELLOINFO" | cut -f1 -d'@')
+                       CDDBHOST=$(echo "$HELLOINFO" | cut -f2- -d'@')
+                       while [ $rc -eq 1 ] && [ "$CDDBPROTO" -ge 3 ]; do
                                vecho "Checking CDDB server status..."
-                               $CDDBTOOL stat $CDDBURL $CDDBUSER $CDDBHOST $CDDBPROTO > "${SOURCE_WORKDIR}/cddbstat"
+                               $CDDBTOOL stat "$CDDBURL" "$CDDBUSER" "$CDDBHOST" "$CDDBPROTO" > "${SOURCE_WORKDIR}/cddbstat"
                                RESPONSECODE=$(head -n 1 "${SOURCE_WORKDIR}/cddbstat" | cut -f1 -d' ')
                                case "$RESPONSECODE" in
                                210)    # 210 OK, status information follows (until terminating `.')
                                        rc=0
                                        ;;
                                501)  # 501 Illegal CDDB protocol level: <n>.
-                                       CDDBPROTO=`expr $CDDBPROTO - 1`
+                                       CDDBPROTO=$(($CDDBPROTO - 1))
                                        ;;
                                *)      # Try a cddb query, since freedb2.org doesn't support the stat or ver commands
                                        # FreeDB TESTCD disc-id is used for query
-                                       $CDDBTOOL query $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST 03015501 1 296 344 > "${SOURCE_WORKDIR}/cddbstat"
+                                       $CDDBTOOL query "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" 03015501 1 296 344 > "${SOURCE_WORKDIR}/cddbstat"
                                        RESPONSECODE=$(head -n 1 "${SOURCE_WORKDIR}/cddbstat" | cut -f1 -d' ')
                                        case "$RESPONSECODE" in
                                                2??)    # Server responded, everything seems OK
@@ -2654,7 +2713,7 @@ do_cddb_read ()
                                        ;;
                                esac
                        done
-                       if test $rc -eq 1; then
+                       if [ $rc -eq 1 ]; then
                                CDDBAVAIL="n"
                        fi
                fi
@@ -2665,7 +2724,7 @@ do_cddb_read ()
        # cddbquery
        ###########
 
-       CDDBDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
+       CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
        CDDBLOCALFILE="${CDDBLOCALDIR}/${CDDBDISCID}"
 
        # Perform CDDB query if it hasn't already been done
@@ -2678,9 +2737,9 @@ do_cddb_read ()
                # contain the entry, or if we are not trying to use the repo.
                else
                        vecho "Querying the CDDB server..."
-                       CDDBUSER=$(echo $HELLOINFO | cut -f1 -d'@')
-                       CDDBHOST=$(echo $HELLOINFO | cut -f2- -d'@')
-                       $CDDBTOOL query $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST $CDDBTRACKINFO > "${SOURCE_WORKDIR}/cddbquery"
+                       CDDBUSER=$(echo "$HELLOINFO" | cut -f1 -d'@')
+                       CDDBHOST=$(echo "$HELLOINFO" | cut -f2- -d'@')
+                       $CDDBTOOL query "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" "$CDDBTRACKINFO" > "${SOURCE_WORKDIR}/cddbquery"
                        ERRORCODE=$?
                        case $ERRORCODE in
                                0)  # success
@@ -2693,7 +2752,7 @@ do_cddb_read ()
                                        echo 503 > "${SOURCE_WORKDIR}/cddbquery"
                                ;;
                                *) # strange and unknown error
-                                       echo ERRORCODE=$ERRORCODE
+                                       echo "ERRORCODE=$ERRORCODE"
                                        echo "abcde: $CDDBTOOL returned unknown error code"
                                ;;
                        esac
@@ -2715,10 +2774,12 @@ do_cddb_read ()
                        # One exact match, retrieve it
                        # 200 [section] [discid] [artist] / [title]
                        NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
-                       $CDDBTOOL read $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST $(cut -f2,3 -d' ' "${SOURCE_WORKDIR}/cddbquery") > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
-                       cat ${SOURCE_WORKDIR}/cddbquery | cut -f2- -d' ' > ${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}
-                       echo "cddb" > ${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}
-                       echo cddb-read-${NUM_CDDB_MATCHES}-complete >> "${ABCDETEMPDIR}/status"
+                       $CDDBTOOL read "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" \
+                                         $(cut -f2,3 -d' ' "${SOURCE_WORKDIR}/cddbquery") \
+                                         > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
+                       cat "${SOURCE_WORKDIR}/cddbquery" | cut -f2- -d' ' > "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+                       echo "cddb" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
+                       echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
                        ;;
                202|403|409|500|503)
                        # TODO: Explain these error codes a little more accurately:
@@ -2728,36 +2789,38 @@ do_cddb_read ()
                210|211)
                        # Multiple exact, (possibly multiple) inexact matches
                        vecho -n "Retrieving multiple matches... "
-                       grep -v ^[.]$ "${SOURCE_WORKDIR}/cddbquery" | (
+                       grep -v '^[.]$' "${SOURCE_WORKDIR}/cddbquery" | (
                                # IN A SUB-SHELL - VARIABLES MODIFIED
                                # HERE DO NOT PERSIST IN THE PARENT
                                read DISCINFO # eat top line
                                while read DISCINFO
                                do
                                        NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
-                                       if checkstatus cddb-read-${NUM_CDDB_MATCHES}-complete; then :; else
-                                               $CDDBTOOL read $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST $(echo $DISCINFO | cut -f1,2 -d' ') > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
-                                               echo "$DISCINFO" > ${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}
-                                               echo "cddb" > ${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}
-                                               echo cddb-read-${NUM_CDDB_MATCHES}-complete >> "${ABCDETEMPDIR}/status"
+                                       if checkstatus "cddb-read-${NUM_CDDB_MATCHES}-complete"; then :; else
+                                               $CDDBTOOL read "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" \
+                                                                 $(echo "$DISCINFO" | cut -f1,2 -d' ') \
+                                                                 > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
+                                               echo "$DISCINFO" > "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+                                               echo "cddb" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
+                                               echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
                                        fi
                                done )
                        # Need to re-count the entries here to be able
                        # to incrememnt $NUM_CDDB_MATCHES in the
                        # parent
-                       NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + $(echo ${SOURCE_WORKDIR}/datasource.* | wc -w)))
+                       NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + $(echo "${SOURCE_WORKDIR}/datasource.*" | wc -w)))
                        vecho "done."
                        ;;
                999)
                        # Using local copy.
                        NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
-                       echo cddb-read-${NUM_CDDB_MATCHES}-complete >> "${ABCDETEMPDIR}/status"
+                       echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
                        ;;
                esac
                echo "cddb-readcomplete" >> "${ABCDETEMPDIR}/status"
                for file in ${SOURCE_WORKDIR}/cddbread.* ${SOURCE_WORKDIR}/cddbquery.* ${SOURCE_WORKDIR}/datasource.*; do
-                       if [ -f $file ]; then
-                               cp $file "${ABCDETEMPDIR}"
+                       if [ -f "$file" ]; then
+                               cp "$file" "${ABCDETEMPDIR}"
                        fi
                done
        fi
@@ -2777,7 +2840,6 @@ do_cddbedit ()
                # or when we are using it but we could not find a proper match
                if [ "$CDDBUSELOCAL" = "y" ] && [ "$CDDBLOCALSTATUS" = "notfound" ] || [ ! "$CDDBUSELOCAL" = "y" ]; then
                        # Display the ${ABCDETEMPDIR}/cddbchoices file created above
-                       # Pick a pager so that if the tracks overflow the screen the user can still view everything
                        if [ -r "${ABCDETEMPDIR}/cddbchoices" ]; then
                                CHOICE=$(checkstatus cddb-choice)
                                if [ -n "$CHOICE" ] ; then
@@ -2791,14 +2853,7 @@ do_cddbedit ()
                                                ;;
                                        esac
                                else
-                                       # The user has a choice to make, display the info in a pager if necessary
-                                       if [ $(cat "${ABCDETEMPDIR}/cddbchoices" | wc -l) -ge $LINES ]; then
-                                               page "${ABCDETEMPDIR}/cddbchoices"
-                                       else
-                                               # It's all going to fit in one page, cat it
-                                               cat "${ABCDETEMPDIR}/cddbchoices" >&2
-                                       fi
-
+                                       page "${ABCDETEMPDIR}/cddbchoices"
                                        CDDBCHOICENUM=""
                                        # Setting the choice to an impossible integer to avoid errors in the numeric comparisons
                                        CDCHOICENUM=-1
@@ -2811,30 +2866,32 @@ do_cddbedit ()
                                                        if [ ! X"$DIFF" = "X" ]; then
                                                                PARSECHOICE1=$(echo $CDDBCHOICE | cut -d"," -f1 | xargs printf %d 2>/dev/null)
                                                                PARSECHOICE2=$(echo $CDDBCHOICE | cut -d"," -f2 | xargs printf %d 2>/dev/null)
-                                                               if [ $PARSECHOICE1 -lt 1 ] || [ $PARSECHOICE1 -gt $NUM_CDDB_MATCHES ] || \
-                                                                  [ $PARSECHOICE2 -lt 1 ] || [ $PARSECHOICE2 -gt $NUM_CDDB_MATCHES ] || \
-                                                                  [ $PARSECHOICE1 -eq $PARSECHOICE2 ]; then
-                                                                       echo "Invalid diff range. Please select two comma-separated numbers between 1 and $NUM_CDDB_MATCHES" >&2
+                                                               if [ "$PARSECHOICE1" -lt 1 ] || [ "$PARSECHOICE1" -gt "$NUM_CDDB_MATCHES" ] || \
+                                                                  [ "$PARSECHOICE2" -lt 1 ] || [ "$PARSECHOICE2" -gt "$NUM_CDDB_MATCHES" ] || \
+                                                                  [ "$PARSECHOICE1" -eq "$PARSECHOICE2" ]; then
+                                                                       echo "Invalid diff range." >&2
+                                                                       echo "Please select two comma-separated numbers between 1 and $NUM_CDDB_MATCHES" >&2
                                                                else
                                                                        # We parse the 2 choices to diff, store them in temporary files and diff them.
                                                                        for PARSECHOICE in $(echo $CDDBCHOICE | tr , \ ); do
-                                                                               do_cddbparse "${ABCDETEMPDIR}/cddbread.$PARSECHOICE" > "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE"
+                                                                               do_cddbparse "${ABCDETEMPDIR}/cddbread.$PARSECHOICE" \
+                                                                                                        > "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE"
                                                                        done
-                                                                       echo "Showing diff between choices $PARSECHOICE1 and $PARSECHOICE2..." > "${ABCDETEMPDIR}/cddbread.diff"
-                                                                       $DIFF $DIFFOPTS "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE1" "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE2" >> "${ABCDETEMPDIR}/cddbread.diff"
-                                                                       if [ $(cat "${ABCDETEMPDIR}/cddbread.diff" | wc -l) -ge $LINES ]; then
-                                                                               page "${ABCDETEMPDIR}/cddbread.diff"
-                                                                       else
-                                                                               cat "${ABCDETEMPDIR}/cddbread.diff" >&2
-                                                                       fi
+                                                                       echo "Showing diff between choices $PARSECHOICE1 and $PARSECHOICE2..." \
+                                                                                > "${ABCDETEMPDIR}/cddbread.diff"
+                                                                       $DIFF $DIFFOPTS "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE1" \
+                                                                                 "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE2" \
+                                                                                 >> "${ABCDETEMPDIR}/cddbread.diff"
+                                                                       page "${ABCDETEMPDIR}/cddbread.diff"
                                                                fi
                                                        else
-                                                               echo "The diff program was not found in your path. Please choose a number between 0 and $NUM_CDDB_MATCHES." >&2
+                                                               echo "The diff program was not found in your path." >&2
+                                                               echo "Please choose a number between 0 and $NUM_CDDB_MATCHES." >&2
                                                        fi
                                                elif echo $CDDBCHOICE | grep -E "[[:space:]]*[[:digit:]]+[[:space:]]*" > /dev/null 2>&1 ; then
                                                        # Make sure we get a valid choice
                                                        CDCHOICENUM=$(echo $CDDBCHOICE | xargs printf %d 2>/dev/null)
-                                                       if [ $CDCHOICENUM -lt 0 ] || [ $CDCHOICENUM -gt $NUM_CDDB_MATCHES ]; then
+                                                       if [ "$CDCHOICENUM" -lt 0 ] || [ "$CDCHOICENUM" -gt "$NUM_CDDB_MATCHES" ]; then
                                                                echo "Invalid selection. Please choose a number between 0 and $NUM_CDDB_MATCHES." >&2
                                                        fi
                                                fi
@@ -2843,12 +2900,13 @@ do_cddbedit ()
                                                vecho "Creating empty CDDB template..."
                                                UNKNOWNDISK=y
                                                $CDDBTOOL template $(cat "${ABCDETEMPDIR}/cddbdiscid") > "${ABCDETEMPDIR}/cddbread.0"
+                                               echo "template" > "${ABCDETEMPDIR}/datasource.0"
                                        else
                                                ATITLE=$(grep -a ^DTITLE= "${ABCDETEMPDIR}/cddbread.$CDCHOICENUM" | cut -f2- -d= | tr -d \\r\\n)
                                                SOURCE=$(cat "${ABCDETEMPDIR}/datasource.$CDCHOICENUM")
                                                echo "Selected: #$CDCHOICENUM ($SOURCE) ($ATITLE)" >&2
-                                               do_cddbparse "${ABCDETEMPDIR}/cddbread.$CDCHOICENUM"
                                        fi
+                                       do_cddbparse "${ABCDETEMPDIR}/cddbread.$CDCHOICENUM"
                                        echo "cddb-choice=$CDCHOICENUM" >> "${ABCDETEMPDIR}/status"
                                fi
                        fi
@@ -2856,7 +2914,6 @@ do_cddbedit ()
                        # We need some code to show the selected option when local repository is selected and we have found a match
                        vecho "Using cached CDDB match..." >&2
                        # Display the ${ABCDETEMPDIR}/cddbchoices file created above
-                       # Pick a pager so that if the tracks overflow the screen the user can still view everything
                        if [ -r "${ABCDETEMPDIR}/cddbchoices" ]; then
                                CHOICE=$(checkstatus cddb-choice)
                                if [ "$USELOCALRESP" = "y" ]; then :; else
@@ -2927,10 +2984,10 @@ do_cddbedit ()
                if [ -x "/usr/bin/sensible-editor" ]; then
                        /usr/bin/sensible-editor "$CDDBDATA"
                elif [ -n "$EDITOR" ]; then
-                       if [ -x $(which "${EDITOR%%\ *}") ]; then
+                       if [ -x "$(which "${EDITOR%%\ *}")" ]; then
                                # That failed, try to load the preferred editor, starting
                                # with their EDITOR variable
-                               eval $(echo "$EDITOR") \"$CDDBDATA\"
+                               $EDITOR "$CDDBDATA"
                        fi
                # If that fails, check for a vi
                elif which vi >/dev/null 2>&1; then
@@ -2980,13 +3037,13 @@ do_cddbedit ()
                DEFAULTSTYLE=1
                # Need NUMTRACKS before cddb-tool will return it:
                NUMTRACKS=$(grep -a -E '^TTITLE[0-9]+=' "$CDDBDATA" | wc -l)
-               if [ "$(grep -ac "^TTITLE.*\/" "$CDDBDATA")" -gt "$(expr $NUMTRACKS / 2 )" ]; then
+               if [ "$(grep -ac "^TTITLE.*\/" "$CDDBDATA")" -gt "$(( $NUMTRACKS / 2 ))" ]; then
                        # More than 1/2 tracks contain a "/", so guess forward
                        DEFAULTSTYLE=1
-               elif [ "$(grep -ac "^TTITLE.*\-" "$CDDBDATA")" -gt "$(expr $NUMTRACKS / 2 )" ]; then
+               elif [ "$(grep -ac "^TTITLE.*\-" "$CDDBDATA")" -gt "$(( $NUMTRACKS / 2 ))" ]; then
                        # More than 1/2 contain a "-", so guess forward-dash
                        DEFAULTSTYLE=2
-               elif [ "$(grep -ac "^TTITLE.*(.*)" "$CDDBDATA")" -gt "$(expr $NUMTRACKS / 2 )" ]; then
+               elif [ "$(grep -ac "^TTITLE.*(.*)" "$CDDBDATA")" -gt "$(( $NUMTRACKS / 2 ))" ]; then
                        # More than 1/2 contain something in parens, so guess trailing-paren
                        DEFAULTSTYLE=6
                fi
@@ -3007,14 +3064,14 @@ do_cddbedit ()
                fi
                VARIOUSARTISTSTYLE=$(echo 0$VARIOUSARTISTSTYLE | xargs printf %d)
                # If they press Enter, then the default style (0) was chosen
-               while [ $VARIOUSARTISTSTYLE -lt 0 ] || [ $VARIOUSARTISTSTYLE -gt 7 ]; do
+               while [ "$VARIOUSARTISTSTYLE" -lt 0 ] || [ "$VARIOUSARTISTSTYLE" -gt 7 ]; do
                        echo "Invalid selection. Please choose a number between 1 and 7."
                        echo -n "Selection [1-7]: "
                        read VARIOUSARTISTSTYLE
-                       VARIOUSARTISTSTYLE=$(echo 0$VARIOUSARTISTSTYLE | xargs printf %d)
+                       VARIOUSARTISTSTYLE=$(echo "0$VARIOUSARTISTSTYLE" | xargs printf "%d")
                done
                if [ "$VARIOUSARTISTSTYLE" = "0" ]; then
-                       VARIOUSARTISTSTYLE=$DEFAULTSTYLE
+                       VARIOUSARTISTSTYLE="$DEFAULTSTYLE"
                fi
                vecho "Selected: $VARIOUSARTISTSTYLE"
                case "$VARIOUSARTISTSTYLE" in
@@ -3068,7 +3125,7 @@ do_cddbedit ()
                                done
                                if [ "$YESNO" = "y" ] || [ "$YESNO" = "Y" ]; then
                                        echo -n "Sending..."
-                                       $CDDBTOOL send "$CDDBDATA" $CDDBSUBMIT
+                                       $CDDBTOOL send "$CDDBDATA" "$CDDBSUBMIT"
                                        echo "done."
                                fi
                        fi
@@ -3079,8 +3136,10 @@ do_cddbedit ()
        # Cache edited CDDB entry in the user's cddb dir
        if [ "$CDDBCOPYLOCAL" = "y" ]; then
                # Make sure the cache directory exists
-               mkdir -p $CDDBLOCALDIR
-               cat "$CDDBDATA" | tail -n $(expr $(cat "$CDDBDATA" | wc -l ) - 1 ) > ${CDDBLOCALDIR}/$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+               mkdir -p "$CDDBLOCALDIR"
+               NUM_LINES=$(( $(wc -l < "$CDDBDATA") - 1 ))
+               OUTPUT_FILE="$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)"
+               tail -n "$NUM_LINES" < "$CDDBDATA" > "${CDDBLOCALDIR}/${OUTPUT_FILE}"
        fi
 
        echo "cddb-edit" >> "${ABCDETEMPDIR}/status"
@@ -3147,11 +3206,11 @@ do_getalbumart()
        if [ "$INTERACTIVE" = "y" ]; then
                if [ -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ]; then
                        # display properties of coverart when identify is available
-                       if new_checkexec $IDENTIFY; then
+                       if new_checkexec "$IDENTIFY"; then
                                $IDENTIFY $IDENTIFYOPTS "${ABCDETEMPDIR}/$ALBUMARTFILE" >&2
                        fi
                        # display coverart when DISPLAY is set and display command is available
-                       if new_checkexec $DISPLAYCMD && [ "$DISPLAY" != "" ]; then
+                       if new_checkexec "$DISPLAYCMD" && [ "$DISPLAY" != "" ]; then
                                $DISPLAYCMD $DISPLAYCMDOPTS "${ABCDETEMPDIR}/$ALBUMARTFILE" >&2 &
                        fi
                else
@@ -3186,22 +3245,23 @@ do_getalbumart()
                fi
        fi
        # convert to ALBUMARTTYPE if ImageMagick is available, if not assume correct type
-       if [ -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ] && new_checkexec $IDENTIFY; then
+       if [ -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ] && new_checkexec "$IDENTIFY"; then
                ALBUMARTURLTYPE=$($IDENTIFY "${ABCDETEMPDIR}/$ALBUMARTFILE" | cut -d' ' -f2)
-               if [ "$ALBUMARTURLTYPE" != "$ALBUMARTTYPE" -o "$ALBUMARTALWAYSCONVERT" = "y" ]; then
-                       if new_checkexec $CONVERT; then
+               if [ "$ALBUMARTURLTYPE" != "$ALBUMARTTYPE" ] || [ "$ALBUMARTALWAYSCONVERT" = "y" ]; then
+                       if new_checkexec "$CONVERT"; then
                                mv "${ABCDETEMPDIR}/$ALBUMARTFILE" "${ABCDETEMPDIR}/$ALBUMARTFILE.tmp"
                                $CONVERT "${ABCDETEMPDIR}/$ALBUMARTFILE.tmp" $CONVERTOPTS "${ABCDETEMPDIR}/$ALBUMARTFILE"
                                rm -f "${ABCDETEMPDIR}/$ALBUMARTFILE.tmp"
                        else
                                rm -f "${ABCDETEMPDIR}/$ALBUMARTFILE"
-                               vecho "sorry, cannot convert $ALBUMARTURLTYPE to $ALBUMARTTYPE without ImageMagick convert" >&2
+                               vecho "sorry, cannot convert $ALBUMARTURLTYPE to $ALBUMARTTYPE" >&2
+                               vecho "without ImageMagick convert" >&2
                        fi
                fi
        fi
        # copy to target directories
        if [ -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ]; then
-               for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+               for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
                do
                        # put cover in the same place as the album
                        if [ "$ONETRACK" = "y" ] ; then
@@ -3242,7 +3302,7 @@ do_embedalbumart()
        YEAR=${CDYEAR:-$CDYEAR}
 
        # Allow for multiple output formats:
-       for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+       for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
        do
                # Find the output directory for multi track encodes:
                if [ "$ONETRACK" != "y" ] ; then
@@ -3299,7 +3359,7 @@ do_embedalbumart()
                        wv)
                                for i in *.wv
                                do
-                               "$WVTAG" --write-binary-tag "Cover Art (Front)=@"$ALBUMARTFILE"" "$i"
+                               "$WVTAG" --write-binary-tag "Cover Art (Front)=@$ALBUMARTFILE" "$i"
                                done
                                mkdir "$FINALDIR"/albumart_backup
                                mv "$ALBUMARTFILE" "$FINALDIR"/albumart_backup
@@ -3409,7 +3469,7 @@ do_cdread ()
        else
                UTRACKNUM=$1
        fi
-       CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+       CDDBTRACKNUM=$(expr $UTRACKNUM - 1) # Unpad
        if [ "$USEPIPES" = "y" ]; then
                TEMPARG="PIPERIPPER_$CDROMREADERSYNTAX"
                FILEARG="$( eval echo "\$$TEMPARG" )"
@@ -3441,22 +3501,22 @@ do_cdread ()
                ### FIXME ### Shall we just use -o $FILEARG ??
                flac)
                        # Avoid problems with math expressions by unpadding the given UTRACKNUM
-                       STRIPTRACKNUM=$(expr $UTRACKNUM + 0)
-                       nice $READNICE $FLAC -d -f --cue=${READTRACKNUMS:-$STRIPTRACKNUM.1-$(($STRIPTRACKNUM + 1)).0} "$FILEARG" "$CDROM" ;;
+                       STRIPTRACKNUM=$(expr $UTRACKNUM + 0 )
+                       nice $READNICE $FLAC -d -f --cue="${READTRACKNUMS:-$STRIPTRACKNUM.1-$(($STRIPTRACKNUM + 1)).0}" "$FILEARG" "$CDROM" ;;
                cdparanoia|libcdio)
                        if [ "$USEPIPES" = "y" ]; then
-                               nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG"
+                               nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG"
                        else
-                               nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG" >&2
+                               nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG" >&2
                        fi
                         ;;
                cdda2wav|icedax)
                        if [ "$OSFLAVOUR" = "OSX" ] ; then
                                # Hei, we have to unmount the device before running anything like cdda2wav/icedax in OSX
-                               diskutil unmount ${CDROM#/dev/}
+                               diskutil unmount "${CDROM#/dev/}"
                                # Also, in OSX the cdrom device for cdda2wav/icedax changes...
                                CDDA2WAVCDROM="IODVDServices"
-                       elif [ "$OSFLAVOUR" = "FBSD" ] ; then
+                       elif [ "$OSFLAVOUR" = "FBSD" ] || [ "$OSFLAVOUR" = "IRIX" ]; then
                                CDDA2WAVCDROM="$CDROMID"
                        else
                                if [ "$CDROMID" = "" ]; then
@@ -3466,27 +3526,27 @@ do_cdread ()
                                fi
                        fi
                        if [ "$USEPIPES" = "y" ]; then
-                               nice $READNICE $CDROMREADER -D $CDDA2WAVCDROM -t ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG"
+                               nice $READNICE $CDROMREADER -D "$CDDA2WAVCDROM" -t "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG"
                        else
-                               nice $READNICE $CDROMREADER -D $CDDA2WAVCDROM -t ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG" >&2
+                               nice $READNICE $CDROMREADER -D "$CDDA2WAVCDROM" -t "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG" >&2
                        fi
                ;;
                dagrab)
                                        # I cannot get USEPIPES to work with dagrab so just this:
-                               nice $READNICE $CDROMREADER -d "$CDROM" -f "$FILEARG" -v $UTRACKNUM >&2
+                               nice $READNICE $CDROMREADER -d "$CDROM" -f "$FILEARG" -v "$UTRACKNUM" >&2
                ;;
                pird)
                        if [ "$USEPIPES" = "y" ]; then
-                               nice $READNICE $CDROMREADER -j ${READTRACKNUMS:-$UTRACKNUM} "$CDROM" "$FILEARG"
+                               nice $READNICE $CDROMREADER -j "${READTRACKNUMS:-$UTRACKNUM}" "$CDROM" "$FILEARG"
                        else
                                # Write ripped audio data to stdout and redirect to $FILEARG.
                                # Progress is written to stderr by default and thus >&2 is not required.
-                               nice $READNICE $CDROMREADER -j ${READTRACKNUMS:-$UTRACKNUM} "$CDROM" "$PIPERIPPER_pird" > "$FILEARG"
+                               nice $READNICE $CDROMREADER -j "${READTRACKNUMS:-$UTRACKNUM}" "$CDROM" "$PIPERIPPER_pird" > "$FILEARG"
                        fi
                ;;
                cddafs)
                        # Find the track's mounted path
-                       REALTRACKNUM=$(expr $UTRACKNUM + 0)
+                       REALTRACKNUM=$(expr $UTRACKNUM + 0) # Unpad
                        FILEPATH=$(mount | grep "$CDROM on" | sed 's/^[^ ]* on \(.*\) (.*/\1/')
                        FILEPATH=$(find "$FILEPATH" | grep "/$REALTRACKNUM ");
                        # If the file exists, copy it
@@ -3501,19 +3561,19 @@ do_cdread ()
                        fi ;;
                debug)
                        if [ "$USEPIPES" = "y" ]; then
-                               nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -w $UTRACKNUM-[:1] "$FILEARG"
+                               nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -w "$UTRACKNUM-[:1]" "$FILEARG"
                        else
-                               nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -w $UTRACKNUM-[:1] "$FILEARG" >&2
+                               nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -w "$UTRACKNUM-[:1]" "$FILEARG" >&2
                        fi
                ;;
        esac
        RETURN=$?
        # If we get some error or we get some missing wav
        # (as long as we dont use pipes)
-       if [ "$RETURN" != "0" -o \( ! -s "$WAVDATA" -a X"$USEPIPES" != "Xy" \) ]; then
+       if [ "$RETURN" != "0" ] || ( [ ! -s "$WAVDATA" ] && [ X"$USEPIPES" != "Xy" ] ); then
                # Thank goodness errors is only machine-parseable up to the
                # first colon, otherwise this woulda sucked
-               if [ "$RETURN" = "0" -a ! -s "$WAVDATA" ]; then
+               if [ "$RETURN" = "0" ] || [ ! -s "$WAVDATA" ]; then
                        RETURN=73 # fake a return code as cdparanoia return 0 also on aborted reads
                fi
                if [ "$USEPIPES" = "y" ]; then
@@ -3524,9 +3584,9 @@ do_cdread ()
                return $RETURN
        else
                if [ "$USEPIPES" = "y" ]; then
-                       echo readencodetrack-$UTRACKNUM >> "${ABCDETEMPDIR}/status"
+                       echo "readencodetrack-$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
                else
-                       echo readtrack-$UTRACKNUM >> "${ABCDETEMPDIR}/status"
+                       echo "readtrack-$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
                fi
                if [ "$1" = "onetrack" ]; then
                        echo onetrack >> "${ABCDETEMPDIR}/status"
@@ -3550,7 +3610,7 @@ do_cdspeed ()
 # vecho outputs a message if EXTRAVERBOSE is 1 or more
 vecho ()
 {
-if [ x"$EXTRAVERBOSE" != "x" ] && [ $EXTRAVERBOSE -gt 0 ] ; then
+if [ x"$EXTRAVERBOSE" != "x" ] && [ "$EXTRAVERBOSE" -gt 0 ] ; then
        case $1 in
                warning) shift ; log warning "$@" ;;
                *) >&4 echo "$@" ;;
@@ -3563,7 +3623,7 @@ fi
 # vvecho outputs a message if EXTRAVERBOSE is 2 or more
 vvecho ()
 {
-if [ x"$EXTRAVERBOSE" != "x" ] && [ $EXTRAVERBOSE -gt 1 ] ; then
+if [ x"$EXTRAVERBOSE" != "x" ] && [ "$EXTRAVERBOSE" -gt 1 ] ; then
        case $1 in
                warning) shift ; log warning "$@" ;;
                *) >&4 echo "$@" ;;
@@ -3577,9 +3637,9 @@ fi
 decho ()
 {
 if [ x"$DEBUG" != "x" ]; then
-       if echo $1 | grep "^\[" > /dev/null 2>&1 ; then
+       if echo "$1" | grep "^\[" > /dev/null 2>&1 ; then
                DEBUGECHO=$(echo "$@" | tr -d '[]')
-               echo >&4 "[DEBUG] $DEBUGECHO: `eval echo \\$${DEBUGECHO}`"
+               echo >&4 "[DEBUG] $DEBUGECHO: $(eval echo \\$${DEBUGECHO})"
        else
                echo >&4 "[DEBUG] $1"
        fi
@@ -3596,25 +3656,25 @@ mungefilename ()
 # Custom filename munging specific to track names:
 mungetrackname ()
 {
-       mungefilename $@
+       mungefilename "$@"
 }
 
 # Custom filename munging specific to artist names:
 mungeartistname ()
 {
-       mungefilename $@
+       mungefilename "$@"
 }
 
 # Custom filename munging specific to album names:
 mungealbumname ()
 {
-       mungefilename $@
+       mungefilename "$@"
 }
 
 # Custom genre munging:
 mungegenre ()
 {
-       echo $CDGENRE | tr "[:upper:]" "[:lower:]"
+       echo "$CDGENRE" | tr "[:upper:]" "[:lower:]"
 }
 
 # pre_read
@@ -3770,18 +3830,18 @@ WVTAG=wvtag
 
 WINE=wine
 CDPARANOIA=cdparanoia
-CD_PARANOIA=cd-paranoia
+CD_PARANOIA="cd-paranoia"
 CDDA2WAV=icedax
 DAGRAB=dagrab
 CDDAFS=cp
 PIRD=pird
-CDDISCID=cd-discid
+CDDISCID="cd-discid"
 CDDBTOOL=cddb-tool
 MUSICBRAINZ=abcde-musicbrainz-tool
 EJECT=eject
 MD5SUM=md5sum
 DISTMP3=distmp3
-NORMALIZE=normalize-audio
+NORMALIZE="normalize-audio"
 CDSPEED=eject
 VORBISGAIN=vorbisgain
 MP3GAIN=mp3gain
@@ -3901,14 +3961,15 @@ exec 4>&1
 # Linux/OpenBSD. ftp is user for NetBSD.
 # Let's use these checkings to determine the OS flavour, which will be used
 # later
-if [ X$(uname) = "XFreeBSD" ] ; then
+UNAME="$(uname)"
+if [ X"$UNAME" = "XFreeBSD" ] ; then
        HTTPGET=fetch
        MD5SUM=md5
        NEEDCDROMID=y
        OSFLAVOUR=FBSD
-elif [ X$(uname) = "XDarwin" ] ; then
+elif [ X"$UNAME" = "XDarwin" ] ; then
        HTTPGET=curl
-# By default md5sum is not installed, use md5 instead:
+       # By default md5sum is not installed, use md5 instead:
        MD5SUM=md5
        OSFLAVOUR=OSX
        # We should have diskutil in OSX, but let's be sure...
@@ -3916,18 +3977,25 @@ elif [ X$(uname) = "XDarwin" ] ; then
        CDROMREADERSYNTAX=cddafs
        # We won't find the eject program in OSX, and doing checkexec will fail further below...
        unset EJECT
-elif [ X$(uname) = "XOpenBSD" ] ; then
+elif [ X"$UNAME" = "XOpenBSD" ] ; then
        HTTPGET=ftp
        MD5SUM=md5
        OSFLAVOUR=OBSD
-elif [ X$(uname) = "XNetBSD" ] ; then
+elif [ X"$UNAME" = "XNetBSD" ] ; then
        HTTPGET=ftp
        MD5SUM=md5
        OSFLAVOUR=NBSD
-elif [ X$(uname) = "SunOS" ] ; then
+elif [ X"$UNAME" = X"SunOS" ] ; then
        HTTPGET=""
        MD5SUM=md5
        OSFLAVOUR=SunOS
+elif [ X"$UNAME" = X"IRIX64" ] ; then
+       HTTPGET="wget"
+       OSFLAVOUR=IRIX
+       NEEDCDROMID=y
+       # Apparently necessary - see
+       # https://abcde.einval.com/bugzilla/show_bug.cgi?id=29
+       CDDISCID_NEEDS_PAUSE=y
 else
        HTTPGET=wget
 fi
@@ -3960,8 +4028,8 @@ if [ -r /etc/abcde.conf ]; then
        . /etc/abcde.conf
 fi
 # Load user preference defaults
-if [ -r $HOME/.abcde.conf ]; then
-       . $HOME/.abcde.conf
+if [ -r "$HOME/.abcde.conf" ]; then
+       . "$HOME/.abcde.conf"
 fi
 
 # By this time, we need some HTTPGETOPTS already defined.
@@ -4011,15 +4079,21 @@ case "$EXTRAVERBOSE" in
 esac
 
 # Parse command line options
-while getopts 1a:bBc:C:d:DefgGhj:klLmMnNo:pP:Q:r:s:S:t:T:UvVxX:w:W:z opt ; do
+while getopts 1a:bBc:C:d:DefgGhj:klLmMnNo:pPQ:r:s:S:t:T:UvVxX:w:W:z opt ; do
        case "$opt" in
                1) ONETRACK=y ;;
                a) ACTIONS="$OPTARG" ;;
                A) EXPACTIONS="$OPTARG" ;;
                b) BATCHNORM=y ;;
                B) GETALBUMART=y ; EMBEDALBUMART=y ;;
-               c) if [ -e "$OPTARG" ] ; then . "$OPTARG" ; else log error "config file \"$OPTARG\" cannot be found." ; exit 1 ; fi ;;
-               C) CDDBDISCID="$( echo ${OPTARG#abcde.} | tr -d /)" ;;
+               c) if [ -e "$OPTARG" ]; then
+                          . "$OPTARG"
+                  else
+                          log error "config file \"$OPTARG\" cannot be found."
+                          exit 1
+                  fi
+                  ;;
+               C) CDDBDISCID="$( echo "${OPTARG#abcde.}" | tr -d /)" ;;
                d) CDROM="$OPTARG" ;;
                D) set -x ;;
                h) usage; exit ;;
@@ -4058,8 +4132,8 @@ while getopts 1a:bBc:C:d:DefgGhj:klLmMnNo:pP:Q:r:s:S:t:T:UvVxX:w:W:z opt ; do
                x) EJECTCD="y" ;;
                X) CUE2DISCID="$OPTARG" ;;
                w) COMMENT="$OPTARG" ;;
-               W) if echo $OPTARG | grep "[[:digit:]]" > /dev/null 2>&1 ; then
-                        STARTTRACKNUMBER="${OPTARG}$(printf %02d ${STARTTRACKNUMBER:-01})"
+               W) if echo "$OPTARG" | grep "[[:digit:]]" > /dev/null 2>&1 ; then
+                        STARTTRACKNUMBER="${OPTARG}$(printf "%02d" "${STARTTRACKNUMBER:-01}")"
                         STARTTRACKNUMBERTAG="y"
                         COMMENT="CD${OPTARG}"
                         DISCNUMBER="${OPTARG}"
@@ -4102,13 +4176,13 @@ if echo "$CDROM" | grep -i '.flac$' > /dev/null 2>&1 ; then
 fi
 
 # If the user provided a CDDBDISCID, disable eject
-if [ -n "$CDDBDISCID" ] || [ "$CDROMREADERSYNTAX" = "flac" ]; then EJECTCD=n ; fi
+if [ -n "${CDDBDISCID}" ] || [ "$CDROMREADERSYNTAX" = "flac" ]; then EJECTCD=n ; fi
 
 # Check the available cd rippers in the system, from the ones we know.
 if [ "$CDROMREADERSYNTAX" = "" ]; then
        for DEFAULT_CDROMREADER in $DEFAULT_CDROMREADERS; do
-               if new_checkexec $DEFAULT_CDROMREADER; then
-                       CDROMREADERSYNTAX=$DEFAULT_CDROMREADER
+               if new_checkexec "$DEFAULT_CDROMREADER"; then
+                       CDROMREADERSYNTAX="$DEFAULT_CDROMREADER"
                        break
                fi
        done
@@ -4153,7 +4227,7 @@ else
                else
                        RSTART=${1%%-*}
                        REND=${1##*-}
-                       while [ ${RSTART:=1} -le ${REND:=0} ] ; do
+                       while [ "${RSTART:=1}" -le "${REND:=0}" ] ; do
                                TRACKQUEUE="$TRACKQUEUE $RSTART"
                                RSTART=$(( $RSTART + 1 ))
                        done
@@ -4181,7 +4255,7 @@ DOCLEAN=n
 ## FIXME ## Lets keep compatibility with -M
 [ "$DOCUE" != "y" ] && DOCUE=n
 
-for ACTION in $(echo $ACTIONS | tr , \ )
+for ACTION in $(echo "$ACTIONS" | tr , \ )
 do
        case $ACTION in
                default) DOCDDB=y; DOREAD=y; DOENCODE=y; DOTAG=y; DOMOVE=y; DOCLEAN=y;;
@@ -4207,7 +4281,7 @@ if [ "$DONORMALIZE" = "y" ] && [ "$DOREPLAYGAIN" = "y" ]; then
        log warning "selected both normalize and replaygain actions"
 fi
 
-for SHOWCDDBFIELD in $(echo $SHOWCDDBFIELDS | tr , \ ); do
+for SHOWCDDBFIELD in $(echo "$SHOWCDDBFIELDS" | tr , \ ); do
        case $SHOWCDDBFIELD in
                y*|Y*) SHOWCDDBYEAR="y";;
                g*|G*) SHOWCDDBGENRE="y";;
@@ -4217,15 +4291,20 @@ done
 
 # At this point a CDROM has to be defined, so we check it exists.
 if [ X"$CDROM" != "X" ] ; then
-       if ( [ "$CDROMREADERSYNTAX" = "cdda2wav" ] || [ "$CDROMREADERSYNTAX" = "icedax" ] ) && [ "$NEEDCDROMID" = "y" ] ; then
-               if [ "$OSFLAVOUR" = "FBSD" ]; then
-                       if echo "$CDROMID" | grep "^[0-9],[0-9],[0-9]$" >/dev/null 2>&1 ; then :; else
+       if [ "$NEEDCDROMID" = "y" ] ; then
+               if [ "$CDROMREADERSYNTAX" = "cdda2wav" ] || [ "$CDROMREADERSYNTAX" = "icedax" ]; then
+                       if [ "$OSFLAVOUR" = "IRIX" ]; then
+                               if [ -z "$CDROMID" ]; then
+                                       CDROMID="$(echo "$CDROM" | sed -e 's;/dev/scsi/sc\([0-9]*\)d\([0-9]*\)l\([0-9]*\)$;\1,\2,\3;')"
+                               fi
+                       fi
+                       if ! echo "$CDROMID" | grep "^[0-9],[0-9],[0-9]$" >/dev/null 2>&1 ; then
                                log error "CDROMID not in the right format for $CDROMREADERSYNTAX"
                                log error "Use \"cdrecord -scanbus\" to obtain an adequate ID and set CDROMID accordingly"
                                exit 1
                        fi
                fi
-       elif [ ! -e "$CDROM" -a X"$DOREAD" = "Xy" ]; then
+       elif [ ! -e "$CDROM" ] && [ X"$DOREAD" = "Xy" ]; then
                log error "CDROM device cannot be found."
                exit 1
        fi
@@ -4242,7 +4321,8 @@ fi
 # - lowdisk algorithm
 # - anything else?
 if [ X"$USEPIPES" = "Xy" ]; then
-       if [ $(echo "$OUTPUTTYPE" | tr , \  | wc -w ) -gt 1 ]; then
+       NUM_OUTPUT_TYPES="$(echo "$OUTPUTTYPE" | tr , \  | wc -w )"
+       if [ "$NUM_OUTPUT_TYPES" -gt 1 ]; then
                log error "Unix pipes not compatible with multiple outputs"
                exit 1
        fi
@@ -4294,9 +4374,9 @@ fi
 # Check the encoding format from the ones available in the system, if nothing has been configured.
 if [ X"$OUTPUTTYPE" = "X" ]; then
        for DEFAULT_OUTPUT in $( echo "$DEFAULT_OUTPUT_BINARIES" | tr , \ ); do
-               DEFAULT_OUTPUT_FORMAT="$(echo $DEFAULT_OUTPUT | cut -d ":" -f 1)"
-               DEFAULT_OUTPUT_BINARY="$(echo $DEFAULT_OUTPUT | cut -d ":" -f 2)"
-               if [ -x $(which $DEFAULT_OUTPUT_BINARY) ] ; then
+               DEFAULT_OUTPUT_FORMAT="$(echo "$DEFAULT_OUTPUT" | cut -d ":" -f 1)"
+               DEFAULT_OUTPUT_BINARY="$(echo "$DEFAULT_OUTPUT" | cut -d ":" -f 2)"
+               if [ -x "$(which "$DEFAULT_OUTPUT_BINARY")" ] ; then
                        OUTPUTTYPE=$DEFAULT_OUTPUT_FORMAT
                        vecho "No default output type defined. Autoselecting $OUTPUTTYPE..." >&2
                        break
@@ -4386,7 +4466,7 @@ esac
 # wavpack for wvs...
 
 # Getting ready for multiple output changes
-for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
 do
        case $OUTPUT in
                vorbis|ogg)
@@ -4738,7 +4818,8 @@ if [ X"$OGGOUTPUTCONTAINER" = "Xogg" ] && [ X"$FLACOUTPUTCONTAINER" = "Xogg" ];
        exit 1
        OGGOUTPUTCONTAINER=ogg.ogg
        FLACOUTPUTCONTAINER=flac.ogg
-       vecho warning "modified file endings due to conflicting transport layers in Ogg/Vorbis and Ogg/FLAC"
+       vecho warning "modified file endings due to conflicting transport"
+       vecho warning "layers in Ogg/Vorbis and Ogg/FLAC"
 fi
 
 # Clean up nice options (either use '-n NICELEVEL or -NICELEVEL')
@@ -4906,7 +4987,7 @@ fi
 
 # And last but not least, check if we can diff between files. We do not abort,
 # since diffing is not critical...
-if [ -x $(which $DIFF) ]; then :; else
+if [ -x "$(which "$DIFF")" ]; then :; else
        vecho warning "Disabling diff since we cannot find it in the \$PATH..."
        DIFF=""
 fi
@@ -4931,8 +5012,19 @@ HTTPGET="$HTTPGET $HTTPGETOPTS"
 # Hey, for grins, as of 2016-08-30 this is now line 4814! -GR
 
 # Export needed things so they can be read in this subshell
-export CDDBTOOL ABCDETEMPDIR TRACKQUEUE LOWDISK EJECTCD EJECT EJECTOPTS
-export CDROM CDDBDATA REMOTEHOSTS MAXPROCS HTTPGET MD5SUM
+export CDDBTOOL        # Path and options for the tool to query CDDB
+export ABCDETEMPDIR    # Path to the tmpdir for this rip
+export TRACKQUEUE      # 0-padded list of tracks to be processed
+export LOWDISK         # Are we using the low-diskspace algorithm?
+export EJECTCD         # Should we eject the CD when we're finished ripping?
+export EJECT           # The commend to use to eject the CD, if we have one
+export EJECTOPTS       # Options to that command
+export CDROM           # Device path for the CD device
+export CDDBDATA        # The filename we're using for CD lookup data
+export REMOTEHOSTS     # List of remote hosts for parallel encoding, if given
+export MAXPROCS        # The number of *local* encodes to do in parallel
+export HTTPGET         # Program to use to grab files via http
+export MD5SUM          # Program to calculate MD5 checksums
 
 if [ "$DOREAD" = "y" ]; then
        # User-definable function to set some things. Use it for
@@ -4990,7 +5082,7 @@ if [ "$DOCDDB" = "y" ]; then
                        done
 
                        rm -f "${ABCDETEMPDIR}/cddbchoices"
-                       CDDBDISCID=$(echo $CDDBTRACKINFO | cut -d' ' -f1)
+                       CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
 
                        if [ $NUM_CDDB_MATCHES = 0 ]; then
                                # If we got no matches, we need to
@@ -4998,12 +5090,13 @@ if [ "$DOCDDB" = "y" ]; then
                                vecho "Unable to find any matches, generating unknown template."
                                echo "No lookup matches." >> "${ABCDETEMPDIR}/cddbchoices"
                                $CDDBTOOL template $(cat "${ABCDETEMPDIR}/cddbdiscid") > "${ABCDETEMPDIR}/cddbread.0"
+                               echo "template" > "${ABCDETEMPDIR}/datasource.0"
                                # List out disc title/author and contents of template
                                echo ---- Unknown Artist / Unknown Album ---- >> "${ABCDETEMPDIR}/cddbchoices"
                                UNKNOWNDISK=y
                                for TRACK in $(f_seq_row 1 $TRACKS)
                                do
-                                       echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "${ABCDETEMPDIR}/cddbread.0" | cut -f2- -d= | tr -d \\r\\n)" >> "${ABCDETEMPDIR}/cddbchoices"
+                                       echo "$TRACK:" "$(grep -a ^TTITLE$(($TRACK - 1))= "${ABCDETEMPDIR}/cddbread.0" | cut -f2- -d= | tr -d \\r\\n)" >> "${ABCDETEMPDIR}/cddbchoices"
                                done
                                echo >> "${ABCDETEMPDIR}/cddbchoices"
                                echo cddb-read-0-complete >> "${ABCDETEMPDIR}/status"
@@ -5029,13 +5122,13 @@ if [ "$DOCDDB" = "y" ]; then
                                for X in $(f_seq_row 1 $NUM_CDDB_MATCHES)
                                do
                                        ATITLE=$(grep -a -e '^DTITLE=' "${ABCDETEMPDIR}/cddbread.$X" | cut -c8- | tr -d \\r\\n)
-                                       SOURCE=$(cat ${ABCDETEMPDIR}/datasource.$X)
+                                       SOURCE=$(cat "${ABCDETEMPDIR}/datasource.$X")
                                        echo "#$X ($SOURCE): ---- ${ATITLE} ----" >> "${ABCDETEMPDIR}/cddbchoices"
-                                        for TRACK in $(f_seq_row 1 $TRACKS)
-                                        do
-                                                echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "${ABCDETEMPDIR}/cddbread.$X" | cut -f2- -d= | tr -d \\r\\n)" >> "${ABCDETEMPDIR}/cddbchoices"
-                                        done
-                                        echo >> "${ABCDETEMPDIR}/cddbchoices"
+                    for TRACK in $(f_seq_row 1 $TRACKS)
+                                       do
+                        echo "$TRACK:" "$(grep -a ^TTITLE$(($TRACK - 1))= "${ABCDETEMPDIR}/cddbread.$X" | cut -f2- -d= | tr -d \\r\\n)" >> "${ABCDETEMPDIR}/cddbchoices"
+                                       done
+                    echo >> "${ABCDETEMPDIR}/cddbchoices"
                                done
                        fi
                fi
@@ -5097,13 +5190,13 @@ if [ "$LOWDISK" = "y" ] || [ "$ONETRACK" = "y" ]; then
 fi
 
 if [ "$ONETRACK" = "y" ]; then
-       TRACKS="$FIRSTTRACK"
+       TRACKS=$FIRSTTRACK
        if [ "$USEPIPES" = "y" ]; then
-               if checkstatus readencodetrack-$FIRSTTRACK; then :; else
+               if checkstatus "readencodetrack-$FIRSTTRACK"; then :; else
                        do_cdread onetrack $FIRSTTRACK $LASTTRACK | do_encode $FIRSTTRACK %local0% > /dev/null 2>&1
                fi
        else
-               if checkstatus readtrack-$FIRSTTRACK; then :; else
+               if checkstatus "readtrack-$FIRSTTRACK"; then :; else
                        do_cdread onetrack $FIRSTTRACK $LASTTRACK
                fi
        fi
@@ -5112,12 +5205,12 @@ else
        do
                if [ "$DOREAD" = "y" ]; then
                        if [ "$USEPIPES" = "y" ]; then
-                               if checkstatus readencodetrack-$UTRACKNUM; then :; else
+                               if checkstatus "readencodetrack-$UTRACKNUM"; then :; else
                                        # Read, pipe, shut up!
                                        do_cdread $UTRACKNUM | do_encode $UTRACKNUM %local0% > /dev/null 2>&1
                                fi
                        else
-                               if checkstatus readtrack-$UTRACKNUM; then :; else
+                               if checkstatus "readtrack-$UTRACKNUM"; then :; else
                                        do_cdread $UTRACKNUM
                                fi
                                if [ "$?" != "0" ]; then
@@ -5139,9 +5232,9 @@ else
                        echo NEXTTRACK # Get the encoder machine churning again
                        if [ "$DOREAD" = "y" ]; then
                                if [ "$LOWDISK" = "y" ] && [ "$DOENCODE" = "y" ]; then
-                                       until checkstatus encodetrack-$UTRACKNUM
+                                       until checkstatus "encodetrack-$UTRACKNUM"
                                        do
-                                               if checkerrors encodetrack-$UTRACKNUM; then
+                                               if checkerrors "encodetrack-$UTRACKNUM"; then
                                                        break
                                                fi
                                                sleep 2
@@ -5175,17 +5268,17 @@ if [ "$EJECTCD" = "y" ]; then
        #CURRENTTRACKINFO=$($CDDISCID $CDROM)
        #if if [ "$?" != "1" ] && [ "$CURRENTTRACKINFO" = "$CDDBTRACKINFO" ] ; then
        # More FreeBSD bits.
-       if [ X"$(uname)" = X"FreeBSD" ] ; then
+       if [ X"$UNAME" = X"FreeBSD" ] ; then
                # FreeBSD eject uses the EJECT environment variable to name the CDROM
                # but in this script EJECT is in the envionment and names the program
                eject=$EJECT
                unset EJECT
                # The FreeBSD eject needs "adc0" not "/dev/adc0c"
-               cd="$(echo $CDROM | sed -e 's=.*/==;s=[a-h]$==;')"
+               cd="$(echo "$CDROM" | sed -e 's=.*/==;s=[a-h]$==;')"
                $eject $EJECTOPTS $cd
-       elif [ X"$(uname)" = X"Darwin" ] ; then
-               diskutil eject ${CDROM#/dev/} 0
-       elif [ -x $(which $EJECT) ]; then
+       elif [ X"$UNAME" = X"Darwin" ] ; then
+               diskutil eject "${CDROM#/dev/}" 0
+       elif [ -x "$(which "$EJECT")" ]; then
                $EJECT $EJECTOPTS "$CDROM"
        fi
        #fi
@@ -5204,7 +5297,7 @@ fi
 #              PREPROCEED=
 #              until [ $PREPROCEED ]
 #              do
-#                      if checkstatus readtrack-$PRETRACKNUM; then PREPROCEED=y; break; fi
+#                      if checkstatus "readtrack-$PRETRACKNUM"; then PREPROCEED=y; break; fi
 #                      # all locations are working, wait and try again later
 #                      if [ ! $PREPROCEED ]; then sleep 3; fi
 #              done
@@ -5222,21 +5315,21 @@ if [ "$BATCHNORM" = "y" ] || [ "$NOGAP" = "y" ]; then
        read GOAHEAD # For blocking - will contain either "NO" or "NEXTTRACK"
        if [ "$GOAHEAD" != "NO" ]; then
                for LASTTRACK in $TRACKQUEUE; do :; done
-               if checkstatus readtrack-$LASTTRACK; then
+               if checkstatus "readtrack-$LASTTRACK"; then
                        if [ "$DONORMALIZE" = "y" ] && [ "$BATCHNORM" = "y" ]; then
-                               if checkstatus normalizetrack-$LASTTRACK; then :; else do_batch_normalize; fi
+                               if checkstatus "normalizetrack-$LASTTRACK"; then :; else do_batch_normalize; fi
                                if checkerrors batch-normalize; then exit 1; fi
                        fi
                        if [ "$DOENCODE" = "y" ] && [ "$NOGAP" = "y" ]; then
                                if [ "$DONORMALIZE" = "y" ]; then
                                        for UTRACKNUM in $TRACKQUEUE
                                        do
-                                               if checkstatus readtrack-$UTRACKNUM; then
-                                                       if checkstatus normalizetrack-$UTRACKNUM; then :; else do_normalize $UTRACKNUM; fi
+                                               if checkstatus "readtrack-$UTRACKNUM"; then
+                                                       if checkstatus "normalizetrack-$UTRACKNUM"; then :; else do_normalize "$UTRACKNUM"; fi
                                                fi
                                        done
                                fi
-                               if checkstatus encodetrack-$LASTTRACK; then :; else do_nogap_encode; fi
+                               if checkstatus "encodetrack-$LASTTRACK"; then :; else do_nogap_encode; fi
                                if checkerrors nogap-encode; then exit 1; fi
                        fi
                fi
@@ -5251,9 +5344,9 @@ fi
 
 # Do the encoding, including parallelization of remote encoding
 # Figure out where each track is going to be encoded
-ENCODELOCATIONS="$(echo $REMOTEHOSTS | tr , ' ')"
+ENCODELOCATIONS="$(echo "$REMOTEHOSTS" | tr , ' ')"
 if [ "$MAXPROCS" != "0" ]; then
-       for NUM in $(f_seq_row 1 "$MAXPROCS")
+       for NUM in $(f_seq_row 1 $MAXPROCS)
        do
                ENCODELOCATIONS="$ENCODELOCATIONS %local$NUM%"
        done
@@ -5266,7 +5359,7 @@ do
        read GOAHEAD # For blocking - will contain either "NO" or "NEXTTRACK"
        if [ "$GOAHEAD" = "NO" ]; then break; fi
        # find out where this track is to be encoded
-       if [ "$DOENCODE" = "y" -a "$USEPIPES" != "y" ]; then
+       if [ "$DOENCODE" = "y" ] && [ "$USEPIPES" != "y" ]; then
                # Make sure we have a place to encode this, if not, exit stage right
                if [ -z "$ENCODELOCATIONS" ]; then
                        continue
@@ -5276,11 +5369,11 @@ do
                do
                        for LOCATION in $ENCODELOCATIONS
                        do
-                               PREVIOUSTRACK="$(checkstatus encodetracklocation-$LOCATION)"
+                               PREVIOUSTRACK="$(checkstatus "encodetracklocation-$LOCATION")"
                                # check first if a track has ever been assigned to this location
                                if [ -z "$PREVIOUSTRACK" ]; then PROCEED=y; break; fi
                                # If it errored out, rebuild $ENCODELOCATIONS without this location in it
-                               if checkerrors encodetrack-$PREVIOUSTRACK; then
+                               if checkerrors "encodetrack-$PREVIOUSTRACK"; then
                                        for TEMPLOCATION in $ENCODELOCATIONS
                                        do
                                                if [ "$TEMPLOCATION" != "$LOCATION" ]; then
@@ -5295,10 +5388,10 @@ do
                                # We're still here, this location must have been previously assigned,
                                # and last completed without error - check if it's done with the
                                # previous track yet
-                               if checkstatus encodetrack-$PREVIOUSTRACK; then PROCEED=y; break; fi
+                               if checkstatus "encodetrack-$PREVIOUSTRACK"; then PROCEED=y; break; fi
                        done
                        # all locations are working, wait and try again later
-                       if [ ! $PROCEED ]; then sleep 3; fi
+                       if [ ! "$PROCEED" ]; then sleep 3; fi
                done
                # Record the location we're about to encode the next track at
                echo "encodetracklocation-$LOCATION=$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
@@ -5306,7 +5399,7 @@ do
        # Don't proceed with the rest of the loop if we can't encode
        if [ "$ABORT" ]; then continue; fi
        ## FIXME ## Add here
-       ## run_command tagtrack-$OUTPUT-$1 $METAFLAC $METAFLACOPTS ${IMPORTCUESHEET:+--import-cuesheet-from="${ABCDETEMPDIR}/$CUEFILE"} --import-tags-from=- "${ABCDETEMPDIR}/track$1.$FLACOUTPUTCONTAINER"
+       ## run_command "tagtrack-$OUTPUT-$1" $METAFLAC $METAFLACOPTS ${IMPORTCUESHEET:+--import-cuesheet-from="${ABCDETEMPDIR}/$CUEFILE"} --import-tags-from=- "${ABCDETEMPDIR}/track$1.$FLACOUTPUTCONTAINER"
        # Set TRACKNUM, TRACKNAME
        if [ -e "$CDDBDATA" ]; then
                if [ "$ONETRACK" = "y" ]; then
@@ -5314,8 +5407,8 @@ do
                        TRACKNUM="$FIRSTTRACK"
                        splitvarious
                else
-                       TRACKNUM=$UTRACKNUM
-                       CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+                       TRACKNUM="$UTRACKNUM"
+                       CDDBTRACKNUM=$(expr $UTRACKNUM - 1) # Unpad
                        getcddbinfo TRACKNAME
                        splitvarious
                fi
@@ -5325,25 +5418,24 @@ do
        # thus all of this is backgrounded together
        (
        if [ "$DONORMALIZE" = "y" ]; then
-               if checkstatus readtrack-$UTRACKNUM; then
-                       if checkstatus normalizetrack-$UTRACKNUM; then :; else do_normalize $UTRACKNUM; fi
+               if checkstatus "readtrack-$UTRACKNUM"; then
+                       if checkstatus "normalizetrack-$UTRACKNUM"; then :; else do_normalize "$UTRACKNUM"; fi
                fi
        fi
-       if [ "$DOENCODE" = "y" -a "$USEPIPES" != "y" ]; then
-               if checkstatus readtrack-$UTRACKNUM; then
-                       #if checkstatus encodetrack-$UTRACKNUM; then :; else do_encode $UTRACKNUM $LOCATION; fi
+       if [ "$DOENCODE" = "y" ] && [ "$USEPIPES" != "y" ]; then
+               if checkstatus "readtrack-$UTRACKNUM"; then
                        if [ "$DONORMALIZE" = "y" ]; then
-                               if checkstatus normalizetrack-$UTRACKNUM; then
-                                       if checkstatus encodetrack-$UTRACKNUM; then :; else do_encode $UTRACKNUM $LOCATION $OUTPUT; fi
+                               if checkstatus "normalizetrack-$UTRACKNUM"; then
+                                       if checkstatus "encodetrack-$UTRACKNUM"; then :; else do_encode "$UTRACKNUM" "$LOCATION" "$OUTPUT"; fi
                                fi
                        else
-                               if checkstatus encodetrack-$UTRACKNUM; then :; else do_encode $UTRACKNUM $LOCATION $OUTPUT; fi
+                               if checkstatus "encodetrack-$UTRACKNUM"; then :; else do_encode "$UTRACKNUM" "$LOCATION" "$OUTPUT"; fi
                        fi
                fi
        fi
        if [ "$DOTAG" = "y" ]; then
-               if checkstatus encodetrack-$UTRACKNUM; then
-                       if checkstatus tagtrack-$UTRACKNUM; then :; else do_tag $UTRACKNUM; fi
+               if checkstatus "encodetrack-$UTRACKNUM"; then
+                       if checkstatus "tagtrack-$UTRACKNUM"; then :; else do_tag "$UTRACKNUM"; fi
                fi
                # Lets tag the cue file
                if checkstatus cleancuefile >/dev/null; then :; else
@@ -5353,8 +5445,8 @@ do
                fi
        fi
        if [ "$DOMOVE" = "y" ]; then
-               if checkstatus tagtrack-$UTRACKNUM; then
-                       if checkstatus movetrack-$UTRACKNUM; then :; else do_move $UTRACKNUM; fi
+               if checkstatus "tagtrack-$UTRACKNUM"; then
+                       if checkstatus "movetrack-$UTRACKNUM"; then :; else do_move "$UTRACKNUM"; fi
                fi
        fi
        ) &
@@ -5372,15 +5464,15 @@ if [ "$DOENCODE" = "y" ] && [ "$USEPIPES" != "y" ] && [ ! "$ABORT" ]; then
                PROCEED=y
                for LOCATION in $ENCODELOCATIONS
                do
-                       CHECKTRACK="$(checkstatus encodetracklocation-$LOCATION)"
+                       CHECKTRACK="$(checkstatus "encodetracklocation-$LOCATION")"
                        # "How can he give us a status update, if he's DEAD?"
-                       if checkstatus encodetrack-$CHECKTRACK; then
+                       if checkstatus "encodetrack-$CHECKTRACK"; then
                                continue
                        fi
                        # Nothing to see here please go quietly back to your homes
                        if [ -z "$CHECKTRACK" ]; then continue; fi
                        # You're still here? Maybe there is something...
-                       if checkstatus encodetrack-$CHECKTRACK; then :; else PROCEED= ; break; fi
+                       if checkstatus "encodetrack-$CHECKTRACK"; then :;       else PROCEED= ; break; fi
                done
                # hold up
                if [ ! $PROCEED ]; then sleep 5; fi
@@ -5416,9 +5508,9 @@ if [ "$DOCLEAN" = "y" ] && [ ! "$FORCE" = "y" ]; then
        MOVED_FORMATS=$(grep -E "^movetrack-output-(.{3,6})$" "${ABCDETEMPDIR}/status" | cut -d"-" -f3 | sort -u | tr '\n' '|')
        if [ "$ENCODED_FORMATS" != "$MOVED_FORMATS" ]; then
                log warning "The encoded formats does not match with the moved ones"
-               log warning "Formats encoded: $( echo $ENCODED_FORMATS | tr "|" " " )"
-               log warning "Formats moved: $( echo $MOVED_FORMATS | tr "|" " " )"
-               log warning "Use \"abcde -a clean -f -C $CDDBDISCID\" to force the removal of the remaining data."
+               log warning "Formats encoded: $( echo "$ENCODED_FORMATS" | tr "|" " " )"
+               log warning "Formats moved: $( echo "$MOVED_FORMATS" | tr "|" " " )"
+               log warning "Use \"abcde -a clean -f -C ${CDDBDISCID}\" to force the removal of the remaining data."
                DOCLEAN=n
        fi
 fi