c_cpp/etc/calc/calc.c

   1 /*
   2  * calc - arbitrary precision calculator
   3  *
   4  * Copyright (C) 1999-2013  David I. Bell, Landon Curt Noll and Ernest Bowen
   5  *
   6  * Primary author:  David I. Bell
   7  *
   8  * Calc is open software; you can redistribute it and/or modify it under
   9  * the terms of the version 2.1 of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation.
  11  *
  12  * Calc is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
  15  * Public License for more details.
  16  *
  17  * A copy of version 2.1 of the GNU Lesser General Public License is
  18  * distributed with calc under the filename COPYING-LGPL.  You should have
  19  * received a copy with calc; if not, write to Free Software Foundation, Inc.
  20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21  *
  22  * @(#) $Revision: 30.6 $
  23  * @(#) $Id: calc.c,v 30.6 2013/03/25 21:39:57 chongo Exp $
  24  * @(#) $Source: /usr/local/src/bin/calc/RCS/calc.c,v $
  25  *
  26  * Under source code control:   1990/02/15 01:48:11
  27  * File existed as early as:    before 1990
  28  *
  29  * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  30  */
  31
  32
  33 #include <stdio.h>
  34 #include <signal.h>
  35
  36 #if !defined (_WIN32)
  37 # include <pwd.h>
  38 #endif
  39
  40 #include <sys/types.h>
  41 #include <ctype.h>
  42
  43 #if defined(_WIN32)
  44 # include <io.h>
  45 # if !defined(NOTCYGWIN)
  46 /*
  47  * getopt.h file is from the Cygwin GNU library
  48  *
  49  * See:
  50  *      http://sources.redhat.com/cygwin/
  51  */
  52 # include "../getopt/getopt.h"
  53 # endif
  54 # define strdup _strdup
  55 # define isatty _isatty
  56 #endif /* Windoz */
  57
  58 #define CALC_C
  59 #include "calc.h"
  60 #include "hist.h"
  61 #include "func.h"
  62 #include "opcodes.h"
  63 #include "conf.h"
  64 #include "token.h"
  65 #include "symbol.h"
  66 #include "have_uid_t.h"
  67 #include "have_const.h"
  68 #include "custom.h"
  69 #include "lib_calc.h"
  70 #include "args.h"
  71 #include "zmath.h"
  72
  73 #include "have_unistd.h"
  74 #if defined(HAVE_UNISTD_H)
  75 #include <unistd.h>
  76 #endif
  77
  78 #include "have_stdlib.h"
  79 #if defined(HAVE_STDLIB_H)
  80 #include <stdlib.h>
  81 #endif
  82
  83 #include "have_strdup.h"
  84 #if !defined(HAVE_STRDUP)
  85 # define strdup(x) calc_strdup((CONST char *)(x))
  86 #endif /* HAVE_STRDUP */
  87
  88 #include "have_unused.h"
  89
  90
  91 /*
  92  * S_FUNC definitions and functions
  93  */
  94 S_FUNC void intint(int arg);    /* interrupt routine */
  95 S_FUNC void calc_interrupt(char *fmt, ...);
  96 S_FUNC int nextcp(char **cpp, int *ip, int argc, char **argv, BOOL haveendstr);
  97 S_FUNC void set_run_state(run state);
  98
  99 /*
 100  * Top level calculator routine.
 101  */
 102 int
 103 main(int argc, char **argv)
 104 {
 105         int want_defhelp = 0;   /* 1=> we only want the default help */
 106         int cmdlen;             /* length of the command string */
 107         int newcmdlen;
 108         int c;                  /* option */
 109         int index;
 110         int maxindex;
 111         char *cp;
 112         char *endcp;
 113         char *bp;
 114         BOOL done = FALSE;
 115         BOOL havearg;
 116         BOOL haveendstr;
 117         size_t len;
 118
 119         /*
 120          * parse args
 121          */
 122         program = argv[0];
 123
 124         cmdbuf[0] = '\0';
 125         cmdlen = 0;
 126
 127         /* process command line options */
 128
 129         index = 1;
 130         cp = endcp = NULL;
 131         maxindex = argc;
 132         havecommands = FALSE;
 133         while (index < maxindex && !done) {
 134                 cp = argv[index];
 135                 if (*cp == '\0') {
 136                         index++;
 137                         continue;
 138                 }
 139                 for (;;) {
 140                         havearg = FALSE;
 141                         if (*cp != '-') {
 142                                 done = TRUE;
 143                                 break;
 144                         }
 145                         ++cp;
 146                         if (*cp == '-') {
 147                                 cp++;
 148                                 while (*cp == ' ')
 149                                         ++cp;
 150                                 done = TRUE;
 151                                 break;
 152                         }
 153
 154                         for (;;) {
 155                                 c = *cp;
 156                                 if (c == '\0' || c == ' ')
 157                                         break;
 158                                 switch (c) {
 159                                 case 'C':
 160 #if defined(CUSTOM)
 161                                         allow_custom = TRUE;
 162                                         break;
 163 #else /* CUSTOM */
 164                                         /*
 165                                          * we are too early in processing to
 166                                          * call libcalc_call_me_last() -
 167                                          * nothing to cleanup
 168                                          */
 169                                         fprintf(stderr,
 170                                             "%s: calc was built with custom"
 171                                             " functions disabled, -C usage is"
 172                                             " disallowed\n", program);
 173                                         exit(1);
 174 #endif /* CUSTOM */
 175                                 case 'e':
 176                                         no_env = TRUE;
 177                                         break;
 178                                 case 'h':
 179                                         want_defhelp = 1;
 180                                         break;
 181                                 case 'i':
 182                                         i_flag = TRUE;
 183                                         break;
 184                                 case 'm':
 185                                         cp++;
 186                                         while (*cp == ' ' || *cp == '\t')
 187                                                 cp++;
 188                                         if (*cp == '\0') {
 189                                                 index++;
 190                                                 if (index >= argc) {
 191                                                         fprintf(stderr,
 192                                                                 "-m expects"
 193                                                                 " argument");
 194                                                         exit(2);
 195                                                 }
 196                                                 cp = argv[index];
 197                                         }
 198
 199                                         if (*cp < '0' || *cp > '7') {
 200                                                 /*
 201                                                  * we are too early in
 202                                                  * processing to call
 203                                                  * libcalc_call_me_last()
 204                                                  * nothing to cleanup
 205                                                  */
 206                                                 fprintf(stderr,
 207                                                         "%s: unknown -m arg\n",
 208                                                         program);
 209                                                 exit(3);
 210                                         }
 211                                         allow_read = (((*cp-'0') & 04) > 0);
 212                                         allow_write = (((*cp-'0') & 02) > 0);
 213                                         allow_exec = (((*cp-'0') & 01) > 0);
 214                                         cp++;
 215                                         if (*cp != ' ' && *cp != '\0') {
 216                                                 fprintf(stderr, "??? m-arg");
 217                                                 exit(4);
 218                                         }
 219                                         havearg = TRUE;
 220                                         break;
 221                                 case 'n':
 222                                         /*
 223                                          * -n is deprecated and may be reused
 224                                          * for another purpose in the future
 225                                          */
 226                                         break;
 227                                 case 'O':
 228                                         use_old_std = TRUE;
 229                                         break;
 230                                 case 'p':
 231                                         p_flag = TRUE;
 232                                         break;
 233                                 case 'q':
 234                                         q_flag = TRUE;
 235                                         break;
 236                                 case 'u':
 237                                         u_flag = TRUE;
 238                                         break;
 239                                 case 'c':
 240                                         c_flag = TRUE;
 241                                         break;
 242                                 case 'd':
 243                                         d_flag = TRUE;
 244                                         break;
 245                                 case 'v':
 246                                         /*
 247                                          * we are too early in processing to
 248                                          * call libcalc_call_me_last() -
 249                                          * nothing to cleanup
 250                                          */
 251                                         fputs(CALC_TITLE, stdout);
 252 #if defined(CUSTOM)
 253                                         fputs(" w/custom functions", stdout);
 254 #else
 255                                         fputs(" w/o custom functions", stdout);
 256 #endif /* CUSTOM */
 257                                         printf(" (version %s)\n", version());
 258                                         exit(0);
 259                                 case 'D':
 260                                         /*
 261                                          * parse the -D arg
 262                                          *
 263                                          * Could be:
 264                                          *
 265                                          * calc_debug
 266                                          * calc_debug:resource_debug
 267                                          * calc_debug:resource_debug:user_debug
 268                                          */
 269                                         if (nextcp(&cp, &index, argc, argv,
 270                                                    FALSE)) {
 271                                             fprintf(stderr,
 272                                                     "-D expects argument\n");
 273                                             exit(5);
 274                                         }
 275                                         havearg = TRUE;
 276                                         if (*cp != ':') {
 277                                                 if (*cp < '0' || *cp > '9') {
 278                                                     fprintf(stderr,
 279                                                             "-D expects"
 280                                                             " integer\n");
 281                                                     exit(6);
 282                                                 }
 283                                                 calc_debug = cp;
 284                                                 (void) strtol(cp, &endcp, 10);
 285                                                 cp = endcp;
 286                                                 if (*cp != '\0' &&
 287                                                     *cp != ' ' && *cp != ':') {
 288                                                     fprintf(stderr,
 289                                                             "Bad syntax im -D"
 290                                                             " arg\n");
 291                                                     exit(7);
 292                                                 }
 293                                                 if (*cp != ':') {
 294                                                     if (nextcp(&cp, &index,
 295                                                                argc, argv,
 296                                                                FALSE)
 297                                                                 || *cp != ':')
 298                                                         break;
 299                                                 }
 300                                         }
 301                                         if (nextcp(&cp, &index, argc, argv,
 302                                                    FALSE)) {
 303                                                 fprintf(stderr,
 304                                                         "-D : expects"
 305                                                         " argument\n");
 306                                                 exit(8);
 307                                         }
 308                                         if (*cp != ':') {
 309                                                 if (*cp < '0' || *cp > '9') {
 310                                                     fprintf(stderr,
 311                                                             "-D : expects"
 312                                                             " integer\n");
 313                                                     exit(9);
 314                                                 }
 315                                                 resource_debug = cp;
 316                                                 (void) strtol(cp, &endcp, 10);
 317                                                 cp = endcp;
 318                                                 if (*cp != '\0' &&
 319                                                     *cp != ' ' && *cp != ':') {
 320                                                     fprintf(stderr,
 321                                                             "Bad syntax im -D"
 322                                                             " : arg\n");
 323                                                     exit(10);
 324                                                 }
 325                                                 if (*cp != ':') {
 326                                                         if (nextcp(&cp, &index,
 327                                                                    argc, argv,
 328                                                                    FALSE)
 329                                                             || *cp != ':') {
 330                                                                 break;
 331                                                         }
 332                                                 }
 333                                         }
 334                                         if (nextcp(&cp, &index, argc, argv,
 335                                                    FALSE)) {
 336                                             fprintf(stderr, "-D : : expects"
 337                                                     " argument\n");
 338                                             exit(11);
 339                                         }
 340                                         if (*cp < '0' || *cp > '9') {
 341                                             fprintf(stderr, "-D :: expects"
 342                                                     " integer\n");
 343                                             exit(12);
 344                                         }
 345                                         user_debug = cp;
 346                                         (void) strtol(cp, &endcp, 10);
 347                                         cp = endcp;
 348                                         if (*cp != '\0' && *cp != ' ') {
 349                                                 fprintf(stderr, "Bad syntax in"
 350                                                         " -D : : arg\n");
 351                                                 exit(13);
 352                                         }
 353                                         break;
 354                                 case 'f':
 355                                         haveendstr = (cp[1] == '\0');
 356                                         if (nextcp(&cp, &index, argc, argv,
 357                                                    haveendstr)) {
 358                                             fprintf(stderr, "-f expects"
 359                                                     " filename\n");
 360                                             exit(14);
 361                                         }
 362                                         if (*cp == ';') {
 363                                                 fprintf(stderr,
 364                                                         "-f expects"
 365                                                         " filename\n");
 366                                                 exit(15);
 367                                         }
 368                                         havearg = TRUE;
 369                                         if (cmdlen > 0)
 370                                                 cmdbuf[cmdlen++] = ' ';
 371                                         strcpy(cmdbuf + cmdlen, "read ");
 372                                         cmdlen += 5;
 373                                         if (strncmp(cp, "-once", 5) == 0 &&
 374                                             (cp[5] == '\0' || cp[5] == ' ')) {
 375                                                 cp += 5;
 376                                                 haveendstr = (*cp == '\0');
 377                                                 strcpy(cmdbuf+cmdlen, "-once ");
 378                                                 cmdlen += 6;
 379                                                 if (nextcp(&cp, &index, argc,
 380                                                            argv, haveendstr)) {
 381                                                     fprintf(stderr, "-f -once"
 382                                                             " expects"
 383                                                             " filename\n");
 384                                                     exit(16);
 385                                                 }
 386                                         }
 387                                         bp = cmdbuf + cmdlen;
 388                                         if (haveendstr) {
 389                                                 len = strlen(cp);
 390                                                 if (len == 0) {
 391                                                         fprintf(stderr,
 392                                                                 "Null"
 393                                                                 " filename!");
 394                                                         exit(17);
 395                                                 }
 396                                                 if (cmdlen + len + 2 > MAXCMD) {
 397                                                         fprintf(stderr,
 398                                                                 "Commands too"
 399                                                                 " long");
 400                                                         exit(18);
 401                                                 }
 402                                                 /* XXX What if *cp = '\''? */
 403                                                 *bp++ = '\'';
 404                                                 strncpy(bp, cp, len+1);
 405                                                 bp += len;
 406                                                 *bp++ = '\'';
 407                                                 cp += len;
 408                                                 cmdlen += len + 2;
 409                                         } else {
 410                                                 do {
 411                                                         if (cmdlen > MAXCMD) {
 412                                                                 fprintf(stderr,
 413                                                                    "Commands"
 414                                                                    " too long");
 415                                                                 exit(19);
 416                                                         }
 417                                                         *bp++ =  *cp++;
 418                                                         cmdlen++;
 419                                                 } while (*cp != '\0' &&
 420                                                          *cp != ';' &&
 421                                                          *cp != ' ');
 422                                         }
 423                                         if (*cp == ';')
 424                                                 cp++;
 425                                         *bp++ = ';';
 426                                         cmdlen++;
 427                                         s_flag = TRUE;  /* -f implies -s */
 428                                         break;
 429
 430                                 case 's':
 431                                         s_flag = TRUE;
 432                                         maxindex = index + 1;
 433                                         break;
 434                                 default:
 435                                         /*
 436                                          * we are too early in processing to
 437                                          * call libcalc_call_me_last() -
 438                                          * nothing to cleanup
 439                                          */
 440                                         fprintf(stderr, "Illegal option -%c\n",
 441                                                         c);
 442                                         fprintf(stderr,
 443                 "usage: %s [-c] [-C] [-d] [-e] [-h] [-i] [-m mode]\n"
 444                 "\t[-D calc_debug[:resource_debug[:user_debug]]]\n"
 445                 "\t[-O] [-p] [-q] [-s] [-u] [-v] "
 446                 "[--] [calc_cmd ...]\n"
 447                 "usage: %s ... -f filename\n"
 448                 "1st cscript line: #/path/to/calc ... -f\n",
 449                 program, program);
 450                                         exit(20);
 451                         }
 452                         if (havearg)
 453                                 break;
 454                         cp++;
 455                         }
 456                         while (*cp == ' ')
 457                                 cp++;
 458                         if (*cp == '\0') {
 459                                 index++;
 460                                 break;
 461                         }
 462                 }
 463         }
 464
 465         while (index < maxindex) {
 466                 size_t cplen;
 467
 468                 if (cmdlen > 0)
 469                         cmdbuf[cmdlen++] = ' ';
 470                 cplen = strlen(cp);
 471                 newcmdlen = cmdlen + cplen;
 472                 if (newcmdlen > MAXCMD) {
 473                         fprintf(stderr,
 474                                 "%s: commands too long\n",
 475                                 program);
 476                         exit(21);
 477                 }
 478                 strncpy(cmdbuf + cmdlen, cp, cplen+1);
 479                 cmdlen = newcmdlen;
 480                 index++;
 481                 if (index < maxindex)
 482                         cp = argv[index];
 483         }
 484
 485         havecommands = (cmdlen > 0);
 486
 487         if (havecommands) {
 488                 cmdbuf[cmdlen++] = '\n';
 489                 cmdbuf[cmdlen] = '\0';
 490                 if (fclose(stdin)) {
 491                         perror("main(): fclose(stdin) failed:");
 492                 }
 493         }
 494
 495         argc_value = argc - maxindex;
 496         argv_value = argv + maxindex;
 497
 498         /*
 499          * unbuffered mode
 500          */
 501         if (u_flag) {
 502                 setbuf(stdin, NULL);
 503                 setbuf(stdout, NULL);
 504         }
 505
 506
 507         /*
 508          * initialize
 509          */
 510         libcalc_call_me_first();
 511         stdin_tty = isatty(0);          /* assume stdin is on fd 0 */
 512         if (conf->calc_debug & CALCDBG_TTY)
 513                 printf("main: stdin_tty is %d\n", stdin_tty);
 514         if (want_defhelp) {
 515                 givehelp(DEFAULTCALCHELP);
 516                 libcalc_call_me_last();
 517                 exit(0);
 518         }
 519
 520         /*
 521          * if allowed or needed, print version and setup bindings
 522          */
 523         if (!havecommands && stdin_tty) {
 524                 if (!d_flag) {
 525                         printf("%s (version %s)\n", CALC_TITLE, version());
 526                         printf("Calc is open software. For license details "
 527                                "type:  help copyright\n");
 528                         printf("[%s]\n\n",
 529                             "Type \"exit\" to exit, or \"help\" for help.");
 530                 }
 531                 switch (hist_init(calcbindings)) {
 532                 case HIST_NOFILE:
 533                         fprintf(stderr,
 534                             "%s: Cannot open bindings file \"%s\", "
 535                             "fancy editing disabled.\n",
 536                              program, calcbindings);
 537                         break;
 538
 539                 case HIST_NOTTY:
 540                         fprintf(stderr,
 541                                 "%s: Cannot set terminal modes, "
 542                                 "fancy editing disabled\n", program);
 543                         break;
 544                 }
 545         }
 546
 547         /*
 548          * establish error longjump point with initial conditions
 549          */
 550         if (setjmp(calc_scanerr_jmpbuf) == 0) {
 551
 552                 /*
 553                  * reset/initialize the computing environment
 554                  */
 555                 initialize();
 556                 calc_use_scanerr_jmpbuf = 1;
 557         }
 558
 559         /*
 560          * (re)establish the interrupt handler
 561          */
 562         (void) signal(SIGINT, intint);
 563
 564         /*
 565          * execute calc code based on the run state
 566          */
 567         if (run_state == RUN_BEGIN) {
 568                 if (!q_flag && allow_read) {
 569                         set_run_state(RUN_RCFILES);
 570                         runrcfiles();
 571                 }
 572                 set_run_state(RUN_PRE_CMD_ARGS);
 573         }
 574
 575         while (run_state == RUN_RCFILES) {
 576                 fprintf(stderr, "Error in rcfiles\n");
 577                 if ((c_flag && !stoponerror) || stoponerror < 0) {
 578                         getcommands(FALSE);
 579                         if (inputlevel() == 0) {
 580                                 closeinput();
 581                                 runrcfiles();
 582                                 set_run_state(RUN_PRE_CMD_ARGS);
 583                         } else {
 584                                 closeinput();
 585                         }
 586                 } else {
 587                         if ((havecommands && !i_flag) || !stdin_tty) {
 588                                 set_run_state(RUN_EXIT_WITH_ERROR);
 589                         } else {
 590                                 set_run_state(RUN_PRE_CMD_ARGS);
 591                         }
 592                 }
 593         }
 594
 595         if (run_state == RUN_PRE_CMD_ARGS) {
 596                 if (havecommands) {
 597                         set_run_state(RUN_CMD_ARGS);
 598                         (void) openstring(cmdbuf, strlen(cmdbuf));
 599                         getcommands(FALSE);
 600                         closeinput();
 601                 }
 602                 set_run_state(RUN_PRE_TOP_LEVEL);
 603         }
 604
 605         while (run_state == RUN_CMD_ARGS) {
 606                 fprintf(stderr, "Error in commands\n");
 607                 if ((c_flag && !stoponerror) || stoponerror < 0) {
 608                         getcommands(FALSE);
 609                         if (inputlevel() == 0)
 610                                 set_run_state(RUN_PRE_TOP_LEVEL);
 611                         closeinput();
 612                 } else {
 613                         closeinput();
 614                         if (!stdin_tty || !i_flag || p_flag) {
 615                                 set_run_state(RUN_EXIT_WITH_ERROR);
 616                         } else {
 617                                 set_run_state(RUN_PRE_TOP_LEVEL);
 618                         }
 619                 }
 620         }
 621
 622         if (run_state == RUN_PRE_TOP_LEVEL) {
 623                 if (stdin_tty &&
 624                     (((havecommands) && !i_flag) || p_flag)) {
 625                         set_run_state(RUN_EXIT);
 626                 } else {
 627                         if (stdin_tty) {
 628                                 reinitialize();
 629                         } else {
 630                                 resetinput();
 631                                 openterminal();
 632                         }
 633                         set_run_state(RUN_TOP_LEVEL);
 634                         getcommands(TRUE);
 635                 }
 636                 if (p_flag || (!i_flag && havecommands))
 637                         set_run_state(RUN_EXIT);
 638         }
 639
 640         while (run_state == RUN_TOP_LEVEL) {
 641                 if (conf->calc_debug & CALCDBG_RUNSTATE)
 642                         printf("main: run_state = TOP_LEVEL\n");
 643                 if ((c_flag && !stoponerror) || stoponerror < 0) {
 644                         getcommands(TRUE);
 645                         if (!inputisterminal()) {
 646                                 closeinput();
 647                                 continue;
 648                         }
 649                         if (!p_flag && i_flag && !stdin_tty) {
 650                                 closeinput();
 651                                 if(!freopen("/dev/tty", "r", stdin)) {
 652 #if defined (_WIN32)
 653                                         fprintf(stderr,
 654                                                 "/dev/tty does not exist on "
 655                                                 "this operating system.  "
 656                                                 "Change operating systems\n"
 657                                                 "or don't use this calc mode "
 658                                                 "in the future, sorry!\n");
 659 #else /* Windoz free systems */
 660                                         fprintf(stderr,
 661                                                 "Unable to associate stdin"
 662                                                 " with /dev/tty");
 663 #endif /* Windoz free systems */
 664                                         set_run_state(RUN_EXIT_WITH_ERROR);
 665                                         break;
 666                                 }
 667
 668                                 stdin_tty = TRUE;
 669                                 if (conf->calc_debug & CALCDBG_TTY)
 670                                         printf("main: stdin_tty is %d\n",
 671                                                stdin_tty);
 672                                 reinitialize();
 673                         }
 674                 } else {
 675                         if (stdin_tty) {
 676                                 reinitialize();
 677                                 getcommands(TRUE);
 678                         } else if (inputisterminal() &&
 679                                         !p_flag && (!havecommands||i_flag)) {
 680                                 closeinput();
 681                                 if(!freopen("/dev/tty", "r", stdin)) {
 682 #if defined (_WIN32)
 683                                         fprintf(stderr,
 684                                                 "/dev/tty does not exist on "
 685                                                 "this operating system.  "
 686                                                 "Change operating systems\n"
 687                                                 "or don't use this calc mode "
 688                                                 "in the future, sorry!\n");
 689 #else /* Windoz free systems */
 690                                         fprintf(stderr,
 691                                                 "Unable to associate stdin"
 692                                                 " with /dev/tty");
 693 #endif /* Windoz free systems */
 694                                         set_run_state(RUN_EXIT_WITH_ERROR);
 695                                         break;
 696                                 }
 697                                 stdin_tty = TRUE;
 698                                 if (conf->calc_debug & CALCDBG_TTY)
 699                                         printf("main: stdin_tty is %d\n",
 700                                                stdin_tty);
 701                                 reinitialize();
 702                         } else {
 703                                 set_run_state(RUN_EXIT_WITH_ERROR);
 704                         }
 705                 }
 706         }
 707         if (conf->calc_debug & CALCDBG_RUNSTATE)
 708                 printf("main: run_state = %s\n", run_state_name(run_state));
 709
 710         /*
 711          * all done
 712          */
 713         libcalc_call_me_last();
 714         return (run_state == RUN_EXIT_WITH_ERROR ||
 715                 run_state == RUN_ZERO) ? 1 : 0;
 716 }
 717
 718
 719 /*
 720  * Interrupt routine.
 721  *
 722  * given:
 723  *      arg             to keep ANSI C happy
 724  */
 725 /*ARGSUSED*/
 726 S_FUNC void
 727 intint(int UNUSED arg)
 728 {
 729         (void) signal(SIGINT, intint);
 730         if (inputwait || (++abortlevel >= ABORT_NOW)) {
 731                 calc_interrupt("\nABORT");
 732                 /*NOTREACHED*/
 733         }
 734         if (abortlevel >= ABORT_MATH)
 735                 _math_abort_ = TRUE;
 736         printf("\n[Abort level %d]\n", abortlevel);
 737 }
 738
 739
 740 /*
 741  * report an interrupt
 742  */
 743 static void
 744 calc_interrupt(char *fmt, ...)
 745 {
 746         va_list ap;
 747
 748         if (funcname && (*funcname != '*'))
 749                 fprintf(stderr, "\"%s\": ", funcname);
 750         if (funcline && ((funcname && (*funcname != '*')) ||
 751             !inputisterminal()))
 752                 fprintf(stderr, "line %ld: ", funcline);
 753         va_start(ap, fmt);
 754         vsnprintf(calc_err_msg, MAXERROR, fmt, ap);
 755         va_end(ap);
 756         calc_err_msg[MAXERROR] = '\0';
 757         fprintf(stderr, "%s\n\n", calc_err_msg);
 758         funcname = NULL;
 759         if (calc_use_scanerr_jmpbuf != 0) {
 760                 longjmp(calc_scanerr_jmpbuf, 22);
 761         } else {
 762                 fprintf(stderr, "It is too early provide a command line prompt "
 763                                 "so we must simply exit.  Sorry!\n");
 764                 /*
 765                  * don't call libcalc_call_me_last() -- we might loop
 766                  * and besides ... this is an unusual internal error case
 767                  */
 768                 exit(22);
 769         }
 770 }
 771
 772 S_FUNC int
 773 nextcp(char **cpp, int *ip, int argc, char **argv, BOOL haveendstr)
 774 {
 775         char *cp;
 776         int index;
 777
 778         cp = *cpp;
 779         index = *ip;
 780
 781
 782         if (haveendstr) {
 783                 index++;
 784                 *ip = index;
 785                 if (index >= argc)
 786                         return 1;
 787                 *cpp = argv[index];
 788                 return 0;
 789         }
 790
 791         if (*cp != '\0')
 792                 cp++;
 793         for (;;) {
 794                 if (*cp == '\0') {
 795                         index++;
 796                         *ip = index;
 797                         if (index >= argc)
 798                                 return 1;
 799                         cp = argv[index];
 800                 }
 801                 while (*cp == ' ')
 802                         cp++;
 803                 if (*cp != '\0')
 804                         break;
 805         }
 806         *cpp = cp;
 807         return 0;
 808 }
 809
 810
 811 S_FUNC void
 812 set_run_state(run state)
 813 {
 814         if (conf->calc_debug & CALCDBG_RUNSTATE)
 815                 printf("main: run_state from %s to %s\n",
 816                             run_state_name(run_state),
 817                             run_state_name(state));
 818         run_state = state;
 819 }
 820