George Peter Staplin: July 10, 2004 - It sometimes amazes me how beautiful some aspects of Tcl are. I've been using proc unknown args {expr $args} for a while for doing calculations and tests when designing software. Today it occured to me that I could make life easier and avoid so many parentheses by extending that simple unknown procedure to this:

 proc unknown args {set ::that [expr $args]}

Now I can do:

 $ echo "proc unknown args {set ::that [expr \$args]}" > .tclshrc
 $ tclsh8.4
 % 1000 * 256
 256000
 % $that / 8
 32000

---

Scott Nichols Really cool. Would there be any issues adding your calculator proc to existing Tcl applications? This would be helpful and save typing time for programmers.

George Peter Staplin: Error handling and auto-loading/lazy-loading might not work the same. You could do it this way:

 rename unknown _unknown
 proc unknown args {
  global that
  if {[catch {expr $args} that]} {
   uplevel 1 [concat _unknown $args]
  }
 }

MG That introduces some bugs for me on Win XP; when you enter a command that can't be parsed by expr, the $that variable is overwritten with an error message. Also, math commands handled by unknown no longer return the answer. Changing it like this works for me. . .

  rename unknown _unknown
  proc unknown {args} {
  global that
  if { [catch {expr $args} temp] } {
       uplevel 1 [concat _unknown $args]
     } else {
       set that $temp
     }
  }

George Peter Staplin: That is better! :)

---

Should the that variable move into a namespace to protect it from accidental overwrites?

---

GN what was the idea of "that"? A slightly improved version:

  rename unknown _unknown
  proc unknown {args} {
    if {! [catch {set result [expr $args]}] } {
      return $result
    }
    uplevel 1 [concat _unknown $args]
  }

MG - GPS explained it up the top; it's so you can continue calculations. For instance, and very basically,

 % 1 + 2
 3
 % $that * 2
 6

Also, in yours, the 'set result ..' isn't necessary, because of the way catch works, that line could've been

 if { ![catch {expr $args} result] } {

with the call to catch automatically setting $result for you, with the return value of the expr call.

GN sure, but without the second arg its less magic for a novice and the overwriting of that with the errormsg can't happen; prepend two ":" before the result string (twice) to get a gobal result variable. To save results, one can use as well:

  set 3pi [acos(-1) * 3]

---

RS Here's a simple one-liner macro for zsh (on bash it didn't work) to start a short-lived tclsh as calculator:

 $ tc () { echo puts '[expr' $@ ']' | tclsh }

Testing:

 $ tc acos(-1)*2
 6.28318530718

HolgerJ This is a version for bash:

 tc() { echo "puts [expr "$@" ] " | tclsh; }

RS Note however that bash has different ideas what * means. Here's an interactive testing session:

 ~ $ tc 7*6
 42
 ~ $ tc 7 * 6
 expected integer but got "0810" (looks like invalid octal number)
 ~ $ tc 7 \* 6
 expected integer but got "0810" (looks like invalid octal number)
 ~ $ tc '7 \* 6'
 42
 ~ $ tc '7 * 6'
 expected integer but got "0810" (looks like invalid octal number)
 ~ $

The last test surprised me - I thought single quotes would prevent interpretation of the "*", similar to Tcl's braces... Maybe some double evaluation going on. before and inside the call to tc(). The old rule of thumb applies: for each round of evaluation, escape once more :^) See:

 ~ $ tc 7 \\\* 6
 42

Of course this gets ugly. And depending on what files you have, more trouble may be in store:

 ~ $ touch 7by6
 ~ $ tc 7*6
 syntax error in expression "7by6": extra tokens at end of expression

awk is safer that way, but needs more syntax:

 ~ $ awk 'BEGIN{print 7*6}'
 42
 ~ $ awk 'BEGIN{print 7 * 6}'
 42

---