autospec/lib/libspec.lib.in

#!/bin/bash -e
# libspec.lib -- @package@ library to manage rpm specfiles
# Copyright (C) 2004-2010 Davide Madrisan <davide.madrisan@gmail.com>

[ -z "$BASH" ] || [ ${BASH_VERSION:0:1} -lt 2 ] &&
   echo $"this script requires bash version 2 or better" >&2 && exit 1

[ -r @libdir@/libmsgmng.lib ] ||
 { echo "$me: "$"library not found"": @libdir@/libmsgmng.lib" 1>&2
   exit 1; }
. @libdir@/libmsgmng.lib

if [[ -z "$LANG" && -r /etc/sysconfig/i18n ]]; then
   . /etc/sysconfig/i18n
   [ "$LANG" ] && export LANG
fi
TEXTDOMAIN="libspec"; export TEXTDOMAIN

# function boolexpr.solve
#    calculate the boolean expression `$1' expanding the variables
#    found in `rpmvar_name[]' and `define_list_name[]'
# args:
#    $1 : boolean expression to calculate
# return values:
#    0  : false
#    1  : true
#    2  : sintax error in expression `$1'
# note:
#    tested families of boolean expressions:
#     - %define use_gcc_33   0
#       %if [!] %{use_gcc_33}
#       ...
#     - %if "%{?cross_target_cpu}" != ""
function boolexpr.solve() {
   local input="$1" boolexpr="$1"

   [[ "$boolexpr" ]] || notify.error $"\
(bug)"" -- $FUNCNAME: "$"missing mandatory arg"" (#1)"

   notify.debug "\
$FUNCNAME: boolean expression [ $boolexpr ]"

   local i

   # expand user --defined variables first...
   for i in `seq 0 1 $(( ${#define_list_name[*]} - 1 ))`; do
         notify.debug "\
$FUNCNAME: expanding boolexpr using: \
${define_list_name[$i]} (${define_list_value[$i]})"

      boolexpr=$(echo $boolexpr | sed "\
s@%${define_list_name[$i]}@${define_list_value[$i]}@g
s@%?${define_list_name[$i]}@${define_list_value[$i]}@g
s@%{${define_list_name[$i]}}@${define_list_value[$i]}@g
s@%{?${define_list_name[$i]}}@${define_list_value[$i]}@g")
   done

   # ...then expand known variables
   for i in `seq 0 1 $(( ${#rpmvar_name[*]} - 1 ))`; do
      notify.debug "\
$FUNCNAME: expanding boolexpr using: \
${rpmvar_name[$i]} (${rpmvar_value[$i]})"

      boolexpr=$(echo $boolexpr | sed "\
s@%${rpmvar_name[$i]}@${rpmvar_value[$i]}@g
s@%?${rpmvar_name[$i]}@${rpmvar_value[$i]}@g
s@%{${rpmvar_name[$i]}}@${rpmvar_value[$i]}@g
s@%{?${rpmvar_name[$i]}}@${rpmvar_value[$i]}@g")
   done

   # unexpanded variables beginning by '?' become void strings
   # i.e. "%{?cross_target_cpu}" --> ""
   case "$boolexpr" in
   *%{?*|*%?*)
      boolexpr=$(echo $boolexpr | \
         sed "s@%{?[^}]*}@@g;s@%?[a-zA-Z0-9_]*@@")
      notify.debug "$FUNCNAME: boolexpr blanked -- [ $boolexpr ]" ;;
   esac

   # expand rpm variables
   # i.e. "%{_build_cpu}"
   notify.debug "$FUNCNAME: expanding rpm variables, if any..."
   boolexpr=$(eval "rpm $define_list_rpm --eval='"$boolexpr"'")
   notify.debug "$FUNCNAME: boolexpr = \`$boolexpr'"

   # catch parsing errors
   #[ "$boolexpr" 2>/dev/null ]
   #[ $? -gt 1 ] && { echo "2"; return; }

   # note: rpm logic: "0" means false, everything else means "true"

   set -- $boolexpr

   local do_negate
   [ "$1" = "!" ] &&
    { let "do_negate = 1"; shift; } || let "do_negate = 0"
   notify.debug "$FUNCNAME: do_negate = $do_negate"

   if [[ ( "$1" = "0" || "$1" = "1" ) && -z "$2" ]]; then
      let "retval = $1"
      [[ "$do_negate" = "1" ]] && let "retval = $((! $1))"
   else
      notify.debug "\
$FUNCNAME: set: \$1 = \"$1\", \$2 = \"$2\", \$3 = \"$3\""
      case "$2" in
         "") # boolean expression with only one operand, i.e
             # %if "%{?stage1}"
             [ "${1//\"/}" ] && let "retval = 1" || let "retval = 0"  #`
         ;;
         "<"|"<="|"="|"=="|"!="|">="|">")
             # boolean expression with operator, i.e
             # "%{?cross_target_cpu}" != ""
             notify.debug "\
$FUNCNAME: retval = \$( expr \"${1//\"/}\" \"$2\" \"${3//\"/}\" )"
             retval=$( expr "${1//\"/}" "$2" "${3//\"/}" )  #`
         ;;
         *)  # FIXME
             notify.warning $"\
detected a specfile with unsupported syntax:"" $1 $2 $3"
         ;;
      esac
      [ "$do_negate" = "1" ] && let "retval = $((! $1))"
   fi

   local boolstr; boolstr=(false true)
   notify.debug "\
$FUNCNAME: boolean expression [ $boolexpr ] --> ${boolstr[$retval]} ($retval)"

   echo "$retval"
}

