/* mpicalc.c - Simple RPN calculator using gcry_mpi functions
 * Copyright (C) 1997, 1998, 1999, 2004, 2006, 2013  Werner Koch
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

/*
   This program is a simple RPN calculator which was originally used
   to develop the mpi functions of GnuPG.  Values must be given in
   hex.  Operation is like dc(1) except that the input/output radix is
   always 16 and you can use a '-' to prefix a negative number.
   Addition operators: ++ and --.  All operators must be delimited by
   a blank.
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#ifdef _GCRYPT_IN_LIBGCRYPT
# undef _GCRYPT_IN_LIBGCRYPT
# include "gcrypt.h"
#else
# include <gcrypt.h>
#endif


#define MPICALC_VERSION "2.0"
#define NEED_LIBGCRYPT_VERSION "1.6.0"

#define STACKSIZE  500
static gcry_mpi_t stack[STACKSIZE];
static int stackidx;


static int
scan_mpi (gcry_mpi_t retval, const char *string)
{
  gpg_error_t err;
  gcry_mpi_t val;

  err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
  if (err)
    {
      fprintf (stderr, "scanning input failed: %s\n", gpg_strerror (err));
      return -1;
    }
  mpi_set (retval, val);
  mpi_release (val);
  return 0;
}


static void
print_mpi (gcry_mpi_t a)
{
  gpg_error_t err;
  char *buf;
  void *bufaddr = &buf;

  err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
  if (err)
    fprintf (stderr, "[error printing number: %s]\n", gpg_strerror (err));
  else
    {
      fputs (buf, stdout);
      gcry_free (buf);
    }
}


static void
do_add (void)
{
  if (stackidx < 2)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_add (stack[stackidx - 2], stack[stackidx - 2], stack[stackidx - 1]);
  stackidx--;
}

static void
do_sub (void)
{
  if (stackidx < 2)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_sub (stack[stackidx - 2], stack[stackidx - 2], stack[stackidx - 1]);
  stackidx--;
}

static void
do_inc (void)
{
  if (stackidx < 1)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_add_ui (stack[stackidx - 1], stack[stackidx - 1], 1);
}

static void
do_dec (void)
{
  if (stackidx < 1)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  /* mpi_sub_ui( stack[stackidx-1], stack[stackidx-1], 1 ); */
}

static void
do_mul (void)
{
  if (stackidx < 2)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_mul (stack[stackidx - 2], stack[stackidx - 2], stack[stackidx - 1]);
  stackidx--;
}

static void
do_mulm (void)
{
  if (stackidx < 3)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_mulm (stack[stackidx - 3], stack[stackidx - 3],
	    stack[stackidx - 2], stack[stackidx - 1]);
  stackidx -= 2;
}

static void
do_div (void)
{
  if (stackidx < 2)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_fdiv (stack[stackidx - 2], NULL,
            stack[stackidx - 2], stack[stackidx - 1]);
  stackidx--;
}

static void
do_rem (void)
{
  if (stackidx < 2)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_mod (stack[stackidx - 2],
           stack[stackidx - 2], stack[stackidx - 1]);
  stackidx--;
}

static void
do_powm (void)
{
  gcry_mpi_t a;
  if (stackidx < 3)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  a = mpi_new (0);
  mpi_powm (a, stack[stackidx - 3], stack[stackidx - 2], stack[stackidx - 1]);
  mpi_release (stack[stackidx - 3]);
  stack[stackidx - 3] = a;
  stackidx -= 2;
}

static void
do_inv (void)
{
  gcry_mpi_t a = mpi_new (0);
  if (stackidx < 2)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_invm (a, stack[stackidx - 2], stack[stackidx - 1]);
  mpi_set (stack[stackidx - 2], a);
  mpi_release (a);
  stackidx--;
}

static void
do_gcd (void)
{
  gcry_mpi_t a = mpi_new (0);
  if (stackidx < 2)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_gcd (a, stack[stackidx - 2], stack[stackidx - 1]);
  mpi_set (stack[stackidx - 2], a);
  mpi_release (a);
  stackidx--;
}

static void
do_rshift (void)
{
  if (stackidx < 1)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  mpi_rshift (stack[stackidx - 1], stack[stackidx - 1], 1);
}


static void
do_nbits (void)
{
  unsigned int n;

  if (stackidx < 1)
    {
      fputs ("stack underflow\n", stderr);
      return;
    }
  n = mpi_get_nbits (stack[stackidx - 1]);
  mpi_set_ui (stack[stackidx - 1], n);
}


