Annotation of OpenXM_contrib/gnuplot/misc.c, Revision 1.1.1.1
1.1 maekawa 1: #ifndef lint
2: static char *RCSid = "$Id: misc.c,v 1.79 1998/04/14 00:16:02 drd Exp $";
3: #endif
4:
5: /* GNUPLOT - misc.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: #ifdef AMIGA_AC_5
38: # include <exec/types.h>
39: #endif /* AMIGA_AC_5 */
40:
41: #include "plot.h"
42: #include "setshow.h"
43:
44: extern int key_vpos, key_hpos, key_just;
45: extern int datatype[];
46: extern char timefmt[];
47:
48: static void save_range __PROTO((FILE * fp, int axis, double min, double max, int autosc, char *text));
49: static void save_tics __PROTO((FILE * fp, int where, int axis, struct ticdef * tdef, TBOOLEAN rotate, char *text));
50: static void save_position __PROTO((FILE * fp, struct position * pos));
51: static void save_functions__sub __PROTO((FILE * fp));
52: static void save_variables__sub __PROTO((FILE * fp));
53: static int lf_pop __PROTO((void));
54: static void lf_push __PROTO((FILE * fp));
55: static int find_maxl_cntr __PROTO((struct gnuplot_contours * contours, int *count));
56:
57:
58: #define SAVE_NUM_OR_TIME(fp, x, axis) \
59: do{if (datatype[axis]==TIME) { \
60: char s[80]; char *p; \
61: putc('"', fp); \
62: gstrftime(s,80,timefmt,(double)(x)); \
63: for(p=s; *p; ++p) {\
64: if ( *p == '\t' ) fputs("\\t",fp);\
65: else if (*p == '\n') fputs("\\n",fp); \
66: else if ( *p > 126 || *p < 32 ) fprintf(fp,"\\%03o",*p);\
67: else putc(*p, fp);\
68: }\
69: putc('"', fp);\
70: } else {\
71: fprintf(fp,"%g",x);\
72: }} while(0)
73:
74:
75: /* State information for load_file(), to recover from errors
76: * and properly handle recursive load_file calls
77: */
78: typedef struct lf_state_struct LFS;
79: struct lf_state_struct {
80: FILE *fp; /* file pointer for load file */
81: char *name; /* name of file */
82: TBOOLEAN interactive; /* value of interactive flag on entry */
83: TBOOLEAN do_load_arg_substitution; /* likewise ... */
84: int inline_num; /* inline_num on entry */
85: LFS *prev; /* defines a stack */
86: char *call_args[10]; /* args when file is 'call'ed instead of 'load'ed */
87: } *lf_head = NULL; /* NULL if not in load_file */
88:
89: /* these two could be in load_file, except for error recovery */
90: extern TBOOLEAN do_load_arg_substitution;
91: extern char *call_args[10];
92:
93: /*
94: * cp_alloc() allocates a curve_points structure that can hold 'num'
95: * points.
96: */
97: struct curve_points *
98: cp_alloc(num)
99: int num;
100: {
101: struct curve_points *cp;
102:
103: cp = (struct curve_points *) gp_alloc((unsigned long) sizeof(struct curve_points), "curve");
104: cp->p_max = (num >= 0 ? num : 0);
105:
106: if (num > 0) {
107: cp->points = (struct coordinate GPHUGE *)
108: gp_alloc((unsigned long) num * sizeof(struct coordinate), "curve points");
109: } else
110: cp->points = (struct coordinate GPHUGE *) NULL;
111: cp->next_cp = NULL;
112: cp->title = NULL;
113: return (cp);
114: }
115:
116:
117: /*
118: * cp_extend() reallocates a curve_points structure to hold "num"
119: * points. This will either expand or shrink the storage.
120: */
121: void cp_extend(cp, num)
122: struct curve_points *cp;
123: int num;
124: {
125:
126: #if defined(DOS16) || defined(WIN16)
127: /* Make sure we do not allocate more than 64k points in msdos since
128: * indexing is done with 16-bit int
129: * Leave some bytes for malloc maintainance.
130: */
131: if (num > 32700)
132: int_error("Array index must be less than 32k in msdos", NO_CARET);
133: #endif /* MSDOS */
134:
135: if (num == cp->p_max)
136: return;
137:
138: if (num > 0) {
139: if (cp->points == NULL) {
140: cp->points = (struct coordinate GPHUGE *)
141: gp_alloc((unsigned long) num * sizeof(struct coordinate), "curve points");
142: } else {
143: cp->points = (struct coordinate GPHUGE *)
144: gp_realloc(cp->points, (unsigned long) num * sizeof(struct coordinate), "expanding curve points");
145: }
146: cp->p_max = num;
147: } else {
148: if (cp->points != (struct coordinate GPHUGE *) NULL)
149: free(cp->points);
150: cp->points = (struct coordinate GPHUGE *) NULL;
151: cp->p_max = 0;
152: }
153: }
154:
155: /*
156: * cp_free() releases any memory which was previously malloc()'d to hold
157: * curve points (and recursively down the linked list).
158: */
159: void cp_free(cp)
160: struct curve_points *cp;
161: {
162: if (cp) {
163: cp_free(cp->next_cp);
164: if (cp->title)
165: free((char *) cp->title);
166: if (cp->points)
167: free((char *) cp->points);
168: free((char *) cp);
169: }
170: }
171:
172: /*
173: * iso_alloc() allocates a iso_curve structure that can hold 'num'
174: * points.
175: */
176: struct iso_curve *
177: iso_alloc(num)
178: int num;
179: {
180: struct iso_curve *ip;
181: ip = (struct iso_curve *) gp_alloc((unsigned long) sizeof(struct iso_curve), "iso curve");
182: ip->p_max = (num >= 0 ? num : 0);
183: if (num > 0) {
184: ip->points = (struct coordinate GPHUGE *)
185: gp_alloc((unsigned long) num * sizeof(struct coordinate), "iso curve points");
186: } else
187: ip->points = (struct coordinate GPHUGE *) NULL;
188: ip->next = NULL;
189: return (ip);
190: }
191:
192: /*
193: * iso_extend() reallocates a iso_curve structure to hold "num"
194: * points. This will either expand or shrink the storage.
195: */
196: void iso_extend(ip, num)
197: struct iso_curve *ip;
198: int num;
199: {
200: if (num == ip->p_max)
201: return;
202:
203: #if defined(DOS16) || defined(WIN16)
204: /* Make sure we do not allocate more than 64k points in msdos since
205: * indexing is done with 16-bit int
206: * Leave some bytes for malloc maintainance.
207: */
208: if (num > 32700)
209: int_error("Array index must be less than 32k in msdos", NO_CARET);
210: #endif /* 16bit (Win)Doze */
211:
212: if (num > 0) {
213: if (ip->points == NULL) {
214: ip->points = (struct coordinate GPHUGE *)
215: gp_alloc((unsigned long) num * sizeof(struct coordinate), "iso curve points");
216: } else {
217: ip->points = (struct coordinate GPHUGE *)
218: gp_realloc(ip->points, (unsigned long) num * sizeof(struct coordinate), "expanding curve points");
219: }
220: ip->p_max = num;
221: } else {
222: if (ip->points != (struct coordinate GPHUGE *) NULL)
223: free(ip->points);
224: ip->points = (struct coordinate GPHUGE *) NULL;
225: ip->p_max = 0;
226: }
227: }
228:
229: /*
230: * iso_free() releases any memory which was previously malloc()'d to hold
231: * iso curve points.
232: */
233: void iso_free(ip)
234: struct iso_curve *ip;
235: {
236: if (ip) {
237: if (ip->points)
238: free((char *) ip->points);
239: free((char *) ip);
240: }
241: }
242:
243: /*
244: * sp_alloc() allocates a surface_points structure that can hold 'num_iso_1'
245: * iso-curves with 'num_samp_2' samples and 'num_iso_2' iso-curves with
246: * 'num_samp_1' samples.
247: * If, however num_iso_2 or num_samp_1 is zero no iso curves are allocated.
248: */
249: struct surface_points *
250: sp_alloc(num_samp_1, num_iso_1, num_samp_2, num_iso_2)
251: int num_samp_1, num_iso_1, num_samp_2, num_iso_2;
252: {
253: struct surface_points *sp;
254:
255: sp = (struct surface_points *) gp_alloc((unsigned long) sizeof(struct surface_points), "surface");
256: sp->next_sp = NULL;
257: sp->title = NULL;
258: sp->contours = NULL;
259: sp->iso_crvs = NULL;
260: sp->num_iso_read = 0;
261:
262: if (num_iso_2 > 0 && num_samp_1 > 0) {
263: int i;
264: struct iso_curve *icrv;
265:
266: for (i = 0; i < num_iso_1; i++) {
267: icrv = iso_alloc(num_samp_2);
268: icrv->next = sp->iso_crvs;
269: sp->iso_crvs = icrv;
270: }
271: for (i = 0; i < num_iso_2; i++) {
272: icrv = iso_alloc(num_samp_1);
273: icrv->next = sp->iso_crvs;
274: sp->iso_crvs = icrv;
275: }
276: } else
277: sp->iso_crvs = (struct iso_curve *) NULL;
278:
279: return (sp);
280: }
281:
282: /*
283: * sp_replace() updates a surface_points structure so it can hold 'num_iso_1'
284: * iso-curves with 'num_samp_2' samples and 'num_iso_2' iso-curves with
285: * 'num_samp_1' samples.
286: * If, however num_iso_2 or num_samp_1 is zero no iso curves are allocated.
287: */
288: void sp_replace(sp, num_samp_1, num_iso_1, num_samp_2, num_iso_2)
289: struct surface_points *sp;
290: int num_samp_1, num_iso_1, num_samp_2, num_iso_2;
291: {
292: int i;
293: struct iso_curve *icrv, *icrvs = sp->iso_crvs;
294:
295: while (icrvs) {
296: icrv = icrvs;
297: icrvs = icrvs->next;
298: iso_free(icrv);
299: }
300: sp->iso_crvs = NULL;
301:
302: if (num_iso_2 > 0 && num_samp_1 > 0) {
303: for (i = 0; i < num_iso_1; i++) {
304: icrv = iso_alloc(num_samp_2);
305: icrv->next = sp->iso_crvs;
306: sp->iso_crvs = icrv;
307: }
308: for (i = 0; i < num_iso_2; i++) {
309: icrv = iso_alloc(num_samp_1);
310: icrv->next = sp->iso_crvs;
311: sp->iso_crvs = icrv;
312: }
313: } else
314: sp->iso_crvs = (struct iso_curve *) NULL;
315: }
316:
317: /*
318: * sp_free() releases any memory which was previously malloc()'d to hold
319: * surface points.
320: */
321: void sp_free(sp)
322: struct surface_points *sp;
323: {
324: if (sp) {
325: sp_free(sp->next_sp);
326: if (sp->title)
327: free((char *) sp->title);
328: if (sp->contours) {
329: struct gnuplot_contours *cntr, *cntrs = sp->contours;
330:
331: while (cntrs) {
332: cntr = cntrs;
333: cntrs = cntrs->next;
334: free(cntr->coords);
335: free(cntr);
336: }
337: }
338: if (sp->iso_crvs) {
339: struct iso_curve *icrv, *icrvs = sp->iso_crvs;
340:
341: while (icrvs) {
342: icrv = icrvs;
343: icrvs = icrvs->next;
344: iso_free(icrv);
345: }
346: }
347: free((char *) sp);
348: }
349: }
350:
351:
352: /*
353: * functions corresponding to the arguments of the GNUPLOT `save` command
354: */
355: void save_functions(fp)
356: FILE *fp;
357: {
358: if (fp) {
359: show_version(fp); /* I _love_ information written */
360: save_functions__sub(fp); /* at the top and the end of an */
361: fputs("# EOF\n", fp); /* human readable ASCII file. */
362: (void) fclose(fp); /* (JFi) */
363: } else
364: os_error("Cannot open save file", c_token);
365: }
366:
367:
368: void save_variables(fp)
369: FILE *fp;
370: {
371: if (fp) {
372: show_version(fp);
373: save_variables__sub(fp);
374: fputs("# EOF\n", fp);
375: (void) fclose(fp);
376: } else
377: os_error("Cannot open save file", c_token);
378: }
379:
380:
381: void save_set(fp)
382: FILE *fp;
383: {
384: if (fp) {
385: show_version(fp);
386: save_set_all(fp);
387: fputs("# EOF\n", fp);
388: (void) fclose(fp);
389: } else
390: os_error("Cannot open save file", c_token);
391: }
392:
393:
394: void save_all(fp)
395: FILE *fp;
396: {
397: if (fp) {
398: show_version(fp);
399: save_set_all(fp);
400: save_functions__sub(fp);
401: save_variables__sub(fp);
402: fprintf(fp, "%s\n", replot_line);
403: if (wri_to_fil_last_fit_cmd(NULL)) {
404: fputs("## ", fp);
405: wri_to_fil_last_fit_cmd(fp);
406: putc('\n', fp);
407: }
408: fputs("# EOF\n", fp);
409: (void) fclose(fp);
410: } else
411: os_error("Cannot open save file", c_token);
412: }
413:
414: /*
415: * auxiliary functions
416: */
417:
418: static void save_functions__sub(fp)
419: FILE *fp;
420: {
421: register struct udft_entry *udf = first_udf;
422:
423: while (udf) {
424: if (udf->definition) {
425: fprintf(fp, "%s\n", udf->definition);
426: }
427: udf = udf->next_udf;
428: }
429: }
430:
431: static void save_variables__sub(fp)
432: FILE *fp;
433: {
434: register struct udvt_entry *udv = first_udv->next_udv; /* always skip pi */
435:
436: while (udv) {
437: if (!udv->udv_undef) {
438: fprintf(fp, "%s = ", udv->udv_name);
439: disp_value(fp, &(udv->udv_value));
440: (void) putc('\n', fp);
441: }
442: udv = udv->next_udv;
443: }
444: }
445:
446: void save_set_all(fp)
447: FILE *fp;
448: {
449: struct text_label *this_label;
450: struct arrow_def *this_arrow;
451: struct linestyle_def *this_linestyle;
452: char str[MAX_LINE_LEN + 1];
453:
454: /* opinions are split as to whether we save term and outfile
455: * as a compromise, we output them as comments !
456: */
457: if (term)
458: fprintf(fp, "# set terminal %s %s\n", term->name, term_options);
459: else
460: fputs("# set terminal unknown\n", fp);
461:
462: if (outstr)
463: fprintf(fp, "# set output '%s'\n", outstr);
464: else
465: fputs("# set output\n", fp);
466:
467: fprintf(fp, "\
468: set %sclip points\n\
469: set %sclip one\n\
470: set %sclip two\n\
471: set bar %f\n",
472: (clip_points) ? "" : "no",
473: (clip_lines1) ? "" : "no",
474: (clip_lines2) ? "" : "no",
475: bar_size);
476:
477: if (draw_border)
478: /* HBB 980609: handle border linestyle, too */
479: fprintf(fp, "set border %d lt %d lw %.3f\n", draw_border, border_lp.l_type + 1, border_lp.l_width);
480: else
481: fprintf(fp, "set noborder\n");
482:
483: fprintf(fp, "\
484: set xdata%s\n\
485: set ydata%s\n\
486: set zdata%s\n\
487: set x2data%s\n\
488: set y2data%s\n",
489: datatype[FIRST_X_AXIS] == TIME ? " time" : "",
490: datatype[FIRST_Y_AXIS] == TIME ? " time" : "",
491: datatype[FIRST_Z_AXIS] == TIME ? " time" : "",
492: datatype[SECOND_X_AXIS] == TIME ? " time" : "",
493: datatype[SECOND_Y_AXIS] == TIME ? " time" : "");
494:
495: if (boxwidth < 0.0)
496: fputs("set boxwidth\n", fp);
497: else
498: fprintf(fp, "set boxwidth %g\n", boxwidth);
499: if (dgrid3d)
500: fprintf(fp, "set dgrid3d %d,%d, %d\n",
501: dgrid3d_row_fineness,
502: dgrid3d_col_fineness,
503: dgrid3d_norm_value);
504:
505: fprintf(fp, "\
506: set dummy %s,%s\n\
507: set format x \"%s\"\n\
508: set format y \"%s\"\n\
509: set format x2 \"%s\"\n\
510: set format y2 \"%s\"\n\
511: set format z \"%s\"\n\
512: set angles %s\n",
513: dummy_var[0], dummy_var[1],
514: conv_text(str, xformat),
515: conv_text(str, yformat),
516: conv_text(str, x2format),
517: conv_text(str, y2format),
518: conv_text(str, zformat),
519: (angles_format == ANGLES_RADIANS) ? "radians" : "degrees");
520:
521: if (work_grid.l_type == 0)
522: fputs("set nogrid\n", fp);
523: else {
524: if (polar_grid_angle) /* set angle already output */
525: fprintf(fp, "set grid polar %f\n", polar_grid_angle / ang2rad);
526: else
527: fputs("set grid nopolar\n", fp);
528: fprintf(fp, "set grid %sxtics %sytics %sztics %sx2tics %sy2tics %smxtics %smytics %smztics %smx2tics %smy2tics lt %d lw %.3f, lt %d lw %.3f\n",
529: work_grid.l_type & GRID_X ? "" : "no",
530: work_grid.l_type & GRID_Y ? "" : "no",
531: work_grid.l_type & GRID_Z ? "" : "no",
532: work_grid.l_type & GRID_X2 ? "" : "no",
533: work_grid.l_type & GRID_Y2 ? "" : "no",
534: work_grid.l_type & GRID_MX ? "" : "no",
535: work_grid.l_type & GRID_MY ? "" : "no",
536: work_grid.l_type & GRID_MZ ? "" : "no",
537: work_grid.l_type & GRID_MX2 ? "" : "no",
538: work_grid.l_type & GRID_MY2 ? "" : "no",
539: grid_lp.l_type + 1, grid_lp.l_width,
540: mgrid_lp.l_type + 1, mgrid_lp.l_width);
541: }
542: fprintf(fp, "set key title \"%s\"\n", conv_text(str, key_title));
543: switch (key) {
544: case -1:{
545: fputs("set key", fp);
546: switch (key_hpos) {
547: case TRIGHT:
548: fputs(" right", fp);
549: break;
550: case TLEFT:
551: fputs(" left", fp);
552: break;
553: case TOUT:
554: fputs(" out", fp);
555: break;
556: }
557: switch (key_vpos) {
558: case TTOP:
559: fputs(" top", fp);
560: break;
561: case TBOTTOM:
562: fputs(" bottom", fp);
563: break;
564: case TUNDER:
565: fputs(" below", fp);
566: break;
567: }
568: break;
569: }
570: case 0:
571: fputs("set nokey\n", fp);
572: break;
573: case 1:
574: fputs("set key ", fp);
575: save_position(fp, &key_user_pos);
576: break;
577: }
578: if (key) {
579: fprintf(fp, " %s %sreverse box linetype %d linewidth %.3f samplen %g spacing %g width %g\n",
580: key_just == JLEFT ? "Left" : "Right",
581: key_reverse ? "" : "no",
582: key_box.l_type + 1, key_box.l_width, key_swidth, key_vert_factor, key_width_fix);
583: }
584: fputs("set nolabel\n", fp);
585: for (this_label = first_label; this_label != NULL;
586: this_label = this_label->next) {
587: fprintf(fp, "set label %d \"%s\" at ",
588: this_label->tag,
589: conv_text(str, this_label->text));
590: save_position(fp, &this_label->place);
591:
592: switch (this_label->pos) {
593: case LEFT:
594: fputs(" left", fp);
595: break;
596: case CENTRE:
597: fputs(" centre", fp);
598: break;
599: case RIGHT:
600: fputs(" right", fp);
601: break;
602: }
603: fprintf(fp, " %srotate", this_label->rotate ? "" : "no");
604: if ((this_label->font)[0] != NUL)
605: fprintf(fp, " font \"%s\"", this_label->font);
606: /* Entry font added by DJL */
607: fputc('\n', fp);
608: }
609: fputs("set noarrow\n", fp);
610: for (this_arrow = first_arrow; this_arrow != NULL;
611: this_arrow = this_arrow->next) {
612: fprintf(fp, "set arrow %d from ", this_arrow->tag);
613: save_position(fp, &this_arrow->start);
614: fputs(" to ", fp);
615: save_position(fp, &this_arrow->end);
616: fprintf(fp, " %s linetype %d linewidth %.3f\n",
617: this_arrow->head ? "" : " nohead",
618: this_arrow->lp_properties.l_type + 1,
619: this_arrow->lp_properties.l_width);
620: }
621: fputs("set nolinestyle\n", fp);
622: for (this_linestyle = first_linestyle; this_linestyle != NULL;
623: this_linestyle = this_linestyle->next) {
624: fprintf(fp, "set linestyle %d ", this_linestyle->tag);
625: fprintf(fp, "linetype %d linewidth %.3f pointtype %d pointsize %.3f\n",
626: this_linestyle->lp_properties.l_type + 1,
627: this_linestyle->lp_properties.l_width,
628: this_linestyle->lp_properties.p_type + 1,
629: this_linestyle->lp_properties.p_size);
630: }
631: fputs("set nologscale\n", fp);
632: if (is_log_x)
633: fprintf(fp, "set logscale x %g\n", base_log_x);
634: if (is_log_y)
635: fprintf(fp, "set logscale y %g\n", base_log_y);
636: if (is_log_z)
637: fprintf(fp, "set logscale z %g\n", base_log_z);
638: if (is_log_x2)
639: fprintf(fp, "set logscale x2 %g\n", base_log_x2);
640: if (is_log_y2)
641: fprintf(fp, "set logscale y2 %g\n", base_log_y2);
642:
643: fprintf(fp, "\
644: set offsets %g, %g, %g, %g\n\
645: set pointsize %g\n\
646: set encoding %s\n\
647: set %spolar\n\
648: set %sparametric\n\
649: set view %g, %g, %g, %g\n\
650: set samples %d, %d\n\
651: set isosamples %d, %d\n\
652: set %ssurface\n\
653: set %scontour",
654: loff, roff, toff, boff,
655: pointsize,
656: encoding_names[encoding],
657: (polar) ? "" : "no",
658: (parametric) ? "" : "no",
659: surface_rot_x, surface_rot_z, surface_scale, surface_zscale,
660: samples_1, samples_2,
661: iso_samples_1, iso_samples_2,
662: (draw_surface) ? "" : "no",
663: (draw_contour) ? "" : "no");
664:
665: switch (draw_contour) {
666: case CONTOUR_NONE:
667: fputc('\n', fp);
668: break;
669: case CONTOUR_BASE:
670: fputs(" base\n", fp);
671: break;
672: case CONTOUR_SRF:
673: fputs(" surface\n", fp);
674: break;
675: case CONTOUR_BOTH:
676: fputs(" both\n", fp);
677: break;
678: }
679: if (label_contours)
680: fprintf(fp, "set clabel '%s'\n", contour_format);
681: else
682: fputs("set noclabel\n", fp);
683:
684: fputs("set mapping ", fp);
685: switch(mapping3d) {
686: case MAP3D_SPHERICAL:
687: fputs("spherical\n", fp);
688: break;
689: case MAP3D_CYLINDRICAL:
690: fputs("cylindrical\n", fp);
691: break;
692: case MAP3D_CARTESIAN:
693: default:
694: fputs("cartesian\n", fp);
695: break;
696: }
697:
698: if (missing_val != NULL)
699: fprintf(fp, "set missing %s\n", missing_val);
700:
701: save_hidden3doptions(fp);
702: fprintf(fp, "set cntrparam order %d\n", contour_order);
703: fputs("set cntrparam ", fp);
704: switch (contour_kind) {
705: case CONTOUR_KIND_LINEAR:
706: fputs("linear\n", fp);
707: break;
708: case CONTOUR_KIND_CUBIC_SPL:
709: fputs("cubicspline\n", fp);
710: break;
711: case CONTOUR_KIND_BSPLINE:
712: fputs("bspline\n", fp);
713: break;
714: }
715: fputs("set cntrparam levels ", fp);
716: switch (levels_kind) {
717: case LEVELS_AUTO:
718: fprintf(fp, "auto %d\n", contour_levels);
719: break;
720: case LEVELS_INCREMENTAL:
721: fprintf(fp, "incremental %g,%g,%g\n",
722: levels_list[0], levels_list[1],
723: levels_list[0] + levels_list[1] * contour_levels);
724: break;
725: case LEVELS_DISCRETE:
726: {
727: int i;
728: fprintf(fp, "discrete %g", levels_list[0]);
729: for (i = 1; i < contour_levels; i++)
730: fprintf(fp, ",%g ", levels_list[i]);
731: fputc('\n', fp);
732: }
733: }
734: fprintf(fp, "\
735: set cntrparam points %d\n\
736: set size ratio %g %g,%g\n\
737: set origin %g,%g\n\
738: set data style ",
739: contour_pts,
740: aspect_ratio, xsize, ysize,
741: xoffset, yoffset);
742:
743: switch (data_style) {
744: case LINES:
745: fputs("lines\n", fp);
746: break;
747: case POINTSTYLE:
748: fputs("points\n", fp);
749: break;
750: case IMPULSES:
751: fputs("impulses\n", fp);
752: break;
753: case LINESPOINTS:
754: fputs("linespoints\n", fp);
755: break;
756: case DOTS:
757: fputs("dots\n", fp);
758: break;
759: case YERRORBARS:
760: fputs("yerrorbars\n", fp);
761: break;
762: case XERRORBARS:
763: fputs("xerrorbars\n", fp);
764: break;
765: case XYERRORBARS:
766: fputs("xyerrorbars\n", fp);
767: break;
768: case BOXES:
769: fputs("boxes\n", fp);
770: break;
771: case BOXERROR:
772: fputs("boxerrorbars\n", fp);
773: break;
774: case BOXXYERROR:
775: fputs("boxxyerrorbars\n", fp);
776: break;
777: case STEPS:
778: fputs("steps\n", fp);
779: break; /* JG */
780: case FSTEPS:
781: fputs("fsteps\n", fp);
782: break; /* HOE */
783: case HISTEPS:
784: fputs("histeps\n", fp);
785: break; /* CAC */
786: case VECTOR:
787: fputs("vector\n", fp);
788: break;
789: case FINANCEBARS:
790: fputs("financebars\n", fp);
791: break;
792: case CANDLESTICKS:
793: fputs("candlesticks\n", fp);
794: break;
795: }
796: fputs("set function style ", fp);
797: switch (func_style) {
798: case LINES:
799: fputs("lines\n", fp);
800: break;
801: case POINTSTYLE:
802: fputs("points\n", fp);
803: break;
804: case IMPULSES:
805: fputs("impulses\n", fp);
806: break;
807: case LINESPOINTS:
808: fputs("linespoints\n", fp);
809: break;
810: case DOTS:
811: fputs("dots\n", fp);
812: break;
813: case YERRORBARS:
814: fputs("yerrorbars\n", fp);
815: break;
816: case XERRORBARS:
817: fputs("xerrorbars\n", fp);
818: break;
819: case XYERRORBARS:
820: fputs("xyerrorbars\n", fp);
821: break;
822: case BOXXYERROR:
823: fputs("boxxyerrorbars\n", fp);
824: break;
825: case BOXES:
826: fputs("boxes\n", fp);
827: break;
828: case BOXERROR:
829: fputs("boxerrorbars\n", fp);
830: break;
831: case STEPS:
832: fputs("steps\n", fp);
833: break; /* JG */
834: case FSTEPS:
835: fputs("fsteps\n", fp);
836: break; /* HOE */
837: case HISTEPS:
838: fputs("histeps\n", fp);
839: break; /* CAC */
840: case VECTOR:
841: fputs("vector\n", fp);
842: break;
843: case FINANCEBARS:
844: fputs("financebars\n", fp);
845: break;
846: case CANDLESTICKS:
847: fputs("candlesticks\n", fp);
848: break;
849: default:
850: /* HBB: default case demanded by gcc, still needed ?? */
851: fputs("---error!---\n", fp);
852: }
853:
854: fprintf(fp, "\
855: set xzeroaxis lt %d lw %.3f\n\
856: set x2zeroaxis lt %d lw %.3f\n\
857: set yzeroaxis lt %d lw %.3f\n\
858: set y2zeroaxis lt %d lw %.3f\n\
859: set tics %s\n\
860: set ticslevel %g\n\
861: set ticscale %g %g\n",
862: xzeroaxis.l_type + 1, xzeroaxis.l_width,
863: x2zeroaxis.l_type + 1, x2zeroaxis.l_width,
864: yzeroaxis.l_type + 1, yzeroaxis.l_width,
865: y2zeroaxis.l_type + 1, y2zeroaxis.l_width,
866: (tic_in) ? "in" : "out",
867: ticslevel,
868: ticscale, miniticscale);
869:
870: #define SAVE_XYZLABEL(name,lab) { \
871: fprintf(fp, "set %s \"%s\" %f,%f ", \
872: name, conv_text(str,lab.text),lab.xoffset,lab.yoffset); \
873: fprintf(fp, " \"%s\"\n", conv_text(str, lab.font)); \
874: }
875:
876:
877: #define SAVE_MINI(name,m,freq) switch(m&TICS_MASK) { \
878: case 0: fprintf(fp, "set no%s\n", name); break; \
879: case MINI_AUTO: fprintf(fp, "set %s\n",name); break; \
880: case MINI_DEFAULT: fprintf(fp, "set %s default\n",name); break; \
881: case MINI_USER: fprintf(fp, "set %s %f\n", name, freq); break; \
882: }
883: SAVE_MINI("mxtics", mxtics, mxtfreq)
884: SAVE_MINI("mytics", mytics, mytfreq)
885: SAVE_MINI("mx2tics", mx2tics, mx2tfreq)
886: SAVE_MINI("my2tics", my2tics, my2tfreq)
887: save_tics(fp, xtics, FIRST_X_AXIS, &xticdef, rotate_xtics, "x");
888: save_tics(fp, ytics, FIRST_Y_AXIS, &yticdef, rotate_ytics, "y");
889: save_tics(fp, ztics, FIRST_Z_AXIS, &zticdef, rotate_ztics, "z");
890: save_tics(fp, x2tics, SECOND_X_AXIS, &x2ticdef, rotate_x2tics, "x2");
891: save_tics(fp, y2tics, SECOND_Y_AXIS, &y2ticdef, rotate_y2tics, "y2");
892: SAVE_XYZLABEL("title", title);
893:
894: fprintf(fp, "set %s \"%s\" %s %srotate %f,%f ",
895: "timestamp", conv_text(str, timelabel.text),
896: (timelabel_bottom ? "bottom" : "top"),
897: (timelabel_rotate ? "" : "no"),
898: timelabel.xoffset, timelabel.yoffset);
899: fprintf(fp, " \"%s\"\n", conv_text(str, timelabel.font));
900:
901: save_range(fp, R_AXIS, rmin, rmax, autoscale_r, "r");
902: save_range(fp, T_AXIS, tmin, tmax, autoscale_t, "t");
903: save_range(fp, U_AXIS, umin, umax, autoscale_u, "u");
904: save_range(fp, V_AXIS, vmin, vmax, autoscale_v, "v");
905:
906: SAVE_XYZLABEL("xlabel", xlabel);
907: SAVE_XYZLABEL("x2label", x2label);
908:
909: if (strlen(timefmt)) {
910: fprintf(fp, "set timefmt \"%s\"\n", conv_text(str, timefmt));
911: }
912: save_range(fp, FIRST_X_AXIS, xmin, xmax, autoscale_x, "x");
913: save_range(fp, SECOND_X_AXIS, x2min, x2max, autoscale_x2, "x2");
914:
915: SAVE_XYZLABEL("ylabel", ylabel);
916: SAVE_XYZLABEL("y2label", y2label);
917:
918: save_range(fp, FIRST_Y_AXIS, ymin, ymax, autoscale_y, "y");
919: save_range(fp, SECOND_Y_AXIS, y2min, y2max, autoscale_y2, "y2");
920:
921: SAVE_XYZLABEL("zlabel", zlabel);
922: save_range(fp, FIRST_Z_AXIS, zmin, zmax, autoscale_z, "z");
923:
924: fprintf(fp, "set zero %g\n", zero);
925: fprintf(fp, "set lmargin %d\nset bmargin %d\nset rmargin %d\nset tmargin %d\n",
926: lmargin, bmargin, rmargin, tmargin);
927:
928: fprintf(fp, "set locale \"%s\"\n", cur_locale);
929: }
930:
931: static void save_tics(fp, where, axis, tdef, rotate, text)
932: FILE *fp;
933: int where;
934: int axis;
935: struct ticdef *tdef;
936: TBOOLEAN rotate;
937: char *text;
938: {
939: char str[MAX_LINE_LEN + 1];
940:
941: if (where == NO_TICS) {
942: fprintf(fp, "set no%stics\n", text);
943: return;
944: }
945: fprintf(fp, "set %stics %s %smirror %srotate ", text,
946: (where & TICS_MASK) == TICS_ON_AXIS ? "axis" : "border",
947: (where & TICS_MIRROR) ? "" : "no", rotate ? "" : "no");
948: switch (tdef->type) {
949: case TIC_COMPUTED:{
950: fputs("autofreq ", fp);
951: break;
952: }
953: case TIC_MONTH:{
954: fprintf(fp, "\nset %smtics", text);
955: break;
956: }
957: case TIC_DAY:{
958: fprintf(fp, "\nset %cdtics", axis);
959: break;
960: }
961: case TIC_SERIES:
962: if (datatype[axis] == TIME) {
963: if (tdef->def.series.start != -VERYLARGE) {
964: char fd[26];
965: gstrftime(fd, 24, timefmt, (double) tdef->def.series.start);
966: fprintf(fp, "\"%s\",", conv_text(str, fd));
967: }
968: fprintf(fp, "%g", tdef->def.series.incr);
969:
970: if (tdef->def.series.end != VERYLARGE) {
971: char td[26];
972: gstrftime(td, 24, timefmt, (double) tdef->def.series.end);
973: fprintf(fp, ",\"%s\"", conv_text(str, td));
974: }
975: } else { /* !TIME */
976:
977: if (tdef->def.series.start != -VERYLARGE)
978: fprintf(fp, "%g,", tdef->def.series.start);
979: fprintf(fp, "%g", tdef->def.series.incr);
980: if (tdef->def.series.end != VERYLARGE)
981: fprintf(fp, ",%g", tdef->def.series.end);
982: }
983:
984: break;
985:
986: case TIC_USER:{
987: register struct ticmark *t;
988: int flag_time;
989: flag_time = (datatype[axis] == TIME);
990: fputs(" (", fp);
991: for (t = tdef->def.user; t != NULL; t = t->next) {
992: if (t->label)
993: fprintf(fp, "\"%s\" ", conv_text(str, t->label));
994: if (flag_time) {
995: char td[26];
996: gstrftime(td, 24, timefmt, (double) t->position);
997: fprintf(fp, "\"%s\"", conv_text(str, td));
998: } else {
999: fprintf(fp, "%g", t->position);
1000: }
1001: if (t->next) {
1002: fputs(", ", fp);
1003: }
1004: }
1005: fputs(")", fp);
1006: break;
1007: }
1008: }
1009: putc('\n', fp);
1010: }
1011:
1012: static void save_position(fp, pos)
1013: FILE *fp;
1014: struct position *pos;
1015: {
1016: static char *msg[] =
1017: {"first_axes ", "second axes ", "graph ", "screen "};
1018:
1019: assert(first_axes == 0 && second_axes == 1 && graph == 2 && screen == 3);
1020:
1021: fprintf(fp, "%s%g, %s%g, %s%g",
1022: pos->scalex == first_axes ? "" : msg[pos->scalex], pos->x,
1023: pos->scaley == pos->scalex ? "" : msg[pos->scaley], pos->y,
1024: pos->scalez == pos->scaley ? "" : msg[pos->scalez], pos->z);
1025: }
1026:
1027: void load_file(fp, name, can_do_args)
1028: FILE *fp;
1029: char *name;
1030: TBOOLEAN can_do_args;
1031: {
1032: register int len;
1033:
1034: int start, left;
1035: int more;
1036: int stop = FALSE;
1037:
1038: lf_push(fp); /* save state for errors and recursion */
1039: do_load_arg_substitution = can_do_args;
1040:
1041: if (fp == (FILE *) NULL) {
1042: /* HBB 980311: alloc() it, to save valuable stack space: */
1043: char *errbuf = gp_alloc(BUFSIZ, "load_file errorstring");
1044: (void) sprintf(errbuf, "Cannot open %s file '%s'",
1045: can_do_args ? "call" : "load", name);
1046: os_error(errbuf, c_token);
1047: free(errbuf);
1048: } else if (fp == stdin) {
1049: /* DBT 10-6-98 go interactive if "-" named as load file */
1050: interactive = TRUE;
1051: while(!com_line())
1052: ;
1053: } else {
1054: /* go into non-interactive mode during load */
1055: /* will be undone below, or in load_file_error */
1056: interactive = FALSE;
1057: inline_num = 0;
1058: infile_name = name;
1059:
1060: if (can_do_args) {
1061: int aix = 0;
1062: while (++c_token < num_tokens && aix <= 9) {
1063: if (isstring(c_token))
1064: m_quote_capture(&call_args[aix++], c_token, c_token);
1065: else
1066: m_capture(&call_args[aix++], c_token, c_token);
1067: }
1068:
1069: /* A GNUPLOT "call" command can have up to _10_ arguments named "$0"
1070: to "$9". After reading the 10th argument (i.e.: "$9") the variable
1071: 'aix' contains the value '10' because of the 'aix++' construction
1072: in '&call_args[aix++]'. So I think the following test of 'aix'
1073: should be done against '10' instead of '9'. (JFi) */
1074:
1075: /* if (c_token >= num_tokens && aix > 9) */
1076: if (c_token >= num_tokens && aix > 10)
1077: int_error("too many arguments for CALL <file>", ++c_token);
1078: }
1079: while (!stop) { /* read all commands in file */
1080: /* read one command */
1081: left = input_line_len;
1082: start = 0;
1083: more = TRUE;
1084:
1085: while (more) {
1086: if (fgets(&(input_line[start]), left, fp) == (char *) NULL) {
1087: stop = TRUE; /* EOF in file */
1088: input_line[start] = '\0';
1089: more = FALSE;
1090: } else {
1091: inline_num++;
1092: len = strlen(input_line) - 1;
1093: if (input_line[len] == '\n') { /* remove any newline */
1094: input_line[len] = '\0';
1095: /* Look, len was 1-1 = 0 before, take care here! */
1096: if (len > 0)
1097: --len;
1098: if (input_line[len] == '\r') { /* remove any carriage return */
1099: input_line[len] = NUL;
1100: if (len > 0)
1101: --len;
1102: }
1103: }
1104: else if (len + 2 >= left) {
1105: extend_input_line();
1106: left = input_line_len - len - 1;
1107: start = len + 1;
1108: continue; /* don't check for '\' */
1109: }
1110: if (input_line[len] == '\\') {
1111: /* line continuation */
1112: start = len;
1113: left = input_line_len - start;
1114: } else
1115: more = FALSE;
1116: }
1117: }
1118:
1119: if (strlen(input_line) > 0) {
1120: if (can_do_args) {
1121: register int il = 0;
1122: register char *rl;
1123: char *raw_line = rl = gp_alloc((unsigned long) strlen(input_line) + 1, "string");
1124:
1125: strcpy(raw_line, input_line);
1126: *input_line = '\0';
1127: while (*rl) {
1128: register int aix;
1129: if (*rl == '$'
1130: && ((aix = *(++rl)) != 0) /* HBB 980308: quiet BCC warning */
1131: &&aix >= '0' && aix <= '9') {
1132: if (call_args[aix -= '0']) {
1133: len = strlen(call_args[aix]);
1134: while (input_line_len - il < len + 1) {
1135: extend_input_line();
1136: }
1137: strcpy(input_line + il, call_args[aix]);
1138: il += len;
1139: }
1140: } else {
1141: /* substitute for $<n> here */
1142: if (il + 1 > input_line_len) {
1143: extend_input_line();
1144: }
1145: input_line[il++] = *rl;
1146: }
1147: rl++;
1148: }
1149: if (il + 1 > input_line_len) {
1150: extend_input_line();
1151: }
1152: input_line[il] = '\0';
1153: free(raw_line);
1154: }
1155: screen_ok = FALSE; /* make sure command line is
1156: echoed on error */
1157: do_line();
1158: }
1159: }
1160: }
1161:
1162: /* pop state */
1163: (void) lf_pop(); /* also closes file fp */
1164: }
1165:
1166: /* pop from load_file state stack */
1167: static TBOOLEAN /* FALSE if stack was empty */
1168: lf_pop()
1169: { /* called by load_file and load_file_error */
1170: LFS *lf;
1171:
1172: if (lf_head == NULL)
1173: return (FALSE);
1174: else {
1175: int argindex;
1176: lf = lf_head;
1177: if (lf->fp != (FILE *)NULL && lf->fp != stdin) {
1178: /* DBT 10-6-98 do not close stdin in the case
1179: * that "-" is named as a load file
1180: */
1181: (void) fclose(lf->fp);
1182: }
1183: for (argindex = 0; argindex < 10; argindex++) {
1184: if (call_args[argindex]) {
1185: free(call_args[argindex]);
1186: }
1187: call_args[argindex] = lf->call_args[argindex];
1188: }
1189: do_load_arg_substitution = lf->do_load_arg_substitution;
1190: interactive = lf->interactive;
1191: inline_num = lf->inline_num;
1192: infile_name = lf->name;
1193: lf_head = lf->prev;
1194: free((char *) lf);
1195: return (TRUE);
1196: }
1197: }
1198:
1199: /* push onto load_file state stack */
1200: /* essentially, we save information needed to undo the load_file changes */
1201: static void lf_push(fp) /* called by load_file */
1202: FILE *fp;
1203: {
1204: LFS *lf;
1205: int argindex;
1206:
1207: lf = (LFS *) gp_alloc((unsigned long) sizeof(LFS), (char *) NULL);
1208: if (lf == (LFS *) NULL) {
1209: if (fp != (FILE *) NULL)
1210: (void) fclose(fp); /* it won't be otherwise */
1211: int_error("not enough memory to load file", c_token);
1212: }
1213: lf->fp = fp; /* save this file pointer */
1214: lf->name = infile_name; /* save current name */
1215: lf->interactive = interactive; /* save current state */
1216: lf->inline_num = inline_num; /* save current line number */
1217: lf->do_load_arg_substitution = do_load_arg_substitution;
1218: for (argindex = 0; argindex < 10; argindex++) {
1219: lf->call_args[argindex] = call_args[argindex];
1220: call_args[argindex] = NULL; /* initially no args */
1221: }
1222: lf->prev = lf_head; /* link to stack */
1223: lf_head = lf;
1224: }
1225:
1226: /* used for reread vsnyder@math.jpl.nasa.gov */
1227: FILE *lf_top()
1228: {
1229: if (lf_head == (LFS *) NULL)
1230: return ((FILE *) NULL);
1231: return (lf_head->fp);
1232: }
1233:
1234: /* called from main */
1235: void load_file_error()
1236: {
1237: /* clean up from error in load_file */
1238: /* pop off everything on stack */
1239: while (lf_pop());
1240: }
1241:
1242: /* find char c in string str; return p such that str[p]==c;
1243: * if c not in str then p=strlen(str)
1244: */
1245: int instring(str, c)
1246: char *str;
1247: int c;
1248: {
1249: int pos = 0;
1250:
1251: while (str != NULL && *str != NUL && c != *str) {
1252: str++;
1253: pos++;
1254: }
1255: return (pos);
1256: }
1257:
1258: void show_functions()
1259: {
1260: register struct udft_entry *udf = first_udf;
1261:
1262: fputs("\n\tUser-Defined Functions:\n", stderr);
1263:
1264: while (udf) {
1265: if (udf->definition)
1266: fprintf(stderr, "\t%s\n", udf->definition);
1267: else
1268: fprintf(stderr, "\t%s is undefined\n", udf->udf_name);
1269: udf = udf->next_udf;
1270: }
1271: }
1272:
1273:
1274: void show_at()
1275: {
1276: (void) putc('\n', stderr);
1277: disp_at(temp_at(), 0);
1278: }
1279:
1280:
1281: void disp_at(curr_at, level)
1282: struct at_type *curr_at;
1283: int level;
1284: {
1285: register int i, j;
1286: register union argument *arg;
1287:
1288: for (i = 0; i < curr_at->a_count; i++) {
1289: (void) putc('\t', stderr);
1290: for (j = 0; j < level; j++)
1291: (void) putc(' ', stderr); /* indent */
1292:
1293: /* print name of instruction */
1294:
1295: fputs(ft[(int) (curr_at->actions[i].index)].f_name, stderr);
1296: arg = &(curr_at->actions[i].arg);
1297:
1298: /* now print optional argument */
1299:
1300: switch (curr_at->actions[i].index) {
1301: case PUSH:
1302: fprintf(stderr, " %s\n", arg->udv_arg->udv_name);
1303: break;
1304: case PUSHC:
1305: (void) putc(' ', stderr);
1306: disp_value(stderr, &(arg->v_arg));
1307: (void) putc('\n', stderr);
1308: break;
1309: case PUSHD1:
1310: fprintf(stderr, " %c dummy\n",
1311: arg->udf_arg->udf_name[0]);
1312: break;
1313: case PUSHD2:
1314: fprintf(stderr, " %c dummy\n",
1315: arg->udf_arg->udf_name[1]);
1316: break;
1317: case CALL:
1318: fprintf(stderr, " %s", arg->udf_arg->udf_name);
1319: if (level < 6) {
1320: if (arg->udf_arg->at) {
1321: (void) putc('\n', stderr);
1322: disp_at(arg->udf_arg->at, level + 2); /* recurse! */
1323: } else
1324: fputs(" (undefined)\n", stderr);
1325: } else
1326: (void) putc('\n', stderr);
1327: break;
1328: case CALLN:
1329: fprintf(stderr, " %s", arg->udf_arg->udf_name);
1330: if (level < 6) {
1331: if (arg->udf_arg->at) {
1332: (void) putc('\n', stderr);
1333: disp_at(arg->udf_arg->at, level + 2); /* recurse! */
1334: } else
1335: fputs(" (undefined)\n", stderr);
1336: } else
1337: (void) putc('\n', stderr);
1338: break;
1339: case JUMP:
1340: case JUMPZ:
1341: case JUMPNZ:
1342: case JTERN:
1343: fprintf(stderr, " +%d\n", arg->j_arg);
1344: break;
1345: case DOLLARS:
1346: fprintf(stderr, " %d\n", arg->v_arg.v.int_val);
1347: break;
1348: default:
1349: (void) putc('\n', stderr);
1350: }
1351: }
1352: }
1353:
1354: /* find max len of keys and count keys with len > 0 */
1355:
1356: int find_maxl_keys(plots, count, kcnt)
1357: struct curve_points *plots;
1358: int count, *kcnt;
1359: {
1360: int mlen, len, curve, cnt;
1361: register struct curve_points *this_plot;
1362:
1363: mlen = cnt = 0;
1364: this_plot = plots;
1365: for (curve = 0; curve < count; this_plot = this_plot->next_cp, curve++)
1366: if (this_plot->title
1367: && ((len = /*assign */ strlen(this_plot->title)) != 0) /* HBB 980308: quiet BCC warning */
1368: ) {
1369: cnt++;
1370: if (len > mlen)
1371: mlen = strlen(this_plot->title);
1372: }
1373: if (kcnt != NULL)
1374: *kcnt = cnt;
1375: return (mlen);
1376: }
1377:
1378:
1379: /* calculate the number and max-width of the keys for an splot.
1380: * Note that a blank line is issued after each set of contours
1381: */
1382: int find_maxl_keys3d(plots, count, kcnt)
1383: struct surface_points *plots;
1384: int count, *kcnt;
1385: {
1386: int mlen, len, surf, cnt;
1387: struct surface_points *this_plot;
1388:
1389: mlen = cnt = 0;
1390: this_plot = plots;
1391: for (surf = 0; surf < count; this_plot = this_plot->next_sp, surf++) {
1392:
1393: /* we draw a main entry if there is one, and we are
1394: * drawing either surface, or unlabelled contours
1395: */
1396: if (this_plot->title && *this_plot->title &&
1397: (draw_surface || (draw_contour && !label_contours))) {
1398: ++cnt;
1399: len = strlen(this_plot->title);
1400: if (len > mlen)
1401: mlen = len;
1402: }
1403: if (draw_contour && label_contours && this_plot->contours != NULL) {
1404: len = find_maxl_cntr(this_plot->contours, &cnt);
1405: if (len > mlen)
1406: mlen = len;
1407: }
1408: }
1409:
1410: if (kcnt != NULL)
1411: *kcnt = cnt;
1412: return (mlen);
1413: }
1414:
1415: static int find_maxl_cntr(contours, count)
1416: struct gnuplot_contours *contours;
1417: int *count;
1418: {
1419: register int cnt;
1420: register int mlen, len;
1421: register struct gnuplot_contours *cntrs = contours;
1422:
1423: mlen = cnt = 0;
1424: while (cntrs) {
1425: if (label_contours && cntrs->isNewLevel) {
1426: len = strlen(cntrs->label);
1427: if (len)
1428: cnt++;
1429: if (len > mlen)
1430: mlen = len;
1431: }
1432: cntrs = cntrs->next;
1433: }
1434: *count += cnt;
1435: return (mlen);
1436: }
1437:
1438: static void save_range(fp, axis, min, max, autosc, text)
1439: FILE *fp;
1440: int axis;
1441: double min, max;
1442: TBOOLEAN autosc;
1443: char *text;
1444: {
1445: int i;
1446:
1447: i = axis;
1448: fprintf(fp, "set %srange [ ", text);
1449: if (autosc & 1) {
1450: putc('*', fp);
1451: } else {
1452: SAVE_NUM_OR_TIME(fp, min, axis);
1453: }
1454: fputs(" : ", fp);
1455: if (autosc & 2) {
1456: putc('*', fp);
1457: } else {
1458: SAVE_NUM_OR_TIME(fp, max, axis);
1459: }
1460:
1461: fprintf(fp, " ] %sreverse %swriteback",
1462: range_flags[axis] & RANGE_REVERSE ? "" : "no",
1463: range_flags[axis] & RANGE_WRITEBACK ? "" : "no");
1464:
1465: if (autosc) {
1466: /* add current (hidden) range as comments */
1467: fputs(" # (currently [", fp);
1468: if (autosc & 1) {
1469: SAVE_NUM_OR_TIME(fp, min, axis);
1470: }
1471: putc(':', fp);
1472: if (autosc & 2) {
1473: SAVE_NUM_OR_TIME(fp, max, axis);
1474: }
1475: fputs("] )", fp);
1476: }
1477: putc('\n', fp);
1478: }
1479:
1480: /* check user defined format strings for valid double conversions */
1481: TBOOLEAN valid_format(format)
1482: const char *format;
1483: {
1484: for (;;) {
1485: if (!(format = strchr(format, '%'))) /* look for format spec */
1486: return TRUE; /* passed Test */
1487: do { /* scan format statement */
1488: format++;
1489: } while (strchr("+-#0123456789.", *format));
1490:
1491: switch (*format) { /* Now at format modifier */
1492: case '*': /* Ignore '*' statements */
1493: case '%': /* Char '%' itself */
1494: format++;
1495: continue;
1496: case 'l': /* Now we found it !!! */
1497: if (!strchr("fFeEgG", format[1])) /* looking for a valid format */
1498: return FALSE;
1499: format++;
1500: break;
1501: default:
1502: return FALSE;
1503: }
1504: }
1505: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot