Shell Programming and Scripting

checkversion_result=

checkversion() {
	checkversion_result=
	local mod="$1"
	local vers="$2"
	local slink="/app/mes_dwh/$mod/${mod}"
	local target=$(readlink "$slink")
	target=${target#*V}
	target=V${target%%V*}

	case "$target" in
        (V_[0-9]_[0-9]_[0-9]_RC_b* | V_[0-9]_[0-9]_[0-9]_b*)
		;;
        (*)	fail "bad version string: '$target'"
		return 1
		;;
	esac
	case "${target##*b}" in
        (*[!0-9]*)
        	fail "bad build number: '$target'"
		return 2
		;;
	esac
  
	#compare major version
	local old=${target#*_}
	old=${old%%_*}
	local new=${vers#*_}
	new=${new%%_*}
	checkversion_result=$((old - new))
printf 'major old:%s new:%s result:%s\n' "$old" "$new" "$checkversion_result"
	[ "$checkversion_result" -ne 0 ] && return 0
	#compare middle version
	old=${target#*_*_}
	old=${old%%_*}
	new=${vers#*_*_}
	new=${new%%_*}
	checkversion_result=$((old - new))
printf 'middle old:%s new:%s result:%s\n' "$old" "$new" "$checkversion_result"
	[ "$checkversion_result" -ne 0 ] && return 0
	#compare minor version
	old=${target#*_*_*_}
	old=${old%%_*}
	new=${vers#*_*_*_}
	new=${new%%_*}
	checkversion_result=$((old - new))
printf 'minor old:%s new:%s result:%s\n' "$old" "$new" "$checkversion_result"
	[ "$checkversion_result" -ne 0 ] && return 0
	#ocmpare RC_b versus b
	old=${target#*_*_*_*_}
	old=${old%%b*}
	new=${vers#*_*_*_*_}
	new=${new%%b*}
	if [ "$old" != "$new" ]
	then	[ "$old" = "" ] && checkversion_result=1 || \
				   checkversion_result=-1
	fi
printf 'RC old:%s new:%s result:%s\n' "$old" "$new" "$checkversion_result"
	[ "$checkversion_result" -ne 0 ] && return 0
	#compare build version
	old=${target##*b}
	new=${vers##*b}
	checkversion_result=$((old - new))
printf 'build old:%s new:%s result:%s\n' "$old" "$new" "$checkversion_result"
	return 0
}

if checkversion mod version
then	echo "version check completed successfully, result: $checkversion_result"
else	echo "version check failed; see diagnostics above"
fi

#!/usr/bin/env bash

# @(#) s2       Demonstrate version strings comparison.

LC_ALL=C ; LANG=C ; export LC_ALL LANG
pe() { for _i;do printf "%s" "$_i";done; printf "\n"; }
pl() { pe;pe "-----" ;pe "$*"; }
db() { ( printf " db, ";for _i;do printf "%s" "$_i";done;printf "\n" ) >&2 ; }
db() { : ; }
C=$HOME/bin/context && [ -f $C ] && $C

FILE=${1-data1}

pl " Input data file $FILE:"
head $FILE

pl " Version comparison script:"
cat vercomp

# Compare, look at exit status.
# return 1 for $1 > $2
# return 2 for $1 < $2
# return 0 for equal

pl " Results:"
while read v1 v2
do

./vercomp "$v1" "$v2"
v0=$?
case $v0 in
        (0) pe " Versions $v1 and $v2 are the equal." ;;
        (1) pe " $v1 is more recent than $v2." ;;
        (2) pe " $v2 is more recent than $v1." ;;
        (*) pe " Internal error." ;;
esac
done < $FILE

exit 0

$ ./s2

Environment: LC_ALL = C, LANG = C
(Versions displayed with local utility "version")
OS, ker|rel, machine: Linux, 3.16.0-4-amd64, x86_64
Distribution        : Debian 8.4 (jessie) 
bash GNU bash 4.3.30

-----
 Input data file data1:
V_1_4_4_b1      V_1_5_1_RC_b1
1.2-r3  1.2-r4
1.2rc3  1.2r4
3.14a   3.14b

-----
 Version comparison script:
#!/usr/bin/env bash

# @(#) vercomp  Compare version strings.
# Adapted from:
# http://stackoverflow.com/questions/4023830/bash-how-compare-two-strings-in-version-format

ascii_frag() {
  expr match "$1" "\([^[:digit:]]*\)"
}

ascii_remainder() {
  expr match "$1" "[^[:digit:]]*\(.*\)"
}

numeric_frag() {
  expr match "$1" "\([[:digit:]]*\)"
}

numeric_remainder() {
  expr match "$1" "[[:digit:]]*\(.*\)"
}

# Disable/enable debugging here.
vercomp_debug() {
  OUT="$1"
  # echo "${OUT}" >&2
}

# return 1 for $1 > $2
# return 2 for $1 < $2
# return 0 for equal
vercomp() {
  local WORK1="$1"
  local WORK2="$2"
  local NUM1="", NUM2="", ASCII1="", ASCII2=""
  while true; do
    vercomp_debug "ASCII compare"
    ASCII1=`ascii_frag "${WORK1}"`
    ASCII2=`ascii_frag "${WORK2}"`
    WORK1=`ascii_remainder "${WORK1}"`
    WORK2=`ascii_remainder "${WORK2}"`
    vercomp_debug "\"${ASCII1}\" remainder \"${WORK1}\""
    vercomp_debug "\"${ASCII2}\" remainder \"${WORK2}\""
    
    if [ "${ASCII1}" \> "${ASCII2}" ]; then
      vercomp_debug "ascii ${ASCII1} > ${ASCII2}"
      return 1
      elif [ "${ASCII1}" \< "${ASCII2}" ]; then
      vercomp_debug "ascii ${ASCII1} < ${ASCII2}"
      return 2
    fi
    vercomp_debug "--------"
    
    vercomp_debug "Numeric compare"
    NUM1=`numeric_frag "${WORK1}"`
    NUM2=`numeric_frag "${WORK2}"`
    WORK1=`numeric_remainder "${WORK1}"`
    WORK2=`numeric_remainder "${WORK2}"`
    vercomp_debug "\"${NUM1}\" remainder \"${WORK1}\""
    vercomp_debug "\"${NUM2}\" remainder \"${WORK2}\""
    
    if [ -z "${NUM1}" -a -z "${NUM2}" ]; then
      vercomp_debug "blank 1 and blank 2 equal"
      return 0
      elif [ -z "${NUM1}" -a -n "${NUM2}" ]; then
      vercomp_debug "blank 1 less than non-blank 2"
      return 2
      elif [ -n "${NUM1}" -a -z "${NUM2}" ]; then
      vercomp_debug "non-blank 1 greater than blank 2"
      return 1
    fi
    
    if [ "${NUM1}" -gt "${NUM2}" ]; then
      vercomp_debug "num ${NUM1} > ${NUM2}"
      return 1
      elif [ "${NUM1}" -lt "${NUM2}" ]; then
      vercomp_debug "num ${NUM1} < ${NUM2}"
      return 2
    fi
    vercomp_debug "--------"
  done
}

vercomp "$@"

-----
 Results:
 V_1_5_1_RC_b1 is more recent than V_1_4_4_b1.
 1.2-r4 is more recent than 1.2-r3.
 1.2rc3 is more recent than 1.2r4.
 3.14b is more recent than 3.14a.