This commit was generated by cvs2svn to track changes on a CVS vendor

[unix-history] / gnu / usr.bin / dc / dc.c

/* 
* `dc' desk calculator utility.
*
* Copyright (C) 1984, 1993 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can either send email to this
* program's author (see below) or write to: The Free Software Foundation,
* Inc.; 675 Mass Ave. Cambridge, MA 02139, USA.
*/

#include <stdio.h>
#include "decimal.h"  /* definitions for our decimal arithmetic package */

FILE *open_file;        /* input file now open */
int file_count;         /* Number of input files not yet opened */
char **next_file;       /* Pointer to vector of names of input files left */

struct regstack
 {
   decimal value;      /* Saved value of register */
   struct regstack *rest;      /* Tail of list */
 };

typedef struct regstack *regstack;

regstack freeregstacks; /* Chain of free regstack structures for fast realloc */

decimal regs[128];      /* "registers", with single-character names */
regstack regstacks[128]; /* For each register, a stack of previous values */

int stacktop;           /* index of last used element in stack */
int stacksize;          /* Current allocates size of stack */
decimal *stack; /* Pointer to computation stack */

/* A decimal number can be regarded as a string by
treating its contents as characters and ignoring the
position of its decimal point.
Decimal numbers are marked as strings by having an `after' field of -1
One use of strings is to execute them as macros.
*/

#define STRING -1

int macrolevel; /* Current macro nesting; 0 if taking keyboard input */
int macrostacksize;     /* Current allocated size of macrostack and macroindex */
decimal *macrostack;    /* Pointer to macro stack array */
int *macroindex;        /* Pointer to index-within-macro stack array */
       /* Note that an empty macro is popped from the stack
          only when an trying to read a character from it
          or trying to push another macro.  */

int ibase;      /* Radix for numeric input.  */
int obase;      /* Radix for numeric output.  */
int precision;  /* Number of digits to keep in multiply and divide.  */

char *buffer;   /* Address of buffer used for reading numbers */
int bufsize;    /* Current size of buffer (made bigger when nec) */

decimal dec_read ();
regstack get_regstack ();
int fetch ();
int fgetchar ();
char *concat ();
void pushsqrt ();
void condop ();
void setibase ();
void setobase ();
void setprecision ();
void pushmacro ();
decimal read_string ();
void pushlength ();
void pushscale ();
void unfetch ();
void popmacros ();
void popmacro ();
void popstack ();
void print_obj ();
void print_string ();
void free_regstack ();
void pushreg ();
void execute ();
void fputchar ();
void push ();
void incref ();
void decref ();
void binop ();
\f
main (argc, argv, env)
    int argc;
    char **argv, **env;
{

 ibase = 10;
 obase = 10;
 precision = 0;

 freeregstacks = 0;

 bzero (regs, sizeof regs);
 bzero (regstacks, sizeof regstacks);

 bufsize = 40;
 buffer = (char *) xmalloc (40);

 stacksize = 40;
 stack = (decimal *) xmalloc (stacksize * sizeof (decimal));
 stacktop = -1;

 macrostacksize = 40;
 macrostack = (decimal *) xmalloc (macrostacksize * sizeof (decimal));
 macroindex = (int *) xmalloc (macrostacksize * sizeof (int));
 macrolevel = 0;
 /* Initialize for reading input files if any */

 open_file = 0;

 file_count = argc - 1;
 next_file = argv + 1;


 while (1)
   {
     execute ();
   }
}
\f
/* Read and execute one command from the current source of input */

