Bash – Assign variable using multiple lines

POSIX

To normalize the slashes in all the parameters, I'll use the rotating argument trick: shift $1 off, transform it and put the result at the end of the parameter list. If you do that as many time as there are parameters, you've transformed all the parameters, and you've got them back in order.

For the second part of the code, I changed your logic to be less confusing: the outer loop iterates over the parameters, and the inner loop iterates over path components. for x; do … done iterates over the positional parameters, it's a convenient idiom. I use a POSIX-compliant way of matching a string against a pattern: the case construct.

Tested with dash 0.5.5.1, pdksh 5.2.14, bash 3.2.39, bash 4.1.5, ksh 93s+, zsh 4.3.10.

^{Side note: there seems to be a bug in bash 4.1.5 (not in 3.2): if the case pattern is "${common_path%/}"/*, one of the tests fails.}

posix_path_common () {
  for tmp; do
    tmp=$(printf %s. "$1" | tr -s "/")
    set -- "$@" "${tmp%.}"
    shift
  done
  common_path=$1; shift
  for tmp; do
    while case ${tmp%/}/ in "${common_path%/}/"*) false;; esac; do
      new_common_path=${common_path%/*}
      if [ "$new_common_path" = "$common_path" ]; then return 1; fi
      common_path=$new_common_path
    done
  done
  printf %s "$common_path"
}

bash, ksh

If you're in bash (or ksh), you can use arrays — I don't understand why you seem to be restricting yourself to the positional parameters. Here's a version that uses an array. I have to admit it's not particularly clearer than the POSIX version, but it does avoid the initial n^2 shuffling.

For the slash normalization part, I use the ksh93 construct ${foo//PATTERN/REPLACEMENT} construct to replace all occurrences of PATTERN in $foo by REPLACEMENT. The pattern is +(\/) to match one or more slash; under bash, shopt -s extglob must be in effect (equivalently, start bash with bash -O extglob). The construct set ${!a[@]} sets the positional parameters to the list of subscripts of the array a. This provides a convenient way to iterate over the elements of the array.

For the second part, I the same loop logic as the POSIX version. This time, I can use [[ … ]] since all the shells targeted here support it.

Tested with bash 3.2.39, bash 4.1.5, ksh 93s+.

array_path_common () {
  typeset a i tmp common_path new_common_path
  a=("$@")
  set ${!a[@]}
  for i; do
    a[$i]=${a[$i]//+(\/)//}
  done
  common_path=${a[$1]}; shift
  for tmp; do
    tmp=${a[$tmp]}
    while [[ "${tmp%/}/" != "${common_path%/}/"* ]]; do
      new_common_path="${common_path%/*}"
      if [[ $new_common_path = $common_path ]]; then return 1; fi
      common_path="$new_common_path"
    done
  done
  printf %s "$common_path"
}

zsh

Sadly, zsh lacks the ${!array[@]} feature to execute the ksh93 version as-is. Fortunately, zsh has two features that make the first part a breeze. You can index the positional parameters as if they were the @ array, so there's no need to use an intermediate array. And zsh has an array iteration construct: "${(@)array//PATTERN/REPLACEMENT}" performs the pattern replacement on each array element in turn and evaluates to the array of results (confusingly, you do need the double quotes even though the result is multiple words; this is a generalization of "$@"). The second part is essentially unchanged.

zsh_path_common () {
  setopt local_options extended_glob
  local tmp common_path new_common_path
  set -- "${(@)@//\/##//}"
  common_path=$1; shift
  for tmp; do
    while [[ "${tmp%/}/" != "${common_path%/}/"* ]]; do
      new_common_path="${common_path%/*}"
      if [[ $new_common_path = $common_path ]]; then return 1; fi
      common_path="$new_common_path"
    done
  done
  printf %s "$common_path"
}

Test cases

My solutions are minimally tested and commented. I've changed the syntax of your test cases to parse under shells that don't have $'…' and report failures in a more convenient way.

do_test () {
  if test "$@"; then echo 0; else echo $? "$@"; failed=$(($failed+1)); fi
}

run_tests () {
  function_to_test=$1; shift
  failed=0
  do_test "$($function_to_test /a/b/c/d /a/b/e/f; echo x)" = /a/bx
  do_test "$($function_to_test /long/names/foo /long/names/bar; echo x)" = /long/namesx
  do_test "$($function_to_test / /a/b/c; echo x)" = /x
  do_test "$($function_to_test a/b/c/d a/b/e/f ; echo x)" = a/bx
  do_test "$($function_to_test ./a/b/c/d ./a/b/e/f; echo x)" = ./a/bx
  do_test "$($function_to_test '
/
/
' '
/
'; echo x)" = '
/
'x
  do_test "$($function_to_test --/-- --; echo x)" = '--x'
  do_test "$($function_to_test '' ''; echo x)" = x
  do_test "$($function_to_test /foo/bar ''; echo x)" = x
  do_test "$($function_to_test /foo /fo; echo x)" = x
  do_test "$($function_to_test '--$`\! *@ \a\b\e\E\f\r\t\v\\\"'\'' 
' '--$`\! *@ \a\b\e\E\f\r\t\v\\\"'\'' 
'; echo x)" = '--$`\! *@ \a\b\e\E\f\r\t\v\\\"'\'' 
'x
  do_test "$($function_to_test /foo/bar //foo//bar//baz; echo x)" = /foo/barx
  do_test "$($function_to_test foo foo; echo x)" = foox
  do_test "$($function_to_test /fo /foo; echo x)" = x
  if [ $failed -ne 0 ]; then echo $failed failures; return 1; fi
}

If your code excerpt is properly representative, it seems that you are typing Bash commands directly in your Makefile and expecting Make to execute them with Bash. That's not how it works. The syntax of a Makefile is entirely different. Within a recipe, you can type Bash commands; each separate line in a recipe will be executed in a separate sub-shell. So you need at least two changes:

• Your shell commands need to be in a target.
• The declare needs to run in the same shell as the loop; otherwise you declare in one Bash instance, then exit that, then run the loop in a separate instance which knows nothing about the now-lost declare.

Here is a simple refactoring of your Makefile with these changes.

SHELL=/bin/bash   # This is the standard compliant method

.PHONY: all
all:
    declare -A PROVS=( ["NL"]=10 ["PE"]=11 ["NS"]=12 ["NB"]=13 \
        ["QC"]=24 ["ON"]=35 ["MB"]=46 ["SK"]=47 ["AB"]=48 \
        ["BC"]=59 ["YK"]=60 ["NT"]=61 ["NU"]=62 )\
    ; for key in "$${!PROVS[@]}" ; do \
        touch "foo_$${key}_$${PROVS[$${key}]}" ; \
    done

Demo: http://ideone.com/t94AOB

The @ convention to run a command silently applies to the entire command line. Thus, you can put it before declare above, in which case it will be stripped off before the entire command line is submitted to Bash. Anywhere else, it will not be stripped or understood, and it will obviously cause a Bash syntax error in the called shell.

(The obsession with @ rules is an anti-pattern anyway. Run with make -s if you don't want to see the output; shutting up make will only make it harder to debug your rules.)