Annotation of OpenXM_contrib/gnuplot/show.c, Revision 1.1.1.1
1.1 maekawa 1: #ifndef lint
2: static char *RCSid = "$Id: show.c,v 1.50 1998/06/18 14:55:18 ddenholm Exp $";
3: #endif
4:
5: /* GNUPLOT - show.c */
6:
7: /*[
8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
9: *
10: * Permission to use, copy, and distribute this software and its
11: * documentation for any purpose with or without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and
13: * that both that copyright notice and this permission notice appear
14: * in supporting documentation.
15: *
16: * Permission to modify the software is granted, but not the right to
17: * distribute the complete modified source code. Modifications are to
18: * be distributed as patches to the released version. Permission to
19: * distribute binaries produced by compiling modified sources is granted,
20: * provided you
21: * 1. distribute the corresponding source modifications from the
22: * released version in the form of a patch file along with the binaries,
23: * 2. add special version identification to distinguish your version
24: * in addition to the base release version number,
25: * 3. provide your name and address as the primary contact for the
26: * support of your modified version, and
27: * 4. retain our contact information in regard to use of the base
28: * software.
29: * Permission to distribute the released version of the source code along
30: * with corresponding source modifications in the form of a patch file is
31: * granted with same provisions 2 through 4 for binary distributions.
32: *
33: * This software is provided "as is" without express or implied warranty
34: * to the extent permitted by applicable law.
35: ]*/
36:
37:
38: /*
39: * 19 September 1992 Lawrence Crowl (crowl@cs.orst.edu)
40: * Added user-specified bases for log scaling.
41: */
42:
43:
44: #include "plot.h"
45: #include "setshow.h"
46:
47: #define DEF_FORMAT "%g" /* default format for tic mark labels */
48: #define SIGNIF (0.01) /* less than one hundredth of a tic mark */
49:
50:
51: /* input data, parsing variables */
52:
53: extern TBOOLEAN is_3d_plot;
54:
55: /* From version.c, used in show_version () */
56: extern char version[];
57: extern char patchlevel[];
58: extern char date[];
59: extern char gnuplot_copyright[];
60: extern char faq_location[];
61: extern char bug_email[];
62: extern char help_email[];
63:
64:
65: #ifndef TIMEFMT
66: #define TIMEFMT "%d/%m/%y,%H:%M"
67: #endif
68: /* format for date/time for reading time in datafile */
69:
70:
71:
72: /******** Local functions ********/
73:
74: static void show_style __PROTO((char name[], enum PLOT_STYLE style));
75: static void show_range __PROTO((int axis, double min, double max, int autosc, char *text));
76: static void show_zero __PROTO((void));
77: static void show_border __PROTO((void));
78: static void show_dgrid3d __PROTO((void));
79: static void show_offsets __PROTO((void));
80: static void show_samples __PROTO((void));
81: static void show_isosamples __PROTO((void));
82: static void show_output __PROTO((void));
83: static void show_view __PROTO((void));
84: static void show_size __PROTO((void));
85: static void show_origin __PROTO((void));
86: static void show_title __PROTO((void));
87: static void show_xyzlabel __PROTO((char *name, label_struct * label));
88: static void show_angles __PROTO((void));
89: static void show_boxwidth __PROTO((void));
90: static void show_bars __PROTO((void));
91: static void show_xzeroaxis __PROTO((void));
92: static void show_yzeroaxis __PROTO((void));
93: static void show_label __PROTO((int tag));
94: static void show_linestyle __PROTO((int tag));
95: static void show_arrow __PROTO((int tag));
96: static void show_grid __PROTO((void));
97: static void show_key __PROTO((void));
98: static void show_keytitle __PROTO((void));
99: static void show_mtics __PROTO((int mini, double freq, char *name));
100: static void show_pointsize __PROTO((void));
101: static void show_encoding __PROTO((void));
102: static void show_polar __PROTO((void));
103: static void show_parametric __PROTO((void));
104: static void show_tics __PROTO((int showx, int showy, int showz, int showx2, int showy2));
105: static void show_ticdef __PROTO((int tics, int axis, struct ticdef * tdef, char *text, int rotate_tics, char *ticfmt));
106: static void show_term __PROTO((void));
107: static void show_plot __PROTO((void));
108: static void show_autoscale __PROTO((void));
109: static void show_clip __PROTO((void));
110: static void show_contour __PROTO((void));
111: static void show_mapping __PROTO((void));
112: static void show_format __PROTO((void));
113: static void show_logscale __PROTO((void));
114: static void show_variables __PROTO((void));
115: static void show_surface __PROTO((void));
116: static void show_hidden3d __PROTO((void));
117: static void show_label_contours __PROTO((void));
118: static void show_margin __PROTO((void));
119: static void show_position __PROTO((struct position * pos));
120:
121: static TBOOLEAN show_one __PROTO((void));
122: static TBOOLEAN show_two __PROTO((void));
123: static void show_timefmt __PROTO((void));
124: static void show_locale __PROTO((void));
125: static void show_missing __PROTO((void));
126: static void show_datatype __PROTO((char *name, int axis));
127: static void show_locale __PROTO((void));
128:
129: /* following code segment appears over and over again */
130:
131: #define SHOW_NUM_OR_TIME(x, axis) \
132: do{if (datatype[axis]==TIME) { \
133: char s[80]; char *p; \
134: putc('"', stderr); \
135: gstrftime(s,80,timefmt,(double)(x)); \
136: for(p=s; *p; ++p) {\
137: if ( *p == '\t' ) fputs("\\t",stderr);\
138: else if (*p == '\n') fputs("\\n",stderr); \
139: else if ( *p > 126 || *p < 32 ) fprintf(stderr,"\\%03o",*p);\
140: else putc(*p, stderr);\
141: }\
142: putc('"', stderr);\
143: } else {\
144: fprintf(stderr,"%g",x);\
145: }} while(0)
146:
147:
148: /******* The 'show' command *******/
149: void show_command()
150: {
151: /* show at is undocumented/hidden... */
152: static char GPFAR showmess[] =
153: "valid set options: [] = choose one, {} means optional\n\n\
154: \t'all', 'angles', 'arrow', 'autoscale', 'bar', 'border', 'boxwidth',\n\
155: \t'clip', 'cntrparam', 'contour', 'data', 'dgrid3d', 'dummy',\n\
156: \t'encoding', 'format', 'function', 'grid', 'hidden', 'isosamples',\n\
157: \t'key', 'label', 'linestyle', 'locale', 'logscale', 'mapping', 'margin',\n\
158: \t'missing', 'offsets', 'origin', 'output', 'plot', 'parametric',\n\
159: \t'pointsize', 'polar', '[rtuv]range', 'samples', 'size', 'terminal',\n\
160: \t'tics', 'timestamp', 'timefmt', 'title', 'variables', 'version',\n\
161: \t'view', '[xyz]{2}label', '[xyz]{2}range', '{m}[xyz]{2}tics',\n\
162: \t'[xyz]{2}[md]tics', '[xyz]{2}zeroaxis', '[xyz]data', 'zero',\n\
163: \t'zeroaxis'";
164:
165:
166: c_token++;
167:
168: if (!show_one() && !show_two())
169: int_error(showmess, c_token);
170: screen_ok = FALSE;
171: (void) putc('\n', stderr);
172: }
173:
174: /* return TRUE if a command match, FALSE if not */
175: static TBOOLEAN
176: show_one()
177: {
178: if (almost_equals(c_token, "ac$tion_table") ||
179: equals(c_token, "at")) {
180: c_token++;
181: show_at();
182: c_token++;
183: } else if (almost_equals(c_token, "ar$row")) {
184: struct value a;
185: int tag = 0;
186:
187: c_token++;
188: if (!END_OF_COMMAND) {
189: tag = (int) real(const_express(&a));
190: if (tag <= 0)
191: int_error("tag must be > zero", c_token);
192: }
193: (void) putc('\n', stderr);
194: show_arrow(tag);
195: } else if (almost_equals(c_token, "au$toscale")) {
196: (void) putc('\n', stderr);
197: show_autoscale();
198: c_token++;
199: } else if (almost_equals(c_token, "b$ars")) {
200: (void) putc('\n', stderr);
201: show_bars();
202: c_token++;
203: } else if (almost_equals(c_token, "bor$der")) {
204: (void) putc('\n', stderr);
205: show_border();
206: c_token++;
207: } else if (almost_equals(c_token, "box$width")) {
208: (void) putc('\n', stderr);
209: show_boxwidth();
210: c_token++;
211: } else if (almost_equals(c_token, "c$lip")) {
212: (void) putc('\n', stderr);
213: show_clip();
214: c_token++;
215: } else if (almost_equals(c_token, "ma$pping")) {
216: (void) putc('\n', stderr);
217: show_mapping();
218: c_token++;
219: } else if (almost_equals(c_token, "co$ntour") ||
220: almost_equals(c_token, "cn$trparam")) {
221: (void) putc('\n', stderr);
222: show_contour();
223: c_token++;
224: } else if (almost_equals(c_token, "da$ta")) {
225: c_token++;
226: if (!almost_equals(c_token, "s$tyle"))
227: int_error("expecting keyword 'style'", c_token);
228: (void) putc('\n', stderr);
229: show_style("data", data_style);
230: c_token++;
231: } else if (almost_equals(c_token, "dg$rid3d")) {
232: (void) putc('\n', stderr);
233: show_dgrid3d();
234: c_token++;
235: } else if (almost_equals(c_token, "du$mmy")) {
236: (void) fprintf(stderr, "\n\tdummy variables are \"%s\" and \"%s\"\n",
237: dummy_var[0], dummy_var[1]);
238: c_token++;
239: } else if (almost_equals(c_token, "fo$rmat")) {
240: show_format();
241: c_token++;
242: } else if (almost_equals(c_token, "fu$nctions")) {
243: c_token++;
244: if (almost_equals(c_token, "s$tyle")) {
245: (void) putc('\n', stderr);
246: show_style("functions", func_style);
247: c_token++;
248: } else
249: show_functions();
250: } else if (almost_equals(c_token, "lo$gscale")) {
251: (void) putc('\n', stderr);
252: show_logscale();
253: c_token++;
254: } else if (almost_equals(c_token, "of$fsets")) {
255: (void) putc('\n', stderr);
256: show_offsets();
257: c_token++;
258: } else if (almost_equals(c_token, "ma$rgin")) {
259: (void) putc('\n', stderr);
260: show_margin();
261: c_token++;
262: } else if (almost_equals(c_token, "o$utput")) {
263: (void) putc('\n', stderr);
264: show_output();
265: c_token++;
266: } else if (almost_equals(c_token, "tit$le")) {
267: (void) putc('\n', stderr);
268: show_xyzlabel("title", &title);
269: c_token++;
270: } else if (almost_equals(c_token, "mis$sing")) {
271: (void) putc('\n', stderr);
272: show_missing();
273: c_token++;
274: } else if (almost_equals(c_token, "xl$abel")) {
275: (void) putc('\n', stderr);
276: show_xyzlabel("xlabel", &xlabel);
277: c_token++;
278: } else if (almost_equals(c_token, "x2l$abel")) {
279: (void) putc('\n', stderr);
280: show_xyzlabel("x2label", &x2label);
281: c_token++;
282: } else if (almost_equals(c_token, "yl$abel")) {
283: (void) putc('\n', stderr);
284: show_xyzlabel("ylabel", &ylabel);
285: c_token++;
286: } else if (almost_equals(c_token, "y2l$abel")) {
287: (void) putc('\n', stderr);
288: show_xyzlabel("y2label", &y2label);
289: c_token++;
290: } else if (almost_equals(c_token, "zl$abel")) {
291: (void) putc('\n', stderr);
292: show_xyzlabel("zlabel", &zlabel);
293: c_token++;
294: } else if (almost_equals(c_token, "keyt$itle")) {
295: (void) putc('\n', stderr);
296: show_keytitle();
297: c_token++;
298: } else if (almost_equals(c_token, "xda$ta")) {
299: (void) putc('\n', stderr);
300: show_datatype("xdata", FIRST_X_AXIS);
301: c_token++;
302: } else if (almost_equals(c_token, "yda$ta")) {
303: (void) putc('\n', stderr);
304: show_datatype("ydata", FIRST_Y_AXIS);
305: c_token++;
306: } else if (almost_equals(c_token, "x2da$ta")) {
307: (void) putc('\n', stderr);
308: show_datatype("x2data", SECOND_X_AXIS);
309: c_token++;
310: } else if (almost_equals(c_token, "y2da$ta")) {
311: (void) putc('\n', stderr);
312: show_datatype("y2data", SECOND_Y_AXIS);
313: c_token++;
314: } else if (almost_equals(c_token, "zda$ta")) {
315: (void) putc('\n', stderr);
316: show_datatype("zdata", FIRST_Z_AXIS);
317: c_token++;
318: } else if (almost_equals(c_token, "timef$mt")) {
319: (void) putc('\n', stderr);
320: show_timefmt();
321: c_token++;
322: } else if (almost_equals(c_token, "loca$le")) {
323: (void) putc('\n', stderr);
324: show_locale();
325: c_token++;
326: } else if (almost_equals(c_token, "xzero$axis")) {
327: (void) putc('\n', stderr);
328: show_xzeroaxis();
329: c_token++;
330: } else if (almost_equals(c_token, "yzero$axis")) {
331: (void) putc('\n', stderr);
332: show_yzeroaxis();
333: c_token++;
334: } else if (almost_equals(c_token, "zeroa$xis")) {
335: (void) putc('\n', stderr);
336: show_xzeroaxis();
337: show_yzeroaxis();
338: c_token++;
339: } else if (almost_equals(c_token, "la$bel")) {
340: struct value a;
341: int tag = 0;
342:
343: c_token++;
344: if (!END_OF_COMMAND) {
345: tag = (int) real(const_express(&a));
346: if (tag <= 0)
347: int_error("tag must be > zero", c_token);
348: }
349: (void) putc('\n', stderr);
350: show_label(tag);
351: } else if (almost_equals(c_token, "li$nestyle") || equals(c_token, "ls")) {
352: struct value a;
353: int tag = 0;
354:
355: c_token++;
356: if (!END_OF_COMMAND) {
357: tag = (int) real(const_express(&a));
358: if (tag <= 0)
359: int_error("tag must be > zero", c_token);
360: }
361: (void) putc('\n', stderr);
362: show_linestyle(tag);
363: } else if (almost_equals(c_token, "g$rid")) {
364: (void) putc('\n', stderr);
365: show_grid();
366: c_token++;
367: } else if (almost_equals(c_token, "mxt$ics")) {
368: (void) putc('\n', stderr);
369: show_mtics(mxtics, mxtfreq, "x");
370: c_token++;
371: } else if (almost_equals(c_token, "myt$ics")) {
372: (void) putc('\n', stderr);
373: show_mtics(mytics, mytfreq, "y");
374: c_token++;
375: } else if (almost_equals(c_token, "mzt$ics")) {
376: (void) putc('\n', stderr);
377: show_mtics(mztics, mztfreq, "z");
378: c_token++;
379: } else if (almost_equals(c_token, "mx2t$ics")) {
380: (void) putc('\n', stderr);
381: show_mtics(mx2tics, mx2tfreq, "x2");
382: c_token++;
383: } else if (almost_equals(c_token, "my2t$ics")) {
384: (void) putc('\n', stderr);
385: show_mtics(my2tics, my2tfreq, "y2");
386: c_token++;
387: } else if (almost_equals(c_token, "k$ey")) {
388: (void) putc('\n', stderr);
389: show_key();
390: c_token++;
391: } else
392: return (FALSE);
393: return TRUE;
394: }
395:
396: /* return TRUE if a command match, FALSE if not */
397: static TBOOLEAN
398: show_two()
399: {
400: if (almost_equals(c_token, "p$lot")) {
401: (void) putc('\n', stderr);
402: show_plot();
403: c_token++;
404: } else if (almost_equals(c_token, "par$ametric")) {
405: (void) putc('\n', stderr);
406: show_parametric();
407: c_token++;
408: } else if (almost_equals(c_token, "poi$ntsize")) {
409: (void) putc('\n', stderr);
410: show_pointsize();
411: c_token++;
412: } else if (almost_equals(c_token, "enc$oding")) {
413: (void) putc('\n', stderr);
414: show_encoding();
415: c_token++;
416: } else if (almost_equals(c_token, "pol$ar")) {
417: (void) putc('\n', stderr);
418: show_polar();
419: c_token++;
420: } else if (almost_equals(c_token, "an$gles")) {
421: (void) putc('\n', stderr);
422: show_angles();
423: c_token++;
424: } else if (almost_equals(c_token, "ti$cs")) {
425: (void) putc('\n', stderr);
426: show_tics(TRUE, TRUE, TRUE, TRUE, TRUE);
427: c_token++;
428: } else if (almost_equals(c_token, "tim$estamp")) {
429: (void) putc('\n', stderr);
430: show_xyzlabel("time", &timelabel);
431: fprintf(stderr, "\twritten in %s corner\n", (timelabel_bottom ? "bottom" : "top"));
432: if (timelabel_rotate)
433: fputs("\trotated if the terminal allows it\n\t", stderr);
434: else
435: fputs("\tnot rotated\n\t", stderr);
436: c_token++;
437: } else if (almost_equals(c_token, "su$rface")) {
438: (void) putc('\n', stderr);
439: show_surface();
440: c_token++;
441: } else if (almost_equals(c_token, "hi$dden3d")) {
442: (void) putc('\n', stderr);
443: show_hidden3d();
444: c_token++;
445: } else if (almost_equals(c_token, "cla$bel")) {
446: (void) putc('\n', stderr);
447: show_label_contours();
448: c_token++;
449: } else if (almost_equals(c_token, "xti$cs")) {
450: show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
451: c_token++;
452: } else if (almost_equals(c_token, "yti$cs")) {
453: show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
454: c_token++;
455: } else if (almost_equals(c_token, "zti$cs")) {
456: show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
457: c_token++;
458: } else if (almost_equals(c_token, "x2ti$cs")) {
459: show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
460: c_token++;
461: } else if (almost_equals(c_token, "y2ti$cs")) {
462: show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
463: c_token++;
464: } else if (almost_equals(c_token, "xdti$cs")) {
465: show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
466: c_token++;
467: } else if (almost_equals(c_token, "ydti$cs")) {
468: show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
469: c_token++;
470: } else if (almost_equals(c_token, "zdti$cs")) {
471: show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
472: c_token++;
473: } else if (almost_equals(c_token, "x2dti$cs")) {
474: show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
475: c_token++;
476: } else if (almost_equals(c_token, "y2dti$cs")) {
477: show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
478: c_token++;
479: } else if (almost_equals(c_token, "xmti$cs")) {
480: show_tics(TRUE, FALSE, FALSE, TRUE, FALSE);
481: c_token++;
482: } else if (almost_equals(c_token, "ymti$cs")) {
483: show_tics(FALSE, TRUE, FALSE, FALSE, TRUE);
484: c_token++;
485: } else if (almost_equals(c_token, "zmti$cs")) {
486: show_tics(FALSE, FALSE, TRUE, FALSE, FALSE);
487: c_token++;
488: } else if (almost_equals(c_token, "x2mti$cs")) {
489: show_tics(FALSE, FALSE, FALSE, TRUE, FALSE);
490: c_token++;
491: } else if (almost_equals(c_token, "y2mti$cs")) {
492: show_tics(FALSE, FALSE, FALSE, FALSE, TRUE);
493: c_token++;
494: } else if (almost_equals(c_token, "sa$mples")) {
495: (void) putc('\n', stderr);
496: show_samples();
497: c_token++;
498: } else if (almost_equals(c_token, "isosa$mples")) {
499: (void) putc('\n', stderr);
500: show_isosamples();
501: c_token++;
502: } else if (almost_equals(c_token, "si$ze")) {
503: (void) putc('\n', stderr);
504: show_size();
505: c_token++;
506: } else if (almost_equals(c_token, "orig$in")) {
507: (void) putc('\n', stderr);
508: show_origin();
509: c_token++;
510: } else if (almost_equals(c_token, "t$erminal")) {
511: (void) putc('\n', stderr);
512: show_term();
513: c_token++;
514: } else if (almost_equals(c_token, "rr$ange")) {
515: (void) putc('\n', stderr);
516: show_range(R_AXIS, rmin, rmax, autoscale_r, "r");
517: c_token++;
518: } else if (almost_equals(c_token, "tr$ange")) {
519: (void) putc('\n', stderr);
520: show_range(T_AXIS, tmin, tmax, autoscale_t, "t");
521: c_token++;
522: } else if (almost_equals(c_token, "ur$ange")) {
523: (void) putc('\n', stderr);
524: show_range(U_AXIS, umin, umax, autoscale_u, "u");
525: c_token++;
526: } else if (almost_equals(c_token, "vi$ew")) {
527: (void) putc('\n', stderr);
528: show_view();
529: c_token++;
530: } else if (almost_equals(c_token, "vr$ange")) {
531: (void) putc('\n', stderr);
532: show_range(V_AXIS, vmin, vmax, autoscale_v, "v");
533: c_token++;
534: } else if (almost_equals(c_token, "v$ariables")) {
535: show_variables();
536: c_token++;
537: } else if (almost_equals(c_token, "ve$rsion")) {
538: show_version(stderr);
539: c_token++;
540: if (almost_equals(c_token, "l$ong")) {
541: show_version_long();
542: c_token++;
543: }
544: } else if (almost_equals(c_token, "xr$ange")) {
545: (void) putc('\n', stderr);
546: show_range(FIRST_X_AXIS, xmin, xmax, autoscale_x, "x");
547: c_token++;
548: } else if (almost_equals(c_token, "yr$ange")) {
549: (void) putc('\n', stderr);
550: show_range(FIRST_Y_AXIS, ymin, ymax, autoscale_y, "y");
551: c_token++;
552: } else if (almost_equals(c_token, "x2r$ange")) {
553: (void) putc('\n', stderr);
554: show_range(SECOND_X_AXIS, x2min, x2max, autoscale_x2, "x2");
555: c_token++;
556: } else if (almost_equals(c_token, "y2r$ange")) {
557: (void) putc('\n', stderr);
558: show_range(SECOND_Y_AXIS, y2min, y2max, autoscale_y2, "y2");
559: c_token++;
560: } else if (almost_equals(c_token, "zr$ange")) {
561: (void) putc('\n', stderr);
562: show_range(FIRST_Z_AXIS, zmin, zmax, autoscale_z, "z");
563: c_token++;
564: } else if (almost_equals(c_token, "z$ero")) {
565: (void) putc('\n', stderr);
566: show_zero();
567: c_token++;
568: } else if (almost_equals(c_token, "a$ll")) {
569: c_token++;
570: show_version(stderr);
571: show_autoscale();
572: show_bars();
573: show_border();
574: show_boxwidth();
575: show_clip();
576: show_contour();
577: show_dgrid3d();
578: show_mapping();
579: (void) fprintf(stderr, "\tdummy variables are \"%s\" and \"%s\"\n",
580: dummy_var[0], dummy_var[1]);
581: show_format();
582: show_style("data", data_style);
583: show_style("functions", func_style);
584: show_grid();
585: show_xzeroaxis();
586: show_yzeroaxis();
587: show_label(0);
588: show_arrow(0);
589: show_linestyle(0);
590: show_keytitle();
591: show_key();
592: show_logscale();
593: show_offsets();
594: show_margin();
595: show_output();
596: show_parametric();
597: show_pointsize();
598: show_encoding();
599: show_polar();
600: show_angles();
601: show_samples();
602: show_isosamples();
603: show_view();
604: show_surface();
605: #ifndef LITE
606: show_hidden3d();
607: #endif
608: show_size();
609: show_origin();
610: show_term();
611: show_tics(TRUE, TRUE, TRUE, TRUE, TRUE);
612: show_mtics(mxtics, mxtfreq, "x");
613: show_mtics(mytics, mytfreq, "y");
614: show_mtics(mztics, mztfreq, "z");
615: show_mtics(mx2tics, mx2tfreq, "x2");
616: show_mtics(my2tics, my2tfreq, "y2");
617: show_xyzlabel("time", &timelabel);
618: if (parametric || polar) {
619: if (!is_3d_plot)
620: show_range(T_AXIS, tmin, tmax, autoscale_t, "t");
621: else {
622: show_range(U_AXIS, umin, umax, autoscale_u, "u");
623: show_range(V_AXIS, vmin, vmax, autoscale_v, "v");
624: }
625: }
626: show_range(FIRST_X_AXIS, xmin, xmax, autoscale_x, "x");
627: show_range(FIRST_Y_AXIS, ymin, ymax, autoscale_y, "y");
628: show_range(SECOND_X_AXIS, x2min, x2max, autoscale_x2, "x2");
629: show_range(SECOND_Y_AXIS, y2min, y2max, autoscale_y2, "y2");
630: show_range(FIRST_Z_AXIS, zmin, zmax, autoscale_z, "z");
631: show_xyzlabel("title", &title);
632: show_xyzlabel("xlabel", &xlabel);
633: show_xyzlabel("ylabel", &ylabel);
634: show_xyzlabel("zlabel", &zlabel);
635: show_xyzlabel("x2label", &x2label);
636: show_xyzlabel("y2label", &y2label);
637: show_datatype("xdata", FIRST_X_AXIS);
638: show_datatype("ydata", FIRST_Y_AXIS);
639: show_datatype("x2data", SECOND_X_AXIS);
640: show_datatype("y2data", SECOND_Y_AXIS);
641: show_datatype("zdata", FIRST_Z_AXIS);
642: show_timefmt();
643: show_locale();
644: show_zero();
645: show_missing();
646: show_plot();
647: show_variables();
648: show_functions();
649: c_token++;
650: } else
651: return (FALSE);
652: return (TRUE);
653: }
654:
655:
656: /*********** support functions for 'show' **********/
657: /* perhaps these need to be put into a constant array ? */
658: static void show_style(name, style)
659: char name[];
660: enum PLOT_STYLE style;
661: {
662: fprintf(stderr, "\t%s are plotted with ", name);
663: switch (style) {
664: case LINES:
665: fputs("lines\n", stderr);
666: break;
667: case POINTSTYLE:
668: fputs("points\n", stderr);
669: break;
670: case IMPULSES:
671: fputs("impulses\n", stderr);
672: break;
673: case LINESPOINTS:
674: fputs("linespoints\n", stderr);
675: break;
676: case DOTS:
677: fputs("dots\n", stderr);
678: break;
679: case YERRORBARS:
680: fputs("yerrorbars\n", stderr);
681: break;
682: case XERRORBARS:
683: fputs("xerrorbars\n", stderr);
684: break;
685: case XYERRORBARS:
686: fputs("xyerrorbars\n", stderr);
687: break;
688: case BOXES:
689: fputs("boxes\n", stderr);
690: break;
691: case BOXERROR:
692: fputs("boxerrorbars\n", stderr);
693: break;
694: case BOXXYERROR:
695: fputs("boxxyerrorbars\n", stderr);
696: break;
697: case STEPS:
698: fputs("steps\n", stderr);
699: break;
700: case FSTEPS:
701: fputs("fsteps\n", stderr);
702: break;
703: case HISTEPS:
704: fputs("histeps\n", stderr);
705: break;
706: case VECTOR:
707: fputs("vector\n", stderr);
708: break;
709: case FINANCEBARS:
710: fputs("financebars\n", stderr);
711: break;
712: case CANDLESTICKS:
713: fputs("candlesticsks\n", stderr);
714: break;
715: }
716: }
717:
718: static void show_bars()
719: {
720: /* I really like this: "terrorbars" ;-) */
721: if (bar_size > 0.0)
722: fprintf(stderr, "\terrorbars are plotted with bars of size %f\n",
723: bar_size);
724: else
725: fputs("\terrors are plotted without bars\n", stderr);
726: }
727:
728: static void show_boxwidth()
729: {
730: if (boxwidth < 0.0)
731: fputs("\tboxwidth is auto\n", stderr);
732: else
733: fprintf(stderr, "\tboxwidth is %g\n", boxwidth);
734: }
735: static void show_dgrid3d()
736: {
737: if (dgrid3d)
738: fprintf(stderr, "\
739: \tdata grid3d is enabled for mesh of size %dx%d, norm=%d\n",
740: dgrid3d_row_fineness,
741: dgrid3d_col_fineness,
742: dgrid3d_norm_value);
743: else
744: fputs("\tdata grid3d is disabled\n", stderr);
745: }
746:
747: static void show_range(axis, min, max, autosc, text)
748: int axis;
749: double min, max;
750: TBOOLEAN autosc;
751: char *text;
752: {
753: /* this probably ought to just invoke save_range(stderr) from misc.c
754: * since I think it is identical
755: */
756:
757: if (datatype[axis] == TIME)
758: fprintf(stderr, "\tset %sdata time\n", text);
759: fprintf(stderr, "\tset %srange [", text);
760: if (autosc & 1) {
761: fputc('*', stderr);
762: } else {
763: SHOW_NUM_OR_TIME(min, axis);
764: }
765: fputs(" : ", stderr);
766: if (autosc & 2) {
767: fputc('*', stderr);
768: } else {
769: SHOW_NUM_OR_TIME(max, axis);
770: }
771: fprintf(stderr, "] %sreverse %swriteback",
772: (range_flags[axis] & RANGE_REVERSE) ? "" : "no",
773: (range_flags[axis] & RANGE_WRITEBACK) ? "" : "no");
774:
775: if (autosc) {
776: /* add current (hidden) range as comments */
777: fputs(" # (currently [", stderr);
778: if (autosc & 1) {
779: SHOW_NUM_OR_TIME(min, axis);
780: }
781: putc(':', stderr);
782: if (autosc & 2) {
783: SHOW_NUM_OR_TIME(max, axis);
784: }
785: fputs("] )\n", stderr);
786: } else {
787: putc('\n', stderr);
788: }
789: }
790:
791: static void show_zero()
792: {
793: fprintf(stderr, "\tzero is %g\n", zero);
794: }
795:
796: static void show_offsets()
797: {
798: fprintf(stderr, "\toffsets are %g, %g, %g, %g\n", loff, roff, toff, boff);
799: }
800:
801: static void show_border()
802: {
803: fprintf(stderr, "\tborder is %sdrawn %d\n", draw_border ? "" : "not ",
804: draw_border);
805: /* HBB 980609: added facilities to specify border linestyle */
806: fprintf(stderr, "\tBorder drawn with linetype %d, linewidth %.3f\n",
807: border_lp.l_type + 1, border_lp.l_width);
808: }
809:
810: static void show_output()
811: {
812: if (outstr)
813: fprintf(stderr, "\toutput is sent to '%s'\n", outstr);
814: else
815: fputs("\toutput is sent to STDOUT\n", stderr);
816: }
817:
818: static void show_samples()
819: {
820: fprintf(stderr, "\tsampling rate is %d, %d\n", samples_1, samples_2);
821: }
822:
823: static void show_isosamples()
824: {
825: fprintf(stderr, "\tiso sampling rate is %d, %d\n",
826: iso_samples_1, iso_samples_2);
827: }
828:
829: static void show_surface()
830: {
831: fprintf(stderr, "\tsurface is %sdrawn\n", draw_surface ? "" : "not ");
832: }
833:
834: static void show_hidden3d()
835: {
836: #ifdef LITE
837: printf(" Hidden Line Removal Not Supported in LITE version\n");
838: #else
839: fprintf(stderr, "\thidden surface is %s\n", hidden3d ? "removed" : "drawn");
840: show_hidden3doptions();
841: #endif /* LITE */
842: }
843:
844: static void show_label_contours()
845: {
846: if (label_contours)
847: fprintf(stderr, "\tcontour line types are varied & labeled with format '%s'\n", contour_format);
848: else
849: fputs("\tcontour line types are all the same\n", stderr);
850: }
851:
852: static void show_view()
853: {
854: fprintf(stderr, "\tview is %g rot_x, %g rot_z, %g scale, %g scale_z\n",
855: surface_rot_x, surface_rot_z, surface_scale, surface_zscale);
856: }
857:
858: static void show_size()
859: {
860: fprintf(stderr, "\tsize is scaled by %g,%g\n", xsize, ysize);
861: if (aspect_ratio > 0)
862: fprintf(stderr, "\tTry to set aspect ratio to %g:1.0\n", aspect_ratio);
863: else if (aspect_ratio == 0)
864: fputs("\tNo attempt to control aspect ratio\n", stderr);
865: else
866: fprintf(stderr, "\tTry to set LOCKED aspect ratio to %g:1.0\n",
867: -aspect_ratio);
868: }
869:
870: static void show_origin()
871: {
872: fprintf(stderr, "\torigin is set to %g,%g\n", xoffset, yoffset);
873: }
874:
875: static void show_xyzlabel(name, label)
876: char *name;
877: label_struct *label;
878: {
879: char str[MAX_LINE_LEN + 1];
880: fprintf(stderr, "\t%s is \"%s\", offset at %f, %f",
881: name, conv_text(str, label->text), label->xoffset, label->yoffset);
882: if (*label->font)
883: fprintf(stderr, ", using font \"%s\"", conv_text(str, label->font));
884: putc('\n', stderr);
885: }
886:
887: static void show_keytitle()
888: {
889: char str[MAX_LINE_LEN+1];
890: fprintf(stderr, "\tkeytitle is \"%s\"\n",
891: conv_text(str, key_title));
892: }
893:
894: static void show_timefmt()
895: {
896: char str[MAX_LINE_LEN+1];
897: fprintf(stderr, "\tread format for time is \"%s\"\n",
898: conv_text(str, timefmt));
899: }
900:
901: static void show_locale()
902: {
903: fprintf(stderr, "\tlocale is \"%s\"\n", cur_locale);
904: }
905:
906: static void show_xzeroaxis()
907: {
908: if (xzeroaxis.l_type > -3)
909: fprintf(stderr, "\txzeroaxis is drawn with linestyle %d, linewidth %.3f\n", xzeroaxis.l_type + 1, xzeroaxis.l_width);
910: else
911: fputs("\txzeroaxis is OFF\n", stderr);
912: if (x2zeroaxis.l_type > -3)
913: fprintf(stderr, "\tx2zeroaxis is drawn with linestyle %d, linewidth %.3f\n", x2zeroaxis.l_type + 1, x2zeroaxis.l_width);
914: else
915: fputs("\tx2zeroaxis is OFF\n", stderr);
916: }
917:
918: static void show_yzeroaxis()
919: {
920: if (yzeroaxis.l_type > -3)
921: fprintf(stderr, "\tyzeroaxis is drawn with linestyle %d, linewidth %.3f\n", yzeroaxis.l_type + 1, yzeroaxis.l_width);
922: else
923: fputs("\tyzeroaxis is OFF\n", stderr);
924: if (y2zeroaxis.l_type > -3)
925: fprintf(stderr, "\ty2zeroaxis is drawn with linestyle %d, linewidth %.3f\n", y2zeroaxis.l_type + 1, y2zeroaxis.l_width);
926: else
927: fputs("\ty2zeroaxis is OFF\n", stderr);
928: }
929:
930: static void show_label(tag)
931: int tag; /* 0 means show all */
932: {
933: struct text_label *this_label;
934: TBOOLEAN showed = FALSE;
935: char str[MAX_LINE_LEN + 1];
936:
937: for (this_label = first_label; this_label != NULL;
938: this_label = this_label->next) {
939: if (tag == 0 || tag == this_label->tag) {
940: showed = TRUE;
941: fprintf(stderr, "\tlabel %d \"%s\" at ",
942: this_label->tag, conv_text(str, this_label->text));
943: show_position(&this_label->place);
944: switch (this_label->pos) {
945: case LEFT:{
946: fputs(" left", stderr);
947: break;
948: }
949: case CENTRE:{
950: fputs(" centre", stderr);
951: break;
952: }
953: case RIGHT:{
954: fputs(" right", stderr);
955: break;
956: }
957: }
958: fprintf(stderr, " %s ", this_label->rotate ? "rotated (if possible)" : "not rotated");
959: if ((this_label->font)[0] != NUL)
960: fprintf(stderr, " font \"%s\"", this_label->font);
961: /* Entry font added by DJL */
962: fputc('\n', stderr);
963: }
964: }
965: if (tag > 0 && !showed)
966: int_error("label not found", c_token);
967: }
968:
969: static void show_arrow(tag)
970: int tag; /* 0 means show all */
971: {
972: struct arrow_def *this_arrow;
973: TBOOLEAN showed = FALSE;
974:
975: for (this_arrow = first_arrow; this_arrow != NULL;
976: this_arrow = this_arrow->next) {
977: if (tag == 0 || tag == this_arrow->tag) {
978: showed = TRUE;
979: fprintf(stderr, "\tarrow %d, linetype %d, linewidth %.3f %s\n\t from ",
980: this_arrow->tag,
981: this_arrow->lp_properties.l_type + 1,
982: this_arrow->lp_properties.l_width,
983: this_arrow->head ? "" : " (nohead)");
984: show_position(&this_arrow->start);
985: fputs(" to ", stderr);
986: show_position(&this_arrow->end);
987: putc('\n', stderr);
988: }
989: }
990: if (tag > 0 && !showed)
991: int_error("arrow not found", c_token);
992: }
993:
994: static void show_linestyle(tag)
995: int tag; /* 0 means show all */
996: {
997: struct linestyle_def *this_linestyle;
998: TBOOLEAN showed = FALSE;
999:
1000: for (this_linestyle = first_linestyle; this_linestyle != NULL;
1001: this_linestyle = this_linestyle->next) {
1002: if (tag == 0 || tag == this_linestyle->tag) {
1003: showed = TRUE;
1004: fprintf(stderr, "\tlinestyle %d, linetype %d, linewidth %.3f, pointtype %d, pointsize %.3f\n",
1005: this_linestyle->tag,
1006: this_linestyle->lp_properties.l_type + 1,
1007: this_linestyle->lp_properties.l_width,
1008: this_linestyle->lp_properties.p_type + 1,
1009: this_linestyle->lp_properties.p_size);
1010: }
1011: }
1012: if (tag > 0 && !showed)
1013: int_error("linestyle not found", c_token);
1014: }
1015:
1016: static void show_grid()
1017: {
1018: if (!work_grid.l_type) {
1019: fputs("\tgrid is OFF\n", stderr);
1020: return;
1021: }
1022: fprintf(stderr, "\t%s grid drawn at%s%s%s%s%s%s%s%s%s%s tics\n",
1023: (polar_grid_angle != 0) ? "Polar" : "Rectangular",
1024: work_grid.l_type & GRID_X ? " x" : "",
1025: work_grid.l_type & GRID_Y ? " y" : "",
1026: work_grid.l_type & GRID_Z ? " z" : "",
1027: work_grid.l_type & GRID_X2 ? " x2" : "",
1028: work_grid.l_type & GRID_Y2 ? " y2" : "",
1029: work_grid.l_type & GRID_MX ? " mx" : "",
1030: work_grid.l_type & GRID_MY ? " my" : "",
1031: work_grid.l_type & GRID_MZ ? " mz" : "",
1032: work_grid.l_type & GRID_MX2 ? " mx2" : "",
1033: work_grid.l_type & GRID_MY2 ? " my2" : "");
1034:
1035: fprintf(stderr, "\tMajor grid drawn with linetype %d, linewidth %.3f\n",
1036: grid_lp.l_type + 1, grid_lp.l_width);
1037: fprintf(stderr, "\tMinor grid drawn with linetype %d, linewidth %.3f\n",
1038: mgrid_lp.l_type + 1, mgrid_lp.l_width);
1039:
1040: if (polar_grid_angle)
1041: fprintf(stderr, "\tGrid radii drawn every %f %s\n",
1042: polar_grid_angle / ang2rad,
1043: angles_format == ANGLES_DEGREES ? "degrees" : "radians");
1044: }
1045:
1046: static void show_mtics(minitic, minifreq, name)
1047: int minitic;
1048: double minifreq;
1049: char *name;
1050: {
1051: switch (minitic) {
1052: case MINI_OFF:
1053: fprintf(stderr, "\tminor %stics are off\n", name);
1054: break;
1055: case MINI_DEFAULT:
1056: fprintf(stderr, "\tminor %stics are computed automatically for log scales\n", name);
1057: break;
1058: case MINI_AUTO:
1059: fprintf(stderr, "\tminor %stics are computed automatically\n", name);
1060: break;
1061: case MINI_USER:
1062: fprintf(stderr, "\tminor %stics are drawn with %d subintervals between major xtic marks\n", name, (int) minifreq);
1063: break;
1064: default:
1065: int_error("Unknown minitic type in show_mtics()", NO_CARET);
1066: }
1067: }
1068:
1069: static void show_key()
1070: {
1071: char str[80];
1072: *str = '\0';
1073: switch (key) {
1074: case -1:
1075: if (key_vpos == TUNDER) {
1076: strcpy(str, "below");
1077: } else if (key_vpos == TTOP) {
1078: strcpy(str, "top");
1079: } else {
1080: strcpy(str, "bottom");
1081: }
1082: if (key_hpos == TOUT) {
1083: strcpy(str, "outside (right)");
1084: } else if (key_hpos == TLEFT) {
1085: strcat(str, " left");
1086: } else {
1087: strcat(str, " right");
1088: }
1089: if (key_vpos != TUNDER && key_hpos != TOUT) {
1090: strcat(str, " corner");
1091: }
1092: fprintf(stderr, "\tkey is ON, position: %s\n", str);
1093: break;
1094: case 0:
1095: fputs("\tkey is OFF\n", stderr);
1096: break;
1097: case 1:
1098: fputs("\tkey is at ", stderr);
1099: show_position(&key_user_pos);
1100: putc('\n', stderr);
1101: break;
1102: }
1103: if (key) {
1104: fprintf(stderr, "\tkey is %s justified, %s reversed and ",
1105: key_just == JLEFT ? "left" : "right",
1106: key_reverse ? "" : "not");
1107: if (key_box.l_type >= -2)
1108: fprintf(stderr, "boxed\n\twith linetype %d, linewidth %.3f\n",
1109: key_box.l_type + 1, key_box.l_width);
1110: else
1111: fprintf(stderr, "not boxed\n\
1112: \tsample length is %g characters\n\
1113: \tvertical spacing is %g characters\n\
1114: \twidth adjustment is %g characters\n\
1115: \tkey title is \"%s\"\n",
1116: key_swidth,
1117: key_vert_factor,
1118: key_width_fix,
1119: key_title);
1120: }
1121: }
1122:
1123: static void show_parametric()
1124: {
1125: fprintf(stderr, "\tparametric is %s\n", (parametric) ? "ON" : "OFF");
1126: }
1127:
1128: static void show_pointsize()
1129: {
1130: fprintf(stderr, "\tpointsize is %g\n", pointsize);
1131: }
1132:
1133: static void show_encoding()
1134: {
1135: fprintf(stderr, "\tencoding is %s\n", encoding_names[encoding]);
1136: }
1137:
1138: static void show_polar()
1139: {
1140: fprintf(stderr, "\tpolar is %s\n", (polar) ? "ON" : "OFF");
1141: }
1142:
1143: static void show_angles()
1144: {
1145: fputs("\tAngles are in ", stderr);
1146: switch (angles_format) {
1147: case ANGLES_RADIANS:
1148: fputs("radians\n", stderr);
1149: break;
1150: case ANGLES_DEGREES:
1151: fputs("degrees\n", stderr);
1152: break;
1153: }
1154: }
1155:
1156:
1157: static void show_tics(showx, showy, showz, showx2, showy2)
1158: TBOOLEAN showx, showy, showz, showx2, showy2;
1159: {
1160: char str[MAX_LINE_LEN+1];
1161: fprintf(stderr, "\ttics are %s, \
1162: \tticslevel is %g\n\
1163: \tmajor ticscale is %g and minor ticscale is %g\n",
1164: (tic_in ? "IN" : "OUT"),
1165: ticslevel,
1166: ticscale, miniticscale);
1167:
1168: if (showx)
1169: show_ticdef(xtics, FIRST_X_AXIS, &xticdef, "x", rotate_xtics,
1170: conv_text(str, xformat));
1171: if (showx2)
1172: show_ticdef(x2tics, SECOND_X_AXIS, &x2ticdef, "x2", rotate_x2tics,
1173: conv_text(str, x2format));
1174: if (showy)
1175: show_ticdef(ytics, FIRST_Y_AXIS, &yticdef, "y", rotate_ytics,
1176: conv_text(str, yformat));
1177: if (showy2)
1178: show_ticdef(y2tics, SECOND_Y_AXIS, &y2ticdef, "y2", rotate_y2tics,
1179: conv_text(str, y2format));
1180: if (showz)
1181: show_ticdef(ztics, FIRST_Z_AXIS, &zticdef, "z", rotate_ztics,
1182: conv_text(str, zformat));
1183: screen_ok = FALSE;
1184: }
1185:
1186: /* called by show_tics */
1187: static void show_ticdef(tics, axis, tdef, text, rotate_tics, ticfmt)
1188: int tics; /* xtics ytics or ztics */
1189: int axis;
1190: struct ticdef *tdef; /* xticdef yticdef or zticdef */
1191: char *text; /* "x", ..., "x2", "y2" */
1192: char *ticfmt;
1193: int rotate_tics;
1194: {
1195: register struct ticmark *t;
1196:
1197: fprintf(stderr, "\t%s-axis tics:\t", text);
1198: switch (tics & TICS_MASK) {
1199: case NO_TICS:
1200: fputs("OFF\n", stderr);
1201: return;
1202: case TICS_ON_AXIS:
1203: fputs("on axis", stderr);
1204: if (tics & TICS_MIRROR)
1205: fprintf(stderr, " and mirrored %s", (tic_in ? "OUT" : "IN"));
1206: break;
1207: case TICS_ON_BORDER:
1208: fputs("on border", stderr);
1209: if (tics & TICS_MIRROR)
1210: fputs(" and mirrored on opposite border", stderr);
1211: break;
1212: }
1213:
1214: fprintf(stderr,"\n\t labels are format \"%s\"", ticfmt);
1215: if (rotate_tics)
1216: fputs(", rotated in 2D mode, terminal permitting.\n\t", stderr);
1217: else
1218: fputs(" and are not rotated\n\t", stderr);
1219:
1220: switch (tdef->type) {
1221: case TIC_COMPUTED:{
1222: fputs(" intervals computed automatically\n", stderr);
1223: break;
1224: }
1225: case TIC_MONTH:{
1226: fputs(" Months computed automatically\n", stderr);
1227: break;
1228: }
1229: case TIC_DAY:{
1230: fputs(" Days computed automatically\n", stderr);
1231: break;
1232: }
1233: case TIC_SERIES:{
1234: fputs(" series", stderr);
1235: if (tdef->def.series.start != -VERYLARGE) {
1236: fputs(" from ", stderr);
1237: SHOW_NUM_OR_TIME(tdef->def.series.start, axis);
1238: }
1239: fprintf(stderr, " by %g%s", tdef->def.series.incr, datatype[axis] == TIME ? " secs" : "");
1240: if (tdef->def.series.end != VERYLARGE) {
1241: fputs(" until ", stderr);
1242: SHOW_NUM_OR_TIME(tdef->def.series.end, axis);
1243: }
1244: putc('\n', stderr);
1245: break;
1246: }
1247: case TIC_USER:{
1248: /* this appears to be unused? lh
1249: int time;
1250: time = (datatype[axis] == TIME);
1251: */
1252: fputs(" list (", stderr);
1253: for (t = tdef->def.user; t != NULL; t = t->next) {
1254: if (t->label) {
1255: char str[MAX_LINE_LEN+1];
1256: fprintf(stderr, "\"%s\" ", conv_text(str, t->label));
1257: }
1258: SHOW_NUM_OR_TIME(t->position, axis);
1259: if (t->next)
1260: fputs(", ", stderr);
1261: }
1262: fputs(")\n", stderr);
1263: break;
1264: }
1265: default:{
1266: int_error("unknown ticdef type in show_ticdef()", NO_CARET);
1267: /* NOTREACHED */
1268: }
1269: }
1270: }
1271:
1272:
1273: static void show_margin()
1274: {
1275: if (lmargin >= 0)
1276: fprintf(stderr, "\tlmargin is set to %d\n", lmargin);
1277: else
1278: fputs("\tlmargin is computed automatically\n", stderr);
1279: if (bmargin >= 0)
1280: fprintf(stderr, "\tbmargin is set to %d\n", bmargin);
1281: else
1282: fputs("\tbmargin is computed automatically\n", stderr);
1283: if (rmargin >= 0)
1284: fprintf(stderr, "\trmargin is set to %d\n", rmargin);
1285: else
1286: fputs("\trmargin is computed automatically\n", stderr);
1287: if (tmargin >= 0)
1288: fprintf(stderr, "\ttmargin is set to %d\n", tmargin);
1289: else
1290: fputs("\ttmargin is computed automatically\n", stderr);
1291: }
1292:
1293: static void show_term()
1294: {
1295: if (term)
1296: fprintf(stderr, "\tterminal type is %s %s\n",
1297: term->name, term_options);
1298: else
1299: fputs("\tterminal type is unknown\n", stderr);
1300: }
1301:
1302: static void show_plot()
1303: {
1304: fprintf(stderr, "\tlast plot command was: %s\n", replot_line);
1305: }
1306:
1307: static void show_autoscale()
1308: {
1309: fputs("\tautoscaling is ", stderr);
1310: if (parametric) {
1311: if (is_3d_plot) {
1312: fprintf(stderr, "\tt: %s%s%s, ",
1313: (autoscale_t) ? "ON" : "OFF",
1314: (autoscale_t == 1) ? " (min)" : "",
1315: (autoscale_t == 2) ? " (max)" : "");
1316: } else {
1317: fprintf(stderr, "\tu: %s%s%s, ",
1318: (autoscale_u) ? "ON" : "OFF",
1319: (autoscale_u == 1) ? " (min)" : "",
1320: (autoscale_u == 2) ? " (max)" : "");
1321: fprintf(stderr, "v: %s%s%s, ",
1322: (autoscale_v) ? "ON" : "OFF",
1323: (autoscale_v == 1) ? " (min)" : "",
1324: (autoscale_v == 2) ? " (max)" : "");
1325: }
1326: } else
1327: putc('\t', stderr);
1328:
1329: if (polar) {
1330: fprintf(stderr, "r: %s%s%s, ", (autoscale_r) ? "ON" : "OFF",
1331: (autoscale_r == 1) ? " (min)" : "",
1332: (autoscale_r == 2) ? " (max)" : "");
1333: }
1334: fprintf(stderr, "x: %s%s%s, ", (autoscale_x) ? "ON" : "OFF",
1335: (autoscale_x == 1) ? " (min)" : "",
1336: (autoscale_x == 2) ? " (max)" : "");
1337: fprintf(stderr, "y: %s%s%s, ", (autoscale_y) ? "ON" : "OFF",
1338: (autoscale_y == 1) ? " (min)" : "",
1339: (autoscale_y == 2) ? " (max)" : "");
1340: fprintf(stderr, "z: %s%s%s\n", (autoscale_z) ? "ON" : "OFF",
1341: (autoscale_z == 1) ? " (min)" : "",
1342: (autoscale_z == 2) ? " (max)" : "");
1343: }
1344:
1345: static void show_clip()
1346: {
1347: fprintf(stderr, "\tpoint clip is %s\n", (clip_points) ? "ON" : "OFF");
1348:
1349: if (clip_lines1)
1350: fputs("\tdrawing and clipping lines between inrange and outrange points\n", stderr);
1351: else
1352: fputs("\tnot drawing lines between inrange and outrange points\n", stderr);
1353:
1354: if (clip_lines2)
1355: fputs("\tdrawing and clipping lines between two outrange points\n", stderr);
1356: else
1357: fputs("\tnot drawing lines between two outrange points\n", stderr);
1358: }
1359:
1360: static void show_mapping()
1361: {
1362: fputs("\tmapping for 3-d data is ", stderr);
1363:
1364: switch (mapping3d) {
1365: case MAP3D_CARTESIAN:
1366: fputs("cartesian\n", stderr);
1367: break;
1368: case MAP3D_SPHERICAL:
1369: fputs("spherical\n", stderr);
1370: break;
1371: case MAP3D_CYLINDRICAL:
1372: fputs("cylindrical\n", stderr);
1373: break;
1374: }
1375: }
1376:
1377: static void show_contour()
1378: {
1379: fprintf(stderr, "\tcontour for surfaces are %s",
1380: (draw_contour) ? "drawn" : "not drawn\n");
1381:
1382: if (draw_contour) {
1383: fprintf(stderr, " in %d levels on ", contour_levels);
1384: switch (draw_contour) {
1385: case CONTOUR_BASE:
1386: fputs("grid base\n", stderr);
1387: break;
1388: case CONTOUR_SRF:
1389: fputs("surface\n", stderr);
1390: break;
1391: case CONTOUR_BOTH:
1392: fputs("grid base and surface\n", stderr);
1393: break;
1394: }
1395: switch (contour_kind) {
1396: case CONTOUR_KIND_LINEAR:
1397: fputs("\t\tas linear segments\n", stderr);
1398: break;
1399: case CONTOUR_KIND_CUBIC_SPL:
1400: fprintf(stderr, "\t\tas cubic spline interpolation segments with %d pts\n", contour_pts);
1401: break;
1402: case CONTOUR_KIND_BSPLINE:
1403: fprintf(stderr, "\t\tas bspline approximation segments of order %d with %d pts\n", contour_order, contour_pts);
1404: break;
1405: }
1406: switch (levels_kind) {
1407: case LEVELS_AUTO:
1408: fprintf(stderr, "\t\tapprox. %d automatic levels\n", contour_levels);
1409: break;
1410: case LEVELS_DISCRETE:
1411: {
1412: int i;
1413: fprintf(stderr, "\t\t%d discrete levels at ", contour_levels);
1414: fprintf(stderr, "%g", levels_list[0]);
1415: for (i = 1; i < contour_levels; i++)
1416: fprintf(stderr, ",%g ", levels_list[i]);
1417: putc('\n', stderr);
1418: break;
1419: }
1420: case LEVELS_INCREMENTAL:
1421: fprintf(stderr, "\t\t%d incremental levels starting at %g, step %g, end %g\n", contour_levels, levels_list[0], levels_list[1],
1422: levels_list[0] + (contour_levels - 1) * levels_list[1]);
1423: /* contour-levels counts both ends */
1424: break;
1425: }
1426: /* fprintf(stderr,"\t\tcontour line types are %s\n", label_contours ? "varied" : "all the same"); */
1427: show_label_contours();
1428: }
1429: }
1430:
1431: static void show_format()
1432: {
1433: char str[5][MAX_LINE_LEN + 1];
1434:
1435: fprintf(stderr, "\ttic format is x-axis: \"%s\"\
1436: , y-axis: \"%s\"\
1437: , z-axis: \"%s\"\
1438: , x2-axis: \"%s\"\
1439: , y2-axis: \"%s\"\n",
1440: conv_text(str[0], xformat),
1441: conv_text(str[1], yformat),
1442: conv_text(str[2], zformat),
1443: conv_text(str[3], x2format),
1444: conv_text(str[4], y2format));
1445: }
1446:
1447: #define SHOW_LOG(FLAG, BASE, TEXT) \
1448: if (FLAG) fprintf(stderr, "%s %s (base %g)", !count++ ? "\tlogscaling" : " and", TEXT,BASE)
1449:
1450: static void show_logscale()
1451: {
1452: int count = 0;
1453:
1454: SHOW_LOG(is_log_x, base_log_x, "x");
1455: SHOW_LOG(is_log_y, base_log_y, "y");
1456: SHOW_LOG(is_log_z, base_log_z, "z");
1457: SHOW_LOG(is_log_x2, base_log_x2, "x2");
1458: SHOW_LOG(is_log_y2, base_log_y2, "y2");
1459:
1460: if (count == 0)
1461: fputs("\tno logscaling\n", stderr);
1462: else if (count == 1)
1463: fputs(" only\n", stderr);
1464: else
1465: putc('\n', stderr);
1466: }
1467:
1468: static void show_variables()
1469: {
1470: register struct udvt_entry *udv = first_udv;
1471: int len;
1472:
1473: fputs("\n\tVariables:\n", stderr);
1474: while (udv) {
1475: len = instring(udv->udv_name, ' ');
1476: fprintf(stderr, "\t%-*s ", len, udv->udv_name);
1477: if (udv->udv_undef)
1478: fputs("is undefined\n", stderr);
1479: else {
1480: fputs("= ", stderr);
1481: disp_value(stderr, &(udv->udv_value));
1482: (void) putc('\n', stderr);
1483: }
1484: udv = udv->next_udv;
1485: }
1486: }
1487:
1488: /*
1489: * Used in plot.c and misc.c
1490: * By adding FILE *fp, we can now use show_version()
1491: * to save version information to a file.
1492: */
1493: void show_version(fp)
1494: FILE *fp;
1495: {
1496: /* If printed to a file, we prefix everything with
1497: * a hash mark to comment out the version information.
1498: */
1499: char prefix[6]; /* "# " */
1500: char *p = prefix;
1501:
1502: prefix[0] = '#';
1503: prefix[1] = prefix[2] = prefix[3] = prefix[4] = ' ';
1504: prefix[5] = NUL;
1505:
1506: if (fp == stderr) {
1507: /* No hash mark - let p point to the trailing '\0' */
1508: p += sizeof(prefix) - 1;
1509: } else {
1510: #ifdef GNUPLOT_BINDIR
1511: # ifdef X11
1512: fprintf(fp, "#!%s/gnuplot -persist\n#\n", GNUPLOT_BINDIR);
1513: # else
1514: fprintf(fp, "#!%s/gnuplot\n#\n", GNUPLOT_BINDIR);
1515: # endif /* not X11 */
1516: #endif /* GNUPLOT_BINDIR */
1517: }
1518: fprintf(fp, "%s\n\
1519: %s\t%s\n\
1520: %s\t%sversion %s\n\
1521: %s\tpatchlevel %s\n\
1522: %s\tlast modified %s\n\
1523: %s\n\
1524: %s\t%s\n\
1525: %s\tThomas Williams, Colin Kelley and many others\n\
1526: %s\n\
1527: %s\tType `help` to access the on-line reference manual\n\
1528: %s\tThe gnuplot FAQ is available from\n\
1529: %s\t\t<%s>\n\
1530: %s\n\
1531: %s\tSend comments and requests for help to <%s>\n\
1532: %s\tSend bugs, suggestions and mods to <%s>\n\
1533: %s\n",
1534: p, /* empty line */
1535: p, PROGRAM,
1536: p, OS, version,
1537: p, patchlevel,
1538: p, date,
1539: p, /* empty line */
1540: p, gnuplot_copyright,
1541: p, /* authors */
1542: p, /* empty line */
1543: p, /* Type help */
1544: p, /* FAQ is at */
1545: p, faq_location,
1546: p, /* empty line */
1547: p, help_email,
1548: p, bug_email,
1549: p); /* empty line */
1550: }
1551:
1552: void show_version_long()
1553: {
1554: char *helpfile = NULL;
1555: #ifdef HAVE_SYS_UTSNAME_H
1556: struct utsname uts;
1557:
1558: /* something is fundamentally wrong if this fails ... */
1559: if (uname(&uts) > -1) {
1560: # ifdef _AIX
1561: fprintf(stderr, "\nSystem: %s %s.%s", uts.sysname, uts.version, uts.release);
1562: # elif defined (SCO)
1563: fprintf(stderr, "\nSystem: SCO %s", uts.release);
1564: # else
1565: fprintf(stderr, "\nSystem: %s %s", uts.sysname, uts.release);
1566: # endif
1567: } else {
1568: fprintf(stderr, "\n%s\n", OS);
1569: }
1570:
1571: #else /* ! HAVE_SYS_UTSNAME_H */
1572:
1573: fprintf(stderr, "\n%s\n", OS);
1574:
1575: #endif /* HAVE_SYS_UTSNAME_H */
1576:
1577: fputs("\nCompile options:\n", stderr);
1578:
1579: {
1580: /* The following code could be a lot simpler if
1581: * it wasn't for Borland's broken compiler ...
1582: */
1583: const char *rdline, *gnu_rdline, *libgd, *libpng, *linuxvga,
1584: *nocwdrc, *x11, *unixplot, *gnugraph;
1585:
1586: rdline =
1587: #ifdef READLINE
1588: "+READLINE "
1589: #else
1590: "-READLINE "
1591: #endif
1592: ,gnu_rdline =
1593: #ifdef GNU_READLINE
1594: "+GNU_READLINE "
1595: #else
1596: "-GNU_READLINE "
1597: #endif
1598: ,libgd =
1599: #ifdef HAVE_LIBGD
1600: "+LIBGD "
1601: #else
1602: "-LIBGD "
1603: #endif
1604: ,libpng =
1605: #ifdef HAVE_LIBPNG
1606: "+LIBPNG "
1607: #else
1608: "-LIBPNG "
1609: #endif
1610: ,linuxvga =
1611: #ifdef LINUXVGA
1612: "+LINUXVGA "
1613: #else
1614: ""
1615: #endif
1616: ,nocwdrc =
1617: #ifdef NOCWDRC
1618: "+NOCWDRC "
1619: #else
1620: "-NOCWDRC "
1621: #endif
1622: ,x11 =
1623:
1624: #ifdef X11
1625: "+X11 "
1626: #else
1627: ""
1628: #endif
1629: ,unixplot =
1630: #ifdef UNIXPLOT
1631: "+UNIXPLOT "
1632: #else
1633: ""
1634: #endif
1635: ,gnugraph =
1636: #ifdef GNUGRAPH
1637: "+GNUGRAPH "
1638: #else
1639: ""
1640: #endif
1641: ;
1642: fprintf(stderr, "%s%s%s%s%s%s%s%s%s\n\n", rdline, gnu_rdline,
1643: libgd, libpng, linuxvga, nocwdrc, x11, unixplot, gnugraph);
1644: }
1645:
1646: if ((helpfile = getenv("GNUHELP")) == NULL) {
1647: #if defined(ATARI) || defined(MTOS)
1648: if ((helpfile = getenv("GNUPLOTPATH")) == NULL) {
1649: helpfile = HELPFILE;
1650: }
1651: #else
1652: helpfile = HELPFILE;
1653: #endif
1654: }
1655: fprintf(stderr, "HELPFILE = \"%s\"\n\
1656: FAQ location = <%s>\n\
1657: CONTACT = <%s>\n\
1658: HELPMAIL = <%s>\n", helpfile, faq_location, bug_email, help_email);
1659: }
1660:
1661: static void show_datatype(name, axis)
1662: char *name;
1663: int axis;
1664: {
1665: fprintf(stderr, "\t%s is set to %s\n", name,
1666: datatype[axis] == TIME ? "time" : "numerical");
1667: }
1668:
1669: char *
1670: conv_text(s, t)
1671: char *s, *t;
1672: {
1673: /* convert unprintable characters as \okt, tab as \t, newline \n .. */
1674: char *r;
1675: r = s;
1676: while (*t != '\0') {
1677: switch (*t) {
1678: case '\t':
1679: *s++ = '\\';
1680: *s++ = 't';
1681: break;
1682: case '\n':
1683: *s++ = '\\';
1684: *s++ = 'n';
1685: break;
1686: #ifndef OSK
1687: case '\r':
1688: *s++ = '\\';
1689: *s++ = 'r';
1690: break;
1691: #endif
1692: case '"':
1693: case '\\':
1694: *s++ = '\\';
1695: *s++ = *t;
1696: break;
1697:
1698: default:{
1699: if ((*t & 0177) > 31 && (*t & 0177) < 127)
1700: *s++ = *t;
1701: else {
1702: *s++ = '\\';
1703: sprintf(s, "%o", *t);
1704: while (*s != '\0')
1705: s++;
1706: }
1707: }
1708: }
1709: t++;
1710: }
1711: *s = '\0';
1712: return (r);
1713: }
1714:
1715:
1716: static void show_position(pos)
1717: struct position *pos;
1718: {
1719: static char *msg[] =
1720: {"(first axes) ", "(second axes) ", "(graph units) ", "(screen units) "};
1721:
1722: assert(first_axes == 0 && second_axes == 1 && graph == 2 && screen == 3);
1723:
1724: fprintf(stderr, "(%s%g, %s%g, %s%g)",
1725: pos->scalex == first_axes ? "" : msg[pos->scalex], pos->x,
1726: pos->scaley == pos->scalex ? "" : msg[pos->scaley], pos->y,
1727: pos->scalez == pos->scaley ? "" : msg[pos->scalez], pos->z);
1728:
1729: }
1730:
1731: static void show_missing()
1732: {
1733: if (missing_val == NULL)
1734: fputs("\tNo string is interpreted as missing data\n", stderr);
1735: else
1736: fprintf(stderr, "\t\"%s\" is interpreted as missing value\n", missing_val);
1737: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to show.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot