Annotation of OpenXM_contrib/gnuplot/util.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: util.c,v 1.46 1998/06/18 14:55:20 ddenholm Exp $";
! 3: #endif
! 4:
! 5: /* GNUPLOT - util.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:
! 38: #include "plot.h"
! 39: #include "setshow.h" /* for month names etc */
! 40:
! 41:
! 42: /* TRUE if command just typed; becomes FALSE whenever we
! 43: * send some other output to screen. If FALSE, the command line
! 44: * will be echoed to the screen before the ^ error message.
! 45: */
! 46: TBOOLEAN screen_ok;
! 47:
! 48: static char *num_to_str __PROTO((double r));
! 49: static void parse_esc __PROTO((char *instr));
! 50:
! 51: /*
! 52: * chr_in_str() compares the characters in the string of token number t_num
! 53: * with c, and returns TRUE if a match was found.
! 54: */
! 55: int chr_in_str(t_num, c)
! 56: int t_num;
! 57: int c;
! 58: {
! 59: register int i;
! 60:
! 61: if (!token[t_num].is_token)
! 62: return (FALSE); /* must be a value--can't be equal */
! 63: for (i = 0; i < token[t_num].length; i++) {
! 64: if (input_line[token[t_num].start_index + i] == c)
! 65: return (TRUE);
! 66: }
! 67: return FALSE;
! 68: }
! 69:
! 70:
! 71: /*
! 72: * equals() compares string value of token number t_num with str[], and
! 73: * returns TRUE if they are identical.
! 74: */
! 75: int equals(t_num, str)
! 76: int t_num;
! 77: char *str;
! 78: {
! 79: register int i;
! 80:
! 81: if (!token[t_num].is_token)
! 82: return (FALSE); /* must be a value--can't be equal */
! 83: for (i = 0; i < token[t_num].length; i++) {
! 84: if (input_line[token[t_num].start_index + i] != str[i])
! 85: return (FALSE);
! 86: }
! 87: /* now return TRUE if at end of str[], FALSE if not */
! 88: return (str[i] == NUL);
! 89: }
! 90:
! 91:
! 92:
! 93: /*
! 94: * almost_equals() compares string value of token number t_num with str[], and
! 95: * returns TRUE if they are identical up to the first $ in str[].
! 96: */
! 97: int almost_equals(t_num, str)
! 98: int t_num;
! 99: char *str;
! 100: {
! 101: register int i;
! 102: register int after = 0;
! 103: register int start = token[t_num].start_index;
! 104: register int length = token[t_num].length;
! 105:
! 106: if (!token[t_num].is_token)
! 107: return (FALSE); /* must be a value--can't be equal */
! 108: for (i = 0; i < length + after; i++) {
! 109: if (str[i] != input_line[start + i]) {
! 110: if (str[i] != '$')
! 111: return (FALSE);
! 112: else {
! 113: after = 1;
! 114: start--; /* back up token ptr */
! 115: }
! 116: }
! 117: }
! 118:
! 119: /* i now beyond end of token string */
! 120:
! 121: return (after || str[i] == '$' || str[i] == NUL);
! 122: }
! 123:
! 124:
! 125:
! 126: int isstring(t_num)
! 127: int t_num;
! 128: {
! 129:
! 130: return (token[t_num].is_token &&
! 131: (input_line[token[t_num].start_index] == '\'' ||
! 132: input_line[token[t_num].start_index] == '"'));
! 133: }
! 134:
! 135:
! 136: int isanumber(t_num)
! 137: int t_num;
! 138: {
! 139: return (!token[t_num].is_token);
! 140: }
! 141:
! 142:
! 143: int isletter(t_num)
! 144: int t_num;
! 145: {
! 146: return (token[t_num].is_token &&
! 147: ((isalpha((int)input_line[token[t_num].start_index])) ||
! 148: (input_line[token[t_num].start_index] == '_')));
! 149: }
! 150:
! 151:
! 152: /*
! 153: * is_definition() returns TRUE if the next tokens are of the form
! 154: * identifier =
! 155: * -or-
! 156: * identifier ( identifer {,identifier} ) =
! 157: */
! 158: int is_definition(t_num)
! 159: int t_num;
! 160: {
! 161: /* variable? */
! 162: if (isletter(t_num) && equals(t_num + 1, "="))
! 163: return 1;
! 164:
! 165: /* function? */
! 166: /* look for dummy variables */
! 167: if (isletter(t_num) && equals(t_num + 1, "(") && isletter(t_num + 2)) {
! 168: t_num += 3; /* point past first dummy */
! 169: while (equals(t_num, ",")) {
! 170: if (!isletter(++t_num))
! 171: return 0;
! 172: t_num += 1;
! 173: }
! 174: return (equals(t_num, ")") && equals(t_num + 1, "="));
! 175: }
! 176: /* neither */
! 177: return 0;
! 178: }
! 179:
! 180:
! 181:
! 182: /*
! 183: * copy_str() copies the string in token number t_num into str, appending
! 184: * a null. No more than max chars are copied (including \0).
! 185: */
! 186: void copy_str(str, t_num, max)
! 187: char str[];
! 188: int t_num;
! 189: int max;
! 190: {
! 191: register int i = 0;
! 192: register int start = token[t_num].start_index;
! 193: register int count;
! 194:
! 195: if ((count = token[t_num].length) >= max) {
! 196: count = max - 1;
! 197: FPRINTF((stderr, "str buffer overflow in copy_str"));
! 198: }
! 199: do {
! 200: str[i++] = input_line[start++];
! 201: } while (i != count);
! 202: str[i] = NUL;
! 203: }
! 204:
! 205: /* length of token string */
! 206: int token_len(t_num)
! 207: int t_num;
! 208: {
! 209: return (token[t_num].length);
! 210: }
! 211:
! 212: /*
! 213: * quote_str() does the same thing as copy_str, except it ignores the
! 214: * quotes at both ends. This seems redundant, but is done for
! 215: * efficency.
! 216: */
! 217: void quote_str(str, t_num, max)
! 218: char str[];
! 219: int t_num;
! 220: int max;
! 221: {
! 222: register int i = 0;
! 223: register int start = token[t_num].start_index + 1;
! 224: register int count;
! 225:
! 226: if ((count = token[t_num].length - 2) >= max) {
! 227: count = max - 1;
! 228: FPRINTF((stderr, "str buffer overflow in quote_str"));
! 229: }
! 230: if (count > 0) {
! 231: do {
! 232: str[i++] = input_line[start++];
! 233: } while (i != count);
! 234: }
! 235: str[i] = NUL;
! 236: /* convert \t and \nnn (octal) to char if in double quotes */
! 237: if (input_line[token[t_num].start_index] == '"')
! 238: parse_esc(str);
! 239: }
! 240:
! 241:
! 242: /*
! 243: * capture() copies into str[] the part of input_line[] which lies between
! 244: * the begining of token[start] and end of token[end].
! 245: */
! 246: void capture(str, start, end, max)
! 247: char str[];
! 248: int start, end;
! 249: int max;
! 250: {
! 251: register int i, e;
! 252:
! 253: e = token[end].start_index + token[end].length;
! 254: if (e - token[start].start_index >= max) {
! 255: e = token[start].start_index + max - 1;
! 256: FPRINTF((stderr, "str buffer overflow in capture"));
! 257: }
! 258: for (i = token[start].start_index; i < e && input_line[i] != NUL; i++)
! 259: *str++ = input_line[i];
! 260: *str = NUL;
! 261: }
! 262:
! 263:
! 264: /*
! 265: * m_capture() is similar to capture(), but it mallocs storage for the
! 266: * string.
! 267: */
! 268: void m_capture(str, start, end)
! 269: char **str;
! 270: int start, end;
! 271: {
! 272: register int i, e;
! 273: register char *s;
! 274:
! 275: if (*str) /* previous pointer to malloc'd memory there */
! 276: free(*str);
! 277: e = token[end].start_index + token[end].length;
! 278: *str = gp_alloc((unsigned long) (e - token[start].start_index + 1), "string");
! 279: s = *str;
! 280: for (i = token[start].start_index; i < e && input_line[i] != NUL; i++)
! 281: *s++ = input_line[i];
! 282: *s = NUL;
! 283: }
! 284:
! 285:
! 286: /*
! 287: * m_quote_capture() is similar to m_capture(), but it removes
! 288: quotes from either end if the string.
! 289: */
! 290: void m_quote_capture(str, start, end)
! 291: char **str;
! 292: int start, end;
! 293: {
! 294: register int i, e, escflag = 0;
! 295: register char *s;
! 296:
! 297: if (*str) /* previous pointer to malloc'd memory there */
! 298: free(*str);
! 299: e = token[end].start_index + token[end].length - 1;
! 300: *str = gp_alloc((unsigned long) (e - token[start].start_index + 1), "string");
! 301: s = *str;
! 302: for (i = token[start].start_index + 1; i < e && input_line[i] != NUL; i++)
! 303: if ((*s++ = input_line[i]) == '\\') ++escflag;
! 304: *s = NUL;
! 305: if (escflag) parse_esc(*str);
! 306: }
! 307:
! 308:
! 309: void convert(val_ptr, t_num)
! 310: struct value *val_ptr;
! 311: int t_num;
! 312: {
! 313: *val_ptr = token[t_num].l_val;
! 314: }
! 315:
! 316: static char *num_to_str(r)
! 317: double r;
! 318: {
! 319: static int i = 0;
! 320: static char s[4][25];
! 321: int j = i++;
! 322:
! 323: if (i > 3)
! 324: i = 0;
! 325:
! 326: sprintf(s[j], "%.15g", r);
! 327: if (strchr(s[j], '.') == NULL &&
! 328: strchr(s[j], 'e') == NULL &&
! 329: strchr(s[j], 'E') == NULL)
! 330: strcat(s[j], ".0");
! 331:
! 332: return s[j];
! 333: }
! 334:
! 335: void disp_value(fp, val)
! 336: FILE *fp;
! 337: struct value *val;
! 338: {
! 339: switch (val->type) {
! 340: case INTGR:
! 341: fprintf(fp, "%d", val->v.int_val);
! 342: break;
! 343: case CMPLX:
! 344: if (val->v.cmplx_val.imag != 0.0)
! 345: fprintf(fp, "{%s, %s}",
! 346: num_to_str(val->v.cmplx_val.real),
! 347: num_to_str(val->v.cmplx_val.imag));
! 348: else
! 349: fprintf(fp, "%s",
! 350: num_to_str(val->v.cmplx_val.real));
! 351: break;
! 352: default:
! 353: int_error("unknown type in disp_value()", NO_CARET);
! 354: }
! 355: }
! 356:
! 357:
! 358: double real(val) /* returns the real part of val */
! 359: struct value *val;
! 360: {
! 361: switch (val->type) {
! 362: case INTGR:
! 363: return ((double) val->v.int_val);
! 364: case CMPLX:
! 365: return (val->v.cmplx_val.real);
! 366: }
! 367: int_error("unknown type in real()", NO_CARET);
! 368: /* NOTREACHED */
! 369: return ((double) 0.0);
! 370: }
! 371:
! 372:
! 373: double imag(val) /* returns the imag part of val */
! 374: struct value *val;
! 375: {
! 376: switch (val->type) {
! 377: case INTGR:
! 378: return (0.0);
! 379: case CMPLX:
! 380: return (val->v.cmplx_val.imag);
! 381: }
! 382: int_error("unknown type in imag()", NO_CARET);
! 383: /* NOTREACHED */
! 384: return ((double) 0.0);
! 385: }
! 386:
! 387:
! 388:
! 389: double magnitude(val) /* returns the magnitude of val */
! 390: struct value *val;
! 391: {
! 392: switch (val->type) {
! 393: case INTGR:
! 394: return ((double) abs(val->v.int_val));
! 395: case CMPLX:
! 396: return (sqrt(val->v.cmplx_val.real *
! 397: val->v.cmplx_val.real +
! 398: val->v.cmplx_val.imag *
! 399: val->v.cmplx_val.imag));
! 400: }
! 401: int_error("unknown type in magnitude()", NO_CARET);
! 402: /* NOTREACHED */
! 403: return ((double) 0.0);
! 404: }
! 405:
! 406:
! 407:
! 408: double angle(val) /* returns the angle of val */
! 409: struct value *val;
! 410: {
! 411: switch (val->type) {
! 412: case INTGR:
! 413: return ((val->v.int_val >= 0) ? 0.0 : Pi);
! 414: case CMPLX:
! 415: if (val->v.cmplx_val.imag == 0.0) {
! 416: if (val->v.cmplx_val.real >= 0.0)
! 417: return (0.0);
! 418: else
! 419: return (Pi);
! 420: }
! 421: return (atan2(val->v.cmplx_val.imag,
! 422: val->v.cmplx_val.real));
! 423: }
! 424: int_error("unknown type in angle()", NO_CARET);
! 425: /* NOTREACHED */
! 426: return ((double) 0.0);
! 427: }
! 428:
! 429:
! 430: struct value *
! 431: Gcomplex(a, realpart, imagpart)
! 432: struct value *a;
! 433: double realpart, imagpart;
! 434: {
! 435: a->type = CMPLX;
! 436: a->v.cmplx_val.real = realpart;
! 437: a->v.cmplx_val.imag = imagpart;
! 438: return (a);
! 439: }
! 440:
! 441:
! 442: struct value *
! 443: Ginteger(a, i)
! 444: struct value *a;
! 445: int i;
! 446: {
! 447: a->type = INTGR;
! 448: a->v.int_val = i;
! 449: return (a);
! 450: }
! 451:
! 452:
! 453: void os_error(str, t_num)
! 454: char str[];
! 455: int t_num;
! 456: {
! 457: #ifdef VMS
! 458: static status[2] =
! 459: {1, 0}; /* 1 is count of error msgs */
! 460: #endif /* VMS */
! 461:
! 462: register int i;
! 463:
! 464: /* reprint line if screen has been written to */
! 465:
! 466: if (t_num != NO_CARET) { /* put caret under error */
! 467: if (!screen_ok)
! 468: fprintf(stderr, "\n%s%s\n", PROMPT, input_line);
! 469:
! 470: for (i = 0; i < sizeof(PROMPT) - 1; i++)
! 471: (void) putc(' ', stderr);
! 472: for (i = 0; i < token[t_num].start_index; i++) {
! 473: (void) putc((input_line[i] == '\t') ? '\t' : ' ', stderr);
! 474: }
! 475: (void) putc('^', stderr);
! 476: (void) putc('\n', stderr);
! 477: }
! 478: for (i = 0; i < sizeof(PROMPT) - 1; i++)
! 479: (void) putc(' ', stderr);
! 480: fputs(str, stderr);
! 481: putc('\n', stderr);
! 482:
! 483: for (i = 0; i < sizeof(PROMPT) - 1; i++)
! 484: (void) putc(' ', stderr);
! 485: if (!interactive) {
! 486: if (infile_name != NULL)
! 487: fprintf(stderr, "\"%s\", line %d: ", infile_name, inline_num);
! 488: else
! 489: fprintf(stderr, "line %d: ", inline_num);
! 490: }
! 491:
! 492:
! 493: #ifdef VMS
! 494: status[1] = vaxc$errno;
! 495: sys$putmsg(status);
! 496: (void) putc('\n', stderr);
! 497: #else /* VMS */
! 498: fprintf(stderr, "(%s)\n\n", strerror(errno));
! 499: #endif /* VMS */
! 500:
! 501: bail_to_command_line();
! 502: }
! 503:
! 504:
! 505: void int_error(str, t_num)
! 506: char str[];
! 507: int t_num;
! 508: {
! 509: register int i;
! 510:
! 511: /* reprint line if screen has been written to */
! 512:
! 513: if (t_num != NO_CARET) { /* put caret under error */
! 514: if (!screen_ok)
! 515: fprintf(stderr, "\n%s%s\n", PROMPT, input_line);
! 516:
! 517: for (i = 0; i < sizeof(PROMPT) - 1; i++)
! 518: (void) putc(' ', stderr);
! 519: for (i = 0; i < token[t_num].start_index; i++) {
! 520: (void) putc((input_line[i] == '\t') ? '\t' : ' ', stderr);
! 521: }
! 522: (void) putc('^', stderr);
! 523: (void) putc('\n', stderr);
! 524: }
! 525: for (i = 0; i < sizeof(PROMPT) - 1; i++)
! 526: (void) putc(' ', stderr);
! 527: if (!interactive) {
! 528: if (infile_name != NULL)
! 529: fprintf(stderr, "\"%s\", line %d: ", infile_name, inline_num);
! 530: else
! 531: fprintf(stderr, "line %d: ", inline_num);
! 532: }
! 533: fputs(str, stderr);
! 534: fputs("\n\n", stderr);
! 535:
! 536: bail_to_command_line();
! 537: }
! 538:
! 539: /* Warn without bailing out to command line. Not a user error */
! 540: void int_warn(str, t_num)
! 541: char str[];
! 542: int t_num;
! 543: {
! 544: register int i;
! 545:
! 546: /* reprint line if screen has been written to */
! 547:
! 548: if (t_num != NO_CARET) { /* put caret under error */
! 549: if (!screen_ok)
! 550: fprintf(stderr, "\n%s%s\n", PROMPT, input_line);
! 551:
! 552: for (i = 0; i < sizeof(PROMPT) - 1; i++)
! 553: (void) putc(' ', stderr);
! 554: for (i = 0; i < token[t_num].start_index; i++) {
! 555: (void) putc((input_line[i] == '\t') ? '\t' : ' ', stderr);
! 556: }
! 557: (void) putc('^', stderr);
! 558: (void) putc('\n', stderr);
! 559: }
! 560: for (i = 0; i < sizeof(PROMPT) - 1; i++)
! 561: (void) putc(' ', stderr);
! 562: if (!interactive) {
! 563: if (infile_name != NULL)
! 564: fprintf(stderr, "\"%s\", line %d: ", infile_name, inline_num);
! 565: else
! 566: fprintf(stderr, "line %d: ", inline_num);
! 567: }
! 568: fprintf(stderr, "warning: %s\n", str);
! 569:
! 570: } /* int_warn */
! 571:
! 572: /* Lower-case the given string (DFK) */
! 573: /* Done in place. */
! 574: void lower_case(s)
! 575: char *s;
! 576: {
! 577: register char *p = s;
! 578:
! 579: while (*p != NUL) {
! 580: if (isupper((int)*p))
! 581: *p = tolower(*p);
! 582: p++;
! 583: }
! 584: }
! 585:
! 586: /* Squash spaces in the given string (DFK) */
! 587: /* That is, reduce all multiple white-space chars to single spaces */
! 588: /* Done in place. */
! 589: void squash_spaces(s)
! 590: char *s;
! 591: {
! 592: register char *r = s; /* reading point */
! 593: register char *w = s; /* writing point */
! 594: TBOOLEAN space = FALSE; /* TRUE if we've already copied a space */
! 595:
! 596: for (w = r = s; *r != NUL; r++) {
! 597: if (isspace((int)*r)) {
! 598: /* white space; only copy if we haven't just copied a space */
! 599: if (!space) {
! 600: space = TRUE;
! 601: *w++ = ' ';
! 602: } /* else ignore multiple spaces */
! 603: } else {
! 604: /* non-space character; copy it and clear flag */
! 605: *w++ = *r;
! 606: space = FALSE;
! 607: }
! 608: }
! 609: *w = NUL; /* null terminate string */
! 610: }
! 611:
! 612:
! 613: static void parse_esc(instr)
! 614: char *instr;
! 615: {
! 616: char *s = instr, *t = instr;
! 617:
! 618: /* the string will always get shorter, so we can do the
! 619: * conversion in situ
! 620: */
! 621:
! 622: while (*s != NUL) {
! 623: if (*s == '\\') {
! 624: s++;
! 625: if (*s == '\\') {
! 626: *t++ = '\\';
! 627: s++;
! 628: } else if (*s == 'n') {
! 629: *t++ = '\n';
! 630: s++;
! 631: } else if (*s == 'r') {
! 632: *t++ = '\r';
! 633: s++;
! 634: } else if (*s == 't') {
! 635: *t++ = '\t';
! 636: s++;
! 637: } else if (*s == '\"') {
! 638: *t++ = '\"';
! 639: s++;
! 640: } else if (*s >= '0' && *s <= '7') {
! 641: int i, n;
! 642: if (sscanf(s, "%o%n", &i, &n) > 0) {
! 643: *t++ = i;
! 644: s += n;
! 645: } else {
! 646: /* int_error("illegal octal number ", c_token); */
! 647: *t++ = '\\';
! 648: *t++ = *s++;
! 649: }
! 650: }
! 651: } else {
! 652: *t++ = *s++;
! 653: }
! 654: }
! 655: *t = NUL;
! 656: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot