path: root/Functions/Misc/zcalc

#!/bin/zsh -i
#
# Zsh calculator.  Understands most ordinary arithmetic expressions.
# Line editing and history are available. A blank line or `q' quits.
#
# Runs as a script or a function.  If used as a function, the history
# is remembered for reuse in a later call (and also currently in the
# shell's own history).  There are various problems using this as a
# script, so a function is recommended.
#
# The prompt shows a number for the current line.  The corresponding
# result can be referred to with $<line-no>, e.g.
#   1> 32 + 10
#   42
#   2> $1 ** 2
#   1764
# The set of remembered numbers is primed with anything given on the
# command line.  For example,
#   zcalc '2 * 16'
#   1> 32                     # printed by function
#   2> $1 + 2                 # typed by user
#   34
#   3> 
# Here, 32 is stored as $1.  This works in the obvious way for any
# number of arguments.
#
# If the mathfunc library is available, probably understands most system
# mathematical functions.  The left parenthesis must be adjacent to the
# end of the function name, to distinguish from shell parameters
# (translation: to prevent the maintainers from having to write proper
# lookahead parsing).  For example,
#   1> sqrt(2)
#   1.4142135623730951
# is right, but `sqrt (2)' will give you an error.
#
# You can do things with parameters like
#   1> pi = 4.0 * atan(1)
# too.  These go into global parameters, so be careful.  You can declare
# local variables, however:
#   1> local pi
# but note this can't appear on the same line as a calculation.  Don't
# use the variables listed in the `local' and `integer' lines below
# (translation: I can't be bothered to provide a sandbox).
#
# You can declare or delete math functions (implemented via zmathfuncdef):
#   1> function cube $1 * $1 * $1
# This has a single compulsory argument.  Note the function takes care of
# the punctuation.  To delete the function, put nothing (at all) after
# the function name:
#   1> function cube
#
# Some constants are already available: (case sensitive as always):
#   PI     pi, i.e. 3.1415926545897931
#   E      e, i.e. 2.7182818284590455
#
# You can also change the output base.
#   1> [#16]
#   1>
# Changes the default output to hexadecimal with numbers preceded by `16#'.
# Note the line isn't remembered.
#   2> [##16]
#   2>
# Change the default output base to hexadecimal with no prefix.
#   3> [#]
# Reset the default output base.
#
# This is based on the builtin feature that you can change the output base
# of a given expression.  For example,
#   1> [##16]  32 + 20 / 2
#   2A
#   2> 
# prints the result of the calculation in hexadecimal.
#
# You can't change the default input base, but the shell allows any small
# integer as a base:
#   1> 2#1111
#   15
#   2> [##13] 13#6 * 13#9
#   42
# and the standard C-like notation with a leading 0x for hexadecimal is
# also understood.  However, leading 0 for octal is not understood --- it's
# too confusing in a calculator.  Use 8#777 etc.
#
# Options: -#<base> is the same as a line containing just `[#<base>],
# similarly -##<base>; they set the default output base, with and without
# a base discriminator in front, respectively.
#
# With the option -e, the arguments are evaluated as if entered
# interactively.  So, for example:
#   zcalc -e -\#16 -e 1055
# prints
#   0x41f
# Any number of expressions may be given and they are evaluated
# sequentially just as if read automatically.

emulate -L zsh
setopt extendedglob

zcalc_show_value() {
  if [[ -n $_base ]]; then
    print -- $(( $_base $1 ))
  elif [[ $1 = *.* ]] || (( _outdigits )); then
    # With normal output, ensure trailing "." doesn't get lost.
    if [[ -z $_forms[_outform] || ($_outform -eq 1 && $1 = *.) ]]; then
      print -- $(( $1 ))
    else
      printf "$_forms[_outform]\n" $_outdigits $1
    fi
  else
    printf "%d\n" $1
  fi
}

# For testing in ZLE functions.
local ZCALC_ACTIVE=1

# TODO: make local variables that shouldn't be visible in expressions
# begin with _.
local _line ans _base _defbase _forms match mbegin mend
local psvar _optlist _opt _arg _tmp
local compcontext="-zcalc-line-"
integer _num _outdigits _outform=1 _expression_mode
integer _rpn_mode _matched _show_stack _i _n
integer _max_stack _push
local -a _expressions stack

# We use our own history file with an automatic pop on exit.
history -ap "${ZDOTDIR:-$HOME}/.zcalc_history"

_forms=( '%2$g' '%.*g' '%.*f' '%.*E' '')