# function rpmvars.init
#    set the vectors 'rpmvar_name[]', 'rpmvar_value[]', 'rpmvar_expr[]'
# args:
#    --clear  : clear all the rpmvar_* variables and exit
#    --pckver : (force) version number of the package
#    $1       : specfile name and path
# note:
#    FIXME : unsupported expressions
#    (see nagios.spec)
#    %{!?EMBPERL: %define EMBPERL 0}
#    DEBUG: : set: $1 = "%{EMBPERL}", $2 = "", $3 = ""
#    expr: sintax error
function rpmvars.init() {
   local ARGS pckver
   ARGS=`LANG=C getopt -o cv: --long clear,pckver: -n "$FUNCNAME" -- "$@"`
   [ $? = 0 ] || notify.error $"\
(bug)"" -- $FUNCNAME: "$"\`getopt' error"

   eval set -- "$ARGS"

   while :; do
      case "$1" in
      -c|--clear)
         unset rpmvar_name
         unset rpmvar_value
         unset rpmvar_expr
         notify.debug "$FUNCNAME: variables \`rpmvar_*' cleared up"
         return
      ;;
      -v|--pckver)
         pckver="$2"
         notify.debug "$FUNCNAME: pckver = $pckver (forced via --pckver)"
         shift
      ;;
      --) shift; break ;;
      *) notify.error $"\
(bug)"" -- $FUNCNAME: "$"\`getopt' error: bad command \`$1'" ;;
      esac
      shift
   done

   local specfile="$1"

   [[ "$specfile" ]] || notify.error $"\
(bug)"" -- $FUNCNAME: "$"missing mandatory arg"" (#1)"

   [[ -r $specfile ]] ||
      notify.error $"specfile not found"": \`$specfile'"

   local i j

   # if rpm variables have not been already set
   if [[ -z "$rpmvar_name" || -z "$rpmvar_value" ]]; then
      # set 'rpmvar_name' and 'rpmvar_value'
      local line rpmvar_name rpmvar_value rpmvar_expr

      rpmvar_name[0]="name"
      rpmvar_value[0]="\
$(sed -n "/%description/q;{ # look in the spec preamble
   /^Name/{s,Name[ \t]*:[ \t]*,,p}}" $specfile)"
      rpmvar_expr[0]="0"

      rpmvar_name[1]="version"
      if [ "$pckver" ]; then
         rpmvar_value[1]="$pckver"
      else
         rpmvar_value[1]="\
$(sed -n "/%description/q;{ # look in the spec preamble
   /^Version/{s,Version[ \t]*:[ \t]*,,p}}" $specfile)"
      fi
      rpmvar_expr[1]="0"

      local ifexpr ifexpr_level boolexpr tok toksave level
      let "ifexpr_level = 0"   # level of nested %if statements
      ifexpr[0]="1"            # '[0]' means: out of any %if statement

      let "level = 0"

      local ignore_lines       # support for '## *AUTOSPEC-{OFF,ON}*'
      let "ignore_lines = 0"

      while read -r -a tok; do
         if [ "${tok[0]}" = "##" ]; then
            if [ "${tok[1]}" = "*AUTOSPEC-OFF*" ]; then
               notify.debug "$FUNCNAME: found an AUTOSPEC-OFF command"
               let "ignore_lines = 1"
               continue
            fi

            if [ "${tok[1]}" = "*AUTOSPEC-ON*" ]; then
               notify.debug "$FUNCNAME: found an AUTOSPEC-ON command"
               let "ignore_lines = 0"
               continue
            fi
         elif [ "$ignore_lines" = "1" ]; then
            # skip lines in the block "*AUTOSPEC-OFF*" .. "*AUTOSPEC-ON*"
            notify.debug "$FUNCNAME: * line ignored --  ${tok[*]}"
            continue
         fi

         case "${tok[0]}" in
         %description)
            # skip all but the specfile preamble
            break
         ;;
         %if)
            #ifexpr=$(rpmvars.solve "${tok2}${fromtok3}" "$specfile")
            # note: if <%var> is undefined (not present) or set to "0"
            #       then the conditional expression is false else is true
            let "ifexpr_level += 1"

            # note: to implement %if statements we must take care of
            # boolean values of all the previous ifexpr[] values,
            # starting from 1 to '$ifexpr_level'
#            [ "$ifexpr_level" -gt 1 ] && notify.warning "\
#$FUNCNAME: "$"FIXME: sorry, not implemented yet..."" (nested \`%if')"

            notify.debug "\
$FUNCNAME: conditional block (%if) [level#$ifexpr_level]  --  ${tok[*]}"

            toksave=${tok[0]}
            unset tok[0]
            ifexpr[$ifexpr_level]=$(boolexpr.solve "${tok[*]}")
            tok[0]=$toksave
         ;;
         %if[a-z]*)   # %ifarch, %ifdef, ?
            notify.warning "\
$FUNCNAME: "$"FIXME: sorry, not implemented yet..."" (\`${tok[0]}')"
            let "ifexpr_level += 1"
            # FIXME: we should call 'boolexpr.solve' here:
            #   toksave=${tok[0]}
            #   unset tok[0]
            #   ifexpr[$ifexpr_level]=$(boolexpr.solve "${tok[*]}")
            #   tok[0]=$toksave
            # for new we chooes a 50% right - 50% wrong approach :(
            ifexpr[$ifexpr_level]=1
         ;;
         %else)
            notify.debug "\
$FUNCNAME: conditional block (%else) [level#$ifexpr_level]"
           #let "level = 0"
            for level in $(seq 1 1 $ifexpr_level); do
            # complement boolean values in %else blocks
               if [ "${ifexpr[$level]}" = "0" ]; then
                  ifexpr[$level]=1
                  notify.debug "$FUNCNAME: ifexpr[$level] = 0 --> 1"
               else
                  ifexpr[$level]=0
                  notify.debug "$FUNCNAME: ifexpr[$level] = 1 --> 0"
               fi
            done
         ;;
         %endif)
            notify.debug "\
$FUNCNAME: conditional block (%end) [level#$ifexpr_level]"
         let "ifexpr_level -= 1" ;;
         %end)
            notify.warning $"\`%end' found; should perhaps be \`%endif'"
         ;;
         %define)
            # note: we want to catch %define directives put in conditional blocks
            # example: %define majversion <single_token>
            let "level = 0"
            for level in $(seq 1 1 $ifexpr_level); do
               notify.debug "$FUNCNAME: ifexpr[$level] = ${ifexpr[$level]}"
               [ "${ifexpr[$level]}" = "0" ] &&
                { # found a false condition
                  let "level = $ifexpr_level + 1"; break; }
            done
            # not all the conditions are true: skip this definition
            [ $level -gt $ifexpr_level ] &&
             { notify.debug "$FUNCNAME: ${tok[*]} ... skipped"
               continue; }

            local tok0save tok1save tmpstr1 tmpstr2
            tok0save=${tok[0]} tok1save=${tok[1]}
            unset tok[0] tok[1]
            unset tmpstr tmpstr2

            notify.debug "$FUNCNAME: $tok1save = \"${tok[*]}\""
            rpmvar_name[${#rpmvar_name[*]}]=$tok1save
            case "${tok[*]}" in
            %\(*\))
               # it's something like:
               # %define major_ver %(echo %version | cut -d. -f 1-2)
               # %define glibver %(echo `rpm -q --queryformat '%{VERSION}' libglib`)

#              rpmvar_value[${#rpmvar_value[*]}]="\
#$( echo "${tok[*]}" | sed "s|%(\(.*\))|\1|" )"

               tmpstr="$(echo "${tok[*]}" | sed "s|%(\(.*\))|\1|")"
               notify.debug "$FUNCNAME: tmpstr = $tmpstr"
               # use the expanded value only if there's no rpm variables inside
               tmpstr2="$(bash -c "$tmpstr" 2>/dev/null)"
               if [ $? -eq  0 ]; then
                  echo "$tmpstr2" | grep -q -- '%' &&
                     rpmvar_expr[${#rpmvar_expr[*]}]="1" ||
                   { tmpstr="$tmpstr2"
                     rpmvar_expr[${#rpmvar_expr[*]}]="0"
                     notify.debug "$FUNCNAME: tmpstr = $tmpstr"; }
               fi
               rpmvar_value[${#rpmvar_value[*]}]="$tmpstr"
            ;;
            *) rpmvar_value[${#rpmvar_value[*]}]=${tok[*]}
               rpmvar_expr[${#rpmvar_expr[*]}]="0"
            ;;
            esac

            tok[0]=$tok0save
            tok[1]=$tok1save
         ;;
         # %define expanded directive
         # example:
         #   %{expand:%%define kminver %(echo %version | cut -d. -f3)}
         %{expand:*|%{expand)
            notify.warning "\
$FUNCNAME: "$"FIXME: sorry, not implemented yet..."" (\`%expand...')"
         ;;
         %{!?*:*%define*)
            # %{!?EMBPERL: %define EMBPERL 0}
            notify.warning "\
$FUNCNAME: "$"FIXME: sorry, not implemented yet..."" (\`%{!?<VAR>:<DEFVALUE>')"
#
#            # condvar_name = "EMBPERL"
#            local condvar_name="$(\
#echo "${tok[0]}" | sed 's,%{!?\(.*\):.*,\1,')"
#            notify.debug "$FUNCNAME: condvar_name = $condvar_name"
#
#            # condvar_expr = "EMBPERL 0"
#            local condvar_expr="$(\
#echo "${tok[0]}" | sed 's,.*%define[ \t]*\(.*\)},\1,')"
#            notify.debug "$FUNCNAME: condvar_expr = $condvar_expr"
         ;;
         *) # not a definition: ignore the line
            continue ;;
         esac
      done < $specfile

      # [1] variable expansion using user `--define' values
      notify.debug "\
$FUNCNAME: * variable expansion using user \`--define' values..."
      local define_applied
      for i in `seq 0 1 $(( ${#define_list_name[*]} - 1 ))`; do
         let "define_applied = 0"
         for j in `seq 0 1 $(( ${#rpmvar_name[*]} - 1 ))`; do
            [[ "${rpmvar_name[$j]}" = "${define_list_name[$i]}" ]] &&
             { rpmvar_value[$j]="${define_list_value[$i]}"
               let "define_applied = 1"
               notify.debug "\
$FUNCNAME: ${rpmvar_name[$j]} = \"${define_list_value[$i]}\" (forced by user)"
               # FIXME : advanced users may --define variables by
               # expressions, but for now expression are not supported by
               # autospec, so we force '0' value
               rpmvar_expr[$j]="0"; }
         done
         if [[ "$define_applied" = "0" ]]; then
            notify.debug "\
$FUNCNAME: added not existing user defined variable \`%${define_list_name[$i]}'"
            rpmvar_name[${#rpmvar_name[*]}]="${define_list_name[$i]}"    # `
            rpmvar_value[${#rpmvar_value[*]}]="${define_list_value[$i]}" # `
            # FIXME : user cannot --define expressions, just values
            rpmvar_expr[${#rpmvar_expr[*]}]="0"
         fi
      done
      notify.debug "\
$FUNCNAME: [1] rpmvar_name  = [ \
$(for i in `seq 0 1 $(( ${#rpmvar_name[*]} - 1 ))`; do
echo -n "\"%${rpmvar_name[$i]}\" "; done)]"
      notify.debug "\
$FUNCNAME: [1] rpmvar_value = [ \
$(for i in `seq 0 1 $(( ${#rpmvar_value[*]} - 1 ))`; do
echo -n "\"${rpmvar_value[$i]}\" "; done)]"

      # [2] variable expansion using 'rpmvar_value[]'
      local tmpvar tmpval
      notify.debug "\
$FUNCNAME: * variable expansion using user \`rpmvar_value[]'..."
      for i in $( seq 0 1 $(( ${#rpmvar_name[*]} - 1 )) ); do
         for j in $( seq 0 1 $(( ${#rpmvar_name[*]} - 1 )) ); do
            # do not expand one variable with itself
            [[ $i -eq $j ]] && continue

            # use 'pck_newver' if defined
            case "${rpmvar_name[$j]}" in
            version) [[ "$pck_newver" ]] &&
             { rpmvar_value[$i]="$(\
echo ${rpmvar_value[$i]} | sed "s#%[{]*version[}]*#$pck_newver#g")"
               continue; } ;;
            esac
            # NOTE: old code
#            rpmvar_value[$i]="$(\
#echo ${rpmvar_value[$i]} | sed "\
#s#%[{]*[?]*${rpmvar_name[$j]}[}]*#${rpmvar_value[$j]}#g")"
            tmpvar="${rpmvar_name[$j]}"; tmpvalue="${rpmvar_value[$j]}"
            notify.debug "\
$FUNCNAME:    * \`${rpmvar_value[$i]}' : \`$tmpvar' --> \`$tmpvalue'..."
            rpmvar_value[$i]="$(\
echo ${rpmvar_value[$i]} | sed -n "\
/%{?$tmpvar:%$tmpvar.*}/{s#%{?$tmpvar:%$tmpvar\(.*\)}#$tmpvalue\1#gp;q};
/%{?$tmpvar}/{s#%{?$tmpvar}#$tmpvalue#gp;q};
/%{$tmpvar}/{s#%{$tmpvar}#$tmpvalue#gp;q};
/%$tmpvar/{s#%$tmpvar#$tmpvalue#gp;q};
p")"
         done
         notify.debug "\
$FUNCNAME:    result: \`${rpmvar_value[$i]}'"
      done
      notify.debug "\
$FUNCNAME: [2] rpmvar_name  = [ \
$(for i in `seq 0 1 $(( ${#rpmvar_name[*]} - 1 ))`; do
echo -n "\"%${rpmvar_name[$i]}\" "; done)]"
      notify.debug "\
$FUNCNAME: [2] rpmvar_value = [ \
$(for i in `seq 0 1 $(( ${#rpmvar_value[*]} - 1 ))`; do
echo -n "\"${rpmvar_value[$i]}\" "; done)]"

      # [3] expand rpm variables using 'rpm --eval=<rpm_var>'
      notify.debug "\
$FUNCNAME: * variable expansion using \`rpm --eval=<rpm_var>'..."
      local rpmvar_value_unexpanded
      for i in $( seq 0 1 $(( ${#rpmvar_name[*]} - 1 )) ); do
         case "${rpmvar_value[$i]}" in
         %*) rpmvar_value_unexpanded="${rpmvar_value[$i]}"
             rpmvar_value[$i]=$(\
rpm --eval="${rpmvar_value[$i]}" 2>/dev/null) ;;
         esac
      done
      notify.debug "\
$FUNCNAME: [3] rpmvar_name  = [ \
$(for i in `seq 0 1 $(( ${#rpmvar_name[*]} - 1 ))`; do
echo -n "\"%${rpmvar_name[$i]}\" "; done)]"
      notify.debug "\
$FUNCNAME: [3] rpmvar_value = [ \
$(for i in `seq 0 1 $(( ${#rpmvar_value[*]} - 1 ))`; do
echo -n "\"${rpmvar_value[$i]}\" "; done)]"

      for i in $( seq 0 1 $(( ${#rpmvar_name[*]} - 1 )) ); do
         # note: we strip the '"' chars from 'rpmvar_value' because
         # otherwise a definition like: 'BUILD_CC "ccache gcc33"'
         # will be expanded into 'rpmvar_value[0]=""ccache gcc33""'
         # and the error message: 'gcc33: no input files' will be
         # printed to stderr at every '. infofile' command
         echo "\
rpmvar_name[$i]=\"${rpmvar_name[$i]}\"
rpmvar_value[$i]=\"${rpmvar_value[$i]//\"/}\"
rpmvar_expr[$i]=\"${rpmvar_expr[$i]}\"" >> ${infofile:-/dev/null} # `

         if [[ "${rpmvar_expr[$i]}" = "1" ]]; then
            notify.debug "$FUNCNAME: eval \"${rpmvar_value[$i]}\""
            # FIXME : the eval command could lead to security issues!
            #         ex. %define foo %(rm -f <a_file_in_HOME_dir>)
            # it's also a problem for rpm itself (at least for rpm 4.0.4)
            eval "${rpmvar_value[$i]}" &>/dev/null
            # note: %define BUILD_CC ccache gcc33
            #         --> eval "ccache gcc33" --> $? == 1
            [[ $? -eq 0 ]] || notify.warning $"\
cannot evaluate:"" \"${rpmvar_value[$i]}\""
         fi
      done
   fi
}

# function rpmvars.solve
#    convert the rpm variables found in the string '$1' with their
#    values using the data vectors 'rpmvar_name' and 'rpmvar_value'
# args:
#    $1 :  string to expand
#    $2 :  specfile name and path
function rpmvars.solve() {
   local i input="$1" output="$1" specfile="$2"

   # skip strings with no variables inside
   case "$input" in *%*) ;; *) echo "$output"; return ;; esac

   [ "$input" ] || notify.error $"\
(bug)"" -- $FUNCNAME: "$"missing mandatory arg"" (#1)"
   [ "$specfile" ] || notify.error $"\
(bug)"" -- $FUNCNAME: "$"missing mandatory arg"" (#2)"

   [ -r "$specfile" ] ||
      notify.error $"specfile not found"": \`$specfile'"

   [[ "${rpmvar_name[@]}" ]] || notify.warning $"\
(bug)"" -- $FUNCNAME: "$"assertion failed:"" \"\${rpmvar_name[@]}\" != \"\""

   notify.debug "$FUNCNAME: input = $input"

   # convert the rpm variables found in 'output'
   local tmpvar tmpvalue
   for i in $(seq 0 1 $(( ${#rpmvar_name[@]} - 1 ))); do
      notify.debug "\
$FUNCNAME:  trying with \"${rpmvar_name[$i]}\" (${rpmvar_value[$i]}) ..."
      if [ "${rpmvar_expr[$i]}" = "0" ]; then
         # ex: "/ruby/%{majorminor}/ruby-%{version}%{?pl:-p%pl}.tar.bz2"
         tmpvar="${rpmvar_name[$i]}"; tmpvalue="${rpmvar_value[$i]}"
         output="$( echo "$output" | sed -n "\
/%{?$tmpvar:%$tmpvar.*}/{s#%{?$tmpvar:%$tmpvar\(.*\)}#$tmpvalue\1#gp;q};
/%{?$tmpvar}/{s#%{?$tmpvar}#$tmpvalue#gp;q};
/%{$tmpvar}/{s#%{$tmpvar}#$tmpvalue#gp;q};
/%$tmpvar/{s#%$tmpvar#$tmpvalue#gp;q};
p")"
#         output="$( echo "$output" | sed "\
#s|%[{]*?${rpmvar_name[$i]}:||g;\
#s|%[{]*[?]*${rpmvar_name[$i]}[}]*|${rpmvar_value[$i]}|g" )"
      else
         # FIXME : the eval command could lead to security issues!
         # so it should be executed in a resticted environment
         j=$( eval "${rpmvar_value[$i]}" 2>/dev/null )

         output="$( echo "$output" | sed "\
s|%[{]*?${rpmvar_name[$i]}:||g;\
s|%[{]*[?]*${rpmvar_name[$i]}[}]*|$j|g" )"
      fi
      notify.debug "$FUNCNAME:  -${rpmvar_expr[$i]}-> '$output'"

      # skip strings with no more variables inside
      case "$output" in
         *%*) ;;
         *) notify.debug "$FUNCNAME: output = \`$output'"
            echo "$output"; return ;;
      esac
   done
   notify.debug "$FUNCNAME: output = \`$output'"

   # unexpanded variables beginning by '?' must become blank strings
   # i.e. "%{?cross_target_cpu}" --> ""
   notify.debug "\
$FUNCNAME: * blank unexpanded and undefined variables beginning by \`?'..."
   output=$(echo $output | sed "s@%{?[^}]*}@@g;s@%?[a-zA-Z0-9_]*@@")
   notify.debug "$FUNCNAME: output = \`$output'"

   # expand rpm variables
   # i.e. 'rpmvars.solve(%{__install_info} $specfile)'
   case "$output" in *%*)
      notify.debug "$FUNCNAME: * expanding rpm variables, if any..."
      # hack to prevent a rpm segfault when evaluating urls containing '%' (e.g. python-pyslsk)
      output_prefix=`echo ${output} | sed "s|\(^[a-z]*://\).*|\1|"`
      output_suffix=`echo ${output} | sed "s|$output_prefix||"`
      notify.debug "$FUNCNAME: rpm --eval \"${output_suffix}\""
      output=$(rpm --eval "${output_suffix}")
      output="${output_prefix}${output}"
      notify.debug "$FUNCNAME: output = \`$output'" ;;
   esac

   echo "$output"
}


# function specfile.getvars
#    set the variable(s) given as argument to the value(s) found
#    in the specfile preamble
# args:
#    $v_! .. $v_n : specfile variables to resolve
#    --specfile   : specfile name and path
#    --verbatim   : do not expand variables
#    --help
# usage example:
#    specfile.getvars SPEC_NAME SPEC_VERSION SPEC_RELEASE
function specfile.getvars() {
   local me="$FUNCNAME"

 { # (to make 'usage' a local function)
   function usage() {
      echo "\
$me, "$"version"" @version@""
Copyright (C) 2005,2010 Davide Madrisan <davide.madrisan@gmail.com>""

"$"Get informations from a given specfile.""

"$"Usage"":
   $me -s <specfile> [-v] <query0> [<query1> [...]]

"$"where the above options mean"":
   -s, --specfile        "$"name (and patch) of the specfile""
   -v, --verbatim        "$"do not try to expand variables""

"$"and <query> belongs to the following list"":
   SPEC_NAME             Name
   SPEC_VERSION          Version
   SPEC_RELEASE          Release
   SPEC_GROUP            "$"list of package groups"" (Group)
   SPEC_BUILDARCH        BuildArch
   SPEC_BUILDROOT        BuildRoot
   SPEC_FILENAME         "$"full name of the srpm package""
   SPEC_PATCH            "$"list of patches"" (Patch[0-9]*)
   SPEC_URL              URL
   SPEC_SOURCE0          Source[0]
   SPEC_SOURCE0_PCKNAME  "$"name of the source0 file""
   SPEC_SOURCE           "$"list of source files"" (Source[0-9]*)
   SPEC_LICENSE          License
   SPEC_TARGET           "$"list of all the generated rpm packages""
   SPEC_OBSOLETES        "$"list of the obsoleted packages""
   SPEC_BUILDREQUIRES    "$"list of the declared build requirements""

"$"Operation modes"":
   -h, --help            "$"Print this help, then exit""

"$"Samples"":
   $me -s /var/tmp/specs/@package@.spec SPEC_TARGET SPEC_VERSION
   echo \"\${SPEC_TARGET[@]}, \$SPEC_VERSION\"  # @package@, @version@

"$"Report bugs to <davide.madrisan@gmail.com>."
   }
 }

   local ARGS
   ARGS=`LANG=C getopt -o hs:v --long help,specfile:,verbatim \
         -n "$FUNCNAME" -- "$@"`
   [ $? = 0 ] || notify.error $"\
(bug)"" -- $FUNCNAME: "$"\`getopt' error"

   local specfile verbatim=0

   eval set -- "$ARGS"

   while :; do
      case "$1" in
      -s|--specfile)
         specfile="$2"; shift
         notify.debug "$FUNCNAME: specfile = \"$specfile\""
      ;;
      -v|--verbatim)
         let "verbatim = 1"
         notify.debug "$FUNCNAME: verbatim = \"1\""
      ;;
      -h|--help)
         usage
         ${EXIT_FUNC:-"exit"}
      ;;
      --) shift; break ;;
      *) notify.error $"\
(bug)"" -- $FUNCNAME: "$"\`getopt' error: bad command \`$1'" ;;
      esac
      shift
   done

   [ "$specfile" ] || { usage; ${EXIT_FUNC:-"exit"} 1; }

   [ -r "$specfile" ] ||
    { # 'return' is required when 'EXIT_FUNC' is equal to 'return'
      notify.error $"specfile not found"": \`$specfile'"; return; }

   [ -r "$infofile" ] && . $infofile

    # when this library is used by external scripts this assertion always fails
#   [[ "${rpmvar_name[@]}" ]] || notify.warning $"\
#(bug)"" -- $FUNCNAME: "$"assertion failed:"" \"\${rpmvar_name[@]}\" != \"\""

   local ignore_lines       # support for '## *AUTOSPEC-{OFF,ON}*'
   let "ignore_lines = 0"
   local var

   for var in $@; do
      notify.debug "$FUNCNAME: expanding \`$var'..."

      case $var in
      SPEC_NAME)
         [ "$SPEC_NAME" ] && continue
         SPEC_NAME=$(sed -n "/%description/q;{ # look in the spec preamble
            /^[ \t]*Name/{s,^[ \t]*Name[ \t]*:[ \t]*,,p}}" $specfile)
         # FIXME (by whitone)
         #  /^[ \t]*Name/{s,[^:]*:[ \t]*,,p}}" $specfile)
         [[ "$(echo "$SPEC_NAME" | wc -w)" != 1 ]] &&
            notify.error $"bad specfile preamble"" (Name)"
         # resolve the rpm variables, if any
         #[ "$(echo $SPEC_NAME | sed -n "s,.*%,%,p")" ] &&
         SPEC_NAME=$(rpmvars.solve "$SPEC_NAME" "$specfile")
         notify.debug "$FUNCNAME: $var = \"$SPEC_NAME\""
      ;;
      SPEC_VERSION)
         [ "$SPEC_VERSION" ] && continue
         SPEC_VERSION=$(sed -n "/%description/q;{
            /^[ \t]*Version/{s,^[ \t]*Version[ \t]*:[ \t]*,,p}}" $specfile)
         [[ "$(echo "$SPEC_VERSION" | wc -w)" != 1 ]] &&
            notify.error $"bad specfile preamble"" (Version)"
         # resolve the rpm variables, if any
         #[ "$(echo $SPEC_VERSION | sed -n "s,.*%,%,p")" ] &&
         SPEC_VERSION="$(rpmvars.solve "$SPEC_VERSION" "$specfile")"
         notify.debug "$FUNCNAME: $var = \"$SPEC_VERSION\""
      ;;
      SPEC_RELEASE)
         [ "$SPEC_RELEASE" ] && continue
         SPEC_RELEASE=$(sed -n "/%description/q;{
            /^[ \t]*Release/{s,.*:[ \t]*,,p}}" $specfile)
         [[ "$(echo "$SPEC_RELEASE" | wc -w)" != 1 ]] &&
            notify.error $"bad specfile preamble"" (Release)"
         # resolve the rpm variables, if any
         #[[ "$(echo $SPEC_RELEASE | sed -n "s,.*%,%,p")" ]] &&
         SPEC_RELEASE=$(rpmvars.solve "$SPEC_RELEASE" "$specfile")
         notify.debug "$FUNCNAME: $var = \"$SPEC_RELEASE\""
      ;;
      SPEC_GROUP)
         [ "$SPEC_GROUP" ] && continue
         local linenum=0
         while read -r -a tok; do
            let "linenum += 1"

            # do support '## *AUTOSPEC-{OFF,ON}*' blocks
            if [ "${tok[0]}" = "##" ]; then
               if [ "${tok[1]}" = "*AUTOSPEC-OFF*" ]; then
                  notify.debug "$FUNCNAME: found an AUTOSPEC-OFF command"
                  let "ignore_lines = 1"
                  continue
               fi

               if [ "${tok[1]}" = "*AUTOSPEC-ON*" ]; then
                  notify.debug "$FUNCNAME: found an AUTOSPEC-ON command"
                  let "ignore_lines = 0"
                  continue
               fi
            elif [ "$ignore_lines" = "1" ]; then
               # skip lines in the block "*AUTOSPEC-OFF*" .. "*AUTOSPEC-ON*"
               notify.debug "$FUNCNAME: * line ignored --  ${tok[*]}"
               continue
            fi

            case ${tok[0]} in
            Group|Group:)
               unset tok[0]
               notify.debug "\
$FUNCNAME: * entry found at line $linenum: \"${tok[*]}\""
               SPEC_GROUP[${#SPEC_GROUP[*]}]="${tok[*]}"   #`
#               notify.debug "\
#$FUNCNAME: SPEC_GROUP = ( ${SPEC_GROUP[*]} )"
            ;;
            esac
         done < $specfile

         notify.debug "$FUNCNAME: $var = ( ${SPEC_GROUP[*]} )"
      ;;
      SPEC_FILENAME)
         [ "$SPEC_FILENAME" ] && continue
         [ "$SPEC_NAME"     ] || specfile.getvars -s "$specfile" SPEC_NAME
         [ "$SPEC_VERSION"  ] || specfile.getvars -s "$specfile" SPEC_VERSION
         [ "$SPEC_RELEASE"  ] || specfile.getvars -s "$specfile" SPEC_RELEASE
         SPEC_FILENAME="\
${SPEC_NAME}-${SPEC_VERSION}-${SPEC_RELEASE}.src.rpm"

         notify.debug "$FUNCNAME: $var = \"$SPEC_FILENAME\""
      ;;
      SPEC_PATCH)
         if [ "$verbatim" = "1" ]; then
            [ "$SPEC_PATCH_VERBATIM" ] ||
             { SPEC_PATCH_VERBATIM=($(\
                  sed -n "/%description/q;{
                     /^[ \t]*Patch[0-9]*/{s,^Patch[0-9]*[ \t]*:[ \t]*,,p}}" \
                  $specfile))
               notify.debug "\
$FUNCNAME: SPEC_PATCH_VERBATIM = ( ${SPEC_PATCH_VERBATIM[*]} )"
             }
            continue
         fi

         [ "$SPEC_PATCH" ] && continue

         [ "$SPEC_NAME"    ] || specfile.getvars -s "$specfile" SPEC_NAME
         [ "$SPEC_VERSION" ] || specfile.getvars -s "$specfile" SPEC_VERSION
         SPEC_PATCH=($(sed -n "/%description/q;{
            /^[ \t]*Patch[0-9]*/{s,^Patch[0-9]*[ \t]*:[ \t]*,,p}}" \
         $specfile))
         for i in $(seq 0 1 $((${#SPEC_PATCH[*]}-1))); do
            SPEC_PATCH[$i]=$(\
rpmvars.solve "${SPEC_PATCH[$i]}" "$specfile" | \
               sed -n "\
                  s,%[{]*name[}]*,$SPEC_NAME,
                  s,%[{]*version[}]*,$SPEC_VERSION,;p" )
         done
         notify.debug "$FUNCNAME: $var = ( ${SPEC_PATCH[*]} )"
      ;;
      SPEC_SOURCE0)
         if [ "$verbatim" = "1" ]; then
            [ "$SPEC_SOURCE0_VERBATIM" ] ||
             { SPEC_SOURCE0_VERBATIM=$(\
                  sed -n "/%description/q;{
                     /^[ \t]*Source[0]*/{s,[ \t]*Source[0]*[ \t]*:[ \t]*,,p}}" \
                  $specfile)
               notify.debug "\
$FUNCNAME: SPEC_SOURCE0_VERBATIM = \"$SPEC_SOURCE0_VERBATIM\""
             }
            continue
         fi

         [ "$SPEC_SOURCE0" ] && continue
         SPEC_SOURCE0=$(sed -n "/%description/q;{
            /^[ \t]*Source[0]*/{
               s,[ \t]*Source[0]*[ \t]*:[ \t]*,,
            p}}" $specfile)
         SPEC_SOURCE0=$(rpmvars.solve "$SPEC_SOURCE0" "$specfile")
         notify.debug "$FUNCNAME: $var = \"$SPEC_SOURCE0\""
      ;;
      SPEC_SOURCE0_PCKNAME)
         [ "$SPEC_SOURCE0_PCKNAME" ] && continue
         [ "$SPEC_NAME"    ] || specfile.getvars -s "$specfile" SPEC_NAME
         [ "$SPEC_VERSION" ] || specfile.getvars -s "$specfile" SPEC_VERSION
         [ "$SPEC_SOURCE0" ] || specfile.getvars -s "$specfile" SPEC_SOURCE0

         SPEC_SOURCE0_PCKNAME=$(echo $SPEC_SOURCE0 | sed -n "\
            s,%[{]*name[}]*,$SPEC_NAME,
            s,%[{]*version[}]*,$SPEC_VERSION,
            s/.*\///  # remove directory name, if any
            s/\.[^0-9].*//  # remove trailing stuff (.tar.gz, ...)
            # <pck_name><pck_ver>
             /^${SPEC_NAME}${SPEC_VERSION}$/{s,$SPEC_VERSION,,p;q}
             /[^-\.][0-9]\./{s/\(.*[^-\.]\)[0-9]\..*/\1/p;q}
            # <pck_name>-<pck_ver>
             /^${SPEC_NAME}\-${SPEC_VERSION}$/{s,\-${SPEC_VERSION},,p;q}
             /-[0-9]\+/{s/-[0-9].*//p;q}
            # <pck_name>_<pck_ver>
             /^${SPEC_NAME}_${SPEC_VERSION}$/{s,_${SPEC_VERSION},,p;q}
             /_[0-9]\+/{s/_[0-9].*//p;q}
            # <pck_name>.<pck_ver>
             /^${SPEC_NAME}\.${SPEC_VERSION}$/{s,\.${SPEC_VERSION},,p;q}
             /^[a-zA-Z0-9_]\+\.[0-9\.]\+$/{s,\(^[a-zA-Z0-9_]\+\)\.[0-9\.]\+$,\1,p;q}
            /^[a-zA-Z0-9]\+$/{p;q}  # <pck_name> (with no version)
            # <pck_name> (no version, but <pck_name> can end with numbers)
            /^[^0-9]*[0-9]*$/p")
         notify.debug "$FUNCNAME: $var = \"$SPEC_SOURCE0_PCKNAME\""
      ;;
      SPEC_SOURCE)
         if [ "$verbatim" = 1 ]; then
            SPEC_SOURCE_VERBATIM=($(sed -n "/%description/q;{
               /^[ \t]*Source/{
                  s,[ \t]*Source[0-9]*[ \t]*:[ \t]*,,
               p}}" $specfile))
            notify.debug "\
$FUNCNAME: SPEC_SOURCE_VERBATIM = ( ${SPEC_SOURCE_VERBATIM[*]} )"
            continue
         fi

         [ "$SPEC_SOURCE"  ] && continue
         [ "$SPEC_NAME"    ] || specfile.getvars -s "$specfile" SPEC_NAME
         [ "$SPEC_VERSION" ] || specfile.getvars -s "$specfile" SPEC_VERSION
         # FIXME : spaces in source URL are not supported
         SPEC_SOURCE=($(sed -n "/%description/q;{
            /^[ \t]*Source/{
               s,[ \t]*Source[0-9]*[ \t]*:[ \t]*,,
               s,%[{]*name[}]*,$SPEC_NAME,
               s,%[{]*version[}]*,${pck_newver:-$SPEC_VERSION},
            p}}" $specfile))

         for i in $(seq 0 1 $((${#SPEC_SOURCE[*]} - 1))); do
            SPEC_SOURCE[$i]=$(\
rpmvars.solve "${SPEC_SOURCE[$i]}" "$specfile")
         done

         notify.debug "$FUNCNAME: $var = ( ${SPEC_SOURCE[*]} )"
      ;;
      SPEC_LICENSE)
         [ "$SPEC_LICENSE" ] && continue
         unset SPEC_LICENSE tmp_spec_license
         i=0
         while read tmp_spec_license; do
            SPEC_LICENSE[$i]="$tmp_spec_license"
            let "i = i+1"
         done < <(sed -n "\
/^[ \t]*License[ \t]*:/{s,.*:[ \t]*,,;
s,\,[ \t]*and[ \t]*,\n,; # remove ', and'
s,\,[ \t]*,\n,g;p} # remove ','
/^[ \t]*License[ \t]*:/{s,.*:[ \t]*,,;s,\,[ \t]*,\n,g;p}" $specfile)
#-or-
#/%description/q;{ # look in the spec preamble
#/^[ \t]*License/{s,.*:[ \t]*,,;s,\,[ \t]*,\n,g;p}}" $specfile)
         [[ "$(echo "$SPEC_LICENSE" | wc -w)" = 0 ]] &&
            notify.error $"bad specfile preamble"" (License)"

         notify.debug "$FUNCNAME: $var = ( \
$(for i in $(seq 0 1 $((${#SPEC_LICENSE[*]} - 1))); do
  echo -n "\"${SPEC_LICENSE[$i]}\" "; done))"
      ;;
      SPEC_URL)   # note: 'SPEC_URL' is not yet used in this script
         [ "$SPEC_URL" ] && continue
         SPEC_URL=$(sed -n "/%description/q;{
/^[ \t]*\(Url\|URL\)[ \t]*:/{s,[ \t]*\(Url\|URL\)[ \t]*:[ \t]*,,p}}" $specfile)
         [[ "$(echo "$SPEC_URL" | wc -w)" != 1 ]] &&
            notify.error $"bad specfile preamble"" (URL)"
         [ "$SPEC_URL" ] &&
            SPEC_URL=$(rpmvars.solve "$SPEC_URL" "$specfile")
         notify.debug "$FUNCNAME: $var = \"$SPEC_URL\""
      ;;
      SPEC_TARGET)
         [ "$SPEC_TARGET" ] && continue
         [ "$SPEC_NAME"   ] ||
            specfile.getvars -s "$specfile" SPEC_NAME

         local ifexpr ifexpr_level level boolexpr tok toksave filesname
         let "ifexpr_level = 0"   # level of nested %if statements
         ifexpr[0]="1"            # '0' means: out of any %if statement

         local linenum=0
         while read -r -a tok; do
            let "linenum += 1"

            # do support '## *AUTOSPEC-{OFF,ON}*' blocks
            if [ "${tok[0]}" = "##" ]; then
               if [ "${tok[1]}" = "*AUTOSPEC-OFF*" ]; then
                  notify.debug "$FUNCNAME: found an AUTOSPEC-OFF command"
                  let "ignore_lines = 1"
                  continue
               fi

               if [ "${tok[1]}" = "*AUTOSPEC-ON*" ]; then
                  notify.debug "$FUNCNAME: found an AUTOSPEC-ON command"
                  let "ignore_lines = 0"
                  continue
               fi
            elif [ "$ignore_lines" = "1" ]; then
               # skip lines in the block "*AUTOSPEC-OFF*" .. "*AUTOSPEC-ON*"
               notify.debug "$FUNCNAME: * line ignored --  ${tok[*]}"
               continue
            fi

            case ${tok[0]} in
            %if)
               #ifexpr=$(rpmvars.solve "${tok2}${fromtok3}" "$specfile")
               # note: if <%var> is undefined (not present) or set to "0"
               #       then the conditional expression is false else is true
               let "ifexpr_level += 1"
               let "ifexpr[$ifexpr_level] = 0"

               # note: to implement %if statements we must take into account
               # the boolean values of the all previous ifexpr[] values
               # starting from 1 to '$ifexpr_level'
#              [ "$ifexpr_level" -gt 1 ] && notify.warning "\
#$FUNCNAME: "$"FIXME: sorry, not implemented yet..."" (nested \`%if')"

               notify.debug "\
$FUNCNAME: ${tok[0]} [level#$ifexpr_level; lineno#$linenum]  --  ${tok[*]}"

               toksave=${tok[0]}
               unset tok[0]
               ifexpr[$ifexpr_level]=$(boolexpr.solve "${tok[*]}")
               tok[0]=$toksave
            ;;
            %if[a-z]*) # %ifarch|%ifnarch|%ifdef
               notify.warning "\
$FUNCNAME: "$"FIXME: sorry, not implemented yet..."" (\`${tok[0]}')"
               let "ifexpr_level += 1"
               # FIXME: we should call 'boolexpr.solve' here:
               #   toksave=${tok[0]}
               #   unset tok[0]
               #   ifexpr[$ifexpr_level]=$(boolexpr.solve "${tok[*]}")
               #   tok[0]=$toksave
               # for new we chooes a 50% right - 50% wrong approach :(
               ifexpr[$ifexpr_level]=1
            ;;
            %else)
               notify.debug "\
$FUNCNAME: ${tok[0]} [level#$ifexpr_level; line#$linenum]"
               let "level = 0"
               for level in $(seq 1 1 $ifexpr_level); do
               # complement boolean values in %else blocks
                  if [ "${ifexpr[$level]}" = "0" ]; then
                     ifexpr[$level]=1
                     notify.debug "$FUNCNAME: ifexpr[$level] = 0 --> 1"
                  else
                     ifexpr[$level]=0
                     notify.debug "$FUNCNAME: ifexpr[$level] = 1 --> 0"
                  fi
               done
            ;;
            %endif)
               notify.debug "\
$FUNCNAME: ${tok[0]} [level#$ifexpr_level; line#$linenum]]"
               let "ifexpr_level -= 1"
            ;;
            %end)
               notify.warning $"\`%end' found; should perhaps be \`%endif'"
            ;;
            %files)
               let "level = 0"
               for level in $(seq 1 1 $ifexpr_level); do
                  notify.debug "$FUNCNAME: ifexpr[$level] = ${ifexpr[$level]}"
                  [ "${ifexpr[$level]}" = "0" ] &&
                   { # found a false condition
                     let "level = $ifexpr_level + 1"; break; }
               done
               # not all the conditions are true: skip this definition

               [ $level -gt $ifexpr_level ] &&
                { notify.debug "\
$FUNCNAME: %file block found (${tok[*]}) [line#$linenum] ... skipped"
                  continue; }

               notify.debug "\
$FUNCNAME: %file block found (${tok[*]})[line#$linenum]"
               filesname="$( \
               rpmvars.solve "${tok[*]}" "$specfile" | \
               sed -n '
               # remove "%files" and "-f file-name" option if present
               s,%files[ \t]*,,;s,-f[ \t]\+[^ ]*[ \t]*,,;p' )"

               case "$filesname" in
               "") # main package
                    SPEC_TARGET=( ${SPEC_TARGET[@]} "$SPEC_NAME" )
               ;;
               -n*) # -n <package-name>
                    filesname="$(echo $filesname | sed 's,-n[ \t]\+,,')"
                    SPEC_TARGET=( \
${SPEC_TARGET[*]} \
"$(rpmvars.solve "$filesname" "$specfile")" )
               ;;
                 *) SPEC_TARGET=(\
${SPEC_TARGET[*]} "$SPEC_NAME-$(\
rpmvars.solve "$filesname" "$specfile")" )
               ;;
               esac
               notify.debug "$FUNCNAME: $var = ( ${SPEC_TARGET[*]} )"
            ;;
            *) if [[ -n "$rpm_macro_debug_package" && \
                    "${tok[0]}" = "$rpm_macro_debug_package" ]]; then
                  # rpm macro for creating debug packages
                  SPEC_TARGET=( ${SPEC_TARGET[@]} \
                               "${SPEC_NAME}-${rpm_macro_debug_package_suffix}" )
               fi
            ;;
            esac
         done < $specfile
         #notify.debug "$FUNCNAME: $var = ( ${SPEC_TARGET[*]} )"
      ;;
      SPEC_OBSOLETES)
         # FIXME : should populate a vector with length '${#SPEC_TARGET[*]}'
         # and with the entries ordered as in 'SPEC_TARGET[]', with '(none)'
         # entries when no obsolete labels are found

         [ "$SPEC_OBSOLETES" ] && continue
         [ "$SPEC_NAME" ] || specfile.getvars -s "$specfile" SPEC_NAME

         local linenum=0
         while read -r -a tok; do
            let "linenum += 1"
            # do support '## *AUTOSPEC-{OFF,ON}*' blocks
            if [ "${tok[0]}" = "##" ]; then
               if [ "${tok[1]}" = "*AUTOSPEC-OFF*" ]; then
                  notify.debug "$FUNCNAME: found an AUTOSPEC-OFF command"
                  let "ignore_lines = 1"
                  continue
               fi

               if [ "${tok[1]}" = "*AUTOSPEC-ON*" ]; then
                  notify.debug "$FUNCNAME: found an AUTOSPEC-ON command"
                  let "ignore_lines = 0"
                  continue
               fi
            elif [ "$ignore_lines" = "1" ]; then
               # skip lines in the block "*AUTOSPEC-OFF*" .. "*AUTOSPEC-ON*"
               notify.debug "$FUNCNAME: * line ignored --  ${tok[*]}"
               continue
            fi

            case ${tok[0]} in
            Obsoletes|Obsoletes:)
               unset tok[0]
               notify.debug "\
$FUNCNAME: * entry found at line $linenum: \"${tok[*]}\""
               SPEC_OBSOLETES[${#SPEC_OBSOLETES[*]}]="\
$(rpmvars.solve "${tok[*]}" "$specfile")"

               notify.debug "\
$FUNCNAME: SPEC_OBSOLETES = ( ${SPEC_OBSOLETES[*]} )"
            ;;
            esac
         done < $specfile

       # SPEC_OBSOLETES=($(sed -n "\
       #    /^[ \t]*Obsoletes[ \t]*:/{
       #       s,[ \t]*Obsoletes[ \t]*:[ \t]*,,
       #       s,%[{]*name[}]*,$SPEC_NAME,;p}" \
       #    $specfile))

         notify.debug "$FUNCNAME: $var = ( ${SPEC_OBSOLETES[*]} )"
      ;;
      SPEC_BUILDARCH)
         # note: 'SPEC_BUILDARCH' can be a null string
         [ "$SPEC_BUILDARCH" ] && continue
         # find for the tokens 'BuildArch' and 'BuildArchitecture'
         SPEC_BUILDARCH=($(sed -n "\
            /^[ \t]*BuildArch[a-z]*[ \t]*:/{
               s,[ \t]*BuildArch[a-z]*[ \t]*:[ \t]*,,;{p}}" \
            $specfile))
         # use only the last 'BuiltArch' entry (rpm behaviour)
         [ ${#SPEC_BUILDARCH[*]} -gt 1 ] &&
            SPEC_BUILDARCH="${SPEC_BUILDARCH[${#SPEC_BUILDARCH[*]}-1]}"  # `
         notify.debug "$FUNCNAME: $var = ( ${SPEC_BUILDARCH[*]} )"
      ;;
      SPEC_BUILDREQUIRES)
         [ "$SPEC_BUILDREQUIRES" ] && continue
         local f rpm_provided_by
         SPEC_BUILDREQUIRES=(`sed -n \
'/^BuildRequires/{s,BuildRequires[ \t]*:[ \t]*,,p}' $specfile | \
           (IFS="$IFS,"; while read -a buildreqs; do
               let "isver = 0"
               for f in ${buildreqs[@]}; do
                  [ "$isver" = "1" ] &&
                   { let "isver = 0"; continue; }
                  case "$f" in
                  # skip '<', '<=', '>', '>=', '=' version or %variable
                  \<*|\>*|=*)
                     let "isver = 1"
                  ;;
                  *%*) # rpm variable(s) (ex. '%{__install_info}')
                     echo "$(rpmvars.solve "$f" $specfile) "
                  ;;
                  *) echo "$f " ;;
                  esac
               done
            done)`)
         notify.debug "$FUNCNAME: $var = ( ${SPEC_BUILDREQUIRES[*]} )"
      ;;
      SPEC_BUILDROOT)
         if [ "$rpm_ignores_buildroot" != 1 ]; then
            [ "$SPEC_BUILDROOT" ] && continue
            [ "$SPEC_NAME"    ] || specfile.getvars -s "$specfile" SPEC_NAME
            [ "$SPEC_VERSION" ] || specfile.getvars -s "$specfile" SPEC_VERSION
            SPEC_BUILDROOT=(`sed -n "/%description/q;{
               /^[ \t]*BuildRoot/{
                  s,[^ ]*[ \t]*:[ \t]*,,
                  s,%[{]*name[}]*,$SPEC_NAME,
                  s,%[{]*version[}]*,$SPEC_VERSION,
                  s,%[{]*release[}]*,$SPEC_RELEASE,
                  s,%[{]*_tmppath[}]*,$(rpm --eval=%{_tmppath}),;p
               }}" $specfile`)
            [ "$(echo "$SPEC_BUILDROOT" | wc -w)" = 1 ] ||
               notify.error $"bad specfile preamble"" (BuildRoot)"
            [ "$SPEC_BUILDROOT" ] &&
               SPEC_BUILDROOT=$(rpmvars.solve "$SPEC_BUILDROOT" $specfile)
         fi
         notify.debug "$FUNCNAME: $var = $SPEC_BUILDROOT"
      ;;
      *) notify.error $"(bug)"" -- $FUNCNAME: "$"bad arg \`$var'" ;;
      esac

      # note: some entries are not mandatory in a specfile
      case "$var" in
      "SPEC_SOURCE"|"SPEC_PATCH"|\
      "SPEC_OBSOLETES"|"SPEC_BUILDARCH"|"SPEC_BUILDREQUIRES")
      ;;
      *) if [[ "$var" = "SPEC_BUILDROOT" && \
               "$rpm_ignores_buildroot" = 1 ]]; then
            :
         else
            [[ -z "${!var}" ]] && notify.error $"\
cannot initialize \`$var' from specfile data"
            #notify.debug "$FUNCNAME: $var = \"${!var}\""
         fi
      ;;
      esac
   done
}

# note: some examples of real package names
# - automake 1.8.5      automake-1.8.5.tar.bz2
# - Xorg 6.7.0          X11R6.7.0-src1.tar.gz
# - hotplug 20040329    hotplug-2004_03_29.tar.gz
# - perl-Tk 800.025     Tk800.025.tar.gz
# - webalizer 2.0.1     webalizer-2.01-10-src.tgz

# function getnamefromtarball
#    get the package name from the tarball name
# args:
#    $1 :  tarball name
function getnamefromtarball() {
   local pck_name=`echo $1 | sed -n "\
      s,.*/,,  # remove directory name, if any
      s/\.[^0-9].*//  # remove trailing stuff (.tar.gz, ...)
      /[^-]\+-[0-9]\+/{s/\([^-]*\)-[0-9].*/\1/p;q}  # <pck_name>-<pck_ver>
      /[^-\.][0-9]\./{s/\(.*[^-\.]\)[0-9]\..*/\1/p;q}  # <pck_name><pck_ver>
      # <pck_name> (no version, but <pck_name> can end with numbers)
      /^[^0-9]*[0-9]*$/p"`

   notify.debug "$FUNCNAME: pck_name = \"$pck_name\""
   echo "$pck_name"
}

# function getversionfromtarball
#    get the package version from the tarball name
# args:
#    $1 :  tarball name
function getversionfromtarball() {
   local pck_version=`echo $1 | sed -n "\
      /[0-9]/!q  # return nothing if no number is found in the package name
      s,.*/,,  # remove directory name, if any
      s/\.[^0-9].*//  # remove trailing stuff (.tar.gz, ...)
      /-[0-9]*/{s/.*-\([0-9]*.*\)/\1/p;q}  # <pck_name>-<pck_ver>
      /[^-\.][0-9]\./{s/.*[^-\.]\([0-9]\..*\)/\1/p;q}  # <pck_name><pck_ver>
      # <pck_name> (no version, but <pck_name> can end with numbers)
      /^[^0-9]*[0-9]*$/q"`

   notify.debug "$FUNCNAME: pck_version = \"$pck_version\""
   echo "$pck_version"
}