Work the Shell

Ooops! Two months ago, I started exploring how you can write a simple but quite helpful interactive command-line calculator as a shell script and ended the column with “Next month, we'll dig into useful refinements and make it a full-blown addition to our Linux toolkit. See you then!”

Unfortunately, last month, I got sidetracked with the movie The Number 23 and started another script looking at how to do numerology within the shell scripting environment. You'd think I was a typical programmer or something, being sidetracked and losing a thread by picking up another one. It reminds me of those glorious startup days from the late 1990s too, but that's an entirely different story.

Anyway, numerology can wait another month. This column, I'd like to complete the command-line calculator because, well, because it's so darn useful and simultaneously astonishing that there isn't a decent command-line calculator in Linux after all these years. I mean, really!

It was a while back, so let me remind you that the wicked short script to give you the rudimentary calculator is this:

#!/bin/sh

bc << EOF
scale=4
$@
quit
EOF

That's it. Name it solve.sh, for example, and you can test it, as shown here:

$ sh solve.sh 1+3
4
$ sh solve.sh 11/7
1.5714

It's easy enough to alias solve to the shell command too:

alias solve="sh solve.sh"

Or, better:

alias solve="sh ~/bin/solve.sh"

As that'll work regardless of where you are in the filesystem (location-dependent commands are a typical shell gaffe).

What I'd really like, however, is to be able to go into a “solve” mode where anything I type automatically is assumed to be a mathematical equation, rather than have to type solve each time.

We've talked about shell script wrappers in the past, so you should recall this basic structure:

while read userinput
do
  echo "you entered $userinput"
done

That's too crude to use as of yet, but we easily can add a prompt so that it looks like a real program:

echo -n "solve"
while read expression
do
  echo "you entered $expression"
  echo -n "solve: "
done

Look good? Actually, it's not. There's a subtle error here, one that's another common scripting mistake. The problem is that there are two echo commands in Linux: one that's the built-in capability of the shell itself, and one that's a separate command located in /bin. This is important because the built-in echo doesn't know what the -n flag does, but the /bin/echo command does. A tiny tweak, and we're ready to test it:

/bin/echo -n "solve: "

while read expression
do
  echo "you entered $expression"
  /bin/echo -n "solve: "
done

Let's see what happens:

solve: 1+1
you entered 1+1
solve: ^D

That's more like it.

What we really want though, is a script that's smart enough to recognize whether you've specified parameters on the command line. If you have, it solves that equation, and if you haven't, it drops you into the interactive mode.

That's surprisingly easy to accomplish by testing the $# variable, which indicates how many arguments are given to the script. Want to see if it's greater than zero? Do this:

if [ $# -gt 0 ] ; then

One more refinement before I show you the script in its entirety: I want to have it quit if users type in quit or exit, rather than force them to type ^D to indicate end of file on standard input (which causes the read statement to return false and the loop to end).

This is done with a simple string comparison test, which you'll recall is done with = (the -eq test is for numeric values). So, testing $expression to see whether it is “quit” is easy:

if [ $expression = "quit" ] ; then

To make it a bit more bulletproof, it's actually better here to quote the variable name, so that if users enter a null string (simply press Return), the conditional test won't fail with an ugly error message:

if [ "$expression" = "quit" ] ; then

Because I like to make my scripts flexible, I've also added exit as an alternative to quit, which easily is done with a slightly more complicated conditional test:

if [ "$expression" = "quit" -o
     "$expression" = "exit" ] ; then

The -o is the logical OR statement in a shell conditional test, but I have a feeling you've already figured that out.

Here's where the script stands at this point, in its entirety:

#!/bin/sh

if [ $# -gt 0 ] ; then
bc << EOF
scale=4
$@
quit
EOF
else
  /bin/echo -n "solve: "

  while read expression
  do
    if [ "$expression" = "quit" -o 
         "$expression" = "exit" ] ; then
      exit 0
    fi
bc << EOF
scale=4
$expression
quit
EOF
    /bin/echo -n "solve: "
  done

  echo ""
  echo "solved."
fi

exit 0

Neat and darn useful, I'd say. If I were to continue hacking on it, the next thing I would do is write a simple help page that I'd store in some library folder and display on entry of ? or help. It simply would explain the syntax of the expressions understood by bc (though as we're invoking bc iteratively, we can't have persistent variables and so forth, so unfortunately, this approach won't let us access the full power of the binary calculator).

To learn what type of sophisticated expressions you can enter, simply type man bc. Then, let that be your inspiration for further tweaks and mods to this script!

Next month, I'll go back to the numerology script and see what strange things we can ascertain about the apparently benign world around us. Remember, just because I got out of sequence, doesn't mean we're not out to get you, dear reader!