local _mathfuncs
if zmodload -i zsh/mathfunc 2>/dev/null; then
  zmodload -P _mathfuncs -FL zsh/mathfunc
  _mathfuncs="("${(j.|.)${_mathfuncs##f:}}")"
fi
local -A _userfuncs
for _line in ${(f)"$(functions -M)"}; do
  match=(${=_line})
  # get minimum number of arguments
  _userfuncs[${match[3]}]=${match[4]}
done
_line=
autoload -Uz zmathfuncdef

if (( ! ${+ZCALCPROMPT} )); then
  typeset -g ZCALCPROMPT="%1v> "
fi

# Supply some constants.
float PI E
(( PI = 4 * atan(1), E = exp(1) ))

if [[ -f "${ZDOTDIR:-$HOME}/.zcalcrc" ]]; then
  . "${ZDOTDIR:-$HOME}/.zcalcrc" || return 1
fi

# Process command line
while [[ -n $1 && $1 = -(|[#-]*|f|e|r(<->|)) ]]; do
  _optlist=${1[2,-1]}
  shift
  [[ $_optlist = (|-) ]] && break
  while [[ -n $_optlist ]]; do
    _opt=${_optlist[1]}
    _optlist=${_optlist[2,-1]}
    case $_opt in
      ('#') # Default base
            if [[ -n $_optlist ]]; then
	       _arg=$_optlist
	       _optlist=
	    elif [[ -n $1 ]]; then
	       _arg=$1
	       shift
	    else
	       print -- "-# requires an argument" >&2
	       return 1
	    fi
	    if [[ $_arg != (|\#)[[:digit:]]## ]]; then
	      print -- "-# requires a decimal number as an argument" >&2
	      return 1
	    fi
            _defbase="[#${_arg}]"
	    ;;
	(f) # Force floating point operation
	    setopt forcefloat
	    ;;
        (e) # Arguments are expressions
	    (( _expression_mode = 1 ));
	    ;;
        (r) # RPN mode.
	    (( _rpn_mode = 1 ))
	    ZCALC_ACTIVE=rpn
	    if [[ $_optlist = (#b)(<->)* ]]; then
	       (( _show_stack = ${match[1]} ))
               _optlist=${_optlist[${#match[1]}+1,-2]}
	    fi
	    ;;
    esac
  done
done

if (( _expression_mode )); then
  _expressions=("$@")
  argv=()
fi

for (( _num = 1; _num <= $#; _num++ )); do
  # Make sure all arguments have been evaluated.
  # The `$' before the second argv forces string rather than numeric
  # substitution.
  (( argv[$_num] = $argv[$_num] ))
  print "$_num> $argv[$_num]"
done

psvar[1]=$_num
local _prev_line _cont_prompt
while (( _expression_mode )) ||
  vared -cehp "${_cont_prompt}${ZCALCPROMPT}" _line; do
  if (( _expression_mode )); then
    (( ${#_expressions} )) || break
    _line=$_expressions[1]
    shift _expressions
  fi
  if [[ $_line = (|*[^\\])('\\')#'\' ]]; then
    _prev_line+=$_line[1,-2]
    _cont_prompt="..."
    _line=
    continue
  fi
  _line="$_prev_line$_line"
  _prev_line=
  _cont_prompt=
  # Test whether there are as many open as close
  # parentheses in the _line so far.
  if [[ ${#_line//[^\(]} -gt ${#_line//[^\)]} ]]; then
      _prev_line+=$_line
      _cont_prompt="..."
      _line=
      continue
  fi
  [[ -z $_line ]] && break
  # special cases
  # Set default base if `[#16]' or `[##16]' etc. on its own.
  # Unset it if `[#]' or `[##]'.
  if [[ $_line = (#b)[[:blank:]]#('[#'(\#|)((<->|)(|_|_<->))']')[[:blank:]]#(*) ]]; then
    if [[ -z $match[6] ]]; then
      if [[ -z $match[3] ]]; then
	_defbase=
      else
	_defbase=$match[1]
      fi
      print -s -- $_line
      print -- $(( ${_defbase} ans ))
      _line=
      continue
    else
      _base=$match[1]
    fi
  else
    _base=$_defbase
  fi

  print -s -- $_line

  _line="${${_line##[[:blank:]]#}%%[[:blank:]]#}"
  case "$_line" in
    # Escapes begin with a colon
    (:(\\|)\!*)
    # shell escape: handle completion's habit of quoting the !
    eval ${_line##:(\\|)\![[:blank:]]#}
    _line=
    continue
    ;;

    ((:|)q)
    # Exit
    return 0
    ;;

    ((:|)norm) # restore output format to default
      _outform=1
    ;;

    ((:|)sci[[:blank:]]#(#b)(<->)(#B))
      _outdigits=$match[1]
      _outform=2
    ;;

    ((:|)fix[[:blank:]]#(#b)(<->)(#B))
      _outdigits=$match[1]
      _outform=3
    ;;

    ((:|)eng[[:blank:]]#(#b)(<->)(#B))
      _outdigits=$match[1]
      _outform=4
    ;;

    (:raw)
    _outform=5
    ;;

    ((:|)local([[:blank:]]##*|))
      eval $_line
      _line=
      continue
    ;;

    ((function|:f(unc(tion|)|))[[:blank:]]##(#b)([^[:blank:]]##)(|[[:blank:]]##([^[:blank:]]*)))
      zmathfuncdef $match[1] $match[3]
      _userfuncs[$match[1]]=${$(functions -Mm $match[1])[4]}
      _line=
      continue
    ;;

    (:*)
    print "Unrecognised escape"
    _line=
    continue
    ;;

    (\$[[:IDENT:]]##)
    # Display only, no calculation
    _line=${_line##\$}
    print -r -- ${(P)_line}
    _line=
    continue
    ;;

    (*)
      _line=${${_line##[[:blank:]]##}%%[[:blank:]]##}
      if [[ _rpn_mode -ne 0 && $_line != '' ]]; then
	_push=1
	_matched=1
	case $_line in
	  (\=|pop|\<[[:IDENT:]]#)
	  if (( ${#stack} < 1 )); then
	    print -r -- "${_line}: not enough values on stack" >&2
	    _line=
	    continue
	  fi
	  case $_line in
	    (=)
	    ans=${stack[1]}
	    ;;
	    (pop|\<)
	    _push=0
	    shift stack
	    ;;
	    (\<[[:IDENT:]]##)
	    (( ${_line##\<} = ${stack[1]} ))
	    _push=0
	    shift stack
	    ;;
	    (*)
	    print "BUG in special RPN functions" >&2
	    _line=
	    continue
	    ;;
	  esac
	  ;;

	  (+|-|\^|\||\&|\*|/|\*\*|\>\>|\<\</)
	  # Operators with two arguments
	  if (( ${#stack} < 2 )); then
	    print -r -- "${_line}: not enough values on stack" >&2
	    _line=
	    continue
	  fi
	  eval "(( ans = \${stack[2]} $_line \${stack[1]} ))"
	  shift 2 stack
	  ;;

	  (ldexp|jn|yn|scalb|xy)
	  # Functions with two arguments
	  if (( ${#stack} < 2 )); then
	    print -r -- "${_line}: not enough values on stack" >&2
	    _line=
	    continue
	  fi
	  if [[ $_line = xy ]]; then
	    _tmp=${stack[1]}
	    stack[1]=${stack[2]}
	    stack[2]=$_tmp
	    _push=0
	  else
	    eval "(( ans = ${_line}(\${stack[2]},\${stack[1]}) ))"
	    shift 2 stack
	  fi
	  ;;

	  (${~_mathfuncs})
	  # Functions with a single argument.
	  # This is actually a superset, but we should have matched
	  # any that shouldn't be in it in previous cases.
	  if (( ${#stack} < 1 )); then
	    print -r -- "${_line}: not enough values on stack" >&2
	    _line=
	    continue
	  fi
	  eval "(( ans = ${_line}(\${stack[1]}) ))"
	  shift stack
	  ;;

	  (${(kj.|.)~_userfuncs})
	  # Get minimum number of arguments to user function
	  _n=${_userfuncs[$_line]}
	  if (( ${#stack} < n_ )); then
	    print -r -- "${_line}: not enough values ($_n) on stack" >&2
	    _line=
	    continue
	  fi
	  _line+="("
	  # least recent elements on stack are earlier arguments
	  for (( _i = _n; _i > 0; _i-- )); do
	    _line+=${stack[_i]}
	    (( _i > 1 )) && _line+=","
	  done
	  _line+=")"
	  shift $_n stack
	  eval "(( ans = $_line ))"
	  ;;

	  (*)
	  # Treat as expression evaluating to new value to go on stack.
	  _matched=0
	  ;;
	esac
      else
	_matched=0
      fi
      if (( ! _matched )); then
	# Latest value is stored` as a string, because it might be floating
	# point or integer --- we don't know till after the evaluation, and
	# arrays always store scalars anyway.
	#
	# Since it's a string, we'd better make sure we know which
	# base it's in, so don't change that until we actually print it.
	if ! eval "ans=\$(( $_line ))"; then
	  _line=
	  continue
	fi
	# on error $ans is not set; let user re-edit _line
	[[ -n $ans ]] || continue
      fi
      argv[_num++]=$ans
      psvar[1]=$_num
      (( _push )) && stack=($ans $stack)
    ;;
  esac
  if (( _show_stack )); then
    (( _max_stack = (_show_stack > ${#stack}) ? ${#stack} : _show_stack ))
    for (( _i = _max_stack; _i > 0; _i-- )); do
      printf "%3d: " $_i
      zcalc_show_value ${stack[_i]}
    done
  else
    zcalc_show_value $ans
  fi
  _line=
done

return 0