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