bash, eval, protect pipes and colon in string - bash

Question

Here is the simplest distilled version of my problem. The complexity that remains is for good reasons even if not self evident here. Additionally the script is internal and has no chance of executing malicious code, so the eval is perfectly fine; don't need to hear about how evil it is... ;) Assume for the moment that the pipes and colons in the key string are required delimiters.
key="target|platform|repo:revision"
hashname="hashmap"
declare -A $hashname
eval $hashname[$key]=0
echo $(eval $hashname[$key])
Of course the last two lines have problems because the eval is acting on the pipes and colons inside of the $key variable. My question is how can I protect a string like this from the eval? And I need the eval because I am referring to the hashmap's name rather than it itself. Thanks in advance.
==================================================================================
Ok I am actually beginning to think that my problem is not with the pipes and colon and the eval. So Let me paste the real code
function print_hashmap()
{
local hashname=$1
for key in `eval echo \$\{\!$hashname[#]\}`; do
local deref="$hashname[$key]"
local value=${!deref}
echo "key=${key} value=${value}"
done
}
function create_permutations2()
{
local hashname=$1 ; shift
local builds=$1 ; shift
local items=$1 ; shift
local separators=$#
echo "create_permutations(hashname=${hashname}, builds=${builds}, items=${items}, separators=${separators})"
if [ NULL != "${builds}" ]; then
for build in `echo $builds | tr ',' ' '`; do
local target="${build%%:*}"
local platforms="${build##*:}"
for platform in `echo $platforms | tr '|' ' '`; do
local key=
local ref=
if [ NULL != "${items}" ]; then
if [ NULL == "${separators}" ]; then separators=' '; fi
for separator in $separators; do
items=`echo $items | tr $separator ' '`
done
for item in $items; do
key="${target}|${platform}|${item}"
ref="$hashname[$key]"
declare "$ref"=0
done
else
key="${target}|${platform}"
ref="$hashname[$key]"
declare "$ref"=0
fi
done
done
fi
echo "created the following permutations:"
print_hashmap $hashname
}
builds="k:r|s|w,l:r|s|w"
repos="c:master,m:master"
hashname="hashmap"
declare -A $hashname
create_permutations2 $hashname $builds $repos ","
print_hashmap $hashname
I recently modified my code to conform with FatalError's suggestions to use ref instead of eval and the error is the same: syntax error in expression (error token near :master)

Answer 1

Maybe doubles quotes around $key?
eval $hashname["$key"]=0
echo $(eval $hashname["$key"]=0)

Answer 2

Try:
eval $hashname'[$key]'=0
eval result=$hashname'[$key]'
This passes the $ to eval rather than expanding the parameter first.

Answer 3

I won't lecture about the evilness of eval, however in this case it at least adds a little extra complexity. The easiest way I can think of, since it's evaluating the string result, would be to add some literal single quotes:
eval $hashname["'"$key"'"]=0
That would guard against everything except for single quotes in $key. However, you can accomplish the same thing with probably fewer headaches. Here's my updated script to illustrate:
key="target|platform|repo:revision"
hashname="hashmap"
declare -A $hashname
echo "With eval:"
eval $hashname["'"$key"'"]=0
eval echo \${$hashname["'"$key"'"]}
echo
echo "Without eval:"
ref="$hashname[$key]"
echo ${!ref}
declare "$ref"="1"
echo ${!ref}
Note I changed your original eval line because it didn't make sense to me -- it was trying to execute the result rather than print it. In the latter part you can use indirection to access the value and then declare to assign to it. Then you don't have to worry about these chars being interpreted.
This produces the result:
With eval:
0
Without eval:
0
1
I'm not 100% sure why that doesn't work, but this seems to:
builds="k:r|s|w,l:r|s|w"
repos="c:master,m:master"
hashname="hashmap"
declare -A $hashname
function print_hashmap()
{
local hashname=$1
for key in `eval echo \$\{\!$hashname[#]\}`; do
local deref="$hashname[$key]"
local value=${!deref}
echo "key=${key} value=${value}"
done
}
function create_permutations2()
{
local hashname=$1 ; shift
local builds=$1 ; shift
local items=$1 ; shift
local separators=$#
echo "create_permutations(hashname=${hashname}, builds=${builds}, items=${items}, separators=${separators})"
if [ NULL != "${builds}" ]; then
for build in `echo $builds | tr ',' ' '`; do
local target="${build%%:*}"
local platforms="${build##*:}"
for platform in `echo $platforms | tr '|' ' '`; do
local key=
if [ NULL != "${items}" ]; then
if [ NULL == "${separators}" ]; then separators=' '; fi
for separator in $separators; do
items=`echo $items | tr $separator ' '`
done
for item in $items; do
key="${target}|${platform}|${item}"
ref="$hashname[$key]"
eval $hashname[\'$key\']=0
done
else
key="${target}|${platform}"
eval $hashname[\'$key\']=0
fi
done
done
fi
echo "created the following permutations:"
print_hashmap $hashname
}
create_permutations2 $hashname $builds $repos ","
print_hashmap $hashname

Answer 4

for this small bit of the question: "My question is how can I protect a string like this from the eval?", i'll just mention bash's "parameter transformation" (see man page), ${parameter#operator}. in particular, the operator Q evaluates to a quoted form that can safely be used as input.
% echo ${key}
target|platform|repo:revision
% echo ${key#Q}
'target|platform|repo:revision'