void
execute ()
{
 int c = fetch ();

 if (c < 0) exit (0);

   {
     switch (c)
       {
       case '+':               /* Arithmetic operators... */
         binop (decimal_add);
         break;

       case '-':
         binop (decimal_sub);
         break;

       case '*':
         binop (decimal_mul_dc);  /* Like decimal_mul but hairy
                                     way of deciding precision to keep */
         break;

       case '/':
         binop (decimal_div);
         break;

       case '%':
         binop (decimal_rem);
         break;

       case '^':
         binop (decimal_expt);
         break;

       case '_':               /* Begin a negative decimal constant */
         {
           decimal tem = dec_read (stdin);
           tem->sign = !tem->sign;
           push (tem);
         }
         break;

       case '.':
       case '0':
       case '1':
       case '2':
       case '3':
       case '4':
       case '5':
       case '6':
       case '7':
       case '8':
       case '9':               /* All these begin decimal constants */
         unfetch (c);
         push (dec_read (stdin));
         break;

       case 'A':
       case 'B':
       case 'C':
       case 'D':
       case 'E':
       case 'F':
         unfetch (c);
         push (dec_read (stdin));
         break;

       case 'c':               /* Clear the stack */
         while (stacktop >= 0)
           decref (stack[stacktop--]);
         break;

       case 'd':               /* Duplicate top of stack */
         if (stacktop < 0)
           error ("stack empty", 0);
         else push (stack[stacktop]);
         break;

       case 'f':               /* Describe all registers and stack contents */
         {
           int regno;
           int somereg = 0;    /* set to 1 if we print any registers */
           for (regno = 0; regno < 128; regno++)
             {
               if (regs[regno])
                 {
                   printf ("register %c: ", regno);
                   print_obj (regs[regno]);
                   somereg = 1;
                   printf ("\n");
                 }
             }
           if (somereg)
             printf ("\n");
           if (stacktop < 0)
             printf ("stack empty\n");
           else
             {
               int i;
               printf ("stack:\n");
               for (i = 0; i <= stacktop; i++)
                 {
                   print_obj (stack[stacktop - i]);
                   printf ("\n");
                 }
             }
         }
         break;

       case 'i':               /* ibase <- top of stack */
         popstack (setibase);
         break;

       case 'I':               /* Push current ibase */
         push (decimal_from_int (ibase));
         break;

       case 'k':               /* like i, I but for precision instead of ibase */
         popstack (setprecision);
         break;

       case 'K':
         push (decimal_from_int (precision));
         break;

       case 'l':               /* l<x> load register <x> onto stack */
         {
           char c1 = fetch ();
           if (c1 < 0) exit (0);
           if (!regs[c1])
             error ("register %c empty", c1);
           else
             push (regs[c1]);
         }
         break;

       case 'L':               /* L<x> load register <x> to stack, pop <x>'s own stack */
         {
           char c1 = fetch ();
           if (c1 < 0) exit (0);
           if (!regstacks[c1])
             error ("nothing pushed on register %c", c1);
           else
             {
               regstack r = regstacks[c1];
               if (!regs[c1])
                 error ("register %c empty after pop", c1);
               else
                 push (regs[c1]);
               regs[c1] = r->value;
               regstacks[c1] = r->rest;
               free_regstack (r);
             }
         }
         break;

       case 'o':               /* o, O like i, I but for obase instead of ibase */
         popstack (setobase);
         break;

       case 'O':
         push (decimal_from_int (obase));
         break;

       case 'p':               /* Print tos, don't pop, do print newline afterward */
         if (stacktop < 0)
           error ("stack empty", 0);
         else
           {
             print_obj (stack[stacktop]);
             printf ("\n");
           }
         break;

       case 'P':               /* Print tos, do pop, no newline afterward */
         popstack (print_obj);
         break;

       case 'q':               /* Exit */
         if (macrolevel)
           { popmacro (); popmacro (); }  /* decrease recursion level by 2 */
         else
           exit (0);           /* If not in a macro, exit the program.  */

         break;

       case 'Q':               /* Tos says how many levels to exit */
         popstack (popmacros);
         break;

       case 's':               /* s<x> -- Pop stack and set register <x> */
         if (stacktop < 0)
           empty ();
         else
           {
             int c1 = fetch ();
             if (c1 < 0) exit (0);
             if (regs[c1]) decref (regs[c1]);
             regs[c1] = stack[stacktop--];
           }
         break;

       case 'S':               /* S<x> -- pop stack and push as new value of register <x> */
         if (stacktop < 0)
           empty ();
         else
           {
             int c1 = fetch ();
             if (c1 < 0) exit (0);
             pushreg (c1);
             regs[c1] = stack[stacktop--];
           }
         break;

       case 'v':               /* tos gets square root of tos */
         popstack (pushsqrt);
         break;

       case 'x':               /* pop stack , call as macro */
         popstack (pushmacro);
         break;

       case 'X':               /* Pop stack, get # fraction digits, push that */
         popstack (pushscale);
         break;

       case 'z':               /* Compute depth of stack, push that */
         push (decimal_from_int (stacktop + 1));
         break;

       case 'Z':               /* Pop stack, get # digits, push that */
         popstack (pushlength);
         break;

       case '<':               /* Conditional: pop two numbers, compare, maybe execute register */
         /* Note: for no obvious reason, the standard Unix `dc'
            considers < to be true if the top of stack is less
            than the next-to-top of stack,
            and vice versa for >.
            This seems backwards to me, but I am preserving compatibility.  */
         condop (1);
         break;

       case '>':
         condop (-1);
         break;

       case '=':
         condop (0);
         break;

       case '?':               /* Read expression from terminal and execute it */
         /* First ignore any leading newlines */
         {
           int c1;
           while ((c1 = getchar ()) == '\n');
           ungetc (c1, stdin);
         }
         /* Read a line from the terminal and execute it.  */
         pushmacro (read_string ('\n', fgetchar, 0));
         break;

       case '[':               /* Begin string constant */
         push (read_string (']', fetch, '['));
         break;

       case ' ':
       case '\n':
         break;

       default:
         error ("undefined command %c", c);
       }
   }
}
\f
/* Functionals for performing arithmetic, etc */

/* Call the function `op', with the top of stack value as argument,
and then pop the stack.
If the stack is empty, print a message and do not call `op'.  */

void
popstack (op)
    void (*op) ();
{
 if (stacktop < 0)
   empty ();
 else
   {
     decimal value = stack[stacktop--];
     op (value);
     decref (value);
   }
}

/* Call the function `op' with two arguments taken from the stack top,
then pop those arguments and push the value returned by `op'.
`op' is assumed to return a decimal number.
If there are not two values on the stack, print a message
and do not call `op'.  */

void
binop (op)
    decimal (*op) ();
{
 if (stacktop < 1)
   error ("stack empty", 0);
 else if (stack[stacktop]->after == STRING || stack[stacktop - 1]->after == STRING)
   error ("operands not both numeric");
 else
   {
     decimal arg2 = stack [stacktop--];
     decimal arg1 = stack [stacktop--];

     push (op (arg1, arg2, precision));

     decref (arg1);
     decref (arg2);
   }
}

void
condop (cond)
    int cond;
{
 int regno = fetch ();
 if (!regs[regno])
   error ("register %c is empty", regno);
 else if (stacktop < 1)
   empty ();
 else
   {
     decimal arg2 = stack[stacktop--];
     decimal arg1 = stack[stacktop--];
     int relation = decimal_compare (arg1, arg2);
     decref (arg1);
     decref (arg2);
     if (cond == relation
         || (cond < 0 && relation < 0)
         || (cond > 0 && relation > 0))
       pushmacro (regs[regno]);
   }
}
\f
/* Handle the command input source */

/* Fetch the next command character from a macro or from the terminal */

int
fetch()
{
 int c = -1;

 while (macrolevel &&
               LENGTH (macrostack[macrolevel-1]) == macroindex[macrolevel-1])
   popmacro();
 if (macrolevel)
   return macrostack[macrolevel - 1]->contents[macroindex[macrolevel-1]++];
 while (1)
   {
     if (open_file)
       {
         c = getc (open_file);
         if (c >= 0) break;
         fclose (open_file);
         open_file = 0;
       }
     else if (file_count)
       {
         open_file = fopen (*next_file++, "r");
         file_count--;
         if (!open_file)
           perror_with_name (*(next_file - 1));
       }
     else break;
   }
 if (c >= 0) return c;
 return getc (stdin);
}

/* Unread character c on command input stream, whatever it is */

void
unfetch (c)
    char c;
{
 if (macrolevel)
   macroindex[macrolevel-1]--;
 else if (open_file)
   ungetc (c, open_file);
 else
   ungetc (c, stdin);
}

/* Begin execution of macro m.  */

void
pushmacro (m)
    decimal m;
{
 while (macrolevel &&
               LENGTH (macrostack[macrolevel-1]) == macroindex[macrolevel-1])
   popmacro();
 if (m->after == STRING)
   {
     if (macrolevel == macrostacksize)
       {
         macrostacksize *= 2;
         macrostack = (decimal *) xrealloc (macrostack, macrostacksize * sizeof (decimal));
         macroindex = (int *) xrealloc (macroindex, macrostacksize * sizeof (int));
       }
     macroindex[macrolevel] = 0;
     macrostack[macrolevel++] = m;
     incref (m);
   }
 else
   {   /* Number supplied as a macro!  */
     push (m);   /* Its effect wouyld be to push the number.  */
   }
}

/* Pop a specified number of levels of macro execution.
The number of levels is specified by a decimal number d.  */

void
popmacros (d)
    decimal d;
{
 int num_pops = decimal_to_int (d);
 int i;
 for (i = 0; i < num_pops; i++)
   popmacro ();
}
/* Exit one level of macro execution.  */

void
popmacro ()
{
 if (!macrolevel)
   exit (0);
 else
   {
     decref (macrostack[--macrolevel]);
   }
}
\f
void
push (d)
    decimal d;
{
 if (stacktop == stacksize - 1)
   stack = (decimal *) xrealloc (stack, (stacksize *= 2) * sizeof (decimal));

   incref (d);

   stack[++stacktop] = d;
}

/* Reference counting and storage freeing */

void
decref (d)
    decimal d;
{
 if (!--d->refcnt)
   free (d);
}

void
incref (d)
    decimal d;
{
 d->refcnt++;
}

empty ()
{
 error ("stack empty", 0);
}

regstack
get_regstack ()
{
 if (freeregstacks)
   {
     regstack r = freeregstacks;
     freeregstacks = r ->rest;
     return r;
   }
 else
   return (regstack) xmalloc (sizeof (struct regstack));
}

void
free_regstack (r)
    regstack r;
{
 r->rest = freeregstacks;
 freeregstacks = r;
}

void
pushreg (c)
    char c;
{
 regstack r = get_regstack ();

 r->rest = regstacks[c];
 r->value = regs[c];
 regstacks[c] = r;
 regs[c] = 0;
}
\f
/* Input of numbers and strings */

/* Return a character read from the terminal.  */

fgetchar ()
{
 return getchar ();
}

void
fputchar (c)
    char (c);
{
 putchar (c);
}

/* Read text from command input source up to a close-bracket,
  make a string out of it, and return it.
  If STARTC is nonzero, then it and STOPC must balance when nested.  */

decimal
read_string (stopc, inputfn, startc)
    char stopc;
    int (*inputfn) ();
    int startc;
{
 int c;
 decimal result;
 int i = 0;
 int count = 0;

 while (1)
   {
     c = inputfn ();
     if (c < 0 || (c == stopc && count == 0))
       {
         if (count != 0)
           error ("Unmatched `%c'", startc);
         break;
       }
     if (c == stopc)
       count--;
     if (c == startc)
       count++;
     if (i + 1 >= bufsize)
       buffer = (char *) xrealloc (buffer, bufsize *= 2);
     buffer[i++] = c;
   }
 result = make_decimal (i, 0);
 result->after = -1;   /* Mark it as a string */
 result->before++;     /* but keep the length unchanged */
 bcopy (buffer, result->contents, i);
 return result;
}

/* Read a number from the current input source */

decimal
dec_read ()
{
 int c;
 int i = 0;

 while (1)
   {
     c = fetch ();
     if (! ((c >= '0' && c <= '9')
            || (c >= 'A' && c <= 'F')
            || c == '.'))
       break;
     if (i + 1 >= bufsize)
       buffer = (char *) xrealloc (buffer, bufsize *= 2);
     buffer[i++] = c;
   }
 buffer[i++] = 0;
 unfetch (c);

 return decimal_parse (buffer, ibase);
}
\f
/* Output of numbers and strings */

/* Print the contents of obj, either numerically or as a string,
according to what obj says it is.  */

void
print_obj (obj)
    decimal obj;
{
 if (obj->after == STRING)
   print_string (obj);
 else
   decimal_print (obj, fputchar, obase);
}

/* Print the contents of the decimal number `string', treated as a string.  */

void
print_string (string)
    decimal string;
{
 char *p = string->contents;
 int len = LENGTH (string);
 int i;

 for (i = 0; i < len; i++)
   {
     putchar (*p++);
   }
}
\f
/* Set the input radix from the value of the decimal number d, if valid.  */

void
setibase (d)
    decimal d;
{
 int value = decimal_to_int (d);
 if (value < 2 || value > 36)
   error ("input radix must be from 2 to 36", 0);
 else
   ibase = value;
}

/* Set the output radix from the value of the decimal number d, if valid.  */

void
setobase (d)
    decimal d;
{
 int value = decimal_to_int (d);
 if (value < 2 || value > 36)
   error ("output radix must be from 2 to 36", 0);
 else
   obase = value;
}

/* Set the precision for mul and div from the value of the decimal number d, if valid.  */

void
setprecision (d)
    decimal d;
{
 int value = decimal_to_int (d);
 if (value < 0 || value > 30000)
   error ("precision must be nonnegative and < 30000", 0);
 else
   precision = value;
}

/* Push the number of digits in decimal number d, as a decimal number.  */

void
pushlength (d)
    decimal d;
{
 push (decimal_from_int (LENGTH (d)));
}

/* Push the number of fraction digits in d.  */

void
pushscale (d)
    decimal d;
{
 push (decimal_from_int (d->after));
}

/* Push the square root of decimal number d.  */

void
pushsqrt (d)
    decimal d;
{
 push (decimal_sqrt (d, precision));
}
\f
/* Print error message and exit.  */

fatal (s1, s2)
    char *s1, *s2;
{
 error (s1, s2);
 exit (1);
}

/* Print error message.  `s1' is printf control string, `s2' is arg for it. */

error (s1, s2)
    char *s1, *s2;
{
 printf ("dc: ");
 printf (s1, s2);
 printf ("\n");
}

decimal_error (s1, s2)
    char *s1, *s2;
{
 error (s1, s2);
}

perror_with_name (name)
    char *name;
{
 extern int errno, sys_nerr;
 extern char *sys_errlist[];
 char *s;

 if (errno < sys_nerr)
   s = concat ("", sys_errlist[errno], " for %s");
 else
   s = "cannot open %s";
 error (s, name);
}

/* Return a newly-allocated string whose contents concatenate those of s1, s2, s3.  */

char *
concat (s1, s2, s3)
    char *s1, *s2, *s3;
{
 int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 char *result = (char *) xmalloc (len1 + len2 + len3 + 1);

 strcpy (result, s1);
 strcpy (result + len1, s2);
 strcpy (result + len1 + len2, s3);
 *(result + len1 + len2 + len3) = 0;

 return result;
}

/* Like malloc but get fatal error if memory is exhausted.  */

int
xmalloc (size)
    int size;
{
 int result = malloc (size);
 if (!result)
   fatal ("virtual memory exhausted", 0);
 return result;
}

int
xrealloc (ptr, size)
    char *ptr;
    int size;
{
 int result = realloc (ptr, size);
 if (!result)
   fatal ("virtual memory exhausted");
 return result;
}