static int
my_getc (void)
{
  static int shown;
  int c;

  for (;;)
    {
      if ((c = getc (stdin)) == EOF)
        return EOF;
      if (!(c & 0x80))
        return c;

      if (!shown)
        {
          shown = 1;
          fputs ("note: Non ASCII characters are ignored\n", stderr);
        }
    }
}


static void
print_help (void)
{
  fputs ("+   add           [0] := [1] + [0]          {-1}\n"
         "-   subtract      [0] := [1] - [0]          {-1}\n"
         "*   multiply      [0] := [1] * [0]          {-1}\n"
         "/   divide        [0] := [1] - [0]          {-1}\n"
         "%   modulo        [0] := [1] % [0]          {-1}\n"
         ">   right shift   [0] := [0] >> 1           {0}\n"
         "++  increment     [0] := [0]++              {0}\n"
         "--  decrement     [0] := [0]--              {0}\n"
         "m   multiply mod  [0] := [2] * [1] mod [0]  {-2}\n"
         "^   power mod     [0] := [2] ^ [1] mod [0]  {-2}\n"
         "I   inverse mod   [0] := [1]^-1 mod [0]     {-1}\n"
         "G   gcd           [0] := gcd([1],[0])       {-1}\n"
         "i   remove item   [0] := [1]                {-1}\n"
         "d   dup item      [-1] := [0]               {+1}\n"
         "r   reverse       [0] := [1], [1] := [0]    {0}\n"
         "b   # of bits     [0] := nbits([0])         {0}\n"
         "c   clear stack\n"
         "p   print top item\n"
         "f   print the stack\n"
         "#   ignore until end of line\n"
         "?   print this help\n"
         , stdout);
}


