home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archives / GNU / GNUPLOTsrc.lha / util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-22  |  23.4 KB  |  1,101 lines
  1. #ifndef lint
  2. static char *RCSid = "$Id: util.c,v 1.33 1995/12/07 21:41:12 drd Exp $";
  3. #endif
  4.  
  5. /* GNUPLOT - util.c */
  6. /*
  7.  * Copyright (C) 1986 - 1993   Thomas Williams, Colin Kelley
  8.  *
  9.  * Permission to use, copy, and distribute this software and its
  10.  * documentation for any purpose with or without fee is hereby granted, 
  11.  * provided that the above copyright notice appear in all copies and 
  12.  * that both that copyright notice and this permission notice appear 
  13.  * in supporting documentation.
  14.  *
  15.  * Permission to modify the software is granted, but not the right to
  16.  * distribute the modified code.  Modifications are to be distributed 
  17.  * as patches to released version.
  18.  *  
  19.  * This software is provided "as is" without express or implied warranty.
  20.  * 
  21.  *
  22.  * AUTHORS
  23.  * 
  24.  *   Original Software:
  25.  *     Thomas Williams,  Colin Kelley.
  26.  * 
  27.  *   Gnuplot 2.0 additions:
  28.  *       Russell Lang, Dave Kotz, John Campbell.
  29.  *
  30.  *   Gnuplot 3.0 additions:
  31.  *       Gershon Elber and many others.
  32.  * 
  33.  */
  34.  
  35. #include <ctype.h>
  36. #include <math.h> /* get prototype for sqrt */
  37. #include "plot.h"
  38. #include "setshow.h" /* for month names etc */
  39.  
  40.  
  41. TBOOLEAN screen_ok;
  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.  
  47. static char *num_to_str __P((double r));
  48. static void parse_esc __P((char *instr));
  49. static char * read_int __P((char *s, int nr, int *d));
  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. #ifdef ANSI_C
  56. int chr_in_str(int t_num, char c)
  57. #else
  58. int chr_in_str(t_num, c)
  59. int t_num;
  60. char c;
  61. #endif
  62. {
  63. register int i;
  64.  
  65.     if (!token[t_num].is_token)
  66.         return(FALSE);                /* must be a value--can't be equal */
  67.     for (i = 0; i < token[t_num].length; i++) {
  68.         if (input_line[token[t_num].start_index+i] == c)
  69.             return(TRUE);
  70.         }
  71.     return FALSE;
  72. }
  73.  
  74.  
  75. /*
  76.  * equals() compares string value of token number t_num with str[], and
  77.  *   returns TRUE if they are identical.
  78.  */
  79. int equals(t_num, str)
  80. int t_num;
  81. char *str;
  82. {
  83. register int i;
  84.  
  85.     if (!token[t_num].is_token)
  86.         return(FALSE);                /* must be a value--can't be equal */
  87.     for (i = 0; i < token[t_num].length; i++) {
  88.         if (input_line[token[t_num].start_index+i] != str[i])
  89.             return(FALSE);
  90.         }
  91.     /* now return TRUE if at end of str[], FALSE if not */
  92.     return(str[i] == '\0');
  93. }
  94.  
  95.  
  96.  
  97. /*
  98.  * almost_equals() compares string value of token number t_num with str[], and
  99.  *   returns TRUE if they are identical up to the first $ in str[].
  100.  */
  101. int almost_equals(t_num, str)
  102. int t_num;
  103. char *str;
  104. {
  105. register int i;
  106. register int after = 0;
  107. register start = token[t_num].start_index;
  108. register length = token[t_num].length;
  109.  
  110.     if (!token[t_num].is_token)
  111.         return(FALSE);                /* must be a value--can't be equal */
  112.     for (i = 0; i < length + after; i++) {
  113.         if (str[i] != input_line[start + i]) {
  114.             if (str[i] != '$')
  115.                 return(FALSE);
  116.             else {
  117.                 after = 1;
  118.                 start--;    /* back up token ptr */
  119.                 }
  120.             }
  121.         }
  122.  
  123.     /* i now beyond end of token string */
  124.  
  125.     return(after || str[i] == '$' || str[i] == '\0');
  126. }
  127.  
  128.  
  129.  
  130. int isstring(t_num)
  131. int t_num;
  132. {
  133.     
  134.     return(token[t_num].is_token &&
  135.            (input_line[token[t_num].start_index] == '\'' ||
  136.            input_line[token[t_num].start_index] == '\"'));
  137. }
  138.  
  139.  
  140. int isanumber(t_num)
  141. int t_num;
  142. {
  143.     return(!token[t_num].is_token);
  144. }
  145.  
  146.  
  147. int isletter(t_num)
  148. int t_num;
  149. {
  150.     return(token[t_num].is_token &&
  151.             ((isalpha(input_line[token[t_num].start_index]))||
  152.              (input_line[token[t_num].start_index] == '_')));
  153. }
  154.  
  155.  
  156. /*
  157.  * is_definition() returns TRUE if the next tokens are of the form
  158.  *   identifier =
  159.  *        -or-
  160.  *   identifier ( identifer {,identifier} ) =
  161.  */
  162. int is_definition(t_num)
  163. int t_num;
  164. {
  165.     /* variable? */
  166.     if(isletter(t_num) && equals(t_num+1,"="))
  167.         return 1;
  168.  
  169.     /* function? */
  170.     /* look for dummy variables */
  171.     if(isletter(t_num) && equals(t_num+1,"(") && isletter(t_num+2)) {
  172.         t_num += 3;  /* point past first dummy */
  173.         while(equals(t_num,",")) {
  174.             if(!isletter(++t_num))
  175.                 return 0;
  176.             t_num += 1;
  177.         }
  178.         return(equals(t_num,")") && equals(t_num+1,"="));
  179.     }
  180.  
  181.     /* neither */
  182.     return 0;
  183. }
  184.  
  185.  
  186.  
  187. /*
  188.  * copy_str() copies the string in token number t_num into str, appending
  189.  *   a null.  No more than max chars are copied (including \0).
  190.  */
  191. void copy_str(str, t_num, max)
  192. char str[];
  193. int t_num;
  194. int max;
  195. {
  196. register int i = 0;
  197. register int start = token[t_num].start_index;
  198. register int count;
  199.  
  200.     if ((count = token[t_num].length) >= max) {
  201.         count = max-1;
  202. #ifdef DEBUG_STR
  203.         fprintf(stderr, "str buffer overflow in copy_str");
  204. #endif
  205.     }
  206.     do {
  207.         str[i++] = input_line[start++];
  208.         } while (i != count);
  209.     str[i] = '\0';
  210. }
  211.  
  212. /* length of token string */
  213. int token_len(t_num)
  214. int t_num;
  215. {
  216.     return (token[t_num].length);
  217. }
  218.  
  219. /*
  220.  * quote_str() does the same thing as copy_str, except it ignores the
  221.  *   quotes at both ends.  This seems redundant, but is done for
  222.  *   efficency.
  223.  */
  224. void quote_str(str, t_num, max)
  225. char str[];
  226. int t_num;
  227. int max;
  228. {
  229. register int i = 0;
  230. register int start = token[t_num].start_index + 1;
  231. register int count;
  232.  
  233.     if ((count = token[t_num].length - 2) >= max) {
  234.         count = max-1;
  235. #ifdef DEBUG_STR
  236.         fprintf(stderr, "str buffer overflow in quote_str");
  237. #endif
  238.     }
  239.     if (count>0) {
  240.         do {
  241.             str[i++] = input_line[start++];
  242.             } while (i != count);
  243.     }
  244.     str[i] = '\0';
  245.     /* convert \t and \nnn (octal) to char if in double quotes */
  246.     if ( input_line[token[t_num].start_index] == '"' )
  247.         parse_esc(str);
  248. }
  249.  
  250.  
  251. /*
  252.  *    capture() copies into str[] the part of input_line[] which lies between
  253.  *    the begining of token[start] and end of token[end].
  254.  */
  255. void capture(str,start,end,max)
  256. char str[];
  257. int start,end;
  258. int max;
  259. {
  260. register int i,e;
  261.  
  262.     e = token[end].start_index + token[end].length;
  263.     if(e-token[start].start_index>=max) {
  264.         e=token[start].start_index+max-1;
  265. #ifdef DEBUG_STR
  266.         fprintf(stderr, "str buffer overflow in capture");
  267. #endif
  268.     }
  269.  
  270.     for (i = token[start].start_index; i < e && input_line[i] != '\0'; i++)
  271.         *str++ = input_line[i];
  272.     *str = '\0';
  273. }
  274.  
  275.  
  276. /*
  277.  *    m_capture() is similar to capture(), but it mallocs storage for the
  278.  *  string.
  279.  */
  280. void m_capture(str,start,end)
  281. char **str;
  282. int start,end;
  283. {
  284. register int i,e;
  285. register char *s;
  286.  
  287.     if (*str)        /* previous pointer to malloc'd memory there */
  288.         free(*str);
  289.     e = token[end].start_index + token[end].length;
  290.     *str = alloc((unsigned long)(e - token[start].start_index + 1), "string");
  291.      s = *str;
  292.      for (i = token[start].start_index; i < e && input_line[i] != '\0'; i++)
  293.       *s++ = input_line[i];
  294.      *s = '\0';
  295. }
  296.  
  297.  
  298. /*
  299.  *    m_quote_capture() is similar to m_capture(), but it removes
  300.     quotes from either end if the string.
  301.  */
  302. void m_quote_capture(str,start,end)
  303. char **str;
  304. int start,end;
  305. {
  306. register int i,e;
  307. register char *s;
  308.  
  309.     if (*str)        /* previous pointer to malloc'd memory there */
  310.         free(*str);
  311.     e = token[end].start_index + token[end].length-1;
  312.     *str = alloc((unsigned long)(e - token[start].start_index + 1), "string");
  313.      s = *str;
  314.     for (i = token[start].start_index + 1; i < e && input_line[i] != '\0'; i++)
  315.      *s++ = input_line[i];
  316.     *s = '\0';
  317. }
  318.  
  319.  
  320. void convert(val_ptr, t_num)
  321. struct value *val_ptr;
  322. int t_num;
  323. {
  324.     *val_ptr = token[t_num].l_val;
  325. }
  326.  
  327. static char *num_to_str(r)
  328. double r;
  329. {
  330.     static i = 0;
  331.     static char s[4][25];
  332.     int j = i++;
  333.  
  334.     if ( i > 3 ) i = 0;
  335.  
  336.     sprintf( s[j], "%.15g", r );
  337.     if ( strchr( s[j], '.' ) == NULL &&
  338.          strchr( s[j], 'e' ) == NULL &&
  339.          strchr( s[j], 'E' ) == NULL )
  340.         strcat( s[j], ".0" );
  341.  
  342.     return s[j];
  343. } 
  344.  
  345. void disp_value(fp,val)
  346. FILE *fp;
  347. struct value *val;
  348. {
  349.     switch(val->type) {
  350.         case INTGR:
  351.             fprintf(fp,"%d",val->v.int_val);
  352.             break;
  353.         case CMPLX:
  354.             if (val->v.cmplx_val.imag != 0.0 )
  355.                 fprintf(fp,"{%s, %s}",
  356.                     num_to_str(val->v.cmplx_val.real),
  357.                     num_to_str(val->v.cmplx_val.imag));
  358.             else
  359.                 fprintf(fp,"%s",
  360.                     num_to_str(val->v.cmplx_val.real));
  361.             break;
  362.         default:
  363.             int_error("unknown type in disp_value()",NO_CARET);
  364.     }
  365. }
  366.  
  367.  
  368. double
  369. real(val)        /* returns the real part of val */
  370. struct value *val;
  371. {
  372.     switch(val->type) {
  373.         case INTGR:
  374.             return((double) val->v.int_val);
  375.         case CMPLX:
  376.             return(val->v.cmplx_val.real);
  377.     }
  378.     int_error("unknown type in real()",NO_CARET);
  379.     /* NOTREACHED */
  380.     return((double)0.0);
  381. }
  382.  
  383.  
  384. double
  385. imag(val)        /* returns the imag part of val */
  386. struct value *val;
  387. {
  388.     switch(val->type) {
  389.         case INTGR:
  390.             return(0.0);
  391.         case CMPLX:
  392.             return(val->v.cmplx_val.imag);
  393.     }
  394.     int_error("unknown type in imag()",NO_CARET);
  395.     /* NOTREACHED */
  396.     return((double)0.0);
  397. }
  398.  
  399.  
  400.  
  401. double
  402. magnitude(val)        /* returns the magnitude of val */
  403. struct value *val;
  404. {
  405.     switch(val->type) {
  406.         case INTGR:
  407.             return((double) abs(val->v.int_val));
  408.         case CMPLX:
  409.             return(sqrt(val->v.cmplx_val.real*
  410.                     val->v.cmplx_val.real +
  411.                     val->v.cmplx_val.imag*
  412.                     val->v.cmplx_val.imag));
  413.     }
  414.     int_error("unknown type in magnitude()",NO_CARET);
  415.     /* NOTREACHED */
  416.     return((double)0.0);
  417. }
  418.  
  419.  
  420.  
  421. double
  422. angle(val)        /* returns the angle of val */
  423. struct value *val;
  424. {
  425.     switch(val->type) {
  426.         case INTGR:
  427.             return((val->v.int_val >= 0) ? 0.0 : Pi);
  428.         case CMPLX:
  429.             if (val->v.cmplx_val.imag == 0.0) {
  430.                 if (val->v.cmplx_val.real >= 0.0)
  431.                     return(0.0);
  432.                 else
  433.                     return(Pi);
  434.             }
  435.             return(atan2(val->v.cmplx_val.imag,
  436.                      val->v.cmplx_val.real));
  437.     }
  438.     int_error("unknown type in angle()",NO_CARET);
  439.     /* NOTREACHED */
  440.     return((double)0.0);
  441. }
  442.  
  443.  
  444. struct value *
  445. Gcomplex(a,realpart,imagpart)
  446. struct value *a;
  447. double realpart, imagpart;
  448. {
  449.     a->type = CMPLX;
  450.     a->v.cmplx_val.real = realpart;
  451.     a->v.cmplx_val.imag = imagpart;
  452.     return(a);
  453. }
  454.  
  455.  
  456. struct value *
  457. Ginteger(a,i)
  458. struct value *a;
  459. int i;
  460. {
  461.     a->type = INTGR;
  462.     a->v.int_val = i;
  463.     return(a);
  464. }
  465.  
  466.  
  467. #if !defined(vms) && !defined(HAVE_STRERROR)
  468. /* substitute for systems that don't have ANSI function strerror */
  469.  
  470. extern int sys_nerr;
  471. extern char *sys_errlist[];
  472.  
  473. char *strerror(no)
  474. int no;
  475. {
  476.   static char res_str[30];
  477.  
  478.   if(no>sys_nerr) {
  479.     sprintf(res_str, "unknown errno %d", no);
  480.     return res_str;
  481.   } else {
  482.     return sys_errlist[no];
  483.   }
  484. }
  485. #endif
  486.  
  487.  
  488. void os_error(str,t_num)
  489. char str[];
  490. int t_num;
  491. {
  492. #ifdef vms
  493. static status[2] = {1, 0};        /* 1 is count of error msgs */
  494. #endif
  495.  
  496. register int i;
  497.  
  498.     /* reprint line if screen has been written to */
  499.  
  500.     if (t_num != NO_CARET) {        /* put caret under error */
  501.         if (!screen_ok)
  502.             fprintf(stderr,"\n%s%s\n", PROMPT, input_line);
  503.  
  504.         for (i = 0; i < sizeof(PROMPT) - 1; i++)
  505.             (void) putc(' ',stderr);
  506.         for (i = 0; i < token[t_num].start_index; i++) {
  507.             (void) putc((input_line[i] == '\t') ? '\t' : ' ',stderr);
  508.             }
  509.         (void) putc('^',stderr);
  510.         (void) putc('\n',stderr);
  511.     }
  512.  
  513.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  514.         (void) putc(' ',stderr);
  515.     fprintf(stderr,"%s\n",str);
  516.  
  517.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  518.         (void) putc(' ',stderr);
  519.      if (!interactive)
  520.       if (infile_name != NULL)
  521.         fprintf(stderr,"\"%s\", line %d: ", infile_name, inline_num);
  522.       else
  523.         fprintf(stderr,"line %d: ", inline_num);
  524.  
  525.  
  526. #ifdef vms
  527.     status[1] = vaxc$errno;
  528.     sys$putmsg(status);
  529.     (void) putc('\n',stderr);
  530. #else /* vms */
  531.     fprintf(stderr,"(%s)\n\n", strerror(errno));
  532. #endif /* vms */
  533.  
  534.     longjmp(env, TRUE);    /* bail out to command line */
  535. }
  536.  
  537.  
  538. void int_error(str,t_num)
  539. char str[];
  540. int t_num;
  541. {
  542. register int i;
  543.  
  544.     /* reprint line if screen has been written to */
  545.  
  546.     if (t_num != NO_CARET) {        /* put caret under error */
  547.         if (!screen_ok)
  548.             fprintf(stderr,"\n%s%s\n", PROMPT, input_line);
  549.  
  550.         for (i = 0; i < sizeof(PROMPT) - 1; i++)
  551.             (void) putc(' ',stderr);
  552.         for (i = 0; i < token[t_num].start_index; i++) {
  553.             (void) putc((input_line[i] == '\t') ? '\t' : ' ',stderr);
  554.             }
  555.         (void) putc('^',stderr);
  556.         (void) putc('\n',stderr);
  557.     }
  558.  
  559.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  560.         (void) putc(' ',stderr);
  561.      if (!interactive)
  562.       if (infile_name != NULL)
  563.         fprintf(stderr,"\"%s\", line %d: ", infile_name, inline_num);
  564.       else
  565.         fprintf(stderr,"line %d: ", inline_num);
  566.      fprintf(stderr,"%s\n\n", str);
  567.  
  568.     longjmp(env, TRUE);    /* bail out to command line */
  569. }
  570.  
  571. void int_warn(str,t_num)
  572. char str[];
  573. int t_num;
  574. {
  575. register int i;
  576.  
  577. /* Warn without bailing out to command line. Not a user error */
  578.  
  579.     /* reprint line if screen has been written to */
  580.  
  581.     if (t_num != NO_CARET) {        /* put caret under error */
  582.         if (!screen_ok)
  583.             fprintf(stderr,"\n%s%s\n", PROMPT, input_line);
  584.  
  585.         for (i = 0; i < sizeof(PROMPT) - 1; i++)
  586.             (void) putc(' ',stderr);
  587.         for (i = 0; i < token[t_num].start_index; i++) {
  588.             (void) putc((input_line[i] == '\t') ? '\t' : ' ',stderr);
  589.             }
  590.         (void) putc('^',stderr);
  591.         (void) putc('\n',stderr);
  592.     }
  593.  
  594.     for (i = 0; i < sizeof(PROMPT) - 1; i++)
  595.         (void) putc(' ',stderr);
  596.      if (!interactive)
  597.       if (infile_name != NULL)
  598.         fprintf(stderr,"\"%s\", line %d: ", infile_name, inline_num);
  599.       else
  600.         fprintf(stderr,"line %d: ", inline_num);
  601.      fprintf(stderr,"warning: %s\n", str);
  602.  
  603. } /* int_warn */
  604.  
  605. /* Lower-case the given string (DFK) */
  606. /* Done in place. */
  607. void
  608. lower_case(s)
  609.      char *s;
  610. {
  611.   register char *p = s;
  612.  
  613.   while (*p != '\0') {
  614.     if (isupper(*p))
  615.      *p = tolower(*p);
  616.     p++;
  617.   }
  618. }
  619.  
  620. /* Squash spaces in the given string (DFK) */
  621. /* That is, reduce all multiple white-space chars to single spaces */
  622. /* Done in place. */
  623. void
  624. squash_spaces(s)
  625.      char *s;
  626. {
  627.   register char *r = s;        /* reading point */
  628.   register char *w = s;        /* writing point */
  629.   TBOOLEAN space = FALSE;        /* TRUE if we've already copied a space */
  630.  
  631.   for (w = r = s; *r != '\0'; r++) {
  632.      if (isspace(*r)) {
  633.         /* white space; only copy if we haven't just copied a space */
  634.         if (!space) {
  635.             space = TRUE;
  636.             *w++ = ' ';
  637.         }                /* else ignore multiple spaces */
  638.      } else {
  639.         /* non-space character; copy it and clear flag */
  640.         *w++ = *r;
  641.         space = FALSE;
  642.      }
  643.   }
  644.   *w = '\0';                /* null terminate string */
  645. }
  646.  
  647. static int mndday[12] = { 31,28,31,30,31,30,31,31,30,31,30,31};
  648.  
  649. /* days in year */
  650. int
  651. gdysize(yr)
  652. int yr;
  653. {
  654.  
  655.     if (!(yr%4)) {
  656.         if ((!(yr%100)) && yr%400) 
  657.             return(365);
  658.         return(366);
  659.     }
  660.     return(365);
  661. }
  662.  
  663.  
  664. /* new strptime() and gmtime() to allow time to be read as 24 hour,
  665.  * and spaces in the format string. time is converted to seconds from
  666.  * year 2000.... */  
  667.  
  668. char *
  669. gstrptime(s,fmt,tm)
  670. char *s;
  671. char *fmt;
  672. struct tm *tm;
  673. {
  674.     int yday, date;
  675.  
  676.     date = yday = 0;
  677.     tm->tm_mday = 0;
  678.     tm->tm_mon = tm->tm_year = tm->tm_yday = tm->tm_hour = tm->tm_min = tm->tm_sec = 0;
  679.  
  680.     while ( *fmt != '\0' ) {
  681.         while(*s == *fmt) {s++; fmt++;}
  682.         if ( *fmt != '%' ) 
  683.             break;
  684.         fmt++;
  685.         if ( *fmt == 'd' ) { /* read a day of month */
  686.             s = read_int(s,2,&tm->tm_mday);
  687.             date++;
  688.         } else if ( *fmt == 'm' ) {
  689.             s = read_int(s,2,&tm->tm_mon);
  690.             date++;
  691.             tm->tm_mon--;
  692.         } else if ( *fmt == 'y' ) {
  693.             s = read_int(s,2,&tm->tm_year);
  694.             date++;
  695.             tm->tm_year += 1900;
  696.         } else if ( *fmt == 'Y' ) {
  697.             s = read_int(s,4,&tm->tm_year);
  698.             date++;
  699.             /* tm->tm_year -= 1900; */
  700.             /* HOE tm->tm_year %= 100; */
  701.         } else if ( *fmt == 'j' ) {
  702.             s = read_int(s,3,&tm->tm_yday);
  703.             tm->tm_yday--;
  704.             date++;
  705.             yday++;
  706.         } else if ( *fmt == 'H' ) {
  707.             s = read_int(s,2,&tm->tm_hour);
  708.         } else if ( *fmt == 'M' ) {
  709.             s = read_int(s,2,&tm->tm_min);
  710.         } else if ( *fmt == 'S' ) {
  711.             s = read_int(s,2,&tm->tm_sec);
  712.         }
  713.         fmt++;
  714.     }
  715.     /* if (!yday && date) { */
  716.     if (date) {
  717.         /* 
  718.         tm->tm_yday = 0;
  719.         for(i=0;i<tm->tm_mon;i++) {
  720.             tm->tm_yday += mndday[i] + (i==1 && (gdysize(tm->tm_year)>365));
  721.         }
  722.         tm->tm_yday += tm->tm_mday-1;
  723.         */
  724.         if (yday) {
  725.             if ( tm->tm_yday < 0 || tm->tm_yday > gdysize(tm->tm_year)) {
  726.                 int_error("illegal day of year",NO_CARET);
  727.                 return(NULL);
  728.             }
  729.         } else {
  730.             if ( tm->tm_mon < 0 || tm->tm_mon > 11 ) {
  731.                 int_error("illegal month",NO_CARET);
  732.                 return(NULL);
  733.             }
  734.             if ( tm->tm_mday < 1 || tm->tm_mday > mndday[tm->tm_mon] + (tm->tm_mon == 1 && (gdysize(tm->tm_year)>365)) ) {
  735.                 int_error("illegal day of month",NO_CARET);
  736.                 return(NULL);
  737.             }
  738.         }
  739.     }
  740.     if ( tm->tm_hour < 0 || tm->tm_hour > 24 ) {
  741.         int_error("illegal hour",NO_CARET);
  742.         return(NULL);
  743.     }
  744.     if ( tm->tm_min < 0 || tm->tm_min > 60 ) {
  745.         int_error("illegal minute",NO_CARET);
  746.         return(NULL);
  747.     }
  748.     if ( tm->tm_sec < 0 || tm->tm_sec > 60 ) {
  749.         int_error("illegal second",NO_CARET);
  750.         return(NULL);
  751.     }
  752.     return(s);
  753. }
  754.  
  755. static char *
  756. read_int(s,nr,d)
  757. char *s;
  758. int nr, *d;
  759. {
  760.     char num[8];
  761.     int i;
  762.  
  763.     i = 0;
  764.     while(i<nr) {
  765.         if( *s >= '0' && *s <= '9' ) {
  766.             num[i++] = *s++;
  767.         } else {
  768.             break;
  769.         }
  770.     }
  771.     num[i] = '\0';
  772.     sscanf(num,"%d",d);
  773.     return(s);
  774. }
  775.  
  776.  
  777. int 
  778. gstrftime(s,bsz,fmt,clock)
  779. char *s;
  780. int bsz;
  781. char *fmt;
  782. double clock;
  783. {
  784.     int xstrftime();
  785.     int days;
  786.     time_t cl;
  787.     struct tm tm;
  788.     struct tm *xtm;
  789.  
  790.     ggmtime(&tm,clock);
  791.     /* weekday, 0 = sunday */
  792.     cl = 0;
  793.     xtm = gmtime(&cl);
  794.     /* antall dager */
  795.     days = (int) (clock+SEC_OFFS_SYS)/DAY_SEC;
  796.     /* weekrest */
  797.     days %= 7;
  798.     if ( days < 0 ) days += 7;
  799.     tm.tm_wday = (xtm->tm_wday+days)%7;
  800. #if 0
  801.     if ((tm.tm_zone = (char *) malloc(strlen(xtm->tm_zone)+1))) 
  802.         strcpy(tm.tm_zone,xtm->tm_zone);
  803.     /* printf("zone: %s - %s\n",tm.tm_zone,xtm->tm_zone); */
  804. #endif
  805.  
  806.     return(xstrftime(s,bsz,fmt,&tm));
  807. }
  808.  
  809. int 
  810. xstrftime(str,bsz,fmt,tm)
  811. char *str;
  812. int bsz;
  813. char *fmt;
  814. struct tm *tm;
  815. {
  816.     int l;
  817.     char *p, *s;
  818.  
  819.     p = fmt;
  820.     s = str;
  821.     memset(s,'\0',bsz+1);
  822.     l=0;
  823.     while (*p != '\0') {
  824.         if (*p != '%') {
  825.             if ( l >= bsz ) return(0);
  826.             *s++ = *p++;
  827.             l++;
  828.         } else {
  829.             p++;
  830.             if ( *p == '%' ) {
  831.                 if ( l >= bsz ) return(0);
  832.                 *s = '%';
  833.             } else if ( *p == 'a' ) {    
  834.                 if ((l+strlen(abbrev_day_names[tm->tm_wday])) > bsz ) return(0);
  835.                 sprintf(s,"%s",abbrev_day_names[tm->tm_wday]);
  836.             } else if ( *p == 'A' ) {    
  837.                 if(l+strlen(full_day_names[tm->tm_wday]) > bsz) return(0);
  838.                 sprintf(s,"%s",full_day_names[tm->tm_wday]);
  839.             } else if ( *p == 'b' || *p == 'h' ) {
  840.                 if(l+strlen(abbrev_month_names[tm->tm_mon])> bsz) return(0);
  841.                 sprintf(s,"%s",abbrev_month_names[tm->tm_mon]);
  842.             } else if ( *p == 'B' ) {
  843.                 if(l+strlen(full_month_names[tm->tm_mon]) > bsz) return(0);
  844.                 sprintf(s,"%s",full_month_names[tm->tm_mon]);
  845.             } else if ( *p == 'c' ) {
  846.                 if (!xstrftime(s,bsz-l,"%x %X",tm)) {
  847.                     return(0);
  848.                 }
  849. #if 0
  850.             } else if ( *p == 'C' ) {
  851.                 if (!xstrftime(s,bsz-l,dtc->ldate_format,tm)) {
  852.                     return(0);
  853.                 }
  854. #endif
  855.             } else if ( *p == 'd' ) {
  856.                 if ( bsz - l < 2 ) return(0);
  857.                 sprintf(s,"%02d",tm->tm_mday);
  858.             } else if ( *p == 'D' ) {
  859.                 if (!xstrftime(s,bsz-l,"%m/%d/%y",tm)) {
  860.                     return(0);
  861.                 }
  862.             } else if ( *p == 'e' ) {
  863.                 if ( bsz - l < 2 ) return(0);
  864.                 sprintf(s,"%2d",tm->tm_mday);
  865.             } else if ( *p == 'H' ) {
  866.                 if ( bsz - l < 2 ) return(0);
  867.                 sprintf(s,"%02d",tm->tm_hour);
  868.             } else if ( *p == 'I' ) {
  869.                 if ( bsz - l < 2 ) return(0);
  870.                 sprintf(s,"%02d",tm->tm_hour%12);
  871.             } else if ( *p == 'j' ) {
  872.                 if ( bsz - l < 3 ) return(0);
  873.                 sprintf(s,"%03d",tm->tm_yday+1);
  874.             } else if ( *p == 'k' ) {
  875.                 if ( bsz - l < 2 ) return(0);
  876.                 sprintf(s,"%2d",tm->tm_hour);
  877.             } else if ( *p == 'l' ) {
  878.                 if ( bsz - l < 2 ) return(0);
  879.                 sprintf(s,"%2d",tm->tm_hour%12);
  880.             } else if ( *p == 'm' ) {
  881.                 if ( bsz - l < 2 ) return(0);
  882.                 sprintf(s,"%02d",tm->tm_mon+1);
  883.             } else if ( *p == 'M' ) {
  884.                 if ( bsz - l < 2 ) return(0);
  885.                 sprintf(s,"%02d",tm->tm_min);
  886.             } else if ( *p == 'n' ) {
  887.                 if ( bsz >= l ) return(0);
  888.                 *s = '\n';
  889.             } else if ( *p == 'p' ) {
  890.                 if(l+strlen((tm->tm_hour<12)?"am":"pm") > bsz) return(0);
  891.                 sprintf(s,"%s",(tm->tm_hour<12)?"am":"pm");
  892.             } else if ( *p == 'r' ) {
  893.                 if (!xstrftime(s,bsz-l,"%I:%M:%S %p",tm)) {
  894.                     return(0);
  895.                 }
  896.             } else if ( *p == 'R' ) {
  897.                 if (!xstrftime(s,bsz-l,"%H:%M",tm)) {
  898.                     return(0);
  899.                 }
  900.             } else if ( *p == 'S' ) {
  901.                 if ( bsz - l < 2 ) return(0);
  902.                 sprintf(s,"%02d",tm->tm_sec);
  903.             } else if ( *p == 't' ) {
  904.                 if ( bsz >= l ) return(0);
  905.                 *s = '\t';
  906.             } else if ( *p == 'T' ) {
  907.                 if (!xstrftime(s,bsz-l,"%H:%M:%S",tm)) {
  908.                     return(0);
  909.                 }
  910.             } else if ( *p == 'W' ) { /* mon 1 day of week */
  911.                 int week, bw;
  912.  
  913.                 if ( bsz - l < 2 ) return(0);
  914.                 if ( tm->tm_yday <= tm->tm_wday ) {
  915.                     week = 1;
  916.                     if ( (tm->tm_mday - tm->tm_yday) > 4 ) {
  917.                         week = 52;
  918.                     } 
  919.                     if ( tm->tm_yday == tm->tm_wday && tm->tm_wday == 0 ) week = 52;
  920.                 } else {
  921.                     bw = tm->tm_yday - tm->tm_wday; /* sun prev week */
  922.                     if ( tm->tm_wday > 0 ) bw += 7; /* sun end of week */
  923.                     week = (int) bw/7;
  924.                     if ( (bw%7) > 2 ) { /* jan 1 is before friday */
  925.                         week++;
  926.                     }
  927.                 }
  928.                 sprintf(s,"%02d",week);
  929.             } else if ( *p == 'U' ) { /* sun 1 day of week */
  930.                 int week, bw;
  931.  
  932.                 if ( bsz - l < 2 ) return(0);
  933.                 if ( tm->tm_yday <= tm->tm_wday ) {
  934.                     week = 1;
  935.                     if ( (tm->tm_mday - tm->tm_yday) > 4 ) {
  936.                         week = 52;
  937.                     } 
  938.                 } else {
  939.                     bw = tm->tm_yday - tm->tm_wday-1; /* sat prev week */
  940.                     if ( tm->tm_wday >= 0 ) bw += 7; /* sat end of week */
  941.                     week = (int) bw/7;
  942.                     if ( (bw%7) > 1 ) { /* jan 1 is before friday */
  943.                         week++;
  944.                     }
  945.                 }
  946.                 sprintf(s,"%02d",week);
  947.             } else if ( *p == 'w' ) { /* day of week, sun=0 */
  948.                 if ( bsz - l < 2 ) return(0);
  949.                 sprintf(s,"%02d",tm->tm_wday);
  950. #if 0
  951.             } else if ( *p == 'x' ) { /* locales date format */
  952.                 if (!xstrftime(s,bsz-l,dtc->sdate_format,tm)) {
  953.                     return(0);
  954.                 }
  955.             } else if ( *p == 'X' ) { /* locales time format */
  956.                 if (!xstrftime(s,bsz-l,dtc->time_format,tm)) {
  957.                     return(0);
  958.                 }
  959. #endif
  960.             } else if ( *p == 'y' ) {
  961.                 if ( bsz - l < 2 ) return(0);
  962.                 sprintf(s,"%02d",tm->tm_year%100);
  963.             } else if ( *p == 'Y' ) {
  964.                 if ( bsz - l < 4 ) return(0);
  965.                 sprintf(s,"%04d",tm->tm_year);
  966. #if 0
  967.             } else if ( *p == 'Z' ) {
  968.                 if ( bsz - l < strlen(tm->tm_zone) ) return(0);
  969.                 sprintf(s,"%s",tm->tm_zone);
  970. #endif
  971.             }
  972.             p++;
  973.             while ( *s != '\0' ) {
  974.                 s++;
  975.                 l++;
  976.             }
  977.         }
  978.     }
  979.     return(l);
  980. }
  981.  
  982. /* time_t  */
  983. double
  984. gtimegm(tm)
  985. struct tm *tm;
  986. {
  987.     register int i;
  988.     /* returns sec from year ZERO_YEAR, defined in plot.h */
  989.     double dsec;
  990.  
  991.     dsec = 0;
  992.     if ( tm->tm_year < ZERO_YEAR ) {
  993.         for(i=tm->tm_year;i<ZERO_YEAR;i++) {
  994.             dsec -= (double) gdysize(i);
  995.         }
  996.     } else {
  997.         for(i=ZERO_YEAR;i<tm->tm_year;i++) {
  998.             dsec += (double) gdysize(i);
  999.         }
  1000.     }
  1001.     if ( tm->tm_mday > 0 ) {
  1002.         for (i=0;i<tm->tm_mon;i++) {
  1003.             dsec += (double) mndday[i] + (i==1 && (gdysize(tm->tm_year)>365));
  1004.         }
  1005.         dsec += (double) tm->tm_mday-1;
  1006.     } else {
  1007.         dsec += (double) tm->tm_yday;
  1008.     }
  1009.     dsec *= (double) 24;
  1010.  
  1011.     dsec += tm->tm_hour;
  1012.     dsec *= 60.0;
  1013.     dsec += tm->tm_min;
  1014.     dsec *= 60.0;
  1015.     dsec += tm->tm_sec;
  1016.  
  1017.     return(dsec);
  1018. }
  1019.  
  1020. int
  1021. ggmtime(tm,clock)
  1022. struct tm *tm;
  1023. /* time_t clock; */
  1024. double clock;
  1025. {
  1026.     /* clock is relative to ZERO_YEAR, jan 1, 00:00:00,defined in plot.h */
  1027.     int i, days;
  1028.     
  1029.     tm->tm_year = ZERO_YEAR;
  1030.     tm->tm_mday = tm->tm_yday = tm->tm_mon = tm->tm_hour = tm->tm_min = tm->tm_sec = 0; 
  1031.     if ( clock < 0 ) {
  1032.         while ( clock < 0 ) {
  1033.             tm->tm_year --;
  1034.             clock += gdysize(tm->tm_year)*DAY_SEC; /* 24*3600 */
  1035.         }
  1036.     } else {
  1037.         while ( clock >= (gdysize(tm->tm_year)*DAY_SEC) ) {
  1038.             clock -= gdysize(tm->tm_year)*DAY_SEC;
  1039.             tm->tm_year ++;
  1040.         }
  1041.     }
  1042.     tm->tm_yday = (int)clock/DAY_SEC;
  1043.     clock -= tm->tm_yday*DAY_SEC;
  1044.     tm->tm_hour = (int)clock/3600;
  1045.     clock -= tm->tm_hour*3600;
  1046.     tm->tm_min = (int)clock/60;
  1047.     clock -= tm->tm_min*60;
  1048.     tm->tm_sec = (int)clock;
  1049.     days = tm->tm_yday;
  1050.     while ( days >= (i = mndday[tm->tm_mon] + (tm->tm_mon==1 && (gdysize(tm->tm_year)>365)))) {
  1051.         days -= i;
  1052.         tm->tm_mon ++;
  1053.     }
  1054.     tm->tm_mday = days+1;
  1055.  
  1056.     return(0);
  1057. }
  1058.  
  1059. static void
  1060. parse_esc(instr)
  1061. char *instr;
  1062. {
  1063.     char *s=instr, *t=instr;
  1064.  
  1065.     /* the string will always get shorter, so we can do the
  1066.      * conversion in situ
  1067.      */
  1068.  
  1069.     while (*s != '\0' ) {
  1070.         if ( *s == '\\' ) {
  1071.             s++;
  1072.             if ( *s == '\\' ) {
  1073.                 *t++ = '\\';
  1074.                 s++;
  1075.             } else if ( *s == 'n' ) {
  1076.                 *t++ = '\n';
  1077.                 s++;
  1078.             } else if ( *s == 'r' ) {
  1079.                 *t++ = '\r';
  1080.                 s++;
  1081.             } else if ( *s == 't' ) {
  1082.                 *t++ = '\t';
  1083.                 s++;
  1084.             } else if ( *s >= '0' && *s <= '7' ) {
  1085.                 int i,n;
  1086.                 if ( sscanf(s,"%o%n",&i, &n) > 0 ) {
  1087.                     *t++ = i;
  1088.                     s+=n;
  1089.                 } else {
  1090.                        /* int_error("illegal octal number ", c_token); */
  1091.                        *t++ = '\\';
  1092.                        *t++ = *s++;
  1093.                 }
  1094.             }
  1095.         } else {
  1096.             *t++ = *s++;
  1097.         }
  1098.     }
  1099.     *t = '\0';
  1100. }
  1101.