Annotation of OpenXM_contrib/gnuplot/parse.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: parse.c,v 1.62 1998/06/18 14:55:13 ddenholm Exp $";
! 3: #endif
! 4:
! 5: /* GNUPLOT - parse.c */
! 6:
! 7: /*[
! 8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
! 9: *
! 10: * Permission to use, copy, and distribute this software and its
! 11: * documentation for any purpose with or without fee is hereby granted,
! 12: * provided that the above copyright notice appear in all copies and
! 13: * that both that copyright notice and this permission notice appear
! 14: * in supporting documentation.
! 15: *
! 16: * Permission to modify the software is granted, but not the right to
! 17: * distribute the complete modified source code. Modifications are to
! 18: * be distributed as patches to the released version. Permission to
! 19: * distribute binaries produced by compiling modified sources is granted,
! 20: * provided you
! 21: * 1. distribute the corresponding source modifications from the
! 22: * released version in the form of a patch file along with the binaries,
! 23: * 2. add special version identification to distinguish your version
! 24: * in addition to the base release version number,
! 25: * 3. provide your name and address as the primary contact for the
! 26: * support of your modified version, and
! 27: * 4. retain our contact information in regard to use of the base
! 28: * software.
! 29: * Permission to distribute the released version of the source code along
! 30: * with corresponding source modifications in the form of a patch file is
! 31: * granted with same provisions 2 through 4 for binary distributions.
! 32: *
! 33: * This software is provided "as is" without express or implied warranty
! 34: * to the extent permitted by applicable law.
! 35: ]*/
! 36:
! 37: #include <signal.h>
! 38: #include "plot.h"
! 39: #include "help.h"
! 40: #include <setjmp.h>
! 41:
! 42: RETSIGTYPE fpe __PROTO((int an_int));
! 43: static void extend_at __PROTO((void));
! 44: static union argument *add_action __PROTO((enum operators sf_index));
! 45: static void express __PROTO((void));
! 46: static void xterm __PROTO((void));
! 47: static void aterm __PROTO((void));
! 48: static void bterm __PROTO((void));
! 49: static void cterm __PROTO((void));
! 50: static void dterm __PROTO((void));
! 51: static void eterm __PROTO((void));
! 52: static void fterm __PROTO((void));
! 53: static void gterm __PROTO((void));
! 54: static void hterm __PROTO((void));
! 55: static void factor __PROTO((void));
! 56: static void xterms __PROTO((void));
! 57: static void aterms __PROTO((void));
! 58: static void bterms __PROTO((void));
! 59: static void cterms __PROTO((void));
! 60: static void dterms __PROTO((void));
! 61: static void eterms __PROTO((void));
! 62: static void fterms __PROTO((void));
! 63: static void gterms __PROTO((void));
! 64: static void hterms __PROTO((void));
! 65: static void iterms __PROTO((void));
! 66: static void unary __PROTO((void));
! 67:
! 68: static struct at_type *at = NULL;
! 69: static int at_size = 0;
! 70: #if defined(_Windows) && !defined(WIN32)
! 71: static jmp_buf far fpe_env;
! 72: #else
! 73: static jmp_buf fpe_env;
! 74: #endif
! 75:
! 76: #define dummy (struct value *) 0
! 77:
! 78: RETSIGTYPE fpe(an_int)
! 79: int an_int;
! 80: {
! 81: #if defined(MSDOS) && !defined(__EMX__) && !defined(DJGPP) && !defined(_Windows) || defined(DOS386)
! 82: /* thanks to lotto@wjh12.UUCP for telling us about this */
! 83: _fpreset();
! 84: #endif
! 85:
! 86: #ifdef OS2
! 87: (void) signal(an_int, SIG_ACK);
! 88: #else
! 89: (void) signal(SIGFPE, (sigfunc) fpe);
! 90: #endif
! 91: undefined = TRUE;
! 92: longjmp(fpe_env, TRUE);
! 93: }
! 94:
! 95:
! 96: #ifdef apollo
! 97: #include <apollo/base.h>
! 98: #include <apollo/pfm.h>
! 99: #include <apollo/fault.h>
! 100:
! 101: /*
! 102: * On an Apollo, the OS can signal a couple errors that are not mapped into
! 103: * SIGFPE, namely signalling NaN and branch on an unordered comparison. I
! 104: * suppose there are others, but none of these are documented, so I handle
! 105: * them as they arise.
! 106: *
! 107: * Anyway, we need to catch these faults and signal SIGFPE.
! 108: */
! 109:
! 110: pfm_$fh_func_val_t apollo_sigfpe(pfm_$fault_rec_t & fault_rec)
! 111: {
! 112: kill(getpid(), SIGFPE);
! 113: return pfm_$continue_fault_handling;
! 114: }
! 115:
! 116: apollo_pfm_catch()
! 117: {
! 118: status_$t status;
! 119: pfm_$establish_fault_handler(fault_$fp_bsun, pfm_$fh_backstop,
! 120: apollo_sigfpe, &status);
! 121: pfm_$establish_fault_handler(fault_$fp_sig_nan, pfm_$fh_backstop,
! 122: apollo_sigfpe, &status);
! 123: }
! 124: #endif
! 125:
! 126:
! 127: void evaluate_at(at_ptr, val_ptr)
! 128: struct at_type *at_ptr;
! 129: struct value *val_ptr;
! 130: {
! 131: double temp;
! 132:
! 133: undefined = FALSE;
! 134: errno = 0;
! 135: reset_stack();
! 136:
! 137: #ifndef DOSX286
! 138: if (setjmp(fpe_env))
! 139: return; /* just bail out */
! 140: (void) signal(SIGFPE, (sigfunc) fpe);
! 141: #endif
! 142:
! 143: execute_at(at_ptr);
! 144:
! 145: #ifndef DOSX286
! 146: (void) signal(SIGFPE, SIG_DFL);
! 147: #endif
! 148:
! 149: if (errno == EDOM || errno == ERANGE) {
! 150: undefined = TRUE;
! 151: } else if (!undefined) { /* undefined (but not errno) may have been set by matherr */
! 152: (void) pop(val_ptr);
! 153: check_stack();
! 154: /* At least one machine (ATT 3b1) computes Inf without a SIGFPE */
! 155: temp = real(val_ptr);
! 156: if (temp > VERYLARGE || temp < -VERYLARGE) {
! 157: undefined = TRUE;
! 158: }
! 159: }
! 160: #if defined(NeXT) || defined(ultrix)
! 161: /*
! 162: * linux was able to fit curves which NeXT gave up on -- traced it to
! 163: * silently returning NaN for the undefined cases and plowing ahead
! 164: * I can force that behavior this way. (0.0/0.0 generates NaN)
! 165: */
! 166: if (undefined && (errno == EDOM || errno == ERANGE)) { /* corey@cac */
! 167: undefined = FALSE;
! 168: errno = 0;
! 169: Gcomplex(val_ptr, 0.0 / 0.0, 0.0 / 0.0);
! 170: }
! 171: #endif /* NeXT || ultrix */
! 172: }
! 173:
! 174:
! 175: struct value *
! 176: const_express(valptr)
! 177: struct value *valptr;
! 178: {
! 179: register int tkn = c_token;
! 180:
! 181: if (END_OF_COMMAND)
! 182: int_error("constant expression required", c_token);
! 183:
! 184: /* div - no dummy variables in a constant expression */
! 185: dummy_func = NULL;
! 186:
! 187: evaluate_at(temp_at(), valptr); /* run it and send answer back */
! 188: if (undefined) {
! 189: int_error("undefined value", tkn);
! 190: }
! 191: return (valptr);
! 192: }
! 193:
! 194:
! 195: /* if dummy_dunc == NULL on entry, do not attempt to compile dummy variables
! 196: * - div
! 197: */
! 198: struct at_type *
! 199: temp_at()
! 200: {
! 201: /* build a static action table and return its
! 202: * pointer */
! 203:
! 204: if (at != NULL) {
! 205: free(at);
! 206: at = NULL;
! 207: }
! 208: at = (struct at_type *) gp_alloc(sizeof(struct at_type), "action table");
! 209:
! 210: at->a_count = 0; /* reset action table !!! */
! 211: at_size = MAX_AT_LEN;
! 212: express();
! 213: return (at);
! 214: }
! 215:
! 216:
! 217: /* build an action table, put it in dynamic memory, and return its pointer */
! 218:
! 219: struct at_type *
! 220: perm_at()
! 221: {
! 222: register struct at_type *at_ptr;
! 223: unsigned int len;
! 224:
! 225: (void) temp_at();
! 226: len = sizeof(struct at_type) +
! 227: (int) (at->a_count - MAX_AT_LEN) * (int) sizeof(struct at_entry);
! 228: at_ptr = (struct at_type *) gp_realloc(at, (unsigned long) len, "perm_at");
! 229: at = NULL; /* invalidate at pointer */
! 230: return (at_ptr);
! 231: }
! 232:
! 233: static void extend_at()
! 234: {
! 235: int newsize = sizeof(struct at_type) + at_size * sizeof(struct at_entry);
! 236:
! 237: at = gp_realloc(at, newsize, "extend_at");
! 238: at_size += MAX_AT_LEN;
! 239: FPRINTF((stderr, "Extending at size to %d\n", at_size));
! 240: }
! 241:
! 242: /* moved from eval.c, the function is only called from this module */
! 243: static union argument *
! 244: add_action(sf_index)
! 245: enum operators sf_index; /* index of p-code function */
! 246: {
! 247: if (at->a_count >= at_size) {
! 248: extend_at();
! 249: }
! 250: at->actions[at->a_count].index = sf_index;
! 251: return (&(at->actions[at->a_count++].arg));
! 252: }
! 253:
! 254:
! 255: static void express()
! 256: { /* full expressions */
! 257: xterm();
! 258: xterms();
! 259: }
! 260:
! 261: static void xterm()
! 262: { /* ? : expressions */
! 263: aterm();
! 264: aterms();
! 265: }
! 266:
! 267:
! 268: static void aterm()
! 269: {
! 270: bterm();
! 271: bterms();
! 272: }
! 273:
! 274:
! 275: static void bterm()
! 276: {
! 277: cterm();
! 278: cterms();
! 279: }
! 280:
! 281:
! 282: static void cterm()
! 283: {
! 284: dterm();
! 285: dterms();
! 286: }
! 287:
! 288:
! 289: static void dterm()
! 290: {
! 291: eterm();
! 292: eterms();
! 293: }
! 294:
! 295:
! 296: static void eterm()
! 297: {
! 298: fterm();
! 299: fterms();
! 300: }
! 301:
! 302:
! 303: static void fterm()
! 304: {
! 305: gterm();
! 306: gterms();
! 307: }
! 308:
! 309:
! 310: static void gterm()
! 311: {
! 312: hterm();
! 313: hterms();
! 314: }
! 315:
! 316:
! 317: static void hterm()
! 318: {
! 319: unary(); /* - things */
! 320: iterms(); /* * / % */
! 321: }
! 322:
! 323:
! 324: static void factor()
! 325: {
! 326: if (equals(c_token, "(")) {
! 327: c_token++;
! 328: express();
! 329: if (!equals(c_token, ")"))
! 330: int_error("')' expected", c_token);
! 331: c_token++;
! 332: } else if (equals(c_token, "$")) {
! 333: struct value a;
! 334: if (!isanumber(++c_token))
! 335: int_error("Column number expected", c_token);
! 336: convert(&a, c_token++);
! 337: if (a.type != INTGR || a.v.int_val < 0)
! 338: int_error("Positive integer expected", c_token);
! 339: add_action(DOLLARS)->v_arg = a;
! 340: } else if (isanumber(c_token)) {
! 341: /* work around HP 9000S/300 HP-UX 9.10 cc limitation ... */
! 342: #if defined(__hpux) && defined(__hp9000s300) && !defined(__GNUC__)
! 343: union argument *foo = add_action(PUSHC);
! 344: convert(&(foo->v_arg), c_token);
! 345: #else
! 346: convert(&(add_action(PUSHC)->v_arg), c_token);
! 347: #endif
! 348: c_token++;
! 349: } else if (isletter(c_token)) {
! 350: if ((c_token + 1 < num_tokens) && equals(c_token + 1, "(")) {
! 351: enum operators value = standard(c_token);
! 352: if (value) { /* it's a standard function */
! 353: c_token += 2;
! 354: express();
! 355: if (equals(c_token, ",")) {
! 356: while (equals(c_token, ",")) {
! 357: c_token += 1;
! 358: express();
! 359: }
! 360: }
! 361: if (!equals(c_token, ")"))
! 362: int_error("')' expected", c_token);
! 363: c_token++;
! 364: (void) add_action(value);
! 365: } else {
! 366: enum operators call_type = (int) CALL;
! 367: int tok = c_token;
! 368: c_token += 2;
! 369: express();
! 370: if (equals(c_token, ",")) {
! 371: struct value num_params;
! 372: num_params.type = INTGR;
! 373: num_params.v.int_val = 1;
! 374: while (equals(c_token, ",")) {
! 375: num_params.v.int_val += 1;
! 376: c_token += 1;
! 377: express();
! 378: }
! 379: add_action(PUSHC)->v_arg = num_params;
! 380: call_type = (int) CALLN;
! 381: }
! 382: if (!equals(c_token, ")"))
! 383: int_error("')' expected", c_token);
! 384: c_token++;
! 385: add_action(call_type)->udf_arg = add_udf(tok);
! 386: }
! 387: /* dummy_func==NULL is a flag to say no dummy variables active */
! 388: } else if (dummy_func) {
! 389: if (equals(c_token, c_dummy_var[0])) {
! 390: c_token++;
! 391: add_action(PUSHD1)->udf_arg = dummy_func;
! 392: } else if (equals(c_token, c_dummy_var[1])) {
! 393: c_token++;
! 394: add_action(PUSHD2)->udf_arg = dummy_func;
! 395: } else {
! 396: int i, param = 0;
! 397: for (i = 2; i < MAX_NUM_VAR; i++) {
! 398: if (equals(c_token, c_dummy_var[i])) {
! 399: struct value num_params;
! 400: num_params.type = INTGR;
! 401: num_params.v.int_val = i;
! 402: param = 1;
! 403: c_token++;
! 404: add_action(PUSHC)->v_arg = num_params;
! 405: add_action(PUSHD)->udf_arg = dummy_func;
! 406: break;
! 407: }
! 408: }
! 409: if (!param) { /* defined variable */
! 410: add_action(PUSH)->udv_arg = add_udv(c_token);
! 411: c_token++;
! 412: }
! 413: }
! 414: /* its a variable, with no dummies active - div */
! 415: } else {
! 416: add_action(PUSH)->udv_arg = add_udv(c_token);
! 417: c_token++;
! 418: }
! 419: }
! 420: /* end if letter */
! 421: else
! 422: int_error("invalid expression ", c_token);
! 423:
! 424: /* add action code for ! (factorial) operator */
! 425: while (equals(c_token, "!")) {
! 426: c_token++;
! 427: (void) add_action(FACTORIAL);
! 428: }
! 429: /* add action code for ** operator */
! 430: if (equals(c_token, "**")) {
! 431: c_token++;
! 432: unary();
! 433: (void) add_action(POWER);
! 434: }
! 435: }
! 436:
! 437:
! 438:
! 439: static void xterms()
! 440: {
! 441: /* create action code for ? : expressions */
! 442:
! 443: if (equals(c_token, "?")) {
! 444: register int savepc1, savepc2;
! 445: register union argument *argptr1, *argptr2;
! 446: c_token++;
! 447: savepc1 = at->a_count;
! 448: argptr1 = add_action(JTERN);
! 449: express();
! 450: if (!equals(c_token, ":"))
! 451: int_error("expecting ':'", c_token);
! 452: c_token++;
! 453: savepc2 = at->a_count;
! 454: argptr2 = add_action(JUMP);
! 455: argptr1->j_arg = at->a_count - savepc1;
! 456: express();
! 457: argptr2->j_arg = at->a_count - savepc2;
! 458: }
! 459: }
! 460:
! 461:
! 462: static void aterms()
! 463: {
! 464: /* create action codes for || operator */
! 465:
! 466: while (equals(c_token, "||")) {
! 467: register int savepc;
! 468: register union argument *argptr;
! 469: c_token++;
! 470: savepc = at->a_count;
! 471: argptr = add_action(JUMPNZ); /* short-circuit if already
! 472: * TRUE */
! 473: aterm();
! 474: argptr->j_arg = at->a_count - savepc; /* offset for jump */
! 475: (void) add_action(BOOLE);
! 476: }
! 477: }
! 478:
! 479:
! 480: static void bterms()
! 481: {
! 482: /* create action code for && operator */
! 483:
! 484: while (equals(c_token, "&&")) {
! 485: register int savepc;
! 486: register union argument *argptr;
! 487: c_token++;
! 488: savepc = at->a_count;
! 489: argptr = add_action(JUMPZ); /* short-circuit if already
! 490: * FALSE */
! 491: bterm();
! 492: argptr->j_arg = at->a_count - savepc; /* offset for jump */
! 493: (void) add_action(BOOLE);
! 494: }
! 495: }
! 496:
! 497:
! 498: static void cterms()
! 499: {
! 500: /* create action code for | operator */
! 501:
! 502: while (equals(c_token, "|")) {
! 503: c_token++;
! 504: cterm();
! 505: (void) add_action(BOR);
! 506: }
! 507: }
! 508:
! 509:
! 510: static void dterms()
! 511: {
! 512: /* create action code for ^ operator */
! 513:
! 514: while (equals(c_token, "^")) {
! 515: c_token++;
! 516: dterm();
! 517: (void) add_action(XOR);
! 518: }
! 519: }
! 520:
! 521:
! 522: static void eterms()
! 523: {
! 524: /* create action code for & operator */
! 525:
! 526: while (equals(c_token, "&")) {
! 527: c_token++;
! 528: eterm();
! 529: (void) add_action(BAND);
! 530: }
! 531: }
! 532:
! 533:
! 534: static void fterms()
! 535: {
! 536: /* create action codes for == and !=
! 537: * operators */
! 538:
! 539: while (TRUE) {
! 540: if (equals(c_token, "==")) {
! 541: c_token++;
! 542: fterm();
! 543: (void) add_action(EQ);
! 544: } else if (equals(c_token, "!=")) {
! 545: c_token++;
! 546: fterm();
! 547: (void) add_action(NE);
! 548: } else
! 549: break;
! 550: }
! 551: }
! 552:
! 553:
! 554: static void gterms()
! 555: {
! 556: /* create action code for < > >= or <=
! 557: * operators */
! 558:
! 559: while (TRUE) {
! 560: /* I hate "else if" statements */
! 561: if (equals(c_token, ">")) {
! 562: c_token++;
! 563: gterm();
! 564: (void) add_action(GT);
! 565: } else if (equals(c_token, "<")) {
! 566: c_token++;
! 567: gterm();
! 568: (void) add_action(LT);
! 569: } else if (equals(c_token, ">=")) {
! 570: c_token++;
! 571: gterm();
! 572: (void) add_action(GE);
! 573: } else if (equals(c_token, "<=")) {
! 574: c_token++;
! 575: gterm();
! 576: (void) add_action(LE);
! 577: } else
! 578: break;
! 579: }
! 580:
! 581: }
! 582:
! 583:
! 584:
! 585: static void hterms()
! 586: {
! 587: /* create action codes for + and - operators */
! 588:
! 589: while (TRUE) {
! 590: if (equals(c_token, "+")) {
! 591: c_token++;
! 592: hterm();
! 593: (void) add_action(PLUS);
! 594: } else if (equals(c_token, "-")) {
! 595: c_token++;
! 596: hterm();
! 597: (void) add_action(MINUS);
! 598: } else
! 599: break;
! 600: }
! 601: }
! 602:
! 603:
! 604: static void iterms()
! 605: {
! 606: /* add action code for * / and % operators */
! 607:
! 608: while (TRUE) {
! 609: if (equals(c_token, "*")) {
! 610: c_token++;
! 611: unary();
! 612: (void) add_action(MULT);
! 613: } else if (equals(c_token, "/")) {
! 614: c_token++;
! 615: unary();
! 616: (void) add_action(DIV);
! 617: } else if (equals(c_token, "%")) {
! 618: c_token++;
! 619: unary();
! 620: (void) add_action(MOD);
! 621: } else
! 622: break;
! 623: }
! 624: }
! 625:
! 626:
! 627: static void unary()
! 628: {
! 629: /* add code for unary operators */
! 630:
! 631: if (equals(c_token, "!")) {
! 632: c_token++;
! 633: unary();
! 634: (void) add_action(LNOT);
! 635: } else if (equals(c_token, "~")) {
! 636: c_token++;
! 637: unary();
! 638: (void) add_action(BNOT);
! 639: } else if (equals(c_token, "-")) {
! 640: c_token++;
! 641: unary();
! 642: (void) add_action(UMINUS);
! 643: } else if (equals(c_token, "+")) { /* unary + is no-op */
! 644: c_token++;
! 645: unary();
! 646: } else
! 647: factor();
! 648: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot