X-Git-Url: http://git.maemo.org/git/?p=gnuplot;a=blobdiff_plain;f=src%2Fshow.c;fp=src%2Fshow.c;h=85af014ec670bfd9a326c4c8e8ba70b679dfa15c;hp=0000000000000000000000000000000000000000;hb=39ec1247a71f61152a4a7f502a30f06a3896c5da;hpb=06be459be4f5f6a7c6ff878e84f355fb2575caa8 diff --git a/src/show.c b/src/show.c new file mode 100644 index 0000000..85af014 --- /dev/null +++ b/src/show.c @@ -0,0 +1,3249 @@ +#ifndef lint +static char *RCSid() { return RCSid("$Id: show.c,v 1.185.2.11 2008/12/15 03:44:22 sfeam Exp $"); } +#endif + +/* GNUPLOT - show.c */ + +/*[ + * Copyright 1986 - 1993, 1998, 2004 Thomas Williams, Colin Kelley + * + * Permission to use, copy, and distribute this software and its + * documentation for any purpose with or without fee is hereby granted, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. + * + * Permission to modify the software is granted, but not the right to + * distribute the complete modified source code. Modifications are to + * be distributed as patches to the released version. Permission to + * distribute binaries produced by compiling modified sources is granted, + * provided you + * 1. distribute the corresponding source modifications from the + * released version in the form of a patch file along with the binaries, + * 2. add special version identification to distinguish your version + * in addition to the base release version number, + * 3. provide your name and address as the primary contact for the + * support of your modified version, and + * 4. retain our contact information in regard to use of the base + * software. + * Permission to distribute the released version of the source code along + * with corresponding source modifications in the form of a patch file is + * granted with same provisions 2 through 4 for binary distributions. + * + * This software is provided "as is" without express or implied warranty + * to the extent permitted by applicable law. +]*/ + + +/* + * 19 September 1992 Lawrence Crowl (crowl@cs.orst.edu) + * Added user-specified bases for log scaling. + */ + +#include "setshow.h" + +#include "alloc.h" +#include "axis.h" +#include "command.h" +#include "contour.h" +#include "datafile.h" +#include "eval.h" +#include "fit.h" +#include "gp_time.h" +#include "graphics.h" +#include "hidden3d.h" +#include "misc.h" +#include "gp_hist.h" +#include "plot2d.h" +#include "plot3d.h" +#include "save.h" +#include "tables.h" +#include "util.h" +#include "term_api.h" +#include "variable.h" +#include "version.h" +#ifdef USE_MOUSE +# include "mouse.h" +#endif +#include "color.h" +#include "pm3d.h" +#include "getcolor.h" +#include + +/******** Local functions ********/ + +static void show_at __PROTO((void)); +static void disp_at __PROTO((struct at_type *, int)); +static void show_all __PROTO((void)); +static void show_autoscale __PROTO((void)); +static void show_bars __PROTO((void)); +static void show_border __PROTO((void)); +static void show_boxwidth __PROTO((void)); +static void show_fillstyle __PROTO((void)); +static void show_clip __PROTO((void)); +static void show_contour __PROTO((void)); +static void show_dgrid3d __PROTO((void)); +static void show_label_contours __PROTO((void)); +#ifdef GP_MACROS +static void show_macros __PROTO((void)); +#endif +static void show_mapping __PROTO((void)); +static void show_dummy __PROTO((void)); +static void show_format __PROTO((void)); +static void show_styles __PROTO((const char *name, enum PLOT_STYLE style)); +static void show_style __PROTO((void)); +static void show_grid __PROTO((void)); +static void show_zeroaxis __PROTO((AXIS_INDEX)); +static void show_label __PROTO((int tag)); +static void show_keytitle __PROTO((void)); +static void show_key __PROTO((void)); +static void show_logscale __PROTO((void)); +static void show_offsets __PROTO((void)); +static void show_margin __PROTO((void)); +static void show_output __PROTO((void)); +static void show_parametric __PROTO((void)); +static void show_pm3d __PROTO((void)); +static void show_palette __PROTO((void)); +static void show_palette_rgbformulae __PROTO((void)); +static void show_palette_fit2rgbformulae __PROTO((void)); +static void show_palette_palette __PROTO((void)); +static void show_palette_gradient __PROTO((void)); +static void show_palette_colornames __PROTO((void)); +static void show_colorbox __PROTO((void)); +static void show_pointsize __PROTO((void)); +static void show_encoding __PROTO((void)); +static void show_decimalsign __PROTO((void)); +static void show_fit __PROTO((void)); +static void show_polar __PROTO((void)); +static void show_print __PROTO((void)); +static void show_angles __PROTO((void)); +static void show_samples __PROTO((void)); +static void show_isosamples __PROTO((void)); +static void show_view __PROTO((void)); +static void show_surface __PROTO((void)); +static void show_hidden3d __PROTO((void)); +static void show_increment __PROTO((void)); +#ifdef EAM_HISTOGRAMS +static void show_histogram __PROTO((void)); +#endif +#ifdef GNUPLOT_HISTORY +static void show_historysize __PROTO((void)); +#endif +static void show_size __PROTO((void)); +static void show_origin __PROTO((void)); +static void show_term __PROTO((void)); +static void show_tics __PROTO((TBOOLEAN showx, TBOOLEAN showy, TBOOLEAN showz, TBOOLEAN showx2, TBOOLEAN showy2, TBOOLEAN showcb)); +static void show_mtics __PROTO((AXIS_INDEX)); +static void show_timestamp __PROTO((void)); +static void show_range __PROTO((AXIS_INDEX axis)); +static void show_xyzlabel __PROTO((const char *name, const char *suffix, text_label * label)); +static void show_title __PROTO((void)); +static void show_axislabel __PROTO((AXIS_INDEX)); +static void show_data_is_timedate __PROTO((AXIS_INDEX)); +static void show_timefmt __PROTO((void)); +static void show_locale __PROTO((void)); +static void show_loadpath __PROTO((void)); +static void show_fontpath __PROTO((void)); +static void show_zero __PROTO((void)); +static void show_datafile __PROTO((void)); +#ifdef USE_MOUSE +static void show_mouse __PROTO((void)); +#endif +static void show_plot __PROTO((void)); +static void show_variables __PROTO((void)); + +static void show_linestyle __PROTO((int tag)); +static void show_arrowstyle __PROTO((int tag)); +static void show_arrow __PROTO((int tag)); + +static void show_ticdef __PROTO((AXIS_INDEX)); +static void show_position __PROTO((struct position * pos)); +static void show_functions __PROTO((void)); + +static char *num_to_str __PROTO((double r)); + +static int var_show_all = 0; + +static char *save_locale = NULL; + +/* following code segment appears over and over again */ + +#define SHOW_NUM_OR_TIME(x, axis) SAVE_NUM_OR_TIME(stderr, x, axis) + +#define SHOW_ALL_NL { if (!var_show_all) (void) putc('\n',stderr); } + +/******* The 'show' command *******/ +void +show_command() +{ + /* show at is undocumented/hidden... */ + static char GPFAR showmess[] = + "valid set options: [] = choose one, {} means optional\n\n\ +\t'all', 'angles', 'arrow', 'autoscale', 'bars', 'border', 'boxwidth', 'clip',\n\ +\t'cntrparam', 'colorbox', 'contour', 'datafile', 'decimalsign','dgrid3d',\n\ +\t'dummy', 'encoding', 'fit', 'fontpath', 'format', 'functions', 'grid',\n\ +\t'hidden', 'isosamples', 'key', 'label', 'loadpath', 'locale', 'logscale',\n\ +\t'mapping', 'margin', 'offsets', 'origin', 'output', 'plot',\n\ +\t'palette', 'parametric', 'pm3d', 'pointsize', 'polar', 'print', '[rtuv]range',\n\ +\t'samples', 'size', 'style', 'terminal', 'tics', 'timestamp',\n\ +\t'timefmt', 'title', 'variables', 'version', 'view',\n\ +\t'[xyz,cb]{2}label', '[xyz,cb]{2}range', '{m}[xyz,cb]{2}tics',\n\ +\t'[xyz,cb]{2}[md]tics', '{[xyz]{2}}zeroaxis', '[xyz,cb]data', 'zero'"; + + enum set_id token_found; + struct value a; + int tag =0; + char *error_message = NULL; + + c_token++; + + token_found = lookup_table(&set_tbl[0],c_token); + +#ifdef HAVE_LOCALE_H + /* Report internal values in C locale (dot for decimal sign) */ + save_locale = gp_strdup(setlocale(LC_NUMERIC,NULL)); + setlocale(LC_NUMERIC,"C"); +#endif + + /* rationalize c_token advancement stuff a bit: */ + if (token_found != S_INVALID) + c_token++; + + switch(token_found) { + case S_ACTIONTABLE: + show_at(); + break; + case S_ALL: + show_all(); + break; + case S_VERSION: + show_version(stderr); + break; + case S_AUTOSCALE: + show_autoscale(); + break; + case S_BARS: + show_bars(); + break; + case S_BORDER: + show_border(); + break; + case S_BOXWIDTH: + show_boxwidth(); + break; + case S_CLIP: + show_clip(); + break; + case S_CLABEL: + /* contour labels are shown with 'show contour' */ + case S_CONTOUR: + case S_CNTRPARAM: + show_contour(); + break; + case S_DGRID3D: + show_dgrid3d(); + break; +#ifdef GP_MACROS + case S_MACROS: + show_macros(); + break; +#endif + case S_MAPPING: + show_mapping(); + break; + case S_DUMMY: + show_dummy(); + break; + case S_FORMAT: + show_format(); + break; + case S_FUNCTIONS: + show_functions(); + break; + case S_GRID: + show_grid(); + break; + case S_ZEROAXIS: + show_zeroaxis(FIRST_X_AXIS); + show_zeroaxis(FIRST_Y_AXIS); + show_zeroaxis(FIRST_Z_AXIS); + break; + case S_XZEROAXIS: + show_zeroaxis(FIRST_X_AXIS); + break; + case S_YZEROAXIS: + show_zeroaxis(FIRST_Y_AXIS); + break; + case S_X2ZEROAXIS: + show_zeroaxis(SECOND_X_AXIS); + break; + case S_Y2ZEROAXIS: + show_zeroaxis(SECOND_Y_AXIS); + break; + case S_ZZEROAXIS: + show_zeroaxis(FIRST_Z_AXIS); + break; + +#define CHECK_TAG_GT_ZERO \ + if (!END_OF_COMMAND) { \ + tag = real(const_express(&a)); \ + if (tag <= 0) { \ + error_message = "tag must be > zero"; \ + break; \ + } \ + } \ + (void) putc('\n',stderr); + + case S_LABEL: + CHECK_TAG_GT_ZERO; + show_label(tag); + break; + case S_ARROW: + CHECK_TAG_GT_ZERO; + show_arrow(tag); + break; +#ifdef BACKWARDS_COMPATIBLE + case S_LINESTYLE: + CHECK_TAG_GT_ZERO; + show_linestyle(tag); + break; +#else + case S_LINESTYLE: + error_message = "keyword 'linestyle' deprecated, use 'show style line'"; + break; +#endif + case S_KEYTITLE: + show_keytitle(); + break; + case S_KEY: + show_key(); + break; + case S_LOGSCALE: + show_logscale(); + break; + case S_OFFSETS: + show_offsets(); + break; + + case S_LMARGIN: /* HBB 20010525: handle like 'show margin' */ + case S_RMARGIN: + case S_TMARGIN: + case S_BMARGIN: + case S_MARGIN: + show_margin(); + break; + + case SET_OUTPUT: + show_output(); + break; + case S_PARAMETRIC: + show_parametric(); + break; + case S_PM3D: + show_pm3d(); + break; + case S_PALETTE: + show_palette(); + break; + case S_COLORBOX: + show_colorbox(); + break; + case S_COLORNAMES: + c_token--; + show_palette_colornames(); + break; + case S_POINTSIZE: + show_pointsize(); + break; + case S_DECIMALSIGN: + show_decimalsign(); + break; + case S_ENCODING: + show_encoding(); + break; + case S_FIT: + show_fit(); + break; + case S_FONTPATH: + show_fontpath(); + break; + case S_POLAR: + show_polar(); + break; + case S_PRINT: + show_print(); + break; + case S_OBJECT: +#ifdef EAM_OBJECTS + if (almost_equals(c_token,"rect$angle")) + c_token++; + CHECK_TAG_GT_ZERO; + save_rectangle(stderr,tag); +#endif + break; + case S_ANGLES: + show_angles(); + break; + case S_SAMPLES: + show_samples(); + break; + case S_ISOSAMPLES: + show_isosamples(); + break; + case S_VIEW: + show_view(); + break; +#ifdef BACKWARDS_COMPATIBLE + case S_DATA: + /* HBB 20010525: re-implement old 'show data style' command */ + /* FIXME: 'show function style' is gone completely */ + if (almost_equals(c_token, "st$yle")) { + show_styles("Data", data_style); + c_token++; + } else + error_message = "keyword 'style' expected after 'show data'"; + break; +#else + case S_DATA: + error_message = "keyword 'data' deprecated, use 'show style data'"; + break; +#endif + case S_STYLE: + show_style(); + break; + case S_SURFACE: + show_surface(); + break; + case S_HIDDEN3D: + show_hidden3d(); + break; +#ifdef GNUPLOT_HISTORY + case S_HISTORYSIZE: + show_historysize(); + break; +#endif + case S_SIZE: + show_size(); + break; + case S_ORIGIN: + show_origin(); + break; + case S_TERMINAL: + show_term(); + break; + case S_TICS: + case S_TICSLEVEL: + case S_TICSCALE: + show_tics(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE); + break; + case S_MXTICS: + show_mtics(FIRST_X_AXIS); + break; + case S_MYTICS: + show_mtics(FIRST_Y_AXIS); + break; + case S_MZTICS: + show_mtics(FIRST_Z_AXIS); + break; + case S_MCBTICS: + show_mtics(COLOR_AXIS); + break; + case S_MX2TICS: + show_mtics(SECOND_X_AXIS); + break; + case S_MY2TICS: + show_mtics(SECOND_Y_AXIS); + break; + case S_TIMESTAMP: + show_timestamp(); + break; + case S_RRANGE: + show_range(R_AXIS); + break; + case S_TRANGE: + show_range(T_AXIS); + break; + case S_URANGE: + show_range(U_AXIS); + break; + case S_VRANGE: + show_range(V_AXIS); + break; + case S_XRANGE: + show_range(FIRST_X_AXIS); + break; + case S_YRANGE: + show_range(FIRST_Y_AXIS); + break; + case S_X2RANGE: + show_range(SECOND_X_AXIS); + break; + case S_Y2RANGE: + show_range(SECOND_Y_AXIS); + break; + case S_ZRANGE: + show_range(FIRST_Z_AXIS); + break; + case S_CBRANGE: + show_range(COLOR_AXIS); + break; + case S_TITLE: + show_title(); + break; + case S_XLABEL: + show_axislabel(FIRST_X_AXIS); + break; + case S_YLABEL: + show_axislabel(FIRST_Y_AXIS); + break; + case S_ZLABEL: + show_axislabel(FIRST_Z_AXIS); + break; + case S_CBLABEL: + show_axislabel(COLOR_AXIS); + break; + case S_X2LABEL: + show_axislabel(SECOND_X_AXIS); + break; + case S_Y2LABEL: + show_axislabel(SECOND_Y_AXIS); + break; + case S_XDATA: + show_data_is_timedate(FIRST_X_AXIS); + break; + case S_YDATA: + show_data_is_timedate(FIRST_Y_AXIS); + break; + case S_X2DATA: + show_data_is_timedate(SECOND_X_AXIS); + break; + case S_Y2DATA: + show_data_is_timedate(SECOND_Y_AXIS); + break; + case S_ZDATA: + show_data_is_timedate(FIRST_Z_AXIS); + break; + case S_CBDATA: + show_data_is_timedate(COLOR_AXIS); + break; + case S_TIMEFMT: + show_timefmt(); + break; + case S_LOCALE: + show_locale(); + break; + case S_LOADPATH: + show_loadpath(); + break; + case S_ZERO: + show_zero(); + break; + case S_DATAFILE: + show_datafile(); + break; +#ifdef USE_MOUSE + case S_MOUSE: + show_mouse(); + break; +#endif + case S_PLOT: + show_plot(); +#if defined(READLINE) || defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE) + if (!END_OF_COMMAND) { + if (almost_equals(c_token, "a$dd2history")) { + c_token++; + add_history(replot_line); + } + } +#endif + break; + case S_VARIABLES: + show_variables(); + break; +/* FIXME: get rid of S_*DTICS, S_*MTICS cases */ + case S_XTICS: + case S_XDTICS: + case S_XMTICS: + show_tics(TRUE, FALSE, FALSE, TRUE, FALSE, FALSE); + break; + case S_YTICS: + case S_YDTICS: + case S_YMTICS: + show_tics(FALSE, TRUE, FALSE, FALSE, TRUE, FALSE); + break; + case S_ZTICS: + case S_ZDTICS: + case S_ZMTICS: + show_tics(FALSE, FALSE, TRUE, FALSE, FALSE, FALSE); + break; + case S_CBTICS: + case S_CBDTICS: + case S_CBMTICS: + show_tics(FALSE, FALSE, FALSE, FALSE, FALSE, TRUE); + break; + case S_X2TICS: + case S_X2DTICS: + case S_X2MTICS: + show_tics(FALSE, FALSE, FALSE, TRUE, FALSE, FALSE); + break; + case S_Y2TICS: + case S_Y2DTICS: + case S_Y2MTICS: + show_tics(FALSE, FALSE, FALSE, FALSE, TRUE, FALSE); + break; + +#ifdef BACKWARDS_COMPATIBLE + /* HBB 20010522: avoid triggering the 'default' parse error + * message for these commands --- they don't really exist, and + * shouldn't cause that message to appear */ + case S_NOMX2TICS: + case S_NOMXTICS: + case S_NOMY2TICS: + case S_NOMYTICS: + case S_NOMZTICS: + case S_NOCBTICS: + case S_NOMCBTICS: + case S_NOCBDTICS: + case S_NOCBMTICS: + case S_NOX2DTICS: + case S_NOX2MTICS: + case S_NOX2TICS: + case S_NOXDTICS: + case S_NOXMTICS: + case S_NOXTICS: + case S_NOY2DTICS: + case S_NOY2MTICS: + case S_NOY2TICS: + case S_NOYDTICS: + case S_NOYMTICS: + case S_NOYTICS: + case S_NOZDTICS: + case S_NOZMTICS: + case S_NOZTICS: + error_message = "'show' does not accept the 'no...' type of 'set' options"; + break; +#endif /* BACKWARDS_COMPATIBLE */ + + case S_MULTIPLOT: + fprintf(stderr,"multiplot mode is %s\n", multiplot ? "on" : "off"); + break; + + case S_TERMOPTIONS: + fprintf(stderr,"Terminal options are '%s'\n", + (*term_options) ? term_options : "[none]"); + break; + + /* HBB 20010525: 'set commands' that don't have an + * accompanying 'show' version, for no particular reason: */ + /* --- such case now, all implemented. */ + + case S_INVALID: + error_message = showmess; + break; + default: + error_message = "invalid or deprecated syntax"; + break; + } + +#ifdef HAVE_LOCALE_H + if (save_locale) { + setlocale(LC_NUMERIC,save_locale); + free(save_locale); + save_locale = NULL; + } +#endif + + if (error_message) + int_error(c_token,error_message); + + screen_ok = FALSE; + (void) putc('\n', stderr); + +#undef CHECK_TAG_GT_ZERO +} + + +/* process 'show actiontable|at' command + * not documented + */ +static void +show_at() +{ + (void) putc('\n', stderr); + disp_at(temp_at(), 0); + c_token++; +} + + +/* called by show_at(), and recursively by itself */ +static void +disp_at(struct at_type *curr_at, int level) +{ + int i, j; + union argument *arg; + + for (i = 0; i < curr_at->a_count; i++) { + (void) putc('\t', stderr); + for (j = 0; j < level; j++) + (void) putc(' ', stderr); /* indent */ + + /* print name of instruction */ + + fputs(ft[(int) (curr_at->actions[i].index)].f_name, stderr); + arg = &(curr_at->actions[i].arg); + + /* now print optional argument */ + + switch (curr_at->actions[i].index) { + case PUSH: + fprintf(stderr, " %s\n", arg->udv_arg->udv_name); + break; + case PUSHC: + (void) putc(' ', stderr); + disp_value(stderr, &(arg->v_arg), TRUE); + (void) putc('\n', stderr); + break; + case PUSHD1: + fprintf(stderr, " %c dummy\n", + arg->udf_arg->udf_name[0]); + break; + case PUSHD2: + fprintf(stderr, " %c dummy\n", + arg->udf_arg->udf_name[1]); + break; + case CALL: + fprintf(stderr, " %s", arg->udf_arg->udf_name); + if (level < 6) { + if (arg->udf_arg->at) { + (void) putc('\n', stderr); + disp_at(arg->udf_arg->at, level + 2); /* recurse! */ + } else + fputs(" (undefined)\n", stderr); + } else + (void) putc('\n', stderr); + break; + case CALLN: + fprintf(stderr, " %s", arg->udf_arg->udf_name); + if (level < 6) { + if (arg->udf_arg->at) { + (void) putc('\n', stderr); + disp_at(arg->udf_arg->at, level + 2); /* recurse! */ + } else + fputs(" (undefined)\n", stderr); + } else + (void) putc('\n', stderr); + break; + case JUMP: + case JUMPZ: + case JUMPNZ: + case JTERN: + fprintf(stderr, " +%d\n", arg->j_arg); + break; + case DOLLARS: + fprintf(stderr, " %d\n", arg->v_arg.v.int_val); + break; + default: + (void) putc('\n', stderr); + } + } +} + + +/* process 'show all' command */ +static void +show_all() +{ + var_show_all = 1; + + show_version(stderr); + show_autoscale(); + show_bars(); + show_border(); + show_boxwidth(); + show_clip(); + show_label_contours(); + show_contour(); + show_dgrid3d(); +#ifdef GP_MACROS + show_macros(); +#endif + show_mapping(); + show_dummy(); + show_format(); + show_style(); + show_grid(); + show_zeroaxis(FIRST_X_AXIS); + show_zeroaxis(FIRST_Y_AXIS); + show_zeroaxis(FIRST_Z_AXIS); + show_label(0); + show_arrow(0); + show_keytitle(); + show_key(); + show_logscale(); + show_offsets(); + show_margin(); + show_output(); + show_print(); + show_parametric(); + show_palette(); + show_colorbox(); + show_pm3d(); + show_pointsize(); + show_encoding(); + show_decimalsign(); + show_fit(); + show_polar(); + show_angles(); +#ifdef EAM_OBJECTS + save_rectangle(stderr,0); +#endif + show_samples(); + show_isosamples(); + show_view(); + show_surface(); + show_hidden3d(); +#ifdef GNUPLOT_HISTORY + show_historysize(); +#endif + show_size(); + show_origin(); + show_term(); + show_tics(TRUE,TRUE,TRUE,TRUE,TRUE,TRUE); + show_mtics(FIRST_X_AXIS); + show_mtics(FIRST_Y_AXIS); + show_mtics(FIRST_Z_AXIS); + show_mtics(SECOND_X_AXIS); + show_mtics(SECOND_Y_AXIS); + show_xyzlabel("", "time", &timelabel); + if (parametric || polar) { + if (!is_3d_plot) + show_range(T_AXIS); + else { + show_range(U_AXIS); + show_range(V_AXIS); + } + } + show_range(FIRST_X_AXIS); + show_range(FIRST_Y_AXIS); + show_range(SECOND_X_AXIS); + show_range(SECOND_Y_AXIS); + show_range(FIRST_Z_AXIS); + show_title(); + show_axislabel(FIRST_X_AXIS ); + show_axislabel(FIRST_Y_AXIS ); + show_axislabel(FIRST_Z_AXIS ); + show_axislabel(SECOND_X_AXIS); + show_axislabel(SECOND_Y_AXIS); + show_data_is_timedate(FIRST_X_AXIS); + show_data_is_timedate(FIRST_Y_AXIS); + show_data_is_timedate(SECOND_X_AXIS); + show_data_is_timedate(SECOND_Y_AXIS); + show_data_is_timedate(FIRST_Z_AXIS); + show_timefmt(); + show_loadpath(); + show_fontpath(); + show_locale(); + show_zero(); + show_datafile(); +#ifdef USE_MOUSE + show_mouse(); +#endif + show_plot(); + show_variables(); + show_functions(); + + var_show_all = 0; +} + + +/* process 'show version' command */ +void +show_version(FILE *fp) +{ + /* If printed to a file, we prefix everything with + * a hash mark to comment out the version information. + */ + char prefix[6]; /* "# " */ + char *p = prefix; + + prefix[0] = '#'; + prefix[1] = prefix[2] = prefix[3] = prefix[4] = ' '; + prefix[5] = NUL; + + /* Construct string of configuration options used to build */ + /* this particular copy of gnuplot. Executed once only. */ + if (!compile_options) { + compile_options = gp_alloc(1024,"compile_options"); + + { + /* The following code could be a lot simpler if + * it wasn't for Borland's broken compiler ... + */ + const char * rdline = +#ifdef READLINE + "+" +#else + "-" +#endif + "READLINE "; + + const char *gnu_rdline = +#if defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE) + "+" +#else + "-" +#endif +#ifdef HAVE_LIBEDITLINE + "LIBEDITLINE " +#else + "LIBREADLINE " +#endif +#ifdef GNUPLOT_HISTORY + "+" +#else + "-" +#endif + "HISTORY " + ""; + + const char *libgd = +#ifdef HAVE_LIBGD +# ifdef HAVE_GD_PNG + "+GD_PNG " +# endif +# ifdef HAVE_GD_JPEG + "+GD_JPEG " +# endif +# ifdef HAVE_GD_TTF + "+GD_TTF " +# endif +# ifdef HAVE_GD_GIF + "+GD_GIF " +# endif +# ifdef GIF_ANIMATION + "+ANIMATION " +# endif +#else + "-LIBGD " +#endif + ""; + + const char *linuxvga = +#ifdef LINUXVGA + "+LINUXVGA " +#endif + ""; + + const char *compatibility = +#ifdef BACKWARDS_COMPATIBLE + "+BACKWARDS_COMPATIBILITY " +#else + "-BACKWARDS_COMPATIBILITY " +#endif + ""; + + const char *binary_files = +#ifdef BINARY_DATA_FILE + "+BINARY_DATA " +#endif + ""; + + const char *nocwdrc = +#ifdef NOCWDRC + "+" +#else + "-" +#endif + "NOCWDRC "; + + const char *x11 = +#ifdef X11 + "+X11 " +#endif +#ifdef BINARY_X11_POLYGON + "+X11_POLYGON " +#endif +#ifdef USE_X11_MULTIBYTE + "+MULTIBYTE " +#endif + ""; + + const char *use_mouse = +#ifdef USE_MOUSE + "+USE_MOUSE " +#endif + ""; + + const char *unixplot = +#ifdef UNIXPLOT + "+UNIXPLOT " +#endif + ""; + + const char *gnugraph = +#ifdef GNUGRAPH + "+GNUGRAPH " +#endif + ""; + + const char *hiddenline = +#ifdef HIDDEN3D_QUADTREE + "+HIDDEN3D_QUADTREE " +#else +# ifdef HIDDEN3D_GRIDBOX + "+HIDDEN3D_GRIDBOX " +# endif +#endif + ""; + + const char *plotoptions= +#ifdef EAM_DATASTRINGS + "+DATASTRINGS " +#endif +#ifdef EAM_HISTOGRAMS + "+HISTOGRAMS " +#endif +#ifdef EAM_OBJECTS + "+OBJECTS " +#endif +#ifdef GP_STRING_VARS + "+STRINGVARS " +#endif +#ifdef GP_MACROS + "+MACROS " +#endif +# ifdef THIN_PLATE_SPLINES_GRID + "+THIN_SPLINES " +# endif +#ifdef WITH_IMAGE + "+IMAGE " +#endif + ""; + + sprintf(compile_options, "\ +%s%s%s%s\n\ +%s%s\n\ +%s%s%s%s%s%s\n%s\n", + rdline, gnu_rdline, compatibility, binary_files, + libgd, linuxvga, + nocwdrc, x11, use_mouse, unixplot, gnugraph, hiddenline, + plotoptions); + } + + compile_options = gp_realloc(compile_options, strlen(compile_options)+1, "compile_options"); + } + + /* The only effect of fp == NULL is to load the compile_options string */ + if (fp == NULL) + return; + + if (fp == stderr) { + /* No hash mark - let p point to the trailing '\0' */ + p += sizeof(prefix) - 1; + } else { +#ifdef BINDIR +# ifdef X11 + fprintf(fp, "#!%s/gnuplot -persist\n#\n", BINDIR); +# else + fprintf(fp, "#!%s/gnuplot\n#\n", BINDIR); +# endif /* not X11 */ +#endif /* BINDIR */ + } + + fprintf(fp, "%s\n\ +%s\t%s\n\ +%s\tVersion %s patchlevel %s\n\ +%s\tlast modified %s\n\ +%s\tSystem: %s %s\n\ +%s\n\ +%s\t%s\n\ +%s\tThomas Williams, Colin Kelley and many others\n\ +%s\n\ +%s\tType `help` to access the on-line reference manual.\n\ +%s\tThe gnuplot FAQ is available from %s\n\ +%s\n\ +%s\tSend bug reports and suggestions to <%s>\n\ +%s\n", + p, /* empty line */ + p, PROGRAM, + p, gnuplot_version, gnuplot_patchlevel, + p, gnuplot_date, + p, os_name, os_rel, + p, /* empty line */ + p, gnuplot_copyright, + p, /* authors */ + p, /* empty line */ + p, /* Type `help` */ + p, faq_location, + p, /* empty line */ + p, bug_email, + p); /* empty line */ + + + /* show version long */ + if (almost_equals(c_token, "l$ong")) { + char *helpfile = NULL; + + c_token++; + fprintf(stderr, "Compile options:\n%s\n", compile_options); + + if ((helpfile = getenv("GNUHELP")) == NULL) { +#if defined(ATARI) || defined(MTOS) + if ((helpfile = user_gnuplotpath) == NULL) { + helpfile = HELPFILE; + } +#else + helpfile = HELPFILE; +#endif + } + +#ifdef X11 + { + char *driverdir = getenv("GNUPLOT_DRIVER_DIR"); + + if (driverdir == NULL) + driverdir = X11_DRIVER_DIR; + fprintf(stderr, "\ +DRIVER_DIR = \"%s\"\n", driverdir); + } +#endif + +#ifdef GNUPLOT_PS_DIR + { + fprintf(stderr, "GNUPLOT_PS_DIR = \"%s\"\n", GNUPLOT_PS_DIR); + } +#endif + + fprintf(stderr, "HELPFILE = \"%s\"\n", helpfile); +#if 0 + /* These are redundant. We just printed them 5 lines ago. */ + fprintf(stderr, "CONTACT = <%s>\n", bug_email); + fprintf(stderr, "HELPMAIL = <%s>\n", help_email); +#endif + + } +} + + +/* process 'show autoscale' command */ +static void +show_autoscale() +{ + SHOW_ALL_NL; + +#define SHOW_AUTOSCALE(axis) { \ + t_autoscale ascale = axis_array[axis].set_autoscale; \ + \ + fprintf(stderr, "\t%s: %s%s%s%s%s, ", \ + axis_defaults[axis].name, \ + (ascale & AUTOSCALE_BOTH) ? "ON" : "OFF", \ + ((ascale & AUTOSCALE_BOTH) == AUTOSCALE_MIN) ? " (min)" : "", \ + ((ascale & AUTOSCALE_BOTH) == AUTOSCALE_MAX) ? " (max)" : "", \ + (ascale & AUTOSCALE_FIXMIN) ? " (fixmin)" : "", \ + (ascale & AUTOSCALE_FIXMAX) ? " (fixmax)" : ""); \ + } + + fputs("\tautoscaling is ", stderr); + if (parametric) { + if (is_3d_plot) { + SHOW_AUTOSCALE(T_AXIS); + } else { + SHOW_AUTOSCALE(U_AXIS); + SHOW_AUTOSCALE(V_AXIS); + } + } + + if (polar) { + SHOW_AUTOSCALE(R_AXIS) + } + + SHOW_AUTOSCALE(FIRST_X_AXIS ); + SHOW_AUTOSCALE(FIRST_Y_AXIS ); + fputs("\n\t ", stderr); + SHOW_AUTOSCALE(SECOND_X_AXIS); + SHOW_AUTOSCALE(SECOND_Y_AXIS); + fputs("\n\t ", stderr); + SHOW_AUTOSCALE(FIRST_Z_AXIS ); + SHOW_AUTOSCALE(COLOR_AXIS); +#undef SHOW_AUTOSCALE + +} + + +/* process 'show bars' command */ +static void +show_bars() +{ + SHOW_ALL_NL; + + /* I really like this: "terrorbars" ;-) */ + if (bar_size > 0.0) + fprintf(stderr, "\terrorbars are plotted with bars of size %f\n", + bar_size); + else + fputs("\terrors are plotted without bars\n", stderr); +} + + +/* process 'show border' command */ +static void +show_border() +{ + SHOW_ALL_NL; + + if (!draw_border) + fprintf(stderr, "\tborder is not drawn\n"); + else { + fprintf(stderr, "\tborder %d is drawn in %s of the plot elements with\n\t ", + draw_border, border_layer == 0 ? "back" : "front"); + save_linetype(stderr, &border_lp, FALSE); + fputc('\n',stderr); + } +} + + +/* process 'show boxwidth' command */ +static void +show_boxwidth() +{ + SHOW_ALL_NL; + + if (boxwidth < 0.0) + fputs("\tboxwidth is auto\n", stderr); + else { + fprintf(stderr, "\tboxwidth is %g %s\n", boxwidth, + (boxwidth_is_absolute) ? "absolute" : "relative"); + } +} + + +/* process 'show fillstyle' command */ +static void +show_fillstyle() +{ + SHOW_ALL_NL; + + switch(default_fillstyle.fillstyle) { + case FS_SOLID: + fprintf(stderr, + "\tFill style is solid colour with density %f", + default_fillstyle.filldensity/100.0); + break; + case FS_PATTERN: + fprintf(stderr, + "\tFill style uses patterns starting at %d", + default_fillstyle.fillpattern); + break; + default: + fprintf(stderr, "\tFill style is empty"); + } + switch(default_fillstyle.border_linetype) { + case LT_NODRAW: + fprintf(stderr," with no border\n"); + break; + case LT_UNDEFINED: + fprintf(stderr," with border\n"); + break; + default: + fprintf(stderr," with border linetype %d\n",default_fillstyle.border_linetype+1); + break; + } +} + + +/* process 'show clip' command */ +static void +show_clip() +{ + SHOW_ALL_NL; + + fprintf(stderr, "\tpoint clip is %s\n", (clip_points) ? "ON" : "OFF"); + + if (clip_lines1) + fputs("\tdrawing and clipping lines between inrange and outrange points\n", stderr); + else + fputs("\tnot drawing lines between inrange and outrange points\n", stderr); + + if (clip_lines2) + fputs("\tdrawing and clipping lines between two outrange points\n", stderr); + else + fputs("\tnot drawing lines between two outrange points\n", stderr); +} + + +/* process 'show cntrparam|contour' commands */ +static void +show_contour() +{ + SHOW_ALL_NL; + + fprintf(stderr, "\tcontour for surfaces are %s", + (draw_contour) ? "drawn" : "not drawn\n"); + + if (draw_contour) { + fprintf(stderr, " in %d levels on ", contour_levels); + switch (draw_contour) { + case CONTOUR_BASE: + fputs("grid base\n", stderr); + break; + case CONTOUR_SRF: + fputs("surface\n", stderr); + break; + case CONTOUR_BOTH: + fputs("grid base and surface\n", stderr); + break; + case CONTOUR_NONE: + /* should not happen --- be easy: don't complain... */ + break; + } + switch (contour_kind) { + case CONTOUR_KIND_LINEAR: + fputs("\t\tas linear segments\n", stderr); + break; + case CONTOUR_KIND_CUBIC_SPL: + fprintf(stderr, "\t\tas cubic spline interpolation segments with %d pts\n", contour_pts); + break; + case CONTOUR_KIND_BSPLINE: + fprintf(stderr, "\t\tas bspline approximation segments of order %d with %d pts\n", contour_order, contour_pts); + break; + } + switch (contour_levels_kind) { + case LEVELS_AUTO: + fprintf(stderr, "\t\tapprox. %d automatic levels\n", contour_levels); + break; + case LEVELS_DISCRETE: + { + int i; + fprintf(stderr, "\t\t%d discrete levels at ", contour_levels); + fprintf(stderr, "%g", contour_levels_list[0]); + for (i = 1; i < contour_levels; i++) + fprintf(stderr, ",%g ", contour_levels_list[i]); + putc('\n', stderr); + break; + } + case LEVELS_INCREMENTAL: + fprintf(stderr, "\t\t%d incremental levels starting at %g, step %g, end %g\n", contour_levels, contour_levels_list[0], + contour_levels_list[1], + contour_levels_list[0] + (contour_levels - 1) * contour_levels_list[1]); + /* contour-levels counts both ends */ + break; + } + /* fprintf(stderr,"\t\tcontour line types are %s\n", label_contours ? "varied" : "all the same"); */ + show_label_contours(); + } +} + + +/* called by show_contour() */ +static void +show_label_contours() +{ + if (label_contours) + fprintf(stderr, "\tcontour line types are varied & labeled with format '%s'\n", contour_format); + else + fputs("\tcontour line types are all the same\n", stderr); +} + + +/* process 'show dgrid3d' command */ +static void +show_dgrid3d() +{ + SHOW_ALL_NL; + + if (dgrid3d) + fprintf(stderr, "\ +\tdata grid3d is enabled for mesh of size %dx%d, norm=%d\n", + dgrid3d_row_fineness, + dgrid3d_col_fineness, + dgrid3d_norm_value); + else + fputs("\tdata grid3d is disabled\n", stderr); +} + +#ifdef GP_MACROS +/* process 'show macros' command */ +static void +show_macros() +{ + SHOW_ALL_NL; + fprintf(stderr,"\tcommand line macros will %sbe expanded\n", + expand_macros ? "" : "not "); +} +#endif + +/* process 'show mapping' command */ +static void +show_mapping() +{ + SHOW_ALL_NL; + + fputs("\tmapping for 3-d data is ", stderr); + + switch (mapping3d) { + case MAP3D_CARTESIAN: + fputs("cartesian\n", stderr); + break; + case MAP3D_SPHERICAL: + fputs("spherical\n", stderr); + break; + case MAP3D_CYLINDRICAL: + fputs("cylindrical\n", stderr); + break; + } +} + + +/* process 'show dummy' command */ +static void +show_dummy() +{ + SHOW_ALL_NL; + + fprintf(stderr, "\tdummy variables are \"%s\" and \"%s\"\n", + set_dummy_var[0], set_dummy_var[1]); +} + + +/* process 'show format' command */ +static void +show_format() +{ + SHOW_ALL_NL; + + fprintf(stderr, "\ttic format is:\n"); +#define SHOW_FORMAT(_axis) \ + fprintf(stderr, "\t %s-axis: \"%s\"\n", axis_defaults[_axis].name, \ + conv_text(axis_array[_axis].formatstring)); + SHOW_FORMAT(FIRST_X_AXIS ); + SHOW_FORMAT(FIRST_Y_AXIS ); + SHOW_FORMAT(SECOND_X_AXIS); + SHOW_FORMAT(SECOND_Y_AXIS); + SHOW_FORMAT(FIRST_Z_AXIS ); + SHOW_FORMAT(COLOR_AXIS); +#undef SHOW_FORMAT +} + + +/* process 'show style' sommand */ +static void +show_style() +{ + struct value a; + int tag = 0; + +#define CHECK_TAG_GT_ZERO \ + if (!END_OF_COMMAND) { \ + tag = real(const_express(&a)); \ + if (tag <= 0) \ + int_error(c_token,"tag must be > zero"); \ + } + + switch(lookup_table(&show_style_tbl[0],c_token)){ + case SHOW_STYLE_DATA: + SHOW_ALL_NL; + show_styles("Data",data_style); + c_token++; + break; + case SHOW_STYLE_FUNCTION: + SHOW_ALL_NL; + show_styles("Functions", func_style); + c_token++; + break; + case SHOW_STYLE_LINE: + c_token++; + CHECK_TAG_GT_ZERO; + show_linestyle(tag); + break; + case SHOW_STYLE_FILLING: + show_fillstyle(); + c_token++; + break; + case SHOW_STYLE_INCREMENT: + show_increment(); + c_token++; + break; +#ifdef EAM_HISTOGRAMS + case SHOW_STYLE_HISTOGRAM: + show_histogram(); + c_token++; + break; +#endif + case SHOW_STYLE_ARROW: + c_token++; + CHECK_TAG_GT_ZERO; + show_arrowstyle(tag); + break; + default: + /* show all styles */ + show_styles("Data",data_style); + show_styles("Functions", func_style); + show_linestyle(0); + show_fillstyle(); + show_increment(); +#ifdef EAM_HISTOGRAMS + show_histogram(); +#endif + show_arrowstyle(0); +#ifdef EAM_OBJECTS + /* Fall through (FIXME: this is ugly) */ + case SHOW_STYLE_RECTANGLE: + fprintf(stderr, "\tRectangle style is %s, fill color ", + default_rectangle.layer > 0 ? "front" : + default_rectangle.layer < 0 ? "behind" : "back"); + if (default_rectangle.lp_properties.use_palette) + save_pm3dcolor(stderr, &default_rectangle.lp_properties.pm3d_color); + else if (default_rectangle.lp_properties.l_type == LT_BACKGROUND) + fprintf(stderr, "background"); + else + fprintf(stderr, "lt %d",default_rectangle.lp_properties.l_type+1); + fprintf(stderr, ", lw %.1f ", default_rectangle.lp_properties.l_width); + fprintf(stderr, ", fillstyle"); + save_fillstyle(stderr, &default_rectangle.fillstyle); + c_token++; +#endif + break; + } +#undef CHECK_TAG_GT_ZERO +} + +/* called by show_data() and show_func() */ +static void +show_styles(const char *name, enum PLOT_STYLE style) +{ + fprintf(stderr, "\t%s are plotted with ", name); + save_data_func_style(stderr, name, style); +} + + +/* called by show_func() */ +static void +show_functions() +{ + struct udft_entry *udf = first_udf; + + fputs("\n\tUser-Defined Functions:\n", stderr); + + while (udf) { + if (udf->definition) + fprintf(stderr, "\t%s\n", udf->definition); + else + fprintf(stderr, "\t%s is undefined\n", udf->udf_name); + udf = udf->next_udf; + } +} + + +/* process 'show grid' command */ +static void +show_grid() +{ + SHOW_ALL_NL; + + if (! some_grid_selected()) { + fputs("\tgrid is OFF\n", stderr); + return; + } + +#if 0 + /* Old method of accessing grid choices */ + fprintf(stderr, "\t%s grid drawn at%s%s%s%s%s%s%s%s%s%s%s%s tics\n", + (polar_grid_angle != 0) ? "Polar" : "Rectangular", + grid_selection & GRID_X ? " x" : "", + grid_selection & GRID_Y ? " y" : "", + grid_selection & GRID_Z ? " z" : "", + grid_selection & GRID_X2 ? " x2" : "", + grid_selection & GRID_Y2 ? " y2" : "", + grid_selection & GRID_MX ? " mx" : "", + grid_selection & GRID_MY ? " my" : "", + grid_selection & GRID_MZ ? " mz" : "", + grid_selection & GRID_MX2 ? " mx2" : "", + grid_selection & GRID_MY2 ? " my2" : "", + grid_selection & GRID_CB ? " cb" : "", + grid_selection & GRID_MCB ? " mcb" : "" + ); +#else + /* HBB 20010806: new storage method for grid options: */ + fprintf(stderr, "\t%s grid drawn at", + (polar_grid_angle != 0) ? "Polar" : "Rectangular"); +#define SHOW_GRID(axis) \ + if (axis_array[axis].gridmajor) \ + fprintf(stderr, " %s", axis_defaults[axis].name); \ + if (axis_array[axis].gridminor) \ + fprintf(stderr, " m%s", axis_defaults[axis].name); + SHOW_GRID(FIRST_X_AXIS ); + SHOW_GRID(FIRST_Y_AXIS ); + SHOW_GRID(SECOND_X_AXIS); + SHOW_GRID(SECOND_Y_AXIS); + SHOW_GRID(FIRST_Z_AXIS ); + SHOW_GRID(COLOR_AXIS); +#undef SHOW_GRID + fputs(" tics\n", stderr); +#endif /* 0/1 */ + + fprintf(stderr, "\tMajor grid drawn with"); + save_linetype(stderr, &(grid_lp), FALSE); + fprintf(stderr, "\n\tMinor grid drawn with"); + save_linetype(stderr, &(mgrid_lp), FALSE); + fputc('\n', stderr); + if (polar_grid_angle) + fprintf(stderr, "\tGrid radii drawn every %f %s\n", + polar_grid_angle / ang2rad, + (ang2rad == 1.0) ? "radians" : "degrees"); + + fprintf(stderr, "\tGrid drawn at %s\n", (grid_layer==-1) ? "default layer" : ((grid_layer==0) ? "back" : "front")); +} + + +/* process 'show {x|y|z}zeroaxis' command */ +static void +show_zeroaxis(AXIS_INDEX axis) +{ + SHOW_ALL_NL; + + if (axis_array[axis].zeroaxis.l_type > LT_NODRAW) { + fprintf(stderr, "\t%szeroaxis is drawn with", axis_defaults[axis].name); + save_linetype(stderr, &(axis_array[axis].zeroaxis), FALSE); + fputc('\n',stderr); + } else + fprintf(stderr, "\t%szeroaxis is OFF\n", axis_defaults[axis].name); + + if ((axis / SECOND_AXES) == 0) { + /* this is a 'first' axis. To output secondary axis, call self + * recursively: */ + show_zeroaxis(axis + SECOND_AXES); + } +} + +/* Show label number (0 means show all) */ +static void +show_label(int tag) +{ + struct text_label *this_label; + TBOOLEAN showed = FALSE; + + for (this_label = first_label; this_label != NULL; + this_label = this_label->next) { + if (tag == 0 || tag == this_label->tag) { + showed = TRUE; + fprintf(stderr, "\tlabel %d \"%s\" at ", + this_label->tag, + (this_label->text==NULL) ? "" : conv_text(this_label->text)); + show_position(&this_label->place); + switch (this_label->pos) { + case LEFT:{ + fputs(" left", stderr); + break; + } + case CENTRE:{ + fputs(" centre", stderr); + break; + } + case RIGHT:{ + fputs(" right", stderr); + break; + } + } + if (this_label->rotate) + fprintf(stderr, " rotated by %d degrees (if possible)", this_label->rotate); + else + fprintf(stderr, " not rotated"); + fprintf(stderr, " %s ", this_label->layer ? "front" : "back"); + if (this_label->font != NULL) + fprintf(stderr, " font \"%s\"", this_label->font); + if (this_label->textcolor.type) + save_textcolor(stderr, &this_label->textcolor); + if (this_label->noenhanced) + fprintf(stderr, " noenhanced"); + if (this_label->lp_properties.pointflag == 0) + fprintf(stderr, " nopoint"); + else { + fprintf(stderr, " point with color of"); + save_linetype(stderr, &(this_label->lp_properties), TRUE); + show_position(&this_label->offset); + } + + /* Entry font added by DJL */ + fputc('\n', stderr); + } + } + if (tag > 0 && !showed) + int_error(c_token, "label not found"); +} + + +/* Show arrow number (0 means show all) */ +static void +show_arrow(int tag) +{ + struct arrow_def *this_arrow; + TBOOLEAN showed = FALSE; + + for (this_arrow = first_arrow; this_arrow != NULL; + this_arrow = this_arrow->next) { + if (tag == 0 || tag == this_arrow->tag) { + showed = TRUE; + fprintf(stderr, "\tarrow %d, %s %s %s", + this_arrow->tag, + arrow_head_names[this_arrow->arrow_properties.head], + ( (this_arrow->arrow_properties.head_filled==2) ? "filled" : + ( (this_arrow->arrow_properties.head_filled==1) ? "empty" : + "nofilled" )), + this_arrow->arrow_properties.layer ? "front" : "back"); + save_linetype(stderr, &(this_arrow->arrow_properties.lp_properties), FALSE); + fprintf(stderr, "\n\t from "); + show_position(&this_arrow->start); + fputs(this_arrow->relative ? " rto " : " to ", stderr); + show_position(&this_arrow->end); + if (this_arrow->arrow_properties.head_length > 0) { + static char *msg[] = + {"(first x axis) ", "(second x axis) ", "(graph units) ", "(screen units) "}; + fprintf(stderr,"\n\t arrow head: length %s%g, angle %g deg", + this_arrow->arrow_properties.head_lengthunit == first_axes ? "" : msg[this_arrow->arrow_properties.head_lengthunit], + this_arrow->arrow_properties.head_length, + this_arrow->arrow_properties.head_angle); + if (this_arrow->arrow_properties.head_filled!=0) + fprintf(stderr,", backangle %g deg", + this_arrow->arrow_properties.head_backangle); + } + putc('\n', stderr); + } + } + if (tag > 0 && !showed) + int_error(c_token, "arrow not found"); +} + + +/* process 'show keytitle' command */ +static void +show_keytitle() +{ + legend_key *key = &keyT; + SHOW_ALL_NL; + + fprintf(stderr, "\tkeytitle is \"%s\"\n", conv_text(key->title)); +} + + +/* process 'show key' command */ +static void +show_key() +{ + legend_key *key = &keyT; + + SHOW_ALL_NL; + + if (!(key->visible)) { + fputs("\ +\tkey is OFF\n", stderr); + return; + } + + switch (key->region) { + case GPKEY_AUTO_INTERIOR_LRTBC: + case GPKEY_AUTO_EXTERIOR_LRTBC: + case GPKEY_AUTO_EXTERIOR_MARGIN: { + fputs("\tkey is ON, position: ", stderr); + if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN && (key->margin == GPKEY_TMARGIN || key->margin == GPKEY_BMARGIN))) { + if (key->vpos == JUST_TOP) + fputs("top", stderr); + else if (key->vpos == JUST_BOT) + fputs("bottom", stderr); + else + fputs("center", stderr); + } + if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN && (key->margin == GPKEY_LMARGIN || key->margin == GPKEY_RMARGIN))) { + if (key->hpos == LEFT) + fputs(" left", stderr); + else if (key->hpos == RIGHT) + fputs(" right", stderr); + else if (key->vpos != JUST_CENTRE) /* Don't print "center" twice. */ + fputs(" center", stderr); + } + if (key->stack_dir == GPKEY_VERTICAL) { + fputs(" vertical", stderr); + } else { + fputs(" horizontal", stderr); + } + if (key->region == GPKEY_AUTO_INTERIOR_LRTBC) + fputs(" inside", stderr); + else if (key->region == GPKEY_AUTO_EXTERIOR_LRTBC) + fputs(" outside", stderr); + else { + switch (key->margin) { + case GPKEY_TMARGIN: + fputs(" tmargin", stderr); + break; + case GPKEY_BMARGIN: + fputs(" bmargin", stderr); + break; + case GPKEY_LMARGIN: + fputs(" lmargin", stderr); + break; + case GPKEY_RMARGIN: + fputs(" rmargin", stderr); + break; + } + } + fputs("\n", stderr); + break; + } + case GPKEY_USER_PLACEMENT: + fputs("\tkey is at ", stderr); + show_position(&key->user_pos); + putc('\n', stderr); + break; + } + + fprintf(stderr, "\ +\tkey is %s justified, %sreversed, %sinverted, %senhanced and ", + key->just == GPKEY_LEFT ? "left" : "right", + key->reverse ? "" : "not ", + key->invert ? "" : "not ", + key->enhanced ? "" : "not "); + if (key->box.l_type > LT_NODRAW) { + fprintf(stderr, "boxed\n\twith "); + save_linetype(stderr, &(key->box), FALSE); + fputc('\n', stderr); + } else + fprintf(stderr, "not boxed\n"); + + fprintf(stderr, "\ +\tsample length is %g characters\n\ +\tvertical spacing is %g characters\n\ +\twidth adjustment is %g characters\n\ +\theight adjustment is %g characters\n\ +\tcurves are%s automatically titled %s\n\ +\tkey title is \"%s\"\n", + key->swidth, + key->vert_factor, + key->width_fix, + key->height_fix, + key->auto_titles ? "" : " not", + key->auto_titles == FILENAME_KEYTITLES ? "with filename" : + key->auto_titles == COLUMNHEAD_KEYTITLES + ? "with column header" : "", + key->title); +} + + +static void +show_position(struct position *pos) +{ + static const char *msg[] = { "(first axes) ", "(second axes) ", + "(graph units) ", "(screen units) ", + "(character units) "}; + + assert(first_axes == 0 && second_axes == 1 && graph == 2 && screen == 3 && + character == 4); + + fprintf(stderr, "(%s%g, %s%g, %s%g)", + pos->scalex == first_axes ? "" : msg[pos->scalex], pos->x, + pos->scaley == pos->scalex ? "" : msg[pos->scaley], pos->y, + pos->scalez == pos->scaley ? "" : msg[pos->scalez], pos->z); + +} + + +/* process 'show logscale' command */ +static void +show_logscale() +{ + int count = 0; + + SHOW_ALL_NL; + +#define SHOW_LOG(axis) \ + { \ + if (axis_array[axis].log) \ + fprintf(stderr, "%s %s (base %g)", \ + !count++ ? "\tlogscaling" : " and", \ + axis_defaults[axis].name,axis_array[axis].base); \ + } + SHOW_LOG(FIRST_X_AXIS ); + SHOW_LOG(FIRST_Y_AXIS ); + SHOW_LOG(FIRST_Z_AXIS ); + SHOW_LOG(SECOND_X_AXIS); + SHOW_LOG(SECOND_Y_AXIS); + SHOW_LOG(COLOR_AXIS ); +#undef SHOW_LOG + + if (count == 0) + fputs("\tno logscaling\n", stderr); + else if (count == 1) + fputs(" only\n", stderr); + else + putc('\n', stderr); +} + + +/* process 'show offsets' command */ +static void +show_offsets() +{ + SHOW_ALL_NL; + + fprintf(stderr, "\toffsets are %g, %g, %g, %g\n", loff, roff, toff, boff); +} + + +/* process 'show margin' command */ +static void +show_margin() +{ + SHOW_ALL_NL; + + if (lmargin.scalex == screen) + fprintf(stderr, "\tlmargin is set to screen %g\n", lmargin.x); + else if (lmargin.x >= 0) + fprintf(stderr, "\tlmargin is set to %g\n", lmargin.x); + else + fputs("\tlmargin is computed automatically\n", stderr); + + if (bmargin.scalex == screen) + fprintf(stderr, "\tbmargin is set to screen %g\n", bmargin.x); + else if (bmargin.x >= 0) + fprintf(stderr, "\tbmargin is set to %g\n", bmargin.x); + else + fputs("\tbmargin is computed automatically\n", stderr); + + if (rmargin.scalex == screen) + fprintf(stderr, "\trmargin is set to screen %g\n", rmargin.x); + else if (rmargin.x >= 0) + fprintf(stderr, "\trmargin is set to %g\n", rmargin.x); + else + fputs("\trmargin is computed automatically\n", stderr); + + if (tmargin.scalex == screen) + fprintf(stderr, "\ttmargin is set to screen %g\n", tmargin.x); + else if (tmargin.x >= 0) + fprintf(stderr, "\ttmargin is set to %g\n", tmargin.x); + else + fputs("\ttmargin is computed automatically\n", stderr); +} + + +/* process 'show output' command */ +static void +show_output() +{ + SHOW_ALL_NL; + + if (outstr) + fprintf(stderr, "\toutput is sent to '%s'\n", outstr); + else + fputs("\toutput is sent to STDOUT\n", stderr); +} + + +/* process 'show print' command */ +static void +show_print() +{ + SHOW_ALL_NL; + + fprintf(stderr, "\tprint output is sent to '%s'\n", print_show_output()); +} + + +/* process 'show parametric' command */ +static void +show_parametric() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tparametric is %s\n", (parametric) ? "ON" : "OFF"); +} + + +static void +show_palette_rgbformulae() +{ + int i; + fprintf(stderr,"\t * there are %i available rgb color mapping formulae:", + sm_palette.colorFormulae); + /* print the description of the color formulae */ + i = 0; + while ( *(ps_math_color_formulae[2*i]) ) { + if (i % 3 == 0) + fputs("\n\t ", stderr); + fprintf(stderr, "%2i: %-15s",i,ps_math_color_formulae[2*i+1]); + i++; + } + fputs("\n", stderr); + fputs("\t * negative numbers mean inverted=negative colour component\n", + stderr); + fprintf(stderr, + "\t * thus the ranges in `set pm3d rgbformulae' are -%i..%i\n", + sm_palette.colorFormulae-1,sm_palette.colorFormulae-1); + ++c_token; +} + + +static void +show_palette_fit2rgbformulae() +{ +#define rgb_distance(r,g,b) ((r)*(r) + (g)*(g) + (b)*(b)) + int pts = 32; /* resolution: nb of points in the discrete raster for comparisons */ + int i, p, ir, ig, ib; + int rMin=0, gMin=0, bMin=0; + int maxFormula = sm_palette.colorFormulae - 1; /* max formula number */ + double gray, dist, distMin; + rgb_color *currRGB; + int *formulaeSeq; + double **formulae; + ++c_token; + if (sm_palette.colorMode == SMPAL_COLOR_MODE_RGB && sm_palette.cmodel == C_MODEL_RGB) { + fprintf(stderr, "\tCurrent palette is\n\t set palette rgbformulae %i,%i,%i\n", sm_palette.formulaR, sm_palette.formulaG, sm_palette.formulaB); + return; + } + /* allocate and fill R, G, B values rastered on pts points */ + currRGB = (rgb_color*)gp_alloc(pts * sizeof(rgb_color), "RGB pts"); + for (p = 0; p < pts; p++) { + gray = (double)p / (pts - 1); + rgb1_from_gray(gray, &(currRGB[p])); + } + /* organize sequence of rgb formulae */ + formulaeSeq = gp_alloc((2*maxFormula+1) * sizeof(int), "formulaeSeq"); + for (i = 0; i <= maxFormula; i++) + formulaeSeq[i] = i; + for (i = 1; i <= maxFormula; i++) + formulaeSeq[maxFormula+i] = -i; + /* allocate and fill all +-formulae on the interval of given number of points */ + formulae = gp_alloc((2*maxFormula+1) * sizeof(double*), "formulae"); + for (i = 0; i < 2*maxFormula+1; i++) { + formulae[i] = gp_alloc(pts * sizeof(double), "formulae pts"); + for (p = 0; p < pts; p++) { + double gray = (double)p / (pts - 1); + formulae[i][p] = GetColorValueFromFormula(formulaeSeq[i], gray); + } + } + /* Now go over all rastered formulae, compare them to the current one, and + find the minimal distance. + */ + distMin = VERYLARGE; + for (ir = 0; ir < 2*maxFormula+1; ir++) { + for (ig = 0; ig < 2*maxFormula+1; ig++) { + for (ib = 0; ib < 2*maxFormula+1; ib++) { + dist = 0; /* calculate distance of the two rgb profiles */ + for (p = 0; p < pts; p++) { + double tmp = rgb_distance( + currRGB[p].r - formulae[ir][p], + currRGB[p].g - formulae[ig][p], + currRGB[p].b - formulae[ib][p] ); + dist += tmp; + } + if (dist < distMin) { + distMin = dist; + rMin = formulaeSeq[ir]; + gMin = formulaeSeq[ig]; + bMin = formulaeSeq[ib]; + } + } + } + } + fprintf(stderr, "\tThe best match of the current palette corresponds to\n\t set palette rgbformulae %i,%i,%i\n", rMin, gMin, bMin); +#undef rgb_distance + for (i = 0; i < 2*maxFormula+1; i++) + free(formulae[i]); + free(formulae); + free(formulaeSeq); + free(currRGB); +} + + +static void +show_palette_palette() +{ + int colors, i; + struct value a; + double gray; + rgb_color rgb1; + rgb255_color rgb255; + int how = 0; /* How to print table: 0: default large; 1: rgb 0..1; 2: integers 0..255 */ + FILE *f; + + c_token++; + if (END_OF_COMMAND) + int_error(c_token,"palette size required"); + colors = (int) real(const_express(&a)); + if (colors<2) colors = 128; + if (!END_OF_COMMAND) { + if (almost_equals(c_token, "f$loat")) /* option: print r,g,b floats 0..1 values */ + how = 1; + else if (almost_equals(c_token, "i$nt")) /* option: print only integer 0..255 values */ + how = 2; + else + int_error(c_token, "expecting no option or int or float"); + c_token++; + } + + i = (print_out==NULL || print_out==stderr || print_out==stdout); + f = (print_out) ? print_out : stderr; + fprintf(stderr, "%s palette with %i discrete colors", + (sm_palette.colorMode == SMPAL_COLOR_MODE_GRAY) ? "Gray" : "Color", colors); + if (!i) + fprintf(stderr," saved to \"%s\".", print_out_name); + else + fprintf(stderr, ".\n"); + + for (i = 0; i < colors; i++) { + /* colours equidistantly from [0,1] */ + gray = (double)i / (colors - 1); + if (sm_palette.positive == SMPAL_NEGATIVE) + gray = 1 - gray; + rgb1_from_gray(gray, &rgb1); + rgb255_from_rgb1(rgb1, &rgb255); + + switch (how) { + case 1: + fprintf(f, "%0.4f\t%0.4f\t%0.4f\n", rgb1.r, rgb1.g, rgb1.b); + break; + case 2: + fprintf(f, "%i\t%i\t%i\n", (int)rgb255.r, (int)rgb255.g, (int)rgb255.b); + break; + default: + fprintf(f, + "%3i. gray=%0.4f, (r,g,b)=(%0.4f,%0.4f,%0.4f), #%02x%02x%02x = %3i %3i %3i\n", + i, gray, rgb1.r, rgb1.g, rgb1.b, + (int)rgb255.r, (int)rgb255.g, (int)rgb255.b, + (int)rgb255.r, (int)rgb255.g, (int)rgb255.b ); + } + } +} + + +static void +show_palette_gradient() +{ + int i; + double gray,r,g,b; + + ++c_token; + if (sm_palette.colorMode != SMPAL_COLOR_MODE_GRADIENT) { + fputs( "\tcolor mapping *not* done by defined gradient.\n", stderr ); + return; + } + + for( i=0; ikey) { +#if 0 + /* Print only color names, table with 4 columns */ + if (i%4 == 0) fputs( "\n ", stderr ); + fprintf( stderr, "%-18s ", tbl->key ); +#else + /* Print color names and their rgb values, table with 1 column */ + int r = ((tbl->value >> 16 ) & 255); + int g = ((tbl->value >> 8 ) & 255); + int b = (tbl->value & 255); + + fprintf( stderr, "\n %-18s ", tbl->key ); + fprintf(stderr, "#%02x%02x%02x = %3i %3i %3i", r,g,b, r,g,b); +#endif + ++tbl; + ++i; + } + fputs( "\n", stderr ); + ++c_token; +} + + +static void +show_palette() +{ + /* no option given, i.e. "show palette" */ + if (END_OF_COMMAND) { + fprintf(stderr,"\tpalette is %s\n", + sm_palette.colorMode == SMPAL_COLOR_MODE_GRAY ? "GRAY" : "COLOR"); + + switch( sm_palette.colorMode ) { + case SMPAL_COLOR_MODE_GRAY: break; + case SMPAL_COLOR_MODE_RGB: + fprintf(stderr,"\trgb color mapping by rgbformulae are %i,%i,%i\n", + sm_palette.formulaR, sm_palette.formulaG, + sm_palette.formulaB); + break; + case SMPAL_COLOR_MODE_GRADIENT: + fputs( "\tcolor mapping by defined gradient\n", stderr ); + break; + case SMPAL_COLOR_MODE_FUNCTIONS: + fputs("\tcolor maping is done by user defined functions\n",stderr); + if (sm_palette.Afunc.at && sm_palette.Afunc.definition) + fprintf( stderr, "\t A-formula: %s\n", + sm_palette.Afunc.definition); + if (sm_palette.Bfunc.at && sm_palette.Bfunc.definition) + fprintf( stderr, "\t B-formula: %s\n", + sm_palette.Bfunc.definition); + if (sm_palette.Cfunc.at && sm_palette.Cfunc.definition) + fprintf( stderr, "\t C-formula: %s\n", + sm_palette.Cfunc.definition); + break; + default: + fprintf( stderr, "%s:%d oops: Unknown color mode '%c'.\n", + __FILE__, __LINE__, (char)(sm_palette.colorMode) ); + } + fprintf(stderr,"\tfigure is %s\n", + sm_palette.positive == SMPAL_POSITIVE ? "POSITIVE" : "NEGATIVE"); + fprintf( stderr, + "\tall color formulae ARE%s written into output postscript file\n", + sm_palette.ps_allcF == 0 ? " NOT" : ""); + fputs("\tallocating ", stderr); + if (sm_palette.use_maxcolors) + fprintf(stderr,"MAX %i",sm_palette.use_maxcolors); + else + fputs("ALL remaining", stderr); + fputs(" color positions for discrete palette terminals\n", stderr); + fputs( "\tColor-Model: ", stderr ); + switch( sm_palette.cmodel ) { + case C_MODEL_RGB: fputs( "RGB\n", stderr ); break; + case C_MODEL_HSV: fputs( "HSV\n", stderr ); break; + case C_MODEL_CMY: fputs( "CMY\n", stderr ); break; + case C_MODEL_YIQ: fputs( "YIQ\n", stderr ); break; + case C_MODEL_XYZ: fputs( "XYZ\n", stderr ); break; + default: + fprintf( stderr, "%s:%d ooops: Unknown color mode '%c'.\n", + __FILE__, __LINE__, (char)(sm_palette.cmodel) ); + } + fprintf(stderr,"\tgamma is %.4g\n", sm_palette.gamma ); + return; + } + + if (almost_equals(c_token, "pal$ette")) { + /* 'show palette palette ' */ + show_palette_palette(); + return; + } + else if (almost_equals(c_token, "gra$dient")) { + /* 'show palette gradient' */ + show_palette_gradient(); + return; + } + else if (almost_equals(c_token, "rgbfor$mulae" )) { + /* 'show palette rgbformulae' */ + show_palette_rgbformulae(); + return; + } + else if (almost_equals(c_token, "color$names" )) { + /* 'show palette colornames' */ + show_palette_colornames(); + return; + } + else if (almost_equals(c_token, "fit2rgb$formulae" )) { + /* 'show palette fit2rgbformulae' */ + show_palette_fit2rgbformulae(); + return; + } + else { /* wrong option to "show palette" */ + int_error( c_token, "Required 'show palette' or 'show palette gradient' or\n\t 'show palette palette ' or 'show palette rgbformulae' or\n\t 'show palette colornames'."); + } +} + + +static void +show_colorbox() +{ + c_token++; + if (color_box.border) { + fputs("\tcolor box with border, ", stderr); + if (color_box.border_lt_tag >= 0) + fprintf(stderr,"line type %d is ", color_box.border_lt_tag); + else + fputs("DEFAULT line type is ", stderr); + } else { + fputs("\tcolor box without border is ", stderr); + } + if (color_box.where != SMCOLOR_BOX_NO) { + if (color_box.layer == LAYER_FRONT) fputs("drawn front\n\t", stderr); + else fputs("drawn back\n\t", stderr); + } + switch (color_box.where) { + case SMCOLOR_BOX_NO: + fputs("NOT drawn\n", stderr); + break; + case SMCOLOR_BOX_DEFAULT: + fputs("at DEFAULT position\n", stderr); + break; + case SMCOLOR_BOX_USER: + fputs("at USER position: ", stderr); + show_position(&color_box.origin); + fputs("\n\t size: ", stderr); + show_position(&color_box.size); + fputs("\n", stderr); + break; + default: /* should *never* happen */ + int_error(NO_CARET, "Argh!"); + } + fprintf(stderr,"\tcolor gradient is %s in the color box\n", + color_box.rotation == 'v' ? "VERTICAL" : "HORIZONTAL"); +} + + +static void +show_pm3d() +{ + c_token++; + fprintf(stderr,"\tpm3d style is %s\n", PM3D_IMPLICIT == pm3d.implicit ? "implicit (pm3d draw for all surfaces)" : "explicit (draw pm3d surface according to style)"); + fputs("\tpm3d plotted at ", stderr); + { int i=0; + for ( ; pm3d.where[i]; i++ ) { + if (i>0) fputs(", then ", stderr); + switch (pm3d.where[i]) { + case PM3D_AT_BASE: fputs("BOTTOM", stderr); break; + case PM3D_AT_SURFACE: fputs("SURFACE", stderr); break; + case PM3D_AT_TOP: fputs("TOP", stderr); break; + } + } + fputs("\n", stderr); + } + if (pm3d.direction == PM3D_DEPTH) { + fprintf(stderr,"\ttrue depth ordering\n"); + } else if (pm3d.direction != PM3D_SCANS_AUTOMATIC) { + fprintf(stderr,"\ttaking scans in %s direction\n", + pm3d.direction == PM3D_SCANS_FORWARD ? "FORWARD" : "BACKWARD"); + } else { + fputs("\ttaking scans direction automatically\n", stderr); + } + fputs("\tsubsequent scans with different nb of pts are ", stderr); + if (pm3d.flush == PM3D_FLUSH_CENTER) fputs("CENTERED\n", stderr); + else fprintf(stderr,"flushed from %s\n", + pm3d.flush == PM3D_FLUSH_BEGIN ? "BEGIN" : "END"); + fprintf(stderr,"\tflushing triangles are %sdrawn\n", + pm3d.ftriangles ? "" : "not "); + fputs("\tclipping: ", stderr); + if (pm3d.clip == PM3D_CLIP_1IN) + fputs("at least 1 point of the quadrangle in x,y ranges\n", stderr); + else + fputs( "all 4 points of the quadrangle in x,y ranges\n", stderr); + if (pm3d.hidden3d_tag) { + fprintf(stderr,"\tpm3d-hidden3d is on an will use linestyle %d\n", + pm3d.hidden3d_tag); + } else { + fputs("\tpm3d-hidden3d is off\n", stderr); + } +#if PM3D_HAVE_SOLID + if (pm3d.solid) { + fputs("\tborders, tics and labels may be hidden by the surface\n", stderr); + } else { + fputs("\tsurface is transparent for borders, tics and labels\n", stderr); + } +#endif + fprintf(stderr,"\tsteps for bilinear interpolation: %d,%d\n", + pm3d.interp_i, pm3d.interp_j); + fprintf(stderr,"\tquadrangle color according to "); + switch (pm3d.which_corner_color) { + case PM3D_WHICHCORNER_MEAN: fputs("averaged 4 corners\n", stderr); break; + case PM3D_WHICHCORNER_GEOMEAN: fputs("geometrical mean of 4 corners\n", stderr); break; + case PM3D_WHICHCORNER_MEDIAN: fputs("median of 4 corners\n", stderr); break; + case PM3D_WHICHCORNER_MIN: fputs("minimum of 4 corners\n", stderr); break; + case PM3D_WHICHCORNER_MAX: fputs("maximum of 4 corners\n", stderr); break; + default: fprintf(stderr, "corner %i\n", pm3d.which_corner_color - PM3D_WHICHCORNER_C1 + 1); + } +} + + +/* process 'show pointsize' command */ +static void +show_pointsize() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tpointsize is %g\n", pointsize); +} + + +/* process 'show encoding' command */ +static void +show_encoding() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tencoding is %s\n", encoding_names[encoding]); +} + + +/* process 'show decimalsign' command */ +static void +show_decimalsign() +{ + SHOW_ALL_NL; +#ifdef HAVE_LOCALE_H + if (save_locale) { + setlocale(LC_NUMERIC,save_locale); + fprintf(stderr, "\tdecimalsign for input is %s \n", localeconv()->decimal_point); + } +#endif + if (decimalsign!=NULL) + fprintf(stderr, "\tdecimalsign for output is %s \n", decimalsign); + else + fprintf(stderr, "\tdecimalsign for output has default value (normally '.')\n"); +} + + +/* process 'show fit' command */ +static void +show_fit() +{ + SHOW_ALL_NL; + +#ifdef GP_FIT_ERRVARS + fprintf(stderr, "\ +\tfit will%s place parameter errors in variables\n", + fit_errorvariables ? "" : " not"); +#endif /* GP_FIT_ERRVARS */ + + if (fitlogfile != NULL) { + fprintf(stderr, "\ +\tlog-file for fits is was set by the user to be \n\ +\t'%s'\n", fitlogfile); + } else { + char *logfile = getfitlogfile(); + + if (logfile) { + fprintf(stderr, "\ +\tlog-file for fits is unchanged from the environment default of\n\ +\t'%s'\n", logfile); + free(logfile); + } + } +} + + +/* process 'show polar' command */ +static void +show_polar() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tpolar is %s\n", (polar) ? "ON" : "OFF"); +} + + +/* process 'show angles' command */ +static void +show_angles() +{ + SHOW_ALL_NL; + + fputs("\tAngles are in ", stderr); + if (ang2rad == 1) { + fputs("radians\n", stderr); + } else { + fputs("degrees\n", stderr); + } +} + + +/* process 'show samples' command */ +static void +show_samples() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tsampling rate is %d, %d\n", samples_1, samples_2); +} + + +/* process 'show isosamples' command */ +static void +show_isosamples() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tiso sampling rate is %d, %d\n", + iso_samples_1, iso_samples_2); +} + + +/* process 'show view' command */ +static void +show_view() +{ + SHOW_ALL_NL; + fputs("\tview is ", stderr); + if (splot_map == TRUE) { + fputs("map\n", stderr); + return; + } + fprintf(stderr, "%g rot_x, %g rot_z, %g scale, %g scale_z\n", + surface_rot_x, surface_rot_z, surface_scale, surface_zscale); + fprintf(stderr,"\t\t%s axes are %s\n", + aspect_ratio_3D == 2 ? "x/y" : aspect_ratio_3D == 3 ? "x/y/z" : "", + aspect_ratio_3D >= 2 ? "on the same scale" : "independently scaled"); +} + + +/* process 'show surface' command */ +static void +show_surface() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tsurface is %sdrawn\n", draw_surface ? "" : "not "); +} + + +/* process 'show hidden3d' command */ +static void +show_hidden3d() +{ + SHOW_ALL_NL; + +#ifdef LITE + printf(" Hidden Line Removal Not Supported in LITE version\n"); +#else + fprintf(stderr, "\thidden surface is %s\n", + hidden3d ? "removed" : "drawn"); + show_hidden3doptions(); +#endif /* LITE */ +} + +static void +show_increment() +{ + fprintf(stderr,"\tPlot lines increment over "); + if (prefer_line_styles) + fprintf(stderr, "user-defined line styles rather than default line types\n"); + else + fprintf(stderr, "default linetypes\n"); +} + +#ifdef EAM_HISTOGRAMS +static void +show_histogram() +{ + if (histogram_opts.type == HT_CLUSTERED) + fprintf(stderr, "\tHistogram style is clustered with gap %d ", + histogram_opts.gap); + else if (histogram_opts.type == HT_ERRORBARS) + fprintf(stderr, "\tHistogram style is errorbars with gap %d lw %g ", + histogram_opts.gap, histogram_opts.bar_lw); + else if (histogram_opts.type == HT_STACKED_IN_LAYERS) + fprintf(stderr, "\tHistogram style is rowstacked "); + else if (histogram_opts.type == HT_STACKED_IN_TOWERS) + fprintf(stderr, "\tHistogram style is columnstacked "); + fprintf(stderr, " title offset "); + show_position(&histogram_opts.title.offset); + if (histogram_opts.title.textcolor.type == TC_LT) + fprintf(stderr," textcolor lt %d", histogram_opts.title.textcolor.lt+1); + fprintf(stderr, "\n"); +} +#endif + +#ifdef GNUPLOT_HISTORY +/* process 'show historysize' command */ +static void +show_historysize() +{ + if (gnuplot_history_size >= 0) { + fprintf(stderr, "\thistory size: %ld\n", gnuplot_history_size); + } else { + fprintf(stderr, "\thistory will not be truncated.\n"); + } +} +#endif + + +/* process 'show size' command */ +static void +show_size() +{ + SHOW_ALL_NL; + + fprintf(stderr, "\tsize is scaled by %g,%g\n", xsize, ysize); + if (aspect_ratio > 0) + fprintf(stderr, "\tTry to set aspect ratio to %g:1.0\n", aspect_ratio); + else if (aspect_ratio == 0) + fputs("\tNo attempt to control aspect ratio\n", stderr); + else + fprintf(stderr, "\tTry to set LOCKED aspect ratio to %g:1.0\n", + -aspect_ratio); +} + + +/* process 'show origin' command */ +static void +show_origin() +{ + SHOW_ALL_NL; + fprintf(stderr, "\torigin is set to %g,%g\n", xoffset, yoffset); +} + + +/* process 'show term' command */ +static void +show_term() +{ + SHOW_ALL_NL; + + if (term) + fprintf(stderr, " terminal type is %s %s\n", + term->name, term_options); + else + fputs("\tterminal type is unknown\n", stderr); +} + + +/* process 'show tics|[xyzx2y2cb]tics' commands */ +static void +show_tics( + TBOOLEAN showx, TBOOLEAN showy, TBOOLEAN showz, + TBOOLEAN showx2, TBOOLEAN showy2, + TBOOLEAN showcb) +{ + SHOW_ALL_NL; + + if (xyplane.absolute) + fprintf(stderr, "xyplane intercepts z axis at %g\n", xyplane.xyplane_z); + else + fprintf(stderr, "xyplane ticslevel is %g\n", xyplane.ticslevel); + + if (grid_layer >= 0) + fprintf(stderr, "tics are in %s of plot\n", (grid_layer==0) ? "back" : "front"); + + if (showx) + show_ticdef(FIRST_X_AXIS); + if (showx2) + show_ticdef(SECOND_X_AXIS); + if (showy) + show_ticdef(FIRST_Y_AXIS); + if (showy2) + show_ticdef(SECOND_Y_AXIS); + if (showz) + show_ticdef(FIRST_Z_AXIS); + if (showcb) + show_ticdef(COLOR_AXIS); + screen_ok = FALSE; +} + + +/* process 'show m[xyzx2y2cb]tics' commands */ +static void +show_mtics(AXIS_INDEX axis) +{ + switch (axis_array[axis].minitics) { + case MINI_OFF: + fprintf(stderr, "\tminor %stics are off\n", axis_defaults[axis].name); + break; + case MINI_DEFAULT: + fprintf(stderr, "\ +\tminor %stics are off for linear scales\n\ +\tminor %stics are computed automatically for log scales\n", axis_defaults[axis].name, axis_defaults[axis].name); + break; + case MINI_AUTO: + fprintf(stderr, "\tminor %stics are computed automatically\n", axis_defaults[axis].name); + break; + case MINI_USER: + fprintf(stderr, "\ +\tminor %stics are drawn with %d subintervals between major xtic marks\n", + axis_defaults[axis].name, (int) axis_array[axis].mtic_freq); + break; + default: + int_error(NO_CARET, "Unknown minitic type in show_mtics()"); + } +} + + +/* process 'show timestamp' command */ +static void +show_timestamp() +{ + SHOW_ALL_NL; + show_xyzlabel("", "time", &timelabel); + fprintf(stderr, "\twritten in %s corner\n", + (timelabel_bottom ? "bottom" : "top")); + if (timelabel_rotate) + fputs("\trotated if the terminal allows it\n\t", stderr); + else + fputs("\tnot rotated\n\t", stderr); +} + + +/* process 'show [xyzx2y2rtuv]range' commands */ +static void +show_range(AXIS_INDEX axis) +{ + SHOW_ALL_NL; + if (axis_array[axis].is_timedata) + fprintf(stderr, "\tset %sdata time\n", axis_defaults[axis].name); + fprintf(stderr,"\t"); + save_range(stderr, axis); +} + + +/* called by the functions below */ +static void +show_xyzlabel(const char *name, const char *suffix, text_label *label) +{ + if (label) { + fprintf(stderr, "\t%s%s is \"%s\", offset at ", name, suffix, + label->text ? conv_text(label->text) : ""); + show_position(&label->offset); + } else + return; + + if (label->font) + fprintf(stderr, ", using font \"%s\"", conv_text(label->font)); + + if (label->rotate) + fprintf(stderr, ", rotated by %d degrees", label->rotate); + + if (label->textcolor.type) + save_textcolor(stderr, &label->textcolor); + + if (label->noenhanced) + fprintf(stderr," noenhanced"); + + putc('\n', stderr); +} + + +/* process 'show title' command */ +static void +show_title() +{ + SHOW_ALL_NL; + show_xyzlabel("","title", &title); +} + + +/* process 'show {x|y|z|x2|y2}label' command */ +static void +show_axislabel(AXIS_INDEX axis) +{ + SHOW_ALL_NL; + show_xyzlabel(axis_defaults[axis].name, "label", &axis_array[axis].label); +} + + +/* process 'show [xyzx2y2]data' commands */ +static void +show_data_is_timedate(AXIS_INDEX axis) +{ + SHOW_ALL_NL; + fprintf(stderr, "\t%s is set to %s\n", axis_defaults[axis].name, + axis_array[axis].is_timedata ? "time" : "numerical"); +} + + +/* process 'show timefmt' command */ +static void +show_timefmt() +{ + int axis; + + SHOW_ALL_NL; + + if ((axis = lookup_table(axisname_tbl, c_token)) >= 0) { + c_token++; + fprintf(stderr, "\tread format for time on %s axis is \"%s\"\n", + axis_defaults[axis].name, + conv_text(axis_array[axis].timefmt)); + } else { + /* show all currently active time axes' formats: */ + for (axis = 0; axis 0) { + fprintf(stderr, "\tdouble click resolution is %d ms\n", + mouse_setting.doubleclick); + } else { + fprintf(stderr, "\tdouble click resolution is off\n"); + } + fprintf(stderr, "\tformatting numbers with \"%s\"\n", + mouse_setting.fmt); + fprintf(stderr, "\tformat for Button 1 is %d\n", (int) clipboard_mode); + if (clipboard_alt_string) { + fprintf(stderr, "\talternative format for Button 1 is '%s'\n", + clipboard_alt_string); + } + fprintf(stderr, "\tformat for Button 2 is %d\n", (int) mouse_mode); + if (mouse_alt_string) { + fprintf(stderr, "\talternative format for Button 2 is '%s'\n", + mouse_alt_string); + } + if (mouse_setting.label) { + fprintf(stderr, "\tButton 2 draws labes with options \"%s\"\n", + mouse_setting.labelopts); + } else { + fprintf(stderr, "\tdrawing temporary annotation on Button 2\n"); + } + fprintf(stderr, "\tzoomjump is %s\n", + mouse_setting.warp_pointer ? "on" : "off"); + fprintf(stderr, "\tcommunication commands will %sbe shown\n", + mouse_setting.verbose ? "" : "not "); + } else { + fprintf(stderr, "\tmouse is off\n"); + } +} +#endif + +/* process 'show plot' command */ +static void +show_plot() +{ + SHOW_ALL_NL; + fprintf(stderr, "\tlast plot command was: %s\n", replot_line); +} + + +/* process 'show variables' command */ +static void +show_variables() +{ + struct udvt_entry *udv = first_udv; + int len; + int show_gpval = 0; + + SHOW_ALL_NL; + + if (!END_OF_COMMAND) { + if (almost_equals(c_token, "all")) + show_gpval = 1; + else + int_error(c_token, "Required no option or 'all'"); + c_token++; + } + + if (show_gpval) + fputs("\n\tAll available variables:\n", stderr); + else + fputs("\n\tUser and default variables:\n", stderr); + + while (udv) { + len = strcspn(udv->udv_name, " "); + if (!show_gpval && !strncmp(udv->udv_name,"GPVAL_",6)) { /* skip GPVAL_ variables */ + udv = udv->next_udv; + continue; + } + if (udv->udv_undef) { + FPRINTF((stderr, "\t%-*s is undefined\n", len, udv->udv_name)); + } else { + fprintf(stderr, "\t%-*s ", len, udv->udv_name); + fputs("= ", stderr); + disp_value(stderr, &(udv->udv_value), TRUE); + (void) putc('\n', stderr); + } + udv = udv->next_udv; + } +} + + +/* Show line style number (0 means show all) */ +static void +show_linestyle(int tag) +{ + struct linestyle_def *this_linestyle; + TBOOLEAN showed = FALSE; + + for (this_linestyle = first_linestyle; this_linestyle != NULL; + this_linestyle = this_linestyle->next) { + if (tag == 0 || tag == this_linestyle->tag) { + showed = TRUE; + fprintf(stderr, "\tlinestyle %d, ", this_linestyle->tag); + save_linetype(stderr, &(this_linestyle->lp_properties), TRUE); + fputc('\n', stderr); + } + } + if (tag > 0 && !showed) + int_error(c_token, "linestyle not found"); +} + + +/* Show arrow style number (0 means show all) */ +static void +show_arrowstyle(int tag) +{ + struct arrowstyle_def *this_arrowstyle; + TBOOLEAN showed = FALSE; + + for (this_arrowstyle = first_arrowstyle; this_arrowstyle != NULL; + this_arrowstyle = this_arrowstyle->next) { + if (tag == 0 || tag == this_arrowstyle->tag) { + showed = TRUE; + fprintf(stderr, "\tarrowstyle %d, ", this_arrowstyle->tag); + fflush(stderr); + + fprintf(stderr, "\t %s %s", + this_arrowstyle->arrow_properties.head ? + (this_arrowstyle->arrow_properties.head==2 ? + " both heads " : " one head ") : " nohead", + this_arrowstyle->arrow_properties.layer ? "front" : "back"); + save_linetype(stderr, &(this_arrowstyle->arrow_properties.lp_properties), FALSE); + fputc('\n', stderr); + + if (this_arrowstyle->arrow_properties.head > 0) { + fprintf(stderr, "\t arrow heads: %s, ", + ( (this_arrowstyle->arrow_properties.head_filled==2) ? "filled" : + ( (this_arrowstyle->arrow_properties.head_filled==1) ? "empty" : + "nofilled" ))); + if (this_arrowstyle->arrow_properties.head_length > 0) { + static char *msg[] = + {"(first x axis) ", "(second x axis) ", + "(graph units) ", "(screen units) ", + "(character units) "}; + fprintf(stderr," length %s%g, angle %g deg", + this_arrowstyle->arrow_properties.head_lengthunit == first_axes ? "" : msg[this_arrowstyle->arrow_properties.head_lengthunit], + this_arrowstyle->arrow_properties.head_length, + this_arrowstyle->arrow_properties.head_angle); + if (this_arrowstyle->arrow_properties.head_filled!=0) + fprintf(stderr,", backangle %g deg", + this_arrowstyle->arrow_properties.head_backangle); + fprintf(stderr,"\n"); + } + else + fprintf(stderr," (default length and angles)\n"); + } + } + } + if (tag > 0 && !showed) + int_error(c_token, "arrowstyle not found"); +} + + +/* called by show_tics */ +static void +show_ticdef(AXIS_INDEX axis) +{ + struct ticmark *t; + + const char *ticfmt = conv_text(axis_array[axis].formatstring); + + fprintf(stderr, "\t%s-axis tics are %s, \ +\tmajor ticscale is %g and minor ticscale is %g\n", + axis_defaults[axis].name, + (axis_array[axis].tic_in ? "IN" : "OUT"), + axis_array[axis].ticscale, axis_array[axis].miniticscale); + + fprintf(stderr, "\t%s-axis tics:\t", axis_defaults[axis].name); + switch (axis_array[axis].ticmode & TICS_MASK) { + case NO_TICS: + fputs("OFF\n", stderr); + return; + case TICS_ON_AXIS: + fputs("on axis", stderr); + if (axis_array[axis].ticmode & TICS_MIRROR) + fprintf(stderr, " and mirrored %s", (axis_array[axis].tic_in ? "OUT" : "IN")); + break; + case TICS_ON_BORDER: + fputs("on border", stderr); + if (axis_array[axis].ticmode & TICS_MIRROR) + fputs(" and mirrored on opposite border", stderr); + break; + } + + if (axis_array[axis].ticdef.rangelimited) + fprintf(stderr, "\n\t tics are limited to data range"); + fprintf(stderr, "\n\t labels are format \"%s\"", ticfmt); + if (axis_array[axis].tic_rotate) { + fprintf(stderr," rotated"); + fprintf(stderr," by %d",axis_array[axis].tic_rotate); + fputs(" in 2D mode, terminal permitting,\n\t", stderr); + } else + fputs(" and are not rotated,\n\t", stderr); + fputs(" offset ",stderr); + show_position(&axis_array[axis].ticdef.offset); + fputs("\n\t",stderr); + + switch (axis_array[axis].ticdef.type) { + case TIC_COMPUTED:{ + fputs(" intervals computed automatically\n", stderr); + break; + } + case TIC_MONTH:{ + fputs(" Months computed automatically\n", stderr); + break; + } + case TIC_DAY:{ + fputs(" Days computed automatically\n", stderr); + break; + } + case TIC_SERIES:{ + fputs(" series", stderr); + if (axis_array[axis].ticdef.def.series.start != -VERYLARGE) { + fputs(" from ", stderr); + SHOW_NUM_OR_TIME(axis_array[axis].ticdef.def.series.start, axis); + } + fprintf(stderr, " by %g%s", axis_array[axis].ticdef.def.series.incr, + axis_array[axis].is_timedata ? " secs" : ""); + if (axis_array[axis].ticdef.def.series.end != VERYLARGE) { + fputs(" until ", stderr); + SHOW_NUM_OR_TIME(axis_array[axis].ticdef.def.series.end, axis); + } + putc('\n', stderr); + break; + } + case TIC_USER:{ + fputs(" no auto-generated tics\n", stderr); + break; + } + default:{ + int_error(NO_CARET, "unknown ticdef type in show_ticdef()"); + /* NOTREACHED */ + } + } + + if (axis_array[axis].ticdef.def.user) { + fputs("\t explicit list (", stderr); + for (t = axis_array[axis].ticdef.def.user; t != NULL; t = t->next) { + if (t->label) + fprintf(stderr, "\"%s\" ", conv_text(t->label)); + SHOW_NUM_OR_TIME(t->position, axis); + if (t->level) + fprintf(stderr," %d",t->level); + if (t->next) + fputs(", ", stderr); + } + fputs(")\n", stderr); + } + + if (axis_array[axis].ticdef.textcolor.type != TC_DEFAULT) { + fputs("\t ", stderr); + save_textcolor(stderr, &axis_array[axis].ticdef.textcolor); + fputs("\n", stderr); + } + + if (axis_array[axis].ticdef.font && *axis_array[axis].ticdef.font) { + fprintf(stderr,"\t font \"%s\"\n", axis_array[axis].ticdef.font); + } +} + +/* Display a value in human-readable form. */ +void +disp_value(FILE *fp, struct value *val, TBOOLEAN need_quotes) +{ + switch (val->type) { + case INTGR: + fprintf(fp, "%d", val->v.int_val); + break; + case CMPLX: +#ifdef HAVE_ISNAN + if (isnan(val->v.cmplx_val.real)) + fprintf(fp, "NaN"); + else +#endif + if (val->v.cmplx_val.imag != 0.0) + fprintf(fp, "{%s, %s}", + num_to_str(val->v.cmplx_val.real), + num_to_str(val->v.cmplx_val.imag)); + else + fprintf(fp, "%s", + num_to_str(val->v.cmplx_val.real)); + break; +#ifdef GP_STRING_VARS + case STRING: + if (val->v.string_val) { + if (need_quotes) + fprintf(fp, "\"%s\"", conv_text(val->v.string_val)); + else + fprintf(fp, "%s", val->v.string_val); + } + break; +#endif + default: + int_error(NO_CARET, "unknown type in disp_value()"); + } +} + +/* Helper for disp_value(): display a single number in decimal + * format. Rotates through 4 buffers 's[j]', and returns pointers to + * them, to avoid execution ordering problems if this function is + * called more than once between sequence points. */ +static char * +num_to_str(double r) +{ + static int i = 0; + static char s[4][25]; + int j = i++; + + if (i > 3) + i = 0; + + sprintf(s[j], "%.15g", r); + if (strchr(s[j], '.') == NULL && +#ifdef HAVE_LOCALE_H + strchr(s[j], ',') == NULL && +#endif + strchr(s[j], 'e') == NULL && + strchr(s[j], 'E') == NULL) + strcat(s[j], ".0"); + + return s[j]; +} + + +/* convert unprintable characters as \okt, tab as \t, newline \n .. */ +char * +conv_text(const char *t) +{ + static char *r = NULL, *s; + + if (t==NULL) return NULL; + + /* is this enough? */ + r = gp_realloc(r, 4 * (strlen(t) + 1), "conv_text buffer"); + + s = r; + + while (*t != NUL) { + switch (*t) { + case '\t': + *s++ = '\\'; + *s++ = 't'; + break; + case '\n': + *s++ = '\\'; + *s++ = 'n'; + break; +#ifndef OSK + case '\r': + *s++ = '\\'; + *s++ = 'r'; + break; +#endif + case '"': + case '\\': + *s++ = '\\'; + *s++ = *t; + break; + + default:{ + if (isprint((unsigned char)*t)) + *s++ = *t; + else { + *s++ = '\\'; + sprintf(s, "%03o", (unsigned char)*t); + while (*s != NUL) + s++; + } + } + break; + } + t++; + } + *s = NUL; + return r; +}