How to create a stack in a shell script? - shell

Question

I need to create a stack in a shell script in order to push values to be processed in a loop. The first requirement is that this must be implemented in a portable manner, as I want to use the script as a portable installer (at least between Unix-like operating systems). The second requirement is that it needs to be able to be altered inside the loop, because new information can appear while the loop is processing an entry, in a recursive manner. The third requirement is that I have more than one line of information per entry (this is mostly a fixed number, and when it isn't it can be calculated based on the first line of information).
My attempt is to use a stack file:
#!/bin/sh
echo "First entry" > stack.txt
echo "More info for the first entry" >> stack.txt
echo "Even more info for the first entry" >> stack.txt
while read ENTRY < stack.txt; do
INFO2=`tail -n +2 stack.txt | head -n 1`
INFO3=`tail -n +3 stack.txt | head -n 1`
tail -n "+4" stack.txt > stack2.txt
# Process the entry...
# When we have to push something:
echo "New entry" > stack.txt
echo "Info 2" >> stack.txt
echo "Info 3" >> stack.txt
# Finally, rebuild stack
cat stack2.txt >> stack.txt
done
This works perfectly, except that it feels wrong. Is there a less "hacky" way to do this?
Thanks in advance for any help!

Answer 1

Rather than using a file, it seems like it would be easier to use a directory and store each item in its own file. For example:
#!/bin/sh
count=0
push() { echo "$*" > $stackdir/item.$((++count)); }
pop() {
if test $count = 0; then
: > $stackdir/data
else
mv $stackdir/item.$((count--)) $stackdir/data
fi
}
trap 'rm -rf $stackdir' 0
stackdir=$( mktemp -d ${TMPDIR-/tmp}/stack.XXXX )
push some data
push 'another
data point, with
multiple lines'
pop
# Now $stackdir/data contains the popped data
cat $stackdir/data # Print the most recently item pushed
push yet more data
pop
cat $stackdir/data # Print 'yet more data'
pop
cat $stackdir/data

Answer 2

Checkout the section here "Example 27-7. Of empty arrays and empty elements". Specifically the comments say, Above is the 'push' and The 'pop' is:
http://tldp.org/LDP/abs/html/arrays.html
If you want to encode multiple lines for each element I suggest you base64, or JSON encode the lines. You could also use url encoding or escape the characters using echo.
Since you require the usage of arrays, you may be able to use this example of arrays in sh:
http://www.linuxquestions.org/questions/linux-general-1/how-to-use-array-in-sh-shell-644142/

Answer 3

This should be pretty cross-platform. It doesn't use arrays, so it can work on older shell versions.
Push(){ let Stack++;eval "Item$Stack=\"$1\"";}
Pop(){ eval "echo -e \$Item$Stack;unset Item$Stack";let Stack--;}
Append(){ Push "`Pop`\n$1";}
Push puts data in variables such as $Item1, $Item2, $Item3, etc. Use it like this:
Push data; Push 'more data'; Push "remember to escape \"quotes\""
Pop by itself destroys the highest-numbered $Item variable after printing its contents. To store the contents in another variable, do this:
Variable=`Pop`
Append adds a line to the variable on the top of the stack. For example:
Push "too much is always better than not enough"
Append "but it's almost as bad"
$Stack stores the height of the stack. Since there's no error handling in these functions, you'll need to reset it if there's a stack underflow.
Even better, you can just check it to prevent one - don't Pop or Append unless $Stack is 1 or more.

Answer 4

Unfortunately I don't think that solution with cat would work. It might work in Linux, but I am using FreeBSD, and I tried to use cat to import the contents of tempfiles, and it failed constantly.
The problem with cat (at least with FreeBSD) is that it causes the shell to interpret its' output as a literal command, and also trips over certain characters, which again causes problems.
My eventual solution was to convert said tempfiles to holders for variables, and then import them with the source command. This works, but I don't like it; mainly because I have to do some ugly cutting with said in order to prefix the data with the variable name, and encase it in quotes.
So in the data file, you'd have:-
variable=foobar
Then in the script, I'd do whatever created my output for the variable, and then to get it into the script would use:-
source datafile
at which point I could use the variable.
Still, even though this doesn't really resemble a stack, it works to store data. I do not like using lone variables in shell scripts if I can avoid them either; mainly because again, it means resorting to ugly substitution hackery, and can become annoying to debug.

Answer 5

Bashisms are disgusting, aren't they? If you need arrays in your program, then you need to use... assembler (kidding)! Well, this is how I implemented the stack in POSIX Shell:
#!/bin/sh
# --------------------
# Stack implementation
# --------------------
s=""
stk=""
STACK_MAX_SIZE="65536"
# Delete all values from the stack:
stack_clear () {
s=""
stk=""
}
# To push a value into the stack:
stack_push () {
local counter
local cnt
counter=$(echo -n "${s}" | wc --bytes)
cnt=$(echo -n "${counter}" | wc --bytes)
# ----- Internal check begin -----
check=$(echo -n "${cnt}" | wc --bytes)
if test "${check}" != "1"
then
echo "Internal error: it is real to meet such a long string..."
exit 2s
fi
# ----- Internal check end -----
stk=$(echo -n "${stk}${s}${counter}${cnt}")
local check
check=$(echo -n "${stk}" | wc --bytes)
if test "${check}" -gt "${STACK_MAX_SIZE}"
then
echo "Error: stack overflow."
exit 1
fi
}
# To pull a value from the stack:
stack_pop () {
local counter
local cnt
if test "${stk}" = ""
then
echo "Error: trying to pop from an empty stack."
exit 1
fi
cnt=$(echo -n "${stk}" | tail --bytes=1)
stk=$(echo -n "${stk}" | head --bytes=-1)
counter=$(echo -n "${stk}" | tail --bytes=${cnt})
stk=$(echo -n "${stk}" | head --bytes=-${cnt})
s=$(echo -n "${stk}" | tail --bytes=${counter})
stk=$(echo -n "${stk}" | head --bytes=-${counter})
# ----- Internal check begin -----
local check
check=$(echo -n "${s}" | wc --bytes)
if test "${check}" != "${counter}"
then
echo "Internal error: the stack is damaged."
exit 2
fi
# ----- Internal check end -----
}
# ---------------
# The entry point
# ---------------
# Push "one", "two", "three" into the stack:
s="one"; stack_push
s="two"; stack_push
s="three"; stack_push
# Extract all the data from the stack:
while test "${stk}" != ""
do
stack_pop
echo "${s}"
done