gcalctool/functions.c

   1
   2 /*  $Header$
   3  *
   4  *  Copyright (c) 1987-2007 Sun Microsystems, Inc. All Rights Reserved.
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2, or (at your option)
   9  *  any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful, but
  12  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  *  General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  *  02111-1307, USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <assert.h>
  28
  29 #include "functions.h"
  30
  31 #include "get.h"
  32 #include "mp.h"
  33 #include "mpmath.h"
  34 #include "display.h"
  35 #include "ce_parser.h"
  36 #include "lr_parser.h"
  37 #include "ui.h"
  38
  39 char *
  40 gc_strdup(char *str)
  41 {
  42     char *dup;
  43     int len;
  44
  45     if (!str) {
  46         return NULL;
  47     }
  48
  49     len = strlen(str);
  50     dup = malloc(len+1);
  51     assert(dup);
  52     memset(dup, 0, len+1);
  53     strncpy(dup, str, len);
  54
  55     return(dup);
  56 }
  57
  58
  59 void
  60 make_exp(char *number, int t[MP_SIZE])
  61 {
  62     int i;
  63     char *a = NULL;
  64     char *b = NULL;
  65
  66     int MP_a[MP_SIZE];
  67     int MP_b[MP_SIZE];
  68
  69     assert(number);
  70     a = gc_strdup(number);
  71     assert(a);
  72
  73     for (i = 0; !((a[i] == 'e') || (a[i] == 'E')); i++) {
  74         assert(a[i]);
  75     }
  76
  77     a[i] = 0;
  78     b = &a[i+2];
  79
  80     MPstr_to_num(a, v->base, MP_a);
  81     MPstr_to_num(b, v->base, MP_b);
  82     if (a[i+1] == '-') {
  83         int MP_c[MP_SIZE];
  84         mpneg(MP_b, MP_c);
  85         calc_xtimestenpowx(MP_a, MP_c, t);
  86     } else {
  87         calc_xtimestenpowx(MP_a, MP_b, t);
  88     }
  89
  90     free(a);
  91 }
  92
  93
  94 static void
  95 update_undo_redo_button_sensitivity(void)
  96 {
  97     int undo = 0;
  98     int redo = 0;
  99
 100     if (v->h.current != v->h.end) {
 101         redo = 1;
 102     }
 103
 104     if (v->h.current != v->h.begin) {
 105         undo = 1;
 106     }
 107
 108     ui_set_undo_enabled(undo, redo);
 109 }
 110
 111
 112 void
 113 clear_undo_history(void)
 114 {
 115     int i = v->h.begin;
 116     while (i != v->h.end) {
 117         if (i != v->h.current) {
 118             free(v->h.e[i].expression);
 119             v->h.e[i].expression = NULL;
 120         }
 121         i = ((i + 1) % UNDO_HISTORY_LENGTH);
 122     }
 123     v->h.begin = v->h.end = v->h.current;
 124     update_undo_redo_button_sensitivity();
 125 }
 126
 127
 128 struct exprm_state *
 129 get_state(void)
 130 {
 131     return &(v->h.e[v->h.current]);
 132 }
 133
 134
 135 static void
 136 copy_state(struct exprm_state *dst, struct exprm_state *src)
 137 {
 138     MEMCPY(dst, src, sizeof(struct exprm_state));
 139     dst->expression = gc_strdup(src->expression);
 140 }
 141
 142
 143 static void
 144 purge_redo_history(void)
 145 {
 146     if (v->h.current != v->h.end) {
 147         int i = v->h.current;
 148
 149         do {
 150             i = ((i + 1) % UNDO_HISTORY_LENGTH);
 151             free(v->h.e[i].expression);
 152             v->h.e[i].expression = NULL;
 153         } while (i != v->h.end);
 154     }
 155
 156     v->h.end = v->h.current;
 157 }
 158
 159
 160 void
 161 new_state(void)
 162 {
 163     int c;
 164
 165     purge_redo_history();
 166
 167     c = v->h.current;
 168     v->h.end = v->h.current = ((v->h.current + 1) % UNDO_HISTORY_LENGTH);
 169     if (v->h.current == v->h.begin) {
 170         free(v->h.e[v->h.begin].expression);
 171         v->h.e[v->h.begin].expression = NULL;
 172         v->h.begin = ((v->h.begin + 1) % UNDO_HISTORY_LENGTH);
 173     }
 174
 175     copy_state(&(v->h.e[v->h.current]), &(v->h.e[c]));
 176     update_undo_redo_button_sensitivity();
 177 }
 178
 179
 180 void
 181 perform_undo(void)
 182 {
 183     if (v->h.current != v->h.begin) {
 184         v->h.current = ((v->h.current - 1) % UNDO_HISTORY_LENGTH);
 185         ui_set_statusbar("", "");
 186     } else {
 187         ui_set_statusbar(_("No undo history"), "gtk-dialog-warning");
 188     }
 189     update_undo_redo_button_sensitivity();
 190 }
 191
 192
 193 static int
 194 is_undo_step()
 195 {
 196     return(v->h.current != v->h.begin);
 197 }
 198
 199
 200 void
 201 perform_redo(void)
 202 {
 203     if (v->h.current != v->h.end) {
 204         v->h.current = ((v->h.current + 1) % UNDO_HISTORY_LENGTH);
 205         ui_set_statusbar("", "");
 206     } else {
 207         ui_set_statusbar(_("No redo steps"), "gtk-dialog-warning");
 208     }
 209     update_undo_redo_button_sensitivity();
 210 }
 211
 212
 213 void
 214 do_accuracy(int value)     /* Set display accuracy. */
 215 {
 216     v->accuracy = value;
 217     set_int_resource(R_ACCURACY, v->accuracy);
 218     ui_set_accuracy(v->accuracy);
 219     ui_make_registers();
 220     clear_undo_history();
 221     syntaxdep_show_display();
 222 }
 223
 224
 225 void
 226 do_business()     /* Perform special business mode calculations. */
 227 {
 228     if (v->current == KEY_FINC_CTRM) {
 229         calc_ctrm(v->MPdisp_val);
 230     } else if (v->current == KEY_FINC_DDB) {
 231         calc_ddb(v->MPdisp_val);
 232     } else if (v->current == KEY_FINC_FV) {
 233         calc_fv(v->MPdisp_val);
 234     } else if (v->current == KEY_FINC_PMT) {
 235         calc_pmt(v->MPdisp_val);
 236     } else if (v->current == KEY_FINC_PV) {
 237         calc_pv(v->MPdisp_val);
 238     } else if (v->current == KEY_FINC_RATE) {
 239         calc_rate(v->MPdisp_val);
 240     } else if (v->current == KEY_FINC_SLN) {
 241         calc_sln(v->MPdisp_val);
 242     } else if (v->current == KEY_FINC_SYD) {
 243         calc_syd(v->MPdisp_val);
 244     } else if (v->current == KEY_FINC_TERM) {
 245         calc_term(v->MPdisp_val);
 246     }
 247     show_display(v->MPdisp_val);
 248 }
 249
 250
 251 void
 252 exp_append(char *text)
 253 {
 254     char *buf;
 255     int orig_len, dest_len;
 256     struct exprm_state *e;
 257
 258     if (!text) {
 259         return;
 260     }
 261
 262     e = get_state();
 263
 264     orig_len = (e->expression) ? strlen(e->expression) : 0;
 265     dest_len = orig_len + strlen(text) +1;
 266     buf = malloc(dest_len);
 267     assert(buf);
 268     if (e->expression) {
 269         if (snprintf(buf, dest_len, "%s%s", e->expression, text) < 0) {
 270             assert(0);
 271         }
 272     } else {
 273         STRCPY(buf, text);
 274     }
 275     free(e->expression);
 276     e->expression = buf;
 277 }
 278
 279
 280 void
 281 exp_del()
 282 {
 283     struct exprm_state *e = get_state();
 284     free(e->expression);
 285     e->expression = NULL;
 286 }
 287
 288
 289 int
 290 usable_num(int MPnum[MP_SIZE])
 291 {
 292     int ret = 0;
 293
 294     struct exprm_state *e = get_state();
 295
 296     if (e->expression) {
 297         ret = ce_parse(e->expression, MPnum);
 298     } else {
 299         do_zero(MPnum);
 300     }
 301
 302     return ret;
 303 }
 304
 305
 306 static void
 307 exp_del_char(char **expr, int amount)
 308 {
 309     char *e = NULL;
 310     int len;
 311
 312     assert(expr);
 313     assert(amount >= 0);
 314
 315     if (!*expr) {
 316         return;
 317     }
 318     len = strlen(*expr);
 319     len = len - amount;
 320     if (len >= 0) {
 321         e = malloc(len+1);
 322         assert(e);
 323         SNPRINTF(e, len+1, "%s", *expr);
 324     }
 325
 326     free(*expr);
 327     *expr = e;
 328 }
 329
 330
 331 void
 332 exp_replace(char *text)
 333 {
 334     struct exprm_state *e = get_state();
 335     free(e->expression);
 336     e->expression = NULL;
 337     exp_append(text);
 338 }
 339
 340
 341 static void
 342 exp_negate()
 343 {
 344     struct exprm_state *e = get_state();
 345
 346     if (e->expression) {
 347         /* Ending zero + parenthesis + minus */
 348         int len = strlen(e->expression) + 4;
 349         char *exp = malloc(len);
 350
 351         assert(exp);
 352         if (snprintf(exp, len, "-(%s)", e->expression) < 0) {
 353             assert(0);
 354         }
 355         free(e->expression);
 356         e->expression = exp;
 357     }
 358 }
 359
 360
 361 static void
 362 exp_inv()
 363 {
 364     struct exprm_state *e = get_state();
 365
 366     if (e->expression) {
 367         /* Ending zero + 1/ + parenthesis */
 368         int len = strlen(e->expression) + 5;
 369         char *exp = malloc(len);
 370
 371         assert(exp);
 372         if (snprintf(exp, len, "1/(%s)", e->expression) < 0) {
 373             assert(0);
 374         }
 375         free(e->expression);
 376         e->expression = exp;
 377     }
 378 }
 379
 380
 381 static int
 382 exp_has_postfix(char *str, char *postfix)
 383 {
 384     int len, plen;
 385
 386     if (!str) {
 387         return(0);
 388     }
 389
 390     assert(postfix);
 391
 392     len = strlen(str);
 393     plen = strlen(postfix);
 394
 395     if (plen > len) {
 396         return(0);
 397     }
 398
 399     if (!strcasecmp(str + len - plen, postfix)) {
 400         return(1);
 401     } else {
 402         return(0);
 403     }
 404 }
 405
 406
 407 void
 408 str_replace(char **str, char *from, char *to)
 409 {
 410     int i, flen, len;
 411
 412     assert(str);
 413     assert(from);
 414     assert(to);
 415
 416     if (!*str) {
 417         return;
 418     }
 419
 420     i = 0;
 421     len = strlen(*str);
 422     flen = strlen(from);
 423
 424     for (i = 0; len-i >= flen; i++) {
 425         if (!strncasecmp(from, *str+i, flen)) {
 426             char *print;
 427             int j = i+flen;
 428             char *prefix = malloc(i+1);
 429             char *postfix = malloc(len-j+1);
 430
 431             assert(prefix && postfix);
 432             memset(prefix, 0, i+1);
 433             memset(postfix, 0, len-j+1);
 434             MEMCPY(prefix, *str, i);
 435             MEMCPY(postfix, *str+i+flen, len-j);
 436
 437             print = malloc(strlen(to)+i+len-j+1);
 438             SPRINTF(print, "%s%s%s", prefix, to, postfix);
 439             free(prefix);
 440             free(postfix);
 441             free(*str);
 442             *str = print;
 443         }
 444     }
 445 }
 446
 447
 448 void
 449 do_expression()
 450 {
 451     int i;
 452     char buf[MAXLINE];
 453     struct exprm_state *e;
 454
 455     e = get_state();
 456
 457     ui_set_statusbar("", "");
 458
 459     if (e->expression != NULL && strlen(e->expression) > 0) {
 460         if (!strcmp(e->expression, "Ans")) {
 461             if (e->button.flags & NUMBER) {
 462                 exp_del();
 463             }
 464         }
 465     } else {
 466         if (e->button.flags & POSTFIXOP) {
 467             int MP1[MP_SIZE];
 468             char *zero = NULL;
 469             do_zero(MP1);
 470             zero = make_number(MP1, v->base, FALSE);
 471             exp_append(zero);
 472         }
 473     }
 474
 475     if ((e->button.flags & (PREFIXOP | FUNC))
 476         && e->expression
 477         && !strcmp(e->expression, "Ans")) {
 478             SNPRINTF(buf, MAXLINE, "%s(Ans)", e->button.symname);
 479             exp_replace(buf);
 480     } else {
 481         switch (e->button.id) {
 482         case KEY_CLEAR:
 483         case KEY_CLEAR_ENTRY:
 484             exp_del();
 485             ui_set_error_state(FALSE);
 486             MPstr_to_num("0", DEC, e->ans);
 487             break;
 488
 489         case KEY_SHIFT:
 490             do_shift(e->value);
 491             return;
 492
 493         case KEY_SET_ACCURACY:
 494             do_accuracy(e->value);
 495             return;
 496
 497         case KEY_FUNCTION:
 498             do_function(e->value);
 499             return;
 500
 501         case KEY_STORE:
 502             do_sto(e->value);
 503             return;
 504
 505         case KEY_EXCHANGE:
 506             do_exchange(e->value);
 507             return;
 508
 509         case KEY_RECALL:
 510             SNPRINTF(buf, MAXLINE, "R%d", e->value);
 511             exp_append(buf);
 512             break;
 513
 514         case KEY_CONSTANT:
 515             exp_append(make_number(v->MPcon_vals[e->value], v->base, FALSE));
 516             break;
 517
 518         case KEY_BACKSPACE:
 519             if (exp_has_postfix(e->expression, "Ans")) {
 520                 char *ans = make_number(e->ans, v->base, FALSE);
 521                 str_replace(&e->expression, "Ans", ans);
 522             } else {
 523                 for (i = 0; i < 10; i++) {
 524                     SNPRINTF(buf, MAXLINE, "R%d", i);
 525                     if (exp_has_postfix(e->expression, buf)) {
 526                         int MP_reg[MP_SIZE];
 527                         char *reg_val;
 528
 529                         do_rcl_reg(i, MP_reg);
 530                         reg_val = make_number(MP_reg, v->base, FALSE);
 531                         /* Remove "Rx" postfix. */
 532                         exp_del_char(&e->expression, 2);
 533                         exp_append(reg_val);
 534                     }
 535                 }
 536             }
 537             exp_del_char(&e->expression, 1);
 538             break;
 539
 540         case KEY_CHANGE_SIGN:
 541             exp_negate();
 542             break;
 543
 544         case KEY_RECIPROCAL:
 545             exp_inv();
 546             break;
 547
 548         case KEY_CALCULATE:
 549             if (e->expression) {
 550                 if (strcmp(e->expression, "Ans")) {
 551                     int MPval[MP_SIZE];
 552                     int ret = ce_parse(e->expression, MPval);
 553
 554                     if (!ret) {
 555                         mpstr(MPval, e->ans);
 556                         exp_replace("Ans");
 557                     } else {
 558                         char *message = NULL;
 559
 560                         switch (ret) {
 561                         case -PARSER_ERR_INVALID_BASE:
 562                             message = _("Invalid number for the current base");
 563                             break;
 564
 565                         case -PARSER_ERR_TOO_LONG_NUMBER:
 566                             message = _("Too long number");
 567                             break;
 568
 569                         case -PARSER_ERR_BITWISEOP:
 570                             message = _("Invalid bitwise operation parameter(s)");
 571                             break;
 572
 573                         case -PARSER_ERR_MODULUSOP:
 574                             message = _("Invalid modulus operation parameter(s)");
 575                             break;
 576
 577                         case -MPMATH_ERR:
 578                             message = _("Math operation error");
 579                             break;
 580
 581                         default:
 582                             message = _("Malformed expression");
 583                         }
 584                         ui_set_statusbar(message, "gtk-dialog-error");
 585                     }
 586                 } else {
 587                     perform_undo();
 588                     if (is_undo_step()) {
 589                         perform_undo();
 590                     }
 591                 }
 592             }
 593             break;
 594
 595         case KEY_NUMERIC_POINT:
 596             exp_append(ui_get_localized_numeric_point());
 597             break;
 598
 599         default:
 600             exp_append(e->button.symname);
 601             if (e->button.flags & FUNC) {
 602                 exp_append("(");
 603             }
 604             break;
 605         }
 606     }
 607
 608     refresh_display();
 609 }
 610
 611
 612 void
 613 do_calc()      /* Perform arithmetic calculation and display result. */
 614 {
 615     double dval, dres;
 616     int MP1[MP_SIZE], MP2[MP_SIZE];
 617
 618     if (v->current == KEY_CALCULATE &&
 619         v->old_cal_value == KEY_CALCULATE) {
 620         if (v->new_input) {
 621             mpstr(v->MPlast_input, v->MPresult);
 622         } else {
 623             mpstr(v->MPlast_input, v->MPdisp_val);
 624         }
 625     }
 626
 627     if (v->current != KEY_CALCULATE &&
 628         v->old_cal_value == KEY_CALCULATE) {
 629         v->cur_op = -1;
 630     }
 631
 632     switch (v->cur_op) {
 633         case KEY_SIN:
 634         case KEY_SINH:
 635         case KEY_ASIN:
 636         case KEY_ASINH:
 637         case KEY_COS:
 638         case KEY_COSH:
 639         case KEY_ACOS:
 640         case KEY_ACOSH:
 641         case KEY_TAN:
 642         case KEY_TANH:
 643         case KEY_ATAN:
 644         case KEY_ATANH:
 645         case -1:
 646             mpstr(v->MPdisp_val, v->MPresult);
 647             break;
 648
 649         case KEY_ADD:
 650             mpadd(v->MPresult, v->MPdisp_val, v->MPresult);
 651             break;
 652
 653         case KEY_SUBTRACT:
 654             mpsub(v->MPresult, v->MPdisp_val, v->MPresult);
 655             break;
 656
 657         case KEY_MULTIPLY:
 658             mpmul(v->MPresult, v->MPdisp_val, v->MPresult);
 659             break;
 660
 661         case KEY_DIVIDE:
 662             mpdiv(v->MPresult, v->MPdisp_val, v->MPresult);
 663             break;
 664
 665         case KEY_MODULUS_DIVIDE:
 666             mpcmim(v->MPresult, MP1);
 667             mpcmim(v->MPdisp_val, MP2);
 668             if (!mpeq(v->MPresult, MP1) || !mpeq(v->MPdisp_val, MP2)) {
 669                 doerr(_("Error, operands must be integers"));
 670             }
 671
 672             mpdiv(v->MPresult, v->MPdisp_val, MP1);
 673             mpcmim(MP1, MP1);
 674             mpmul(MP1, v->MPdisp_val, MP2);
 675             mpsub(v->MPresult, MP2, v->MPresult);
 676             break;
 677
 678         case KEY_X_POW_Y:
 679             calc_xpowy(v->MPresult, v->MPdisp_val, v->MPresult);
 680             break;
 681
 682         case KEY_AND:
 683             mpcmd(v->MPresult, &dres);
 684             mpcmd(v->MPdisp_val, &dval);
 685             dres = setbool(ibool(dres) & ibool(dval));
 686             mpcdm(&dres, v->MPresult);
 687             break;
 688
 689         case KEY_OR:
 690             mpcmd(v->MPresult, &dres);
 691             mpcmd(v->MPdisp_val, &dval);
 692             dres = setbool(ibool(dres) | ibool(dval));
 693             mpcdm(&dres, v->MPresult);
 694             break;
 695
 696         case KEY_XOR:
 697             mpcmd(v->MPresult, &dres);
 698             mpcmd(v->MPdisp_val, &dval);
 699             dres = setbool(ibool(dres) ^ ibool(dval));
 700             mpcdm(&dres, v->MPresult);
 701             break;
 702
 703         case KEY_XNOR:
 704             mpcmd(v->MPresult, &dres);
 705             mpcmd(v->MPdisp_val, &dval);
 706             dres = setbool(~ibool(dres) ^ ibool(dval));
 707             mpcdm(&dres, v->MPresult);
 708
 709         default:
 710             break;
 711     }
 712
 713     show_display(v->MPresult);
 714
 715     if (!(v->current == KEY_CALCULATE &&
 716         v->old_cal_value == KEY_CALCULATE)) {
 717         mpstr(v->MPdisp_val, v->MPlast_input);
 718     }
 719
 720     mpstr(v->MPresult, v->MPdisp_val);
 721     if (v->current != KEY_CALCULATE) {
 722         v->cur_op = v->current;
 723     }
 724     v->old_cal_value = v->current;
 725     v->new_input     = v->key_exp = 0;
 726 }
 727
 728
 729 void
 730 do_sin(void)
 731 {
 732     calc_trigfunc(sin_t, v->MPdisp_val, v->MPresult);
 733     show_display(v->MPresult);
 734     mpstr(v->MPresult, v->MPdisp_val);
 735 }
 736
 737
 738 void
 739 do_sinh(void)
 740 {
 741     calc_trigfunc(sinh_t, v->MPdisp_val, v->MPresult);
 742     show_display(v->MPresult);
 743     mpstr(v->MPresult, v->MPdisp_val);
 744 }
 745
 746
 747 void
 748 do_asin(void)
 749 {
 750     calc_trigfunc(asin_t, v->MPdisp_val, v->MPresult);
 751     show_display(v->MPresult);
 752     mpstr(v->MPresult, v->MPdisp_val);
 753 }
 754
 755
 756 void
 757 do_asinh(void)
 758 {
 759     calc_trigfunc(asinh_t, v->MPdisp_val, v->MPresult);
 760     show_display(v->MPresult);
 761     mpstr(v->MPresult, v->MPdisp_val);
 762 }
 763
 764
 765 void
 766 do_cos(void)
 767 {
 768     calc_trigfunc(cos_t, v->MPdisp_val, v->MPresult);
 769     show_display(v->MPresult);
 770     mpstr(v->MPresult, v->MPdisp_val);
 771 }
 772
 773
 774 void
 775 do_cosh(void)
 776 {
 777     calc_trigfunc(cosh_t, v->MPdisp_val, v->MPresult);
 778     show_display(v->MPresult);
 779     mpstr(v->MPresult, v->MPdisp_val);
 780 }
 781
 782
 783 void
 784 do_acos(void)
 785 {
 786     calc_trigfunc(acos_t, v->MPdisp_val, v->MPresult);
 787     show_display(v->MPresult);
 788     mpstr(v->MPresult, v->MPdisp_val);
 789 }
 790
 791
 792 void
 793 do_acosh(void)
 794 {
 795     calc_trigfunc(acosh_t, v->MPdisp_val, v->MPresult);
 796     show_display(v->MPresult);
 797     mpstr(v->MPresult, v->MPdisp_val);
 798 }
 799
 800
 801 void
 802 do_tan(void)
 803 {
 804     calc_trigfunc(tan_t, v->MPdisp_val, v->MPresult);
 805     show_display(v->MPresult);
 806     mpstr(v->MPresult, v->MPdisp_val);
 807 }
 808
 809
 810 void
 811 do_tanh(void)
 812 {
 813     calc_trigfunc(tanh_t, v->MPdisp_val, v->MPresult);
 814     show_display(v->MPresult);
 815     mpstr(v->MPresult, v->MPdisp_val);
 816 }
 817
 818
 819 void
 820 do_atan(void)
 821 {
 822     calc_trigfunc(atan_t, v->MPdisp_val, v->MPresult);
 823     show_display(v->MPresult);
 824     mpstr(v->MPresult, v->MPdisp_val);
 825 }
 826
 827
 828 void
 829 do_atanh(void)
 830 {
 831     calc_trigfunc(atanh_t, v->MPdisp_val, v->MPresult);
 832     show_display(v->MPresult);
 833     mpstr(v->MPresult, v->MPdisp_val);
 834 }
 835
 836
 837 void
 838 do_percent(void)
 839 {
 840     calc_percent(v->MPdisp_val, v->MPresult);
 841     show_display(v->MPresult);
 842     mpstr(v->MPresult, v->MPdisp_val);
 843 }
 844
 845
 846 void
 847 do_clear()       /* Clear the calculator display and re-initialise. */
 848 {
 849     clear_display(TRUE);
 850     if (v->error) {
 851         ui_set_display("");
 852     }
 853     initialise();
 854 }
 855
 856
 857 void
 858 do_clear_entry()     /* Clear the calculator display. */
 859 {
 860     clear_display(FALSE);
 861 }
 862
 863 void
 864 do_base(enum base_type b)    /* Change the current base setting. */
 865 {
 866     struct exprm_state *e;
 867     int ret, MP[MP_SIZE];
 868
 869     switch (v->syntax) {
 870         case NPA:
 871             v->base = b;
 872             set_resource(R_BASE, Rbstr[(int) v->base]);
 873             ui_set_base(v->base);
 874             ui_make_registers();
 875                 break;
 876
 877         case EXPRS:
 878             e = get_state();
 879             ret = usable_num(MP);
 880
 881             if (ret) {
 882                 ui_set_statusbar(_("No sane value to convert"),
 883                                  "gtk-dialog-error");
 884             } else if (!v->ghost_zero) {
 885                 mpstr(MP, e->ans);
 886                 exp_replace("Ans");
 887             }
 888             v->base = b;
 889             set_resource(R_BASE, Rbstr[(int) v->base]);
 890             ui_set_base(v->base);
 891             ui_make_registers();
 892             clear_undo_history();
 893             break;
 894
 895         default:
 896             assert(0);
 897     }
 898
 899     refresh_display();
 900 }
 901
 902
 903 void
 904 do_constant(int index)
 905 {
 906     int *MPval;
 907     struct exprm_state *e;
 908
 909     assert(index >= 0);
 910     assert(index <= 9);
 911
 912     switch (v->syntax) {
 913         case NPA:
 914             MPval = v->MPcon_vals[index];
 915             mpstr(MPval, v->MPdisp_val);
 916             break;
 917
 918         case EXPRS:
 919                 e = get_state();
 920             do_expression();
 921             break;
 922
 923         default:
 924             assert(0);
 925     }
 926
 927     v->new_input = 1;
 928     syntaxdep_show_display();
 929 }
 930
 931
 932 void
 933 do_delete()     /* Remove the last numeric character typed. */
 934 {
 935     size_t len;
 936
 937     len = strlen(v->display);
 938     if (len > 0) {
 939         v->display[len-1] = '\0';
 940     }
 941
 942 /*  If we were entering a scientific number, and we have backspaced over
 943  *  the exponent sign, then this reverts to entering a fixed point number.
 944  */
 945
 946     if (v->key_exp && !(strchr(v->display, '+'))) {
 947         v->key_exp = 0;
 948         v->display[strlen(v->display)-1] = '\0';
 949     }
 950
 951 /* If we've backspaced over the numeric point, clear the pointed flag. */
 952
 953     if (v->pointed && !(strchr(v->display, '.'))) {
 954         v->pointed = 0;
 955     }
 956
 957     ui_set_display(v->display);
 958     MPstr_to_num(v->display, v->base, v->MPdisp_val);
 959
 960     if (v->dtype == FIX) {
 961         STRCPY(v->fnum, v->display);
 962         ui_set_display(v->fnum);
 963     }
 964 }
 965
 966
 967 void
 968 do_exchange(int index)         /* Exchange display with memory register. */
 969 {
 970     int MPtemp[MP_SIZE];
 971     int MPexpr[MP_SIZE];
 972     struct exprm_state *e;
 973     int ret;
 974     int n;
 975
 976     switch (v->syntax) {
 977         case NPA:
 978             mpstr(v->MPdisp_val, MPtemp);
 979             mpstr(v->MPmvals[index], v->MPdisp_val);
 980             mpstr(MPtemp, v->MPmvals[index]);
 981             ui_make_registers();
 982             break;
 983
 984         case EXPRS:
 985             e = get_state();
 986             ret = usable_num(MPexpr);
 987             n = e->value;
 988
 989             if (ret) {
 990                 ui_set_statusbar(_("No sane value to store"),
 991                                  "gtk-dialog-error");
 992             } else {
 993                 mpstr(v->MPmvals[n], MPtemp);
 994                 mpstr(MPexpr, v->MPmvals[n]);
 995                 mpstr(MPtemp, e->ans);
 996                 exp_replace("Ans");
 997                 refresh_display();
 998                 ui_make_registers();
 999             }
1000             break;
1001
1002         default:
1003             assert(0);
1004     }
1005
1006     v->new_input = 1;
1007     syntaxdep_show_display();
1008
1009 }
1010
1011
1012 void
1013 do_expno()           /* Get exponential number. */
1014 {
1015     v->pointed = (strchr(v->display, '.') != NULL);
1016     if (!v->new_input) {
1017         STRCPY(v->display, "1.0 +");
1018         v->new_input = v->pointed = 1;
1019     } else if (!v->pointed) {
1020         STRNCAT(v->display, ". +", 3);
1021         v->pointed = 1;
1022     } else if (!v->key_exp) {
1023         STRNCAT(v->display, " +", 2);
1024     }
1025     v->toclear = 0;
1026     v->key_exp = 1;
1027     v->exp_posn = strchr(v->display, '+');
1028     ui_set_display(v->display);
1029     MPstr_to_num(v->display, v->base, v->MPdisp_val);
1030 }
1031
1032
1033 /* Calculate the factorial of MPval. */
1034
1035 void
1036 do_factorial(int *MPval, int *MPres)
1037 {
1038     double val;
1039     int i, MPa[MP_SIZE], MP1[MP_SIZE], MP2[MP_SIZE];
1040
1041 /*  NOTE: do_factorial, on each iteration of the loop, will attempt to
1042  *        convert the current result to a double. If v->error is set,
1043  *        then we've overflowed. This is to provide the same look&feel
1044  *        as V3.
1045  *
1046  *  XXX:  Needs to be improved. Shouldn't need to convert to a double in
1047  *        order to check this.
1048  */
1049
1050     mpstr(MPval, MPa);
1051     mpcmim(MPval, MP1);
1052     i = 0;
1053     mpcim(&i, MP2);
1054     if (mpeq(MPval, MP1) && mpge(MPval, MP2)) {   /* Only positive integers. */
1055         i = 1;
1056         if (mpeq(MP1, MP2)) {                     /* Special case for 0! */
1057             mpcim(&i, MPres);
1058             return;
1059         }
1060         mpcim(&i, MPa);
1061         mpcmi(MP1, &i);
1062         if (!i) {
1063             matherr((struct exception *) NULL);
1064         } else {
1065             while (i > 0) {
1066                 mpmuli(MPa, &i, MPa);
1067                 mpcmd(MPa, &val);
1068                 if (v->error) {
1069                     mperr();
1070                     return;
1071                 }
1072                 i--;
1073             }
1074         }
1075     } else {
1076         matherr((struct exception *) NULL);
1077     }
1078     mpstr(MPa, MPres);
1079 }
1080
1081
1082 void
1083 do_function(int index)      /* Perform a user defined function. */
1084 {
1085     char *str;
1086     int ret;
1087
1088     assert(index >= 0);
1089     assert(index <= 9);
1090
1091     switch (v->syntax) {
1092         case NPA:
1093             str = v->fun_vals[index];
1094             assert(str);
1095             ret = lr_udf_parse(str);
1096             break;
1097
1098         case EXPRS:
1099             str = v->fun_vals[index];
1100             assert(str);
1101             ret = ce_udf_parse(str);
1102             break;
1103
1104         default:
1105             assert(0);
1106     }
1107
1108     if (!ret) {
1109         ui_set_statusbar("", "");
1110     } else {
1111         ui_set_statusbar(_("Malformed function"), "gtk-dialog-error");
1112     }
1113     v->new_input = 1;
1114 }
1115
1116
1117 static void
1118 do_immedfunc(int s[MP_SIZE], int t[MP_SIZE])
1119 {
1120     int MP1[MP_SIZE];
1121
1122     if (v->current == KEY_MASK_32) {                     /* &32 */
1123         calc_u32(s, t);
1124     } else if (v->current == KEY_MASK_16) {              /* &16 */
1125         calc_u16(s, t);
1126     } else if (v->current == KEY_E_POW_X) {              /* e^x  */
1127         mpstr(s, MP1);
1128         mpexp(MP1, t);
1129     } else if (v->current == KEY_10_POW_X) {             /* 10^x */
1130         calc_tenpowx(s, t);
1131     } else if (v->current == KEY_NATURAL_LOGARITHM) {    /* Ln */
1132         mpstr(s, MP1);
1133         mpln(MP1, t);
1134     } else if (v->current == KEY_LOGARITHM) {            /* Log */
1135         mplog10(s, t);
1136     } else if (v->current == KEY_RANDOM) {               /* Rand */
1137         calc_rand(t);
1138     } else if (v->current == KEY_SQUARE_ROOT) {          /* Sqrt */
1139         mpstr(s, MP1);
1140         mpsqrt(MP1, t);
1141     } else if (v->current == KEY_NOT) {                  /* NOT */
1142         calc_not(t, s);
1143     } else if (v->current == KEY_RECIPROCAL) {           /* 1/x */
1144         calc_inv(s, t);
1145     } else if (v->current == KEY_FACTORIAL) {            /* x! */
1146         do_factorial(s, MP1);
1147         mpstr(MP1, t);
1148     } else if (v->current == KEY_SQUARE) {               /* x^2 */
1149         mpstr(s, MP1);
1150         mpmul(MP1, MP1, t);
1151     } else if (v->current == KEY_CHANGE_SIGN) {          /* +/- */
1152          if (v->key_exp) {
1153              if (*v->exp_posn == '+') {
1154                  *v->exp_posn = '-';
1155              } else {
1156                  *v->exp_posn = '+';
1157              }
1158              ui_set_display(v->display);
1159              MPstr_to_num(v->display, v->base, s);
1160              v->key_exp = 0;
1161          } else {
1162              mpneg(s, t);
1163         }
1164     }
1165 }
1166
1167
1168 void
1169 do_immed()
1170 {
1171     do_immedfunc(v->MPdisp_val, v->MPdisp_val);
1172     show_display(v->MPdisp_val);
1173 }
1174
1175
1176 void
1177 do_mode(int toclear)           /* Set special calculator mode. */
1178 {
1179     set_resource(R_MODE, Rmstr[(int) v->modetype]);
1180     ui_set_mode(v->modetype);
1181     if (toclear) {
1182         do_clear();
1183     }
1184 }
1185
1186
1187 void
1188 do_number()
1189 {
1190     int offset;
1191
1192     if (v->toclear) {
1193         offset = 0;
1194         v->toclear = 0;
1195     } else {
1196         offset = strlen(v->display);
1197     }
1198     if (offset < MAXLINE) {
1199         SNPRINTF(v->display+offset, MAXLINE-offset, "%s", buttons[v->current].symname);
1200     }
1201
1202     ui_set_display(v->display);
1203     MPstr_to_num(v->display, v->base, v->MPdisp_val);
1204     v->new_input = 1;
1205 }
1206
1207
1208 void
1209 do_numtype(enum num_type n)   /* Set number display type. */
1210 {
1211     struct exprm_state *e;
1212     int ret, MP[MP_SIZE];
1213
1214     v->dtype = n;
1215     set_resource(R_DISPLAY, Rdstr[(int) v->dtype]);
1216
1217     switch (v->syntax) {
1218         case NPA:
1219             ui_make_registers();
1220             break;
1221
1222         case EXPRS:
1223             e = get_state();
1224             ret = usable_num(MP);
1225             if (ret) {
1226                 ui_set_statusbar(_("No sane value to convert"),
1227                                  "gtk-dialog-error");
1228             } else if (!v->ghost_zero) {
1229                 mpstr(MP, e->ans);
1230                 exp_replace("Ans");
1231                 ui_make_registers();
1232             }
1233             clear_undo_history();
1234             break;
1235
1236     default:
1237         assert(0);
1238     }
1239
1240     refresh_display();
1241 }
1242
1243
1244 void
1245 do_paren()
1246 {
1247     ui_set_statusbar("", "");
1248
1249     switch (v->current) {
1250         case KEY_START_BLOCK:
1251             if (v->noparens == 0) {
1252                 if (v->cur_op == -1) {
1253                     v->display[0] = 0;
1254                     ui_set_statusbar(_("Cleared display, prefix without an operator is not allowed"), "");
1255                 } else {
1256                     paren_disp(v->cur_op);
1257                 }
1258             }
1259             v->noparens++;
1260             break;
1261
1262         case KEY_END_BLOCK:
1263             v->noparens--;
1264             if (!v->noparens) {
1265                 int ret, i = 0;
1266                 while (v->display[i++] != '(') {
1267                     /* do nothing */;
1268                 }
1269
1270                 ret = lr_parse(&v->display[i], v->MPdisp_val);
1271                 if (!ret) {
1272                     show_display(v->MPdisp_val);
1273                     return;
1274                 } else {
1275                     ui_set_statusbar(_("Malformed parenthesis expression"),
1276                                      "gtk-dialog-error");
1277                 }
1278             }
1279             break;
1280
1281         default:
1282             /* Queue event */
1283             break;
1284     }
1285     paren_disp(v->current);
1286 }
1287
1288
1289 void
1290 do_sto(int index)
1291 {
1292     int ret;
1293
1294     switch (v->syntax) {
1295         case NPA:
1296             mpstr(v->MPdisp_val, v->MPmvals[index]);
1297             break;
1298
1299         case EXPRS:
1300             ret = usable_num(v->MPmvals[index]);
1301             if (ret) {
1302                 ui_set_statusbar(_("No sane value to store"),
1303                                  "gtk-dialog-error");
1304             }
1305             break;
1306
1307         default:
1308             assert(0);
1309     }
1310
1311     ui_make_registers();
1312 }
1313
1314
1315 /* Return: 0 = success, otherwise failed.
1316  *
1317  * TODO: remove hardcoding from reg ranges.
1318  */
1319
1320 int
1321 do_sto_reg(int reg, int value[MP_SIZE])
1322 {
1323     if ((reg >= 0) && (reg <= 10)) {
1324         mpstr(value, v->MPmvals[reg]);
1325         return(0);
1326     } else {
1327         return(-EINVAL);
1328     }
1329 }
1330
1331
1332 void
1333 do_rcl(int index)
1334 {
1335     switch (v->syntax) {
1336         case NPA:
1337             mpstr(v->MPmvals[index], v->MPdisp_val);
1338             break;
1339
1340         case EXPRS:
1341             do_expression();
1342             break;
1343
1344         default:
1345             assert(0);
1346     }
1347
1348     v->new_input = 1;
1349     syntaxdep_show_display();
1350 }
1351
1352
1353 /* Return: 0 = success, otherwise failed.
1354  *
1355  * TODO: remove hardcoding from reg ranges.
1356  */
1357
1358 int
1359 do_rcl_reg(int reg, int value[MP_SIZE])
1360 {
1361     if ((reg >= 0) && (reg <= 10)) {
1362         mpstr(v->MPmvals[reg], value);
1363         return(0);
1364     } else {
1365         return(-EINVAL);
1366     }
1367 }
1368
1369
1370 void
1371 syntaxdep_show_display()
1372 {
1373     switch (v->syntax) {
1374         case NPA:
1375             show_display(v->MPdisp_val);
1376             break;
1377
1378         case EXPRS:
1379             refresh_display();
1380             break;
1381
1382         default:
1383             assert(0);
1384     }
1385 }
1386
1387
1388 void
1389 do_point()                   /* Handle numeric point. */
1390 {
1391     if (!v->pointed) {
1392         if (v->toclear) {
1393             STRCPY(v->display, ".");
1394             v->toclear = 0;
1395         } else {
1396             STRCAT(v->display, ".");
1397         }
1398         v->pointed = 1;
1399     }
1400     ui_set_display(v->display);
1401     MPstr_to_num(v->display, v->base, v->MPdisp_val);
1402 }
1403
1404
1405 static void
1406 do_portionfunc(int num[MP_SIZE])
1407 {
1408     int MP1[MP_SIZE];
1409
1410     if (v->current == KEY_ABSOLUTE_VALUE) {                 /* Abs */
1411         mpstr(num, MP1);
1412         mpabs(MP1, num);
1413
1414     } else if (v->current == KEY_FRACTION) {               /* Frac */
1415         mpstr(num, MP1);
1416         mpcmf(MP1, num);
1417
1418     } else if (v->current == KEY_INTEGER) {                /* Int */
1419         mpstr(num, MP1);
1420         mpcmim(MP1, num);
1421     }
1422 }
1423
1424
1425 void
1426 do_portion()
1427 {
1428     do_portionfunc(v->MPdisp_val);
1429     show_display(v->MPdisp_val);
1430 }
1431
1432
1433 void
1434 do_shift(int count)     /* Perform bitwise shift on display value. */
1435 {
1436     int n, ret;
1437     BOOLEAN temp;
1438     double dval;
1439     struct exprm_state *e;
1440     int MPtemp[MP_SIZE], MPval[MP_SIZE];
1441
1442     switch (v->syntax) {
1443         case NPA:
1444             MPstr_to_num(v->display, v->base, MPtemp);
1445             mpcmd(MPtemp, &dval);
1446             temp = ibool(dval);
1447
1448             if (count < 0) {
1449                 temp = temp >> -count;
1450             } else {
1451                 temp = temp << count;
1452             }
1453
1454             dval = setbool(temp);
1455             mpcdm(&dval, v->MPdisp_val);
1456             show_display(v->MPdisp_val);
1457             mpstr(v->MPdisp_val, v->MPlast_input);
1458             break;
1459
1460         case EXPRS:
1461             e = get_state();
1462             n = e->value;
1463             ret = usable_num(MPval);
1464             if (ret || !is_integer(MPval)) {
1465                 ui_set_statusbar(_("No sane value to do bitwise shift"),
1466                                  "gtk-dialog-error");
1467                 break;
1468             }
1469
1470             calc_shift(MPval, e->ans, n);
1471
1472             exp_replace("Ans");
1473             break;
1474
1475         default:
1476             assert(0);
1477     }
1478
1479     v->new_input = 1;
1480     syntaxdep_show_display();
1481 }
1482
1483
1484 void
1485 do_trigtype(enum trig_type t)    /* Change the current trigonometric type. */
1486 {
1487     v->ttype = t;
1488     set_resource(R_TRIG, Rtstr[(int) v->ttype]);
1489     switch (v->cur_op) {
1490         case KEY_SIN:
1491         case KEY_SINH:
1492         case KEY_ASIN:
1493         case KEY_ASINH:
1494         case KEY_COS:
1495         case KEY_COSH:
1496         case KEY_ACOS:
1497         case KEY_ACOSH:
1498         case KEY_TAN:
1499         case KEY_TANH:
1500         case KEY_ATAN:
1501         case KEY_ATANH:
1502             mpstr(v->MPtresults[(int) v->ttype], v->MPdisp_val);
1503             show_display(v->MPtresults[(int) v->ttype]);
1504             break;
1505
1506         default:
1507             break;
1508     }
1509 }
1510
1511 void
1512 show_error(char *message)
1513 {
1514     ui_set_statusbar(message, "gtk-dialog-error");
1515 }