int
main (int argc, char **argv)
{
  const char *pgm;
  int last_argc = -1;
  int print_config = 0;
  int i, c;
  int state = 0;
  char strbuf[1000];
  int stridx = 0;

  if (argc)
    {
      pgm = strrchr (*argv, '/');
      if (pgm)
        pgm++;
      else
        pgm = *argv;
      argc--; argv++;
    }
  else
    pgm = "?";

  while (argc && last_argc != argc )
    {
      last_argc = argc;
      if (!strcmp (*argv, "--"))
        {
          argc--; argv++;
          break;
        }
      else if (!strcmp (*argv, "--version")
               || !strcmp (*argv, "--help"))
        {
          printf ("%s " MPICALC_VERSION "\n"
                  "libgcrypt %s\n"
                  "Copyright (C) 1997, 2013  Werner Koch\n"
                  "License LGPLv2.1+: GNU LGPL version 2.1 or later "
                  "<http://gnu.org/licenses/old-licenses/lgpl-2.1.html>\n"
                  "This is free software: you are free to change and "
                  "redistribute it.\n"
                  "There is NO WARRANTY, to the extent permitted by law.\n"
                  "\n"
                  "Syntax: mpicalc [options]\n"
                  "Simple interactive big integer RPN calculator\n"
                  "\n"
                  "Options:\n"
                  "  --version           print version information\n"
                  "  --print-config      print the Libgcrypt config\n"
                  "  --disable-hwf NAME  disable feature NAME\n",
                  pgm, gcry_check_version (NULL));
          exit (0);
        }
      else if (!strcmp (*argv, "--print-config"))
        {
          argc--; argv++;
          print_config = 1;
        }
      else if (!strcmp (*argv, "--disable-hwf"))
        {
          argc--; argv++;
          if (argc)
            {
              if (gcry_control (GCRYCTL_DISABLE_HWF, *argv, NULL))
                fprintf (stderr, "%s: unknown hardware feature `%s'"
                         " - option ignored\n", pgm, *argv);
              argc--; argv++;
            }
        }
    }

  if (argc)
    {
      fprintf (stderr, "usage: %s [options]  (--help for help)\n", pgm);
      exit (1);
    }

  if (!gcry_check_version (NEED_LIBGCRYPT_VERSION))
    {
      fprintf (stderr, "%s: Libgcrypt is too old (need %s, have %s)\n",
               pgm, NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
      exit (1);
    }
  gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
  gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
  if (print_config)
    {
      gcry_control (GCRYCTL_PRINT_CONFIG, stdout);
      exit (0);
    }

  for (i = 0; i < STACKSIZE; i++)
    stack[i] = NULL;
  stackidx = 0;

  while ((c = my_getc ()) != EOF)
    {
      if (!state) /* waiting */
	{
	  if (isdigit (c))
	    {
	      state = 1;
	      ungetc (c, stdin);
	      strbuf[0] = '0';
	      strbuf[1] = 'x';
	      stridx = 2;
	    }
	  else if (isspace (c))
	    ;
	  else
	    {
	      switch (c)
		{
                case '#':
                  state = 2;
                  break;
		case '+':
		  if ((c = my_getc ()) == '+')
		    do_inc ();
		  else
		    {
		      ungetc (c, stdin);
		      do_add ();
		    }
		  break;
                case '-':
		  if ((c = my_getc ()) == '-')
		    do_dec ();
		  else if (isdigit (c)
                           || (c >= 'A' && c <= 'F')
                           || (c >= 'a' && c <= 'f'))
		    {
		      state = 1;
		      ungetc (c, stdin);
		      strbuf[0] = '-';
		      strbuf[1] = '0';
		      strbuf[2] = 'x';
		      stridx = 3;
		    }
		  else
		    {
		      ungetc (c, stdin);
		      do_sub ();
		    }
		  break;
		case '*':
		  do_mul ();
		  break;
		case 'm':
		  do_mulm ();
		  break;
		case '/':
		  do_div ();
		  break;
		case '%':
		  do_rem ();
		  break;
		case '^':
		  do_powm ();
		  break;
		case '>':
		  do_rshift ();
		  break;
		case 'I':
		  do_inv ();
		  break;
		case 'G':
		  do_gcd ();
		  break;
		case 'i':	/* dummy */
		  if (!stackidx)
		    fputs ("stack underflow\n", stderr);
		  else
		    {
		      mpi_release (stack[stackidx - 1]);
		      stackidx--;
		    }
		  break;
		case 'd':	/* duplicate the tos */
		  if (!stackidx)
		    fputs ("stack underflow\n", stderr);
		  else if (stackidx < STACKSIZE)
		    {
		      mpi_release (stack[stackidx]);
		      stack[stackidx] = mpi_copy (stack[stackidx - 1]);
		      stackidx++;
		    }
		  else
		    fputs ("stack overflow\n", stderr);
		  break;
		case 'r':	/* swap top elements */
		  if (stackidx < 2)
		    fputs ("stack underflow\n", stderr);
		  else if (stackidx < STACKSIZE)
		    {
		      gcry_mpi_t tmp = stack[stackidx-1];
                      stack[stackidx-1] = stack[stackidx - 2];
                      stack[stackidx-2] = tmp;
		    }
		  break;
                case 'b':
                  do_nbits ();
                  break;
		case 'c':
		  for (i = 0; i < stackidx; i++)
                    {
                      mpi_release (stack[i]); stack[i] = NULL;
                    }
		  stackidx = 0;
		  break;
		case 'p':	/* print the tos */
		  if (!stackidx)
		    puts ("stack is empty");
		  else
		    {
		      print_mpi (stack[stackidx - 1]);
		      putchar ('\n');
		    }
		  break;
		case 'f':	/* print the stack */
		  for (i = stackidx - 1; i >= 0; i--)
		    {
		      printf ("[%2d]: ", i);
		      print_mpi (stack[i]);
		      putchar ('\n');
		    }
		  break;
                case '?':
                  print_help ();
                  break;
		default:
		  fputs ("invalid operator\n", stderr);
		}
	    }
	}
      else if (state == 1) /* In a number. */
	{
	  if (!isxdigit (c))
	    {
              /* Store the number */
	      state = 0;
	      ungetc (c, stdin);
	      if (stridx < sizeof strbuf)
		strbuf[stridx] = 0;

	      if (stackidx < STACKSIZE)
		{
		  if (!stack[stackidx])
		    stack[stackidx] = mpi_new (0);
		  if (scan_mpi (stack[stackidx], strbuf))
		    fputs ("invalid number\n", stderr);
		  else
		    stackidx++;
		}
	      else
		fputs ("stack overflow\n", stderr);
	    }
	  else
	    { /* Store a digit.  */
	      if (stridx < sizeof strbuf - 1)
		strbuf[stridx++] = c;
	      else if (stridx == sizeof strbuf - 1)
		{
		  strbuf[stridx] = 0;
		  fputs ("input too large - truncated\n", stderr);
		  stridx++;
		}
	    }
	}
      else if (state == 2) /* In a comment. */
        {
          if (c == '\n')
            state = 0;
        }

    }

  for (i = 0; i < stackidx; i++)
    mpi_release (stack[i]);
  return 0;
}