--- /dev/null
+#ifndef lint
+static char *RCSid() { return RCSid("$Id: command.c,v 1.144.2.11 2008/12/12 06:57:50 sfeam Exp $"); }
+#endif
+
+/* GNUPLOT - command.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.
+]*/
+
+/*
+ * Changes:
+ *
+ * Feb 5, 1992 Jack Veenstra (veenstra@cs.rochester.edu) Added support to
+ * filter data values read from a file through a user-defined function before
+ * plotting. The keyword "thru" was added to the "plot" command. Example
+ * syntax: f(x) = x / 100 plot "test.data" thru f(x) This example divides all
+ * the y values by 100 before plotting. The filter function processes the
+ * data before any log-scaling occurs. This capability should be generalized
+ * to filter x values as well and a similar feature should be added to the
+ * "splot" command.
+ *
+ * 19 September 1992 Lawrence Crowl (crowl@cs.orst.edu)
+ * Added user-specified bases for log scaling.
+ *
+ * April 1999 Franz Bakan (bakan@ukezyk.desy.de)
+ * Added code to support mouse-input from OS/2 PM window
+ * Changes marked by USE_MOUSE
+ *
+ * May 1999, update by Petr Mikulik
+ * Use gnuplot's pid in shared mem name
+ *
+ * August 1999 Franz Bakan and Petr Mikulik
+ * Encapsulating read_line into a thread, acting on input when thread or
+ * gnupmdrv posts an event semaphore. Thus mousing works even when gnuplot
+ * is used as a plotting device (commands passed via pipe).
+ *
+ */
+
+#include "command.h"
+
+#include "alloc.h"
+#include "eval.h"
+#include "fit.h"
+#include "binary.h"
+#include "datafile.h"
+#include "getcolor.h"
+#include "gp_hist.h"
+#include "gp_time.h"
+#include "misc.h"
+#include "parse.h"
+#include "plot.h"
+#include "plot2d.h"
+#include "plot3d.h"
+#include "readline.h"
+#include "save.h"
+#include "scanner.h"
+#include "setshow.h"
+#include "tables.h"
+#include "term_api.h"
+#include "util.h"
+
+#ifdef USE_MOUSE
+# include "mouse.h"
+#endif
+
+#define PROMPT "gnuplot> "
+
+#if (defined(MSDOS) || defined(DOS386)) && defined(__TURBOC__) && !defined(_Windows)
+unsigned _stklen = 16394; /* increase stack size */
+#endif /* MSDOS && TURBOC */
+
+#ifdef OS2_IPC
+# define INCL_DOSMEMMGR
+# define INCL_DOSPROCESS
+# define INCL_DOSSEMAPHORES
+# include <os2.h>
+PVOID input_from_PM_Terminal = NULL;
+char mouseSharedMemName[40] = "";
+HEV semInputReady = 0; /* semaphore to be created in plot.c */
+int thread_rl_Running = 0; /* running status */
+int thread_rl_RetCode = -1; /* return code from readline in a thread */
+#endif /* OS2_IPC */
+
+
+#ifndef _Windows
+# include "help.h"
+#else
+# ifdef USE_OWN_WINSYSTEM_FUNCTION
+static int winsystem __PROTO((const char *));
+# endif
+#endif /* _Windows */
+
+#ifdef _Windows
+# include <windows.h>
+# ifdef __MSC__
+# include <malloc.h>
+# include <direct.h> /* getcwd() */
+# else
+# include <alloc.h>
+# ifndef __WATCOMC__
+# include <dir.h> /* setdisk() */
+# endif
+# endif /* !MSC */
+# include "win/winmain.h"
+#endif /* _Windows */
+
+#ifdef VMS
+int vms_vkid; /* Virtual keyboard id */
+int vms_ktid; /* key table id, for translating keystrokes */
+#endif /* VMS */
+
+
+/* static prototypes */
+static void command __PROTO((void));
+static int changedir __PROTO((char *path));
+static char* fgets_ipc __PROTO((char* dest, int len));
+static int read_line __PROTO((const char *prompt));
+static void do_system __PROTO((const char *));
+static void test_palette_subcommand __PROTO((void));
+static void test_time_subcommand __PROTO((void));
+
+#ifdef AMIGA_AC_5
+static void getparms __PROTO((char *, char **));
+#endif
+#ifdef GP_MACROS
+static int string_expand __PROTO((void));
+TBOOLEAN expand_macros = FALSE;
+#endif
+
+struct lexical_unit *token;
+int token_table_size;
+
+
+char *gp_input_line;
+size_t gp_input_line_len;
+int inline_num; /* input line number */
+
+struct udft_entry *dummy_func;
+
+/* support for replot command */
+char *replot_line;
+int plot_token; /* start of 'plot' command */
+
+/* flag to disable `replot` when some data are sent through stdin;
+ * used by mouse/hotkey capable terminals */
+TBOOLEAN replot_disabled = FALSE;
+
+#ifdef USE_MOUSE
+int paused_for_mouse = 0;
+#endif
+
+/* output file for the print command */
+FILE *print_out = NULL;
+char *print_out_name = NULL;
+
+/* input data, parsing variables */
+#ifdef AMIGA_SC_6_1
+__far int num_tokens, c_token;
+#else
+int num_tokens, c_token;
+#endif
+
+static int if_depth = 0;
+static TBOOLEAN if_condition = FALSE;
+
+static int command_exit_status = 0;
+
+/* support for dynamic size of input line */
+void
+extend_input_line()
+{
+ if (gp_input_line_len == 0) {
+ /* first time */
+ gp_input_line = gp_alloc(MAX_LINE_LEN, "gp_input_line");
+ gp_input_line_len = MAX_LINE_LEN;
+ gp_input_line[0] = NUL;
+
+#ifdef OS2_IPC
+ sprintf( mouseSharedMemName, "\\SHAREMEM\\GP%i_Mouse_Input", getpid() );
+ if (DosAllocSharedMem((PVOID) & input_from_PM_Terminal,
+ mouseSharedMemName, MAX_LINE_LEN, PAG_WRITE | PAG_COMMIT))
+ fputs("command.c: DosAllocSharedMem ERROR\n",stderr);
+#endif /* OS2_IPC */
+
+ } else {
+ gp_input_line = gp_realloc(gp_input_line, gp_input_line_len + MAX_LINE_LEN,
+ "extend input line");
+ gp_input_line_len += MAX_LINE_LEN;
+ FPRINTF((stderr, "extending input line to %d chars\n",
+ gp_input_line_len));
+ }
+}
+
+/* constant by which token table grows */
+#define MAX_TOKENS 400
+
+void
+extend_token_table()
+{
+ if (token_table_size == 0) {
+ /* first time */
+ token = (struct lexical_unit *) gp_alloc(MAX_TOKENS * sizeof(struct lexical_unit), "token table");
+ token_table_size = MAX_TOKENS;
+ /* HBB: for checker-runs: */
+ memset(token, 0, MAX_TOKENS * sizeof(*token));
+ } else {
+ token = gp_realloc(token, (token_table_size + MAX_TOKENS) * sizeof(struct lexical_unit), "extend token table");
+ memset(token+token_table_size, 0, MAX_TOKENS * sizeof(*token));
+ token_table_size += MAX_TOKENS;
+ FPRINTF((stderr, "extending token table to %d elements\n", token_table_size));
+ }
+}
+
+
+#ifdef OS2_IPC
+void thread_read_line()
+{
+ thread_rl_Running = 1;
+ thread_rl_RetCode = ( read_line(PROMPT) );
+ thread_rl_Running = 0;
+ DosPostEventSem(semInputReady);
+}
+#endif /* OS2_IPC */
+
+
+int
+com_line()
+{
+#ifdef OS2_IPC
+static char *input_line_SharedMem = NULL;
+
+ if (input_line_SharedMem == NULL) { /* get shared mem only once */
+ if (DosGetNamedSharedMem((PVOID) &input_line_SharedMem,
+ mouseSharedMemName, PAG_WRITE | PAG_READ))
+ fputs("readline.c: DosGetNamedSharedMem ERROR\n", stderr);
+ else
+ *input_line_SharedMem = 0;
+ }
+#endif /* OS2_IPC */
+
+ if (multiplot) {
+ /* calls int_error() if it is not happy */
+ term_check_multiplot_okay(interactive);
+
+ if (read_line("multiplot> "))
+ return (1);
+ } else {
+
+#ifndef USE_MOUSE
+ if (read_line(PROMPT))
+ return (1);
+#else
+# ifdef OS2_IPC
+ ULONG u;
+ if (thread_rl_Running == 0) {
+ int res = _beginthread(thread_read_line,NULL,32768,NULL);
+ if (res == -1)
+ fputs("error command.c could not begin thread\n",stderr);
+ }
+ /* wait until a line is read or gnupmdrv makes shared mem available */
+ DosWaitEventSem(semInputReady,SEM_INDEFINITE_WAIT);
+ DosResetEventSem(semInputReady,&u);
+ if (thread_rl_Running) {
+ if (input_line_SharedMem == NULL || !*input_line_SharedMem)
+ return (0);
+ if (*input_line_SharedMem=='%') {
+ do_event( (struct gp_event_t*)(input_line_SharedMem+1) ); /* pass terminal's event */
+ input_line_SharedMem[0] = 0; /* discard the whole command line */
+ thread_rl_RetCode = 0;
+ return (0);
+ }
+ if (*input_line_SharedMem &&
+ strstr(input_line_SharedMem,"plot") != NULL &&
+ (strcmp(term->name,"pm") && strcmp(term->name,"x11"))) {
+ /* avoid plotting if terminal is not PM or X11 */
+ fprintf(stderr,"\n\tCommand(s) ignored for other than PM and X11 terminals\a\n");
+ if (interactive) fputs(PROMPT,stderr);
+ input_line_SharedMem[0] = 0; /* discard the whole command line */
+ return (0);
+ }
+# if 0
+ fprintf(stderr,"shared mem received: |%s|\n",input_line_SharedMem);
+ if (*input_line_SharedMem && input_line_SharedMem[strlen(input_line_SharedMem)-1] != '\n') fprintf(stderr,"\n");
+# endif
+ strcpy(gp_input_line, input_line_SharedMem);
+ input_line_SharedMem[0] = 0;
+ thread_rl_RetCode = 0;
+ }
+ if (thread_rl_RetCode)
+ return (1);
+# else /* OS2_IPC */
+ if (read_line(PROMPT))
+ return (1);
+# endif /* OS2_IPC */
+#endif /* USE_MOUSE */
+ }
+
+ /* So we can flag any new output: if false at time of error,
+ * we reprint the command line before printing caret.
+ * TRUE for interactive terminals, since the command line is typed.
+ * FALSE for non-terminal stdin, so command line is printed anyway.
+ * (DFK 11/89)
+ */
+ screen_ok = interactive;
+
+ if (do_line())
+ return (1);
+ else
+ return (0);
+}
+
+
+int
+do_line()
+{
+ /* Line continuation has already been handled
+ * by read_line() */
+ char *inlptr = gp_input_line;
+
+ /* Skip leading whitespace */
+ while (isspace((unsigned char) *inlptr))
+ inlptr++;
+
+ if (inlptr != gp_input_line) {
+ /* If there was leading whitespace, copy the actual
+ * command string to the front. use memmove() because
+ * source and target may overlap */
+ memmove(gp_input_line, inlptr, strlen(inlptr));
+ /* Terminate resulting string */
+ gp_input_line[strlen(inlptr)] = NUL;
+ }
+ FPRINTF((stderr, "Input line: \"%s\"\n", gp_input_line));
+
+#ifdef GP_MACROS
+ /* Expand any string variables in the current input line.
+ * Allow up to 4 levels of recursion */
+ if (expand_macros)
+ if (string_expand() && string_expand() && string_expand() && string_expand() && string_expand())
+ int_error(NO_CARET, "Too many levels of nested macros");
+#endif
+
+ /* also used in load_file */
+ if (is_system(gp_input_line[0])) {
+ do_system(gp_input_line + 1);
+ if (interactive) /* 3.5 did it unconditionally */
+ (void) fputs("!\n", stderr); /* why do we need this ? */
+ return (0);
+ }
+
+ if_depth = 0;
+ if_condition = TRUE;
+ num_tokens = scanner(&gp_input_line, &gp_input_line_len);
+ c_token = 0;
+ while (c_token < num_tokens) {
+ command();
+ if (command_exit_status) {
+ command_exit_status = 0;
+ return 1;
+ }
+ if (c_token < num_tokens) { /* something after command */
+ if (equals(c_token, ";"))
+ c_token++;
+ else
+ int_error(c_token, "';' expected");
+ }
+ }
+ return (0);
+}
+
+
+void
+do_string(char *s)
+{
+ char *orig_input_line = gp_strdup(gp_input_line);
+
+ while (gp_input_line_len < strlen(s) + 1)
+ extend_input_line();
+ strcpy(gp_input_line, s);
+
+#ifdef USE_MOUSE
+ if (display_ipc_commands())
+ fprintf(stderr, "%s\n", s);
+#endif
+
+ do_line();
+
+ strcpy(gp_input_line, orig_input_line);
+ free(orig_input_line);
+}
+
+
+#ifdef USE_MOUSE
+void
+toggle_display_of_ipc_commands()
+{
+ if (mouse_setting.verbose)
+ mouse_setting.verbose = 0;
+ else
+ mouse_setting.verbose = 1;
+}
+
+int
+display_ipc_commands()
+{
+ return mouse_setting.verbose;
+}
+
+void
+do_string_replot(char *s)
+{
+ char *orig_input_line = gp_strdup(gp_input_line);
+
+ while (gp_input_line_len < strlen(s) + 1)
+ extend_input_line();
+ strcpy(gp_input_line, s);
+ if (display_ipc_commands())
+ fprintf(stderr, "%s\n", s);
+
+ do_line();
+ if (!replot_disabled)
+ replotrequest();
+
+ strcpy(gp_input_line, orig_input_line);
+ free(orig_input_line);
+}
+
+void
+restore_prompt()
+{
+ if (interactive) {
+#if defined(HAVE_LIBREADLINE)
+ rl_forced_update_display();
+#else
+#if defined(HAVE_LIBEDITLINE)
+ /* FIXME: editline does not support forced update,
+ so this is probably not enough */
+ rl_redisplay();
+#endif
+ fputs(PROMPT, stderr);
+ fflush(stderr);
+#endif
+ }
+}
+#endif /* USE_MOUSE */
+
+
+void
+define()
+{
+ int start_token; /* the 1st token in the function definition */
+ struct udvt_entry *udv;
+ struct udft_entry *udf;
+ struct value result;
+
+ if (equals(c_token + 1, "(")) {
+ /* function ! */
+ int dummy_num = 0;
+ struct at_type *at_tmp;
+ char save_dummy[MAX_NUM_VAR][MAX_ID_LEN+1];
+ memcpy(save_dummy, c_dummy_var, sizeof(save_dummy));
+ start_token = c_token;
+ do {
+ c_token += 2; /* skip to the next dummy */
+ copy_str(c_dummy_var[dummy_num++], c_token, MAX_ID_LEN);
+ } while (equals(c_token + 1, ",") && (dummy_num < MAX_NUM_VAR));
+ if (equals(c_token + 1, ","))
+ int_error(c_token + 2, "function contains too many parameters");
+ c_token += 3; /* skip (, dummy, ) and = */
+ if (END_OF_COMMAND)
+ int_error(c_token, "function definition expected");
+ udf = dummy_func = add_udf(start_token);
+ udf->dummy_num = dummy_num;
+ if ((at_tmp = perm_at()) == (struct at_type *) NULL)
+ int_error(start_token, "not enough memory for function");
+ if (udf->at) /* already a dynamic a.t. there */
+ free_at(udf->at); /* so free it first */
+ udf->at = at_tmp; /* before re-assigning it. */
+ memcpy(c_dummy_var, save_dummy, sizeof(save_dummy));
+ m_capture(&(udf->definition), start_token, c_token - 1);
+ dummy_func = NULL; /* dont let anyone else use our workspace */
+ } else {
+ /* variable ! */
+ char *varname = gp_input_line + token[c_token].start_index;
+ if (!strncmp(varname, "GPVAL_", 6) || !strncmp(varname, "MOUSE_", 6))
+ int_error(c_token, "Cannot set internal variables GPVAL_ and MOUSE_");
+ start_token = c_token;
+ c_token += 2;
+ udv = add_udv(start_token);
+ (void) const_express(&result);
+#ifdef GP_STRING_VARS
+ /* Prevents memory leak if the variable name is re-used */
+ if (!udv->udv_undef)
+ gpfree_string(&udv->udv_value);
+#endif
+ udv->udv_value = result;
+ udv->udv_undef = FALSE;
+ }
+}
+
+
+void
+undefine_command()
+{
+ char key[MAX_ID_LEN+1];
+ struct udvt_entry **udv_ptr = &first_udv;
+ c_token++;
+ while (!END_OF_COMMAND) {
+ copy_str(key, c_token, MAX_ID_LEN);
+ if (strncmp(key, "GPVAL_", 6) && strncmp(key, "MOUSE_", 6)) {
+ udv_ptr = &first_udv;
+ while (*udv_ptr) {
+ if (!strcmp(key, (*udv_ptr)->udv_name)) {
+ (*udv_ptr)->udv_undef = TRUE;
+ gpfree_string(&((*udv_ptr)->udv_value));
+ break;
+ }
+ udv_ptr = &((*udv_ptr)->next_udv);
+ }
+ }
+ c_token++;
+ }
+}
+
+
+static void
+command()
+{
+ int i;
+
+ for (i = 0; i < MAX_NUM_VAR; i++)
+ c_dummy_var[i][0] = NUL; /* no dummy variables */
+
+ if (is_definition(c_token))
+ define();
+ else
+ (*lookup_ftable(&command_ftbl[0],c_token))();
+
+ return;
+}
+
+
+/* process the 'raise' or 'lower' command */
+void
+raise_lower_command(int lower)
+{
+ ++c_token;
+
+ if (END_OF_COMMAND) {
+ if (lower) {
+#ifdef OS2
+ pm_lower_terminal_window();
+#endif
+#ifdef X11
+ x11_lower_terminal_group();
+#endif
+#ifdef _Windows
+ win_lower_terminal_window();
+#endif
+#ifdef WXWIDGETS
+ wxt_lower_terminal_group();
+#endif
+ } else {
+#ifdef OS2
+ pm_raise_terminal_window();
+#endif
+#ifdef X11
+ x11_raise_terminal_group();
+#endif
+#ifdef _Windows
+ win_raise_terminal_window();
+#endif
+#ifdef WXWIDGETS
+ wxt_raise_terminal_group();
+#endif
+ }
+ return;
+ } else {
+ int number;
+ int negative = equals(c_token, "-");
+
+ if (negative || equals(c_token, "+")) c_token++;
+ if (!END_OF_COMMAND && isanumber(c_token)) {
+ struct value a;
+ number = real(const_express(&a));
+ if (negative)
+ number = -number;
+ if (lower) {
+#ifdef OS2
+ pm_lower_terminal_window();
+#endif
+#ifdef X11
+ x11_lower_terminal_window(number);
+#endif
+#ifdef _Windows
+ win_lower_terminal_window();
+#endif
+#ifdef WXWIDGETS
+ wxt_lower_terminal_window(number);
+#endif
+ } else {
+#ifdef OS2
+ pm_raise_terminal_window();
+#endif
+#ifdef X11
+ x11_raise_terminal_window(number);
+#endif
+#ifdef _Windows
+ win_raise_terminal_window();
+#endif
+#ifdef WXWIDGETS
+ wxt_raise_terminal_window(number);
+#endif
+ }
+ ++c_token;
+ return;
+ }
+ }
+ int_error(c_token, "usage: raise {x11_plot_n}");
+}
+
+void
+raise_command(void)
+{
+ raise_lower_command(0);
+}
+
+void
+lower_command(void)
+{
+ raise_lower_command(1);
+}
+
+
+#ifdef USE_MOUSE
+
+#define WHITE_AFTER_TOKEN(x) \
+(' ' == gp_input_line[token[x].start_index + token[x].length] \
+|| '\t' == gp_input_line[token[x].start_index + token[x].length] \
+|| '\0' == gp_input_line[token[x].start_index + token[x].length])
+
+/* process the 'bind' command */
+void
+bind_command()
+{
+ char* lhs = (char*) 0;
+ char* rhs = (char*) 0;
+ TBOOLEAN allwindows = FALSE;
+ ++c_token;
+
+ if (!END_OF_COMMAND && equals(c_token,"!")) {
+ bind_remove_all();
+ ++c_token;
+ return;
+ }
+
+ if (!END_OF_COMMAND && almost_equals(c_token,"all$windows")) {
+ allwindows = TRUE;
+ c_token++;
+ }
+
+ /* get left hand side: the key or key sequence */
+ if (!END_OF_COMMAND) {
+ char* first = gp_input_line + token[c_token].start_index;
+ int size = (int) (strchr(first, ' ') - first);
+ if (size < 0) {
+ size = (int) (strchr(first, '\0') - first);
+ }
+ if (size < 0) {
+ fprintf(stderr, "(bind_command) %s:%d\n", __FILE__, __LINE__);
+ return;
+ }
+ lhs = (char*) gp_alloc(size + 1, "bind_command->lhs");
+ if (isstring(c_token)) {
+ quote_str(lhs, c_token, token_len(c_token));
+ } else {
+ char* ptr = lhs;
+ while (!END_OF_COMMAND) {
+ copy_str(ptr, c_token, token_len(c_token) + 1);
+ ptr += token_len(c_token);
+ if (WHITE_AFTER_TOKEN(c_token)) {
+ break;
+ }
+ ++c_token;
+ }
+ }
+ ++c_token;
+ }
+
+ /* get right hand side: the command. allocating the size
+ * of gp_input_line is too big, but shouldn't hurt too much. */
+ if (!END_OF_COMMAND) {
+ rhs = (char*) gp_alloc(strlen(gp_input_line) + 1, "bind_command->rhs");
+ if (isstring(c_token)) {
+ /* bind <lhs> "..." */
+ quote_str(rhs, c_token, token_len(c_token));
+ c_token++;
+ } else {
+ char* ptr = rhs;
+ while (!END_OF_COMMAND) {
+ /* bind <lhs> ... ... ... */
+ copy_str(ptr, c_token, token_len(c_token) + 1);
+ ptr += token_len(c_token);
+ if (WHITE_AFTER_TOKEN(c_token)) {
+ *ptr++ = ' ';
+ *ptr = '\0';
+ }
+ c_token++;
+ }
+ }
+ }
+
+ FPRINTF((stderr, "(bind_command) |%s| |%s|\n", lhs, rhs));
+
+ /* bind_process() will eventually free lhs / rhs ! */
+ bind_process(lhs, rhs, allwindows);
+
+}
+#endif /* USE_MOUSE */
+
+
+/*
+ * Command parser functions
+ */
+
+/* process the 'call' command */
+void
+call_command()
+{
+ char *save_file = NULL;
+
+ c_token++;
+ save_file = try_to_get_string();
+
+ if (!save_file)
+ int_error(c_token, "expecting filename");
+
+ gp_expand_tilde(&save_file);
+ /* Argument list follows filename */
+ load_file(loadpath_fopen(save_file, "r"), save_file, TRUE);
+ /* gp_input_line[] and token[] now destroyed! */
+ c_token = 0;
+ num_tokens = 0;
+ free(save_file);
+}
+
+
+/* process the 'cd' command */
+void
+changedir_command()
+{
+ char *save_file = NULL;
+
+ c_token++;
+ save_file = try_to_get_string();
+ if (!save_file)
+ int_error(c_token, "expecting directory name");
+
+ gp_expand_tilde(&save_file);
+ if (changedir(save_file))
+ int_error(c_token, "Can't change to this directory");
+ free(save_file);
+}
+
+
+/* process the 'clear' command */
+void
+clear_command()
+{
+
+ term_start_plot();
+
+ if (multiplot && term->fillbox) {
+ unsigned int xx1 = (unsigned int) (xoffset * term->xmax);
+ unsigned int yy1 = (unsigned int) (yoffset * term->ymax);
+ unsigned int width = (unsigned int) (xsize * term->xmax);
+ unsigned int height = (unsigned int) (ysize * term->ymax);
+ (*term->fillbox) (0, xx1, yy1, width, height);
+ }
+ term_end_plot();
+
+ screen_ok = FALSE;
+ c_token++;
+
+}
+
+
+/* process the 'exit' and 'quit' commands */
+void
+exit_command()
+{
+ /* If the command is "exit gnuplot" then do so */
+ if (equals(c_token+1,"gnuplot"))
+ exit(0);
+
+ /* else graphics will be tidied up in main */
+ command_exit_status = 1;
+}
+
+
+/* fit_command() is in fit.c */
+
+
+/* help_command() is below */
+
+
+/* process the 'history' command */
+void
+history_command()
+{
+#if defined(READLINE) || defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE)
+ c_token++;
+
+ if (!END_OF_COMMAND && equals(c_token,"?")) {
+ static char *search_str = NULL; /* string from command line to search for */
+
+ /* find and show the entries */
+ c_token++;
+ m_capture(&search_str, c_token, c_token); /* reallocates memory */
+ printf ("history ?%s\n", search_str);
+ if (!history_find_all(search_str))
+ int_error(c_token,"not in history");
+ c_token++;
+
+ } else if (!END_OF_COMMAND && equals(c_token,"!")) {
+ char *search_str = NULL; /* string from command line to search for */
+ const char *line_to_do = NULL; /* command to execute at end if necessary */
+ int c_token_copy;
+ static char *gpil_copy = NULL;
+
+ c_token++;
+ m_capture(&search_str, c_token, c_token);
+ line_to_do = history_find(search_str);
+ free(search_str);
+ if (line_to_do == NULL)
+ int_error(c_token, "not in history");
+
+ /* Must keep current input line in case there are some remaining lines
+ * to process after a semicolon. However, could int_error() some where
+ * during do_line() so a static copy is kept.
+ */
+ free(gpil_copy);
+ gpil_copy = gp_strdup(gp_input_line);
+ c_token_copy = c_token;
+
+ while (gp_input_line_len < strlen(line_to_do) + 1)
+ extend_input_line();
+ strcpy(gp_input_line, line_to_do);
+ if (scanner(&gp_input_line, &gp_input_line_len)) {
+ if (almost_equals(0, "hi$story") && equals(1, "!"))
+ int_error(c_token-1,"petitio principii"); /* Oops... infinite loop */
+ else {
+ printf(" Executing:\n\t%s\n", line_to_do);
+ do_line();
+ }
+ }
+ /* Restore previous state of line and parser, gpil_copy will be freed next time */
+ strcpy(gp_input_line, gpil_copy);
+ num_tokens = scanner(&gp_input_line, &gp_input_line_len);
+ c_token = c_token_copy + 1;
+
+ } else {
+ struct value a;
+ int n = 0; /* print only <last> entries */
+ TBOOLEAN append = FALSE; /* rewrite output file or append it */
+ static char *name = NULL; /* name of the output file; NULL for stdout */
+
+ TBOOLEAN quiet = FALSE;
+ if (!END_OF_COMMAND && almost_equals(c_token,"q$uiet")) {
+ /* option quiet to suppress history entry numbers */
+ quiet = TRUE;
+ c_token++;
+ }
+ /* show history entries */
+ if (!END_OF_COMMAND && isanumber(c_token)) {
+ n = (int)real(const_express(&a));
+ }
+ free(name);
+ if ((name = try_to_get_string())) {
+ if (!END_OF_COMMAND && almost_equals(c_token, "ap$pend")) {
+ append = TRUE;
+ c_token++;
+ }
+ }
+ write_history_n(n, (quiet ? "" : name), (append ? "a" : "w"));
+ }
+
+#else
+ c_token++;
+ int_warn(NO_CARET, "You have to compile gnuplot with builtin readline or GNU readline to enable history support.");
+#endif /* defined(READLINE) || defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE) */
+}
+
+#define REPLACE_ELSE(tok) \
+do { \
+ int idx = token[tok].start_index; \
+ token[tok].length = 1; \
+ gp_input_line[idx++] = ';'; /* e */ \
+ gp_input_line[idx++] = ' '; /* l */ \
+ gp_input_line[idx++] = ' '; /* s */ \
+ gp_input_line[idx++] = ' '; /* e */ \
+} while (0)
+
+#if 0
+#define PRINT_TOKEN(tok) \
+do { \
+ int i; \
+ int end_index = token[tok].start_index + token[tok].length; \
+ for (i = token[tok].start_index; i < end_index && gp_input_line[i]; i++) { \
+ fputc(gp_input_line[i], stderr); \
+ } \
+ fputc('\n', stderr); \
+ fflush(stderr); \
+} while (0)
+#endif
+
+/* process the 'if' command */
+void
+if_command()
+{
+ double exprval;
+ struct value t;
+
+ if_depth++;
+
+ if (!equals(++c_token, "(")) /* no expression */
+ int_error(c_token, "expecting (expression)");
+ exprval = real(const_express(&t));
+ if (exprval != 0.0) {
+ /* fake the condition of a ';' between commands */
+ int eolpos = token[num_tokens - 1].start_index + token[num_tokens - 1].length;
+ --c_token;
+ token[c_token].length = 1;
+ token[c_token].start_index = eolpos + 2;
+ gp_input_line[eolpos + 2] = ';';
+ gp_input_line[eolpos + 3] = NUL;
+
+ if_condition = TRUE;
+ } else {
+ while (c_token < num_tokens) {
+ /* skip over until the next command */
+ while (!END_OF_COMMAND) {
+ ++c_token;
+ }
+ if (++c_token < num_tokens && (equals(c_token, "else"))) {
+ /* break if an "else" was found */
+ if_condition = FALSE;
+ --c_token; /* go back to ';' */
+ return;
+ }
+ }
+ /* no else found */
+ c_token = num_tokens = 0;
+ }
+}
+
+/* process the 'else' command */
+void
+else_command()
+{
+ if (if_depth <= 0) {
+ int_error(c_token, "else without if");
+ return;
+ } else {
+ if_depth--;
+ }
+
+ if (TRUE == if_condition) {
+ /* First part of line was true so
+ * discard the rest of the line. */
+ c_token = num_tokens = 0;
+ } else {
+ REPLACE_ELSE(c_token);
+ if_condition = TRUE;
+ }
+}
+
+
+/* process the 'load' command */
+void
+load_command()
+{
+ FILE *fp;
+ char *save_file;
+
+ c_token++;
+ save_file = try_to_get_string();
+ if (!save_file)
+ int_error(c_token, "expecting filename");
+ if (c_token < num_tokens) { /* not EOL */
+ if (!equals(c_token, ";"))
+ int_error(c_token, "expecting end of line");
+ else if ( c_token + 1 < num_tokens ) /* not EOL even after ';' */
+ int_warn(c_token + 1, "ignoring rest of line");
+ }
+
+ gp_expand_tilde(&save_file);
+ fp = strcmp(save_file, "-") ? loadpath_fopen(save_file, "r") : stdout;
+ load_file(fp, save_file, FALSE);
+ /* gp_input_line[] and token[] now destroyed! */
+ c_token = num_tokens = 0;
+ free(save_file);
+}
+
+
+
+/* null command */
+void
+null_command()
+{
+ return;
+}
+
+
+/* process the 'pause' command */
+void
+pause_command()
+{
+ struct value a;
+ int text = 0;
+ double sleep_time;
+ char *buf = gp_alloc(MAX_LINE_LEN+1, "pause argument");
+
+ c_token++;
+
+ *buf = NUL;
+
+#ifdef USE_MOUSE
+ paused_for_mouse = 0;
+ if (equals(c_token,"mouse")) {
+ sleep_time = -1;
+ c_token++;
+
+/* EAM FIXME - This is not the correct test; what we really want */
+/* to know is whether or not the terminal supports mouse feedback */
+/* if (term_initialised) { */
+ if (mouse_setting.on && term) {
+ struct udvt_entry *current;
+ int end_condition = 0;
+
+ while (!(END_OF_COMMAND)) {
+ if (almost_equals(c_token,"key$press")) {
+ end_condition |= PAUSE_KEYSTROKE;
+ c_token++;
+ } else if (equals(c_token,",")) {
+ c_token++;
+ } else if (equals(c_token,"any")) {
+ end_condition |= PAUSE_ANY;
+ c_token++;
+ } else if (equals(c_token,"button1")) {
+ end_condition |= PAUSE_BUTTON1;
+ c_token++;
+ } else if (equals(c_token,"button2")) {
+ end_condition |= PAUSE_BUTTON2;
+ c_token++;
+ } else if (equals(c_token,"button3")) {
+ end_condition |= PAUSE_BUTTON3;
+ c_token++;
+ } else if (equals(c_token,"close")) {
+ end_condition |= PAUSE_WINCLOSE;
+ c_token++;
+ } else
+ break;
+ }
+
+ if (end_condition)
+ paused_for_mouse = end_condition;
+ else
+ paused_for_mouse = PAUSE_CLICK;
+
+ /* Set the pause mouse return codes to -1 */
+ current = add_udv_by_name("MOUSE_KEY");
+ current->udv_undef = FALSE;
+ Ginteger(¤t->udv_value,-1);
+ current = add_udv_by_name("MOUSE_BUTTON");
+ current->udv_undef = FALSE;
+ Ginteger(¤t->udv_value,-1);
+ } else
+ int_warn(NO_CARET,"Mousing not active");
+ } else
+#endif
+ sleep_time = real(const_express(&a));
+
+ if (!(END_OF_COMMAND)) {
+ if (!isstring(c_token))
+ int_error(c_token, "expecting string");
+ else {
+ quote_str(buf, c_token, MAX_LINE_LEN);
+ ++c_token;
+#ifdef _Windows
+ if (sleep_time >= 0)
+#elif defined(OS2)
+ if (strcmp(term->name, "pm") != 0 || sleep_time >= 0)
+#elif defined(MTOS)
+ if (strcmp(term->name, "mtos") != 0 || sleep_time >= 0)
+#endif /* _Windows */
+ fputs(buf, stderr);
+ text = 1;
+ }
+ }
+ if (sleep_time < 0) {
+#ifdef _Windows
+ if (paused_for_mouse && !graphwin.hWndGraph) {
+ if (interactive) { /* cannot wait for Enter in a non-interactive session without the graph window */
+ char tmp[512];
+ if (buf) fprintf(stderr,"%s\n", buf);
+ fgets(tmp, 512, stdin); /* graphical window not yet initialized, wait for any key here */
+ }
+ } else { /* pausing via graphical windows */
+ int tmp = paused_for_mouse;
+ if (buf && paused_for_mouse) fprintf(stderr,"%s\n", buf);
+ if (!Pause(buf)) {
+ if (!tmp) {
+ free(buf);
+ bail_to_command_line();
+ } else {
+ if (!graphwin.hWndGraph)
+ bail_to_command_line();
+ }
+ }
+ }
+#elif defined(OS2)
+ if (strcmp(term->name, "pm") == 0 && sleep_time < 0) {
+ int rc;
+ if ((rc = PM_pause(buf)) == 0) {
+ /* if (!CallFromRexx)
+ * would help to stop REXX programs w/o raising an error message
+ * in RexxInterface() ...
+ */
+ free(buf);
+ bail_to_command_line();
+ } else if (rc == 2) {
+ fputs(buf, stderr);
+ text = 1;
+ (void) fgets(buf, strlen(buf), stdin);
+ }
+ }
+#elif defined(_Macintosh)
+ if (strcmp(term->name, "macintosh") == 0 && sleep_time < 0)
+ Pause( (int)sleep_time );
+#elif defined(MTOS)
+ if (strcmp(term->name, "mtos") == 0) {
+ int MTOS_pause(char *buf);
+ int rc;
+ if ((rc = MTOS_pause(buf)) == 0)
+ free(buf);
+ bail_to_command_line();
+ else if (rc == 2) {
+ fputs(buf, stderr);
+ text = 1;
+ (void) fgets(buf, strlen(buf), stdin);
+ }
+ } else if (strcmp(term->name, "atari") == 0) {
+ char *line = readline("");
+ if (line)
+ free(line);
+ } else
+ (void) fgets(buf, strlen(buf), stdin);
+#elif defined(ATARI)
+ if (strcmp(term->name, "atari") == 0) {
+ char *line = readline("");
+ if (line)
+ free(line);
+ } else
+ (void) fgets(buf, strlen(buf), stdin);
+#else /* !(_Windows || OS2 || _Macintosh || MTOS || ATARI) */
+#ifdef USE_MOUSE
+ if (term && term->waitforinput) {
+ /* term->waitforinput() will return,
+ * if CR was hit */
+ term->waitforinput();
+ } else {
+#endif /* USE_MOUSE */
+ (void) fgets(buf, sizeof(buf), stdin);
+ /* Hold until CR hit. */
+#ifdef USE_MOUSE
+ }
+#endif /* USE_MOUSE */
+#endif /* !(_Windows || OS2 || _Macintosh || MTOS || ATARI) */
+ }
+ if (sleep_time > 0)
+ GP_SLEEP(sleep_time);
+
+ if (text != 0 && sleep_time >= 0)
+ fputc('\n', stderr);
+ screen_ok = FALSE;
+
+ free(buf);
+
+}
+
+
+/* process the 'plot' command */
+void
+plot_command()
+{
+ plot_token = c_token++;
+ plotted_data_from_stdin = FALSE;
+ SET_CURSOR_WAIT;
+#ifdef USE_MOUSE
+ plot_mode(MODE_PLOT);
+ add_udv_by_name("MOUSE_X")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_Y")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_X2")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_Y2")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_BUTTON")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_SHIFT")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_ALT")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_CTRL")->udv_undef = TRUE;
+#endif
+ plotrequest();
+ SET_CURSOR_ARROW;
+}
+
+
+void
+print_set_output(char *name, TBOOLEAN append_p)
+{
+ if (print_out && print_out != stderr && print_out != stdout) {
+#ifdef PIPES
+ if (print_out_name[0] == '|') {
+ if (0 > pclose(print_out))
+ perror(print_out_name);
+ } else
+#endif
+ if (0 > fclose(print_out))
+ perror(print_out_name);
+ }
+
+ if (print_out_name)
+ free(print_out_name);
+
+ print_out_name = NULL;
+
+ if (! name) {
+ print_out = stderr;
+ return;
+ }
+
+ if (! strcmp(name, "-")) {
+ print_out = stdout;
+ return;
+ }
+
+#ifdef PIPES
+ if (name[0]=='|') {
+ print_out = popen(name + 1, "w");
+ if (!print_out)
+ perror(name);
+ else
+ print_out_name = name;
+ return;
+ }
+#endif
+
+ print_out = fopen(name, append_p ? "a" : "w");
+ if (!print_out) {
+ perror(name);
+ return;
+ }
+
+ print_out_name = name;
+}
+
+char *
+print_show_output()
+{
+ if (print_out==stdout)
+ return "<stdout>";
+ if (!print_out || print_out==stderr || !print_out_name)
+ return "<stderr>";
+ return print_out_name;
+}
+
+/* process the 'print' command */
+void
+print_command()
+{
+ struct value a;
+ /* space printed between two expressions only */
+ int need_space = 0;
+
+ if (!print_out) {
+ print_out = stderr;
+ }
+ screen_ok = FALSE;
+ do {
+#ifdef GP_STRING_VARS
+ ++c_token;
+ const_express(&a);
+ if (a.type == STRING) {
+ fputs(a.v.string_val, print_out);
+ gpfree_string(&a);
+ need_space = 0;
+ } else {
+ if (need_space)
+ putc(' ', print_out);
+ disp_value(print_out, &a, FALSE);
+ need_space = 1;
+ }
+#else
+ char *s;
+ ++c_token;
+ s = try_to_get_string();
+ if (s) {
+ fputs(s, print_out);
+ free(s);
+ need_space = 0;
+ } else {
+ (void) const_express(&a);
+ if (need_space)
+ putc(' ', print_out);
+ disp_value(print_out, &a, FALSE);
+ need_space = 1;
+ }
+#endif
+ } while (!END_OF_COMMAND && equals(c_token, ","));
+
+ (void) putc('\n', print_out);
+ fflush(print_out);
+}
+
+
+/* process the 'pwd' command */
+void
+pwd_command()
+{
+ char *save_file = NULL;
+
+ save_file = (char *) gp_alloc(PATH_MAX, "print current dir");
+ if (save_file) {
+ GP_GETCWD(save_file, PATH_MAX);
+ fprintf(stderr, "%s\n", save_file);
+ free(save_file);
+ }
+ c_token++;
+}
+
+
+/* process the 'replot' command */
+void
+replot_command()
+{
+ if (!*replot_line)
+ int_error(c_token, "no previous plot");
+ /* Disable replot for some reason; currently used by the mouse/hotkey
+ capable terminals to avoid replotting when some data come from stdin,
+ i.e. when plotted_data_from_stdin==1 after plot "-".
+ */
+ if (replot_disabled) {
+ replot_disabled = FALSE;
+#if 1
+ bail_to_command_line(); /* be silent --- don't mess the screen */
+#else
+ int_error(c_token, "cannot replot data coming from stdin");
+#endif
+ }
+ if (!term) /* unknown terminal */
+ int_error(c_token, "use 'set term' to set terminal type first");
+
+ c_token++;
+ SET_CURSOR_WAIT;
+ if (term->flags & TERM_INIT_ON_REPLOT)
+ term->init();
+ replotrequest();
+ SET_CURSOR_ARROW;
+}
+
+
+/* process the 'reread' command */
+void
+reread_command()
+{
+ FILE *fp = lf_top();
+
+ if (fp != (FILE *) NULL)
+ rewind(fp);
+ c_token++;
+}
+
+
+/* process the 'save' command */
+void
+save_command()
+{
+ FILE *fp;
+ char *save_file = NULL;
+ char *save_locale = NULL;
+ int what;
+
+ c_token++;
+ what = lookup_table(&save_tbl[0], c_token);
+
+ switch (what) {
+ case SAVE_FUNCS:
+ case SAVE_SET:
+ case SAVE_TERMINAL:
+ case SAVE_VARS:
+ c_token++;
+ break;
+ default:
+ break;
+ }
+
+ save_file = try_to_get_string();
+ if (!save_file)
+ int_error(c_token, "expecting filename");
+#ifdef PIPES
+ if (save_file[0]=='|')
+ fp = popen(save_file+1,"w");
+ else
+#endif
+ {
+ gp_expand_tilde(&save_file);
+ fp = strcmp(save_file,"-") ? loadpath_fopen(save_file,"w") : stdout;
+ }
+
+ if (!fp)
+ os_error(c_token, "Cannot open save file");
+
+#ifdef HAVE_LOCALE_H
+ /* Make sure that numbers in the saved gnuplot commands use standard form */
+ if (strcmp(localeconv()->decimal_point,".")) {
+ save_locale = gp_strdup(setlocale(LC_NUMERIC,NULL));
+ setlocale(LC_NUMERIC,"C");
+ }
+#endif
+
+ switch (what) {
+ case SAVE_FUNCS:
+ save_functions(fp);
+ break;
+ case SAVE_SET:
+ save_set(fp);
+ break;
+ case SAVE_TERMINAL:
+ save_term(fp);
+ break;
+ case SAVE_VARS:
+ save_variables(fp);
+ break;
+ default:
+ save_all(fp);
+ }
+
+#ifdef HAVE_LOCALE_H
+ if (save_locale) {
+ setlocale(LC_NUMERIC,save_locale);
+ free(save_locale);
+ fprintf(fp, "set decimalsign locale \"%s\"\n", setlocale(LC_NUMERIC,NULL));
+ fprintf(fp, "set decimalsign '%s'\n", decimalsign);
+ }
+#endif
+
+ if (stdout != fp) {
+#ifdef PIPES
+ if (save_file[0] == '|')
+ (void) pclose(fp);
+ else
+#endif
+ (void) fclose(fp);
+ }
+
+ free(save_file);
+}
+
+
+/* process the 'screendump' command */
+void
+screendump_command()
+{
+ c_token++;
+#ifdef _Windows
+ screen_dump();
+#else
+ fputs("screendump not implemented\n", stderr);
+#endif
+}
+
+
+/* set_command() is in set.c */
+
+/* 'shell' command is processed by do_shell(), see below */
+
+/* show_command() is in show.c */
+
+
+/* process the 'splot' command */
+void
+splot_command()
+{
+ plot_token = c_token++;
+ plotted_data_from_stdin = FALSE;
+ SET_CURSOR_WAIT;
+#ifdef USE_MOUSE
+ plot_mode(MODE_SPLOT);
+ add_udv_by_name("MOUSE_X")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_Y")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_X2")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_Y2")->udv_undef = TRUE;
+ add_udv_by_name("MOUSE_BUTTON")->udv_undef = TRUE;
+#endif
+ plot3drequest();
+ SET_CURSOR_ARROW;
+}
+
+
+/* process the 'system' command */
+void
+system_command()
+{
+ char *cmd;
+ ++c_token;
+ cmd = try_to_get_string();
+ do_system(cmd);
+ free(cmd);
+}
+
+
+/* process the 'test palette' command
+ *
+ * note 1: it works on terminals supporting as well as not supporting pm3d
+ * note 2: due to the call to load_file(), the rest of the current command
+ * line after 'test palette ;' is discarded
+ */
+static void
+test_palette_subcommand()
+{
+ enum {test_palette_colors = 256};
+
+ double gray, z[test_palette_colors];
+ rgb_color rgb1[test_palette_colors];
+ int i;
+ static const char pre1[] = "\
+reset;set multi;\
+uns border;uns key;set tic out;uns xtics;uns ytics;\
+se cbtic 0,0.1,1;se cbtic nomirr;\
+se xr[0:1];se yr[0:1];se zr[0:1];se cbr[0:1];\
+se pm3d map;set colorbox hor user orig 0.08,0.07 size 0.79,0.12;";
+ static const char pre2[] = "splot 1/0;\n\n\n";
+ /* note: those \n's are because of x11 terminal problems with blocking pipe */
+ static const char pre3[] = "\
+se size 1,0.8;se orig 0,0.2;uns pm3d;\
+se key outside;se grid;se tics in;se xtics 0,0.1;se ytics 0,0.1;\
+se tit'R,G,B profiles of the current color palette';";
+ static const char post[] = "\
+\n\n\nuns multi;se orig 0,0;se size 1,1;\n"; /* no final 'reset' in favour of mousing */
+ int can_pm3d = (term->make_palette && term->set_color);
+ char *order = "rgb";
+ char *save_replot_line;
+ TBOOLEAN save_is_3d_plot;
+#ifdef WITH_IMAGE
+ TBOOLEAN save_is_cb_plot;
+#endif
+ FILE *f = tmpfile();
+ char *save_locale = NULL;
+
+ c_token++;
+ /* parse optional option */
+ if (!END_OF_COMMAND) {
+ int err = (token[c_token].length != 3);
+
+ order = gp_input_line + token[c_token].start_index;
+ if (!err) {
+ err += (memchr(order, 'r', 3) == NULL);
+ err += (memchr(order, 'g', 3) == NULL);
+ err += (memchr(order, 'b', 3) == NULL);
+ }
+ if (err)
+ int_error(c_token, "combination rgb or gbr or brg etc. expected");
+ c_token++;
+ }
+ if (!f)
+ int_error(NO_CARET, "cannot write temporary file");
+
+#ifdef HAVE_LOCALE_H
+ /* Make sure that numbers in the saved gnuplot commands use standard form */
+ if (strcmp(localeconv()->decimal_point,".")) {
+ save_locale = gp_strdup(setlocale(LC_NUMERIC,NULL));
+ setlocale(LC_NUMERIC,"C");
+ }
+#endif
+
+ /* generate r,g,b curves */
+ for (i = 0; i < test_palette_colors; i++) {
+ /* colours equidistantly from [0,1] */
+ z[i] = (double)i / (test_palette_colors - 1);
+ gray = (sm_palette.positive == SMPAL_NEGATIVE) ? 1-z[i] : z[i];
+ rgb1_from_gray(gray, &rgb1[i]);
+ }
+
+ /* commands to setup the test palette plot */
+ enable_reset_palette = 0;
+ save_replot_line = gp_strdup(replot_line);
+ save_is_3d_plot = is_3d_plot;
+#ifdef WITH_IMAGE
+ save_is_cb_plot = is_cb_plot;
+#endif
+ fputs(pre1, f);
+ if (can_pm3d)
+ fputs(pre2, f);
+ fputs(pre3, f);
+ /* put inline data of the r,g,b curves */
+ fputs("p", f);
+ for (i=0; i<strlen(order); i++) {
+ if (i > 0)
+ fputs(",", f);
+ fputs("'-'tit'", f);
+ switch (order[i]) {
+ case 'r':
+ fputs("red'w l 1", f);
+ break;
+ case 'g':
+ fputs("green'w l 2", f);
+ break;
+ case 'b':
+ fputs("blue'w l 3", f);
+ break;
+ } /* switch(order[i]) */
+ } /* for (i) */
+ fputs("\n", f);
+ for (i = 0; i < 3; i++) {
+ int k, c = order[i];
+
+ for (k = 0; k < test_palette_colors; k++) {
+ double rgb = (c=='r')
+ ? rgb1[k].r :
+ ((c=='g') ? rgb1[k].g : rgb1[k].b);
+
+ fprintf(f, "%0.4f\t%0.4f\n", z[k], rgb);
+ }
+ fputs("e\n", f);
+ }
+ fputs(post, f);
+
+ /* save current gnuplot 'set' status because of the tricky sets
+ * for our temporary testing plot.
+ */
+ save_set(f);
+
+#ifdef HAVE_LOCALE_H
+ if (save_locale) {
+ setlocale(LC_NUMERIC,save_locale);
+ free(save_locale);
+ fprintf(f, "set decimalsign locale \"%s\"\n", setlocale(LC_NUMERIC,NULL));
+ fprintf(f, "set decimalsign '%s'\n", decimalsign);
+ }
+#endif
+
+ /* execute all commands from the temporary file */
+ rewind(f);
+ load_file(f, NULL, FALSE); /* note: it does fclose(f) */
+
+ /* enable reset_palette() and restore replot line */
+ enable_reset_palette = 1;
+ free(replot_line);
+ replot_line = save_replot_line;
+ is_3d_plot = save_is_3d_plot;
+#ifdef WITH_IMAGE
+ is_cb_plot = save_is_cb_plot;
+#endif
+
+ /* further, gp_input_line[] and token[] now destroyed! */
+ c_token = num_tokens = 0;
+}
+
+
+/* process the undocumented 'test time' command
+ * test time 'format' 'string'
+ * to assist testing of time routines
+ */
+static void
+test_time_subcommand()
+{
+ char *format = NULL;
+ char *string = NULL;
+ struct tm tm;
+ double secs;
+
+ /* given a format and a time string, exercise the time code */
+
+ if (isstring(++c_token)) {
+ m_quote_capture(&format, c_token, c_token);
+ if (isstring(++c_token)) {
+ m_quote_capture(&string, c_token, c_token);
+ memset(&tm, 0, sizeof(tm));
+ gstrptime(string, format, &tm);
+ secs = gtimegm(&tm);
+ fprintf(stderr, "internal = %f - %d/%d/%d::%d:%d:%d , wday=%d, yday=%d\n",
+ secs, tm.tm_mday, tm.tm_mon + 1, tm.tm_year % 100,
+ tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday,
+ tm.tm_yday);
+ memset(&tm, 0, sizeof(tm));
+ ggmtime(&tm, secs);
+ gstrftime(string, strlen(string), format, secs);
+ fprintf(stderr, "convert back \"%s\" - %d/%d/%d::%d:%d:%d , wday=%d, yday=%d\n",
+ string, tm.tm_mday, tm.tm_mon + 1, tm.tm_year % 100,
+ tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday,
+ tm.tm_yday);
+ free(string);
+ ++c_token;
+ } /* else: expecting time string */
+ free(format);
+ } /* else: expecting format string */
+}
+
+
+/* process the 'test' command */
+void
+test_command()
+{
+ int what;
+ c_token++;
+ if (END_OF_COMMAND) {
+ test_term();
+ return;
+ }
+
+ what = lookup_table(&test_tbl[0], c_token);
+ switch (what) {
+ case TEST_TERMINAL: test_term(); break;
+ case TEST_PALETTE: test_palette_subcommand(); break;
+ case TEST_TIME: test_time_subcommand(); break;
+ default:
+#if 1
+ int_error(c_token, "none or keyword 'terminal' or 'palette' expected");
+#else
+ /* don't document undocumented command :-) */
+ int_error(c_token, "none or keyword 'terminal', 'palette' or 'time' expected");
+#endif
+ }
+}
+
+
+/* unset_command is in unset.c */
+
+
+/* process the 'update' command */
+void
+update_command()
+{
+ /* old parameter filename */
+ char *opfname = NULL;
+ /* new parameter filename */
+ char *npfname = NULL;
+
+ c_token++;
+ if (!(opfname = try_to_get_string()))
+ int_error(c_token, "Parameter filename expected");
+ if (!END_OF_COMMAND && !(npfname = try_to_get_string()))
+ int_error(c_token, "New parameter filename expected");
+
+ update(opfname, npfname);
+ free(npfname);
+ free(opfname);
+}
+
+
+/* process invalid commands and, on OS/2, REXX commands */
+void
+invalid_command()
+{
+#ifdef OS2
+ if (token[c_token].is_token) {
+ int rc;
+ rc = ExecuteMacro(gp_input_line + token[c_token].start_index,
+ token[c_token].length);
+ if (rc == 0) {
+ c_token = num_tokens = 0;
+ return;
+ }
+ }
+#endif
+ int_error(c_token, "invalid command");
+}
+
+
+/*
+ * Auxiliary routines
+ */
+
+/* used by changedir_command() */
+static int
+changedir(char *path)
+{
+#if defined(MSDOS) || defined(WIN16) || defined(ATARI) || defined(DOS386)
+# if defined(__ZTC__)
+ unsigned dummy; /* it's a parameter needed for dos_setdrive */
+# endif
+
+ /* first deal with drive letter */
+
+ if (isalpha(path[0]) && (path[1] == ':')) {
+ int driveno = toupper(path[0]) - 'A'; /* 0=A, 1=B, ... */
+
+# if defined(ATARI)
+ (void) Dsetdrv(driveno);
+# endif
+
+# if defined(__ZTC__)
+ (void) dos_setdrive(driveno + 1, &dummy);
+# endif
+
+# if (defined(MSDOS) && defined(__EMX__)) || defined(__MSC__)
+ (void) _chdrive(driveno + 1);
+# endif
+
+
+/* HBB: recent versions of DJGPP also have setdisk():,
+ * so I del'ed the special code */
+# if ((defined(MSDOS) || defined(_Windows)) && defined(__TURBOC__)) || defined(DJGPP)
+ (void) setdisk(driveno);
+# endif
+ path += 2; /* move past drive letter */
+ }
+ /* then change to actual directory */
+ if (*path)
+ if (chdir(path))
+ return 1;
+
+ return 0; /* should report error with setdrive also */
+
+#elif defined(WIN32)
+ return !(SetCurrentDirectory(path));
+#elif defined(__EMX__) && defined(OS2)
+ return _chdir2(path);
+#else
+ return chdir(path);
+#endif /* MSDOS, ATARI etc. */
+}
+
+
+/* used by replot_command() */
+void
+replotrequest()
+{
+ if (equals(c_token, "["))
+ int_error(c_token, "cannot set range with replot");
+
+ /* do not store directly into the replot_line string, until the
+ * new plot line has been successfully plotted. This way,
+ * if user makes a typo in a replot line, they do not have
+ * to start from scratch. The replot_line will be committed
+ * after do_plot has returned, whence we know all is well
+ */
+ if (END_OF_COMMAND) {
+ char *rest_args = &gp_input_line[token[c_token].start_index];
+ size_t replot_len = strlen(replot_line);
+ size_t rest_len = strlen(rest_args);
+
+ /* preserve commands following 'replot ;' */
+ /* move rest of input line to the start
+ * necessary because of realloc() in extend_input_line() */
+ memmove(gp_input_line,rest_args,rest_len+1);
+ /* reallocs if necessary */
+ while (gp_input_line_len < replot_len+rest_len+1)
+ extend_input_line();
+ /* move old rest args off begin of input line to
+ * make space for replot_line */
+ memmove(gp_input_line+replot_len,gp_input_line,rest_len+1);
+ /* copy previous plot command to start of input line */
+ memcpy(gp_input_line, replot_line, replot_len);
+ } else {
+ char *replot_args = NULL; /* else m_capture will free it */
+ int last_token = num_tokens - 1;
+
+ /* length = length of old part + length of new part + ", " + \0 */
+ size_t newlen = strlen(replot_line) + token[last_token].start_index +
+ token[last_token].length - token[c_token].start_index + 3;
+
+ m_capture(&replot_args, c_token, last_token); /* might be empty */
+ while (gp_input_line_len < newlen)
+ extend_input_line();
+ strcpy(gp_input_line, replot_line);
+ strcat(gp_input_line, ", ");
+ strcat(gp_input_line, replot_args);
+ free(replot_args);
+ }
+ plot_token = 0; /* whole line to be saved as replot line */
+
+ screen_ok = FALSE;
+ num_tokens = scanner(&gp_input_line, &gp_input_line_len);
+ c_token = 1; /* skip the 'plot' part */
+ if (is_3d_plot)
+ plot3drequest();
+ else
+ plotrequest();
+}
+
+
+/* Is 'set view map' currently working inside 'splot' or not? Calculation of
+ * mouse coordinates and the corresponding routines must know it, because
+ * 'splot' can be either true 3D plot or a 2D map.
+ * This flag is set when entering splot command and 'set view map', i.e. by
+ * splot_map_activate(), and reset when calling splot_map_deactivate().
+ */
+static int splot_map_active = 0;
+/* Store values reset by 'set view map' during splot, used by those two
+ * routines below.
+ */
+static float splot_map_surface_rot_x;
+static float splot_map_surface_rot_z;
+static float splot_map_surface_scale;
+
+/* This routine is called at the beginning of 'splot'. It sets up some splot
+ * parameters needed to present the 'set view map'.
+ */
+void
+splot_map_activate()
+{
+ if (splot_map_active)
+ return;
+ splot_map_active = 1;
+ /* save current values */
+ splot_map_surface_rot_x = surface_rot_x;
+ splot_map_surface_rot_z = surface_rot_z ;
+ splot_map_surface_scale = surface_scale;
+ /* set new values */
+ surface_rot_x = 180;
+ surface_rot_z = 0;
+ surface_scale = 1.3;
+ axis_array[FIRST_Y_AXIS].range_flags ^= RANGE_REVERSE;
+ axis_array[SECOND_Y_AXIS].range_flags ^= RANGE_REVERSE;
+ /* note: ^ is xor */
+}
+
+
+/* This routine is called when the current 'set view map' is no more needed,
+ * i.e., when calling "plot" --- the reversed y-axis et al must still be
+ * available for mousing.
+ */
+void
+splot_map_deactivate()
+{
+ if (!splot_map_active)
+ return;
+ splot_map_active = 0;
+ /* restore the original values */
+ surface_rot_x = splot_map_surface_rot_x;
+ surface_rot_z = splot_map_surface_rot_z;
+ surface_scale = splot_map_surface_scale;
+ axis_array[FIRST_Y_AXIS].range_flags ^= RANGE_REVERSE;
+ axis_array[SECOND_Y_AXIS].range_flags ^= RANGE_REVERSE;
+ /* note: ^ is xor */
+}
+
+
+/* Support for input, shell, and help for various systems */
+
+#ifdef VMS
+
+# include <descrip.h>
+# include <rmsdef.h>
+# include <smgdef.h>
+# include <smgmsg.h>
+# include <ssdef.h>
+
+extern lib$get_input(), lib$put_output();
+extern smg$read_composed_line();
+extern sys$putmsg();
+extern lbr$output_help();
+extern lib$spawn();
+
+int vms_len;
+
+unsigned int status[2] = { 1, 0 };
+
+static char Help[MAX_LINE_LEN+1] = "gnuplot";
+
+$DESCRIPTOR(prompt_desc, PROMPT);
+/* temporary fix until change to variable length */
+struct dsc$descriptor_s line_desc =
+{0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL};
+
+$DESCRIPTOR(help_desc, Help);
+$DESCRIPTOR(helpfile_desc, "GNUPLOT$HELP");
+
+/* HBB 990829: confirmed this to be used on VMS, only --> moved into
+ * the VMS-specific section */
+void
+done(int status)
+{
+ term_reset();
+ exit(status);
+}
+
+/* please note that the vms version of read_line doesn't support variable line
+ length (yet) */
+
+static int
+read_line(const char *prompt)
+{
+ int more, start = 0;
+ char expand_prompt[40];
+
+ current_prompt = prompt; /* HBB NEW 20040727 */
+
+ prompt_desc.dsc$w_length = strlen(prompt);
+ prompt_desc.dsc$a_pointer = (char *) prompt;
+ strcpy(expand_prompt, "_");
+ strncat(expand_prompt, prompt, 38);
+ do {
+ line_desc.dsc$w_length = MAX_LINE_LEN - start;
+ line_desc.dsc$a_pointer = &gp_input_line[start];
+ switch (status[1] = smg$read_composed_line(&vms_vkid, &vms_ktid, &line_desc, &prompt_desc, &vms_len)) {
+ case SMG$_EOF:
+ done(EXIT_SUCCESS); /* ^Z isn't really an error */
+ break;
+ case RMS$_TNS: /* didn't press return in time */
+ vms_len--; /* skip the last character */
+ break; /* and parse anyway */
+ case RMS$_BES: /* Bad Escape Sequence */
+ case RMS$_PES: /* Partial Escape Sequence */
+ sys$putmsg(status);
+ vms_len = 0; /* ignore the line */
+ break;
+ case SS$_NORMAL:
+ break; /* everything's fine */
+ default:
+ done(status[1]); /* give the error message */
+ }
+ start += vms_len;
+ gp_input_line[start] = NUL;
+ inline_num++;
+ if (gp_input_line[start - 1] == '\\') {
+ /* Allow for a continuation line. */
+ prompt_desc.dsc$w_length = strlen(expand_prompt);
+ prompt_desc.dsc$a_pointer = expand_prompt;
+ more = 1;
+ --start;
+ } else {
+ line_desc.dsc$w_length = strlen(gp_input_line);
+ line_desc.dsc$a_pointer = gp_input_line;
+ more = 0;
+ }
+ } while (more);
+ return 0;
+}
+
+
+# ifdef NO_GIH
+void
+help_command()
+{
+ int first = c_token;
+
+ while (!END_OF_COMMAND)
+ ++c_token;
+
+ strcpy(Help, "GNUPLOT ");
+ capture(Help + 8, first, c_token - 1, sizeof(Help) - 9);
+ help_desc.dsc$w_length = strlen(Help);
+ if ((vaxc$errno = lbr$output_help(lib$put_output, 0, &help_desc,
+ &helpfile_desc, 0, lib$get_input)) != SS$_NORMAL)
+ os_error(NO_CARET, "can't open GNUPLOT$HELP");
+}
+# endif /* NO_GIH */
+
+
+void
+do_shell()
+{
+ screen_ok = FALSE;
+ c_token++;
+
+ if ((vaxc$errno = lib$spawn()) != SS$_NORMAL) {
+ os_error(NO_CARET, "spawn error");
+ }
+}
+
+
+static void
+do_system(const char *cmd)
+{
+
+ if (!cmd)
+ return;
+
+ /* gp_input_line is filled by read_line or load_file, but
+ * line_desc length is set only by read_line; adjust now
+ */
+ line_desc.dsc$w_length = strlen(cmd);
+ line_desc.dsc$a_pointer = (char *) cmd;
+
+ if ((vaxc$errno = lib$spawn(&line_desc)) != SS$_NORMAL)
+ os_error(NO_CARET, "spawn error");
+
+ (void) putc('\n', stderr);
+
+}
+#endif /* VMS */
+
+
+#ifdef _Windows
+# ifdef NO_GIH
+void
+help_command()
+{
+
+ if (END_OF_COMMAND)
+ WinHelp(textwin.hWndParent, (LPSTR) winhelpname, HELP_INDEX, (DWORD) NULL);
+ else {
+ char buf[128];
+ int start = ++c_token;
+ while (!(END_OF_COMMAND))
+ c_token++;
+ capture(buf, start, c_token - 1, 128);
+ WinHelp(textwin.hWndParent, (LPSTR) winhelpname, HELP_PARTIALKEY, (DWORD) buf);
+ }
+}
+# endif /* NO_GIH */
+#endif /* _Windows */
+
+
+/*
+ * help_command: (not VMS, although it would work) Give help to the user. It
+ * parses the command line into helpbuf and supplies help for that string.
+ * Then, if there are subtopics available for that key, it prompts the user
+ * with this string. If more input is given, help_command is called
+ * recursively, with argument 0. Thus a more specific help can be supplied.
+ * This can be done repeatedly. If null input is given, the function returns,
+ * effecting a backward climb up the tree.
+ * David Kotz (David.Kotz@Dartmouth.edu) 10/89
+ * drd - The help buffer is first cleared when called with toplevel=1.
+ * This is to fix a bug where help is broken if ^C is pressed whilst in the
+ * help.
+ * Lars - The "int toplevel" argument is gone. I have converted it to a
+ * static variable.
+ *
+ * FIXME - helpbuf is never free()'d
+ */
+
+#ifndef NO_GIH
+void
+help_command()
+{
+ static char *helpbuf = NULL;
+ static char *prompt = NULL;
+ static int toplevel = 1;
+ int base; /* index of first char AFTER help string */
+ int len; /* length of current help string */
+ TBOOLEAN more_help;
+ TBOOLEAN only; /* TRUE if only printing subtopics */
+ TBOOLEAN subtopics; /* 0 if no subtopics for this topic */
+ int start; /* starting token of help string */
+ char *help_ptr; /* name of help file */
+# if defined(SHELFIND)
+ static char help_fname[256] = ""; /* keep helpfilename across calls */
+# endif
+
+# if defined(ATARI) || defined(MTOS)
+ char const *const ext[] = { NULL };
+# endif
+
+ if ((help_ptr = getenv("GNUHELP")) == (char *) NULL)
+# ifndef SHELFIND
+ /* if can't find environment variable then just use HELPFILE */
+
+/* patch by David J. Liu for getting GNUHELP from home directory */
+# if (defined(__TURBOC__) && (defined(MSDOS) || defined(DOS386))) || defined(__DJGPP__)
+ help_ptr = HelpFile;
+# else
+# if defined(ATARI) || defined(MTOS)
+ {
+ /* I hope findfile really can accept a NULL argument ... */
+ if ((help_ptr = findfile(HELPFILE, user_gnuplotpath, ext)) == NULL)
+ help_ptr = findfile(HELPFILE, getenv("PATH"), ext);
+ if (!help_ptr)
+ help_ptr = HELPFILE;
+ }
+# else
+ help_ptr = HELPFILE;
+# endif /* ATARI || MTOS */
+# endif /* __TURBOC__ */
+#ifdef OS2
+ {
+ /* look in the path where the executable lives */
+ static char buf[MAXPATHLEN];
+ char *ptr;
+
+ _execname(buf, sizeof(buf));
+ _fnslashify(buf);
+ ptr=strrchr(buf, '/');
+ if (ptr) {
+ *(ptr+1)='\0';
+ strcat(buf, HELPFILE);
+ help_ptr=&buf[0];
+ }
+ else
+ help_ptr = HELPFILE;
+ }
+#endif
+/* end of patch - DJL */
+
+# else /* !SHELFIND */
+ /* try whether we can find the helpfile via shell_find. If not, just
+ use the default. (tnx Andreas) */
+
+ if (!strchr(HELPFILE, ':') && !strchr(HELPFILE, '/') &&
+ !strchr(HELPFILE, '\\')) {
+ if (strlen(help_fname) == 0) {
+ strcpy(help_fname, HELPFILE);
+ if (shel_find(help_fname) == 0) {
+ strcpy(help_fname, HELPFILE);
+ }
+ }
+ help_ptr = help_fname;
+ } else {
+ help_ptr = HELPFILE;
+ }
+# endif /* !SHELFIND */
+
+ /* Since MSDOS DGROUP segment is being overflowed we can not allow such */
+ /* huge static variables (1k each). Instead we dynamically allocate them */
+ /* on the first call to this function... */
+ if (helpbuf == NULL) {
+ helpbuf = gp_alloc(MAX_LINE_LEN, "help buffer");
+ prompt = gp_alloc(MAX_LINE_LEN, "help prompt");
+ helpbuf[0] = prompt[0] = 0;
+ }
+ if (toplevel)
+ helpbuf[0] = prompt[0] = 0; /* in case user hit ^c last time */
+
+ /* if called recursively, toplevel == 0; toplevel must == 1 if called
+ * from command() to get the same behaviour as before when toplevel
+ * supplied as function argument
+ */
+ toplevel = 1;
+
+ len = base = strlen(helpbuf);
+
+ start = ++c_token;
+
+ /* find the end of the help command */
+ while (!(END_OF_COMMAND))
+ c_token++;
+
+ /* copy new help input into helpbuf */
+ if (len > 0)
+ helpbuf[len++] = ' '; /* add a space */
+ capture(helpbuf + len, start, c_token - 1, MAX_LINE_LEN - len);
+ squash_spaces(helpbuf + base); /* only bother with new stuff */
+ lower_case(helpbuf + base); /* only bother with new stuff */
+ len = strlen(helpbuf);
+
+ /* now, a lone ? will print subtopics only */
+ if (strcmp(helpbuf + (base ? base + 1 : 0), "?") == 0) {
+ /* subtopics only */
+ subtopics = 1;
+ only = TRUE;
+ helpbuf[base] = NUL; /* cut off question mark */
+ } else {
+ /* normal help request */
+ subtopics = 0;
+ only = FALSE;
+ }
+
+ switch (help(helpbuf, help_ptr, &subtopics)) {
+ case H_FOUND:{
+ /* already printed the help info */
+ /* subtopics now is true if there were any subtopics */
+ screen_ok = FALSE;
+
+ do {
+ if (subtopics && !only) {
+ /* prompt for subtopic with current help string */
+ if (len > 0) {
+ strcpy (prompt, "Subtopic of ");
+ strncat (prompt, helpbuf, MAX_LINE_LEN - 16);
+ strcat (prompt, ": ");
+ } else
+ strcpy(prompt, "Help topic: ");
+ read_line(prompt);
+ num_tokens = scanner(&gp_input_line, &gp_input_line_len);
+ c_token = 0;
+ more_help = !(END_OF_COMMAND);
+ if (more_help) {
+ c_token--;
+ toplevel = 0;
+ /* base for next level is all of current helpbuf */
+ help_command();
+ }
+ } else
+ more_help = FALSE;
+ } while (more_help);
+
+ break;
+ }
+ case H_NOTFOUND:
+ printf("Sorry, no help for '%s'\n", helpbuf);
+ break;
+ case H_ERROR:
+ perror(help_ptr);
+ break;
+ default:
+ int_error(NO_CARET, "Impossible case in switch");
+ break;
+ }
+
+ helpbuf[base] = NUL; /* cut it off where we started */
+}
+#endif /* !NO_GIH */
+
+#ifndef VMS
+
+static void
+do_system(const char *cmd)
+{
+# ifdef AMIGA_AC_5
+ static char *parms[80];
+ if (!cmd)
+ return;
+ getparms(input_line + 1, parms);
+ fexecv(parms[0], parms);
+# elif (defined(ATARI) && defined(__GNUC__))
+/* || (defined(MTOS) && defined(__GNUC__)) */
+ /* use preloaded shell, if available */
+ short (*shell_p) (char *command);
+ void *ssp;
+
+ if (!cmd)
+ return;
+
+ ssp = (void *) Super(NULL);
+ shell_p = *(short (**)(char *)) 0x4f6;
+ Super(ssp);
+
+ /* this is a bit strange, but we have to have a single if */
+ if (shell_p)
+ (*shell_p) (cmd);
+ else
+ system(cmd);
+# elif defined(_Windows) && defined(USE_OWN_WINSYSTEM_FUNCTION)
+ if (!cmd)
+ return;
+ winsystem(cmd);
+# else /* !(AMIGA_AC_5 || ATARI && __GNUC__ || _Windows) */
+/* (am, 19980929)
+ * OS/2 related note: cmd.exe returns 255 if called w/o argument.
+ * i.e. calling a shell by "!" will always end with an error message.
+ * A workaround has to include checking for EMX,OS/2, two environment
+ * variables,...
+ */
+ if (!cmd)
+ return;
+ system(cmd);
+# endif /* !(AMIGA_AC_5 || ATARI&&__GNUC__ || _Windows) */
+}
+
+
+# ifdef AMIGA_AC_5
+/******************************************************************************
+ * Parses the command string (for fexecv use) and converts the first token
+ * to lower case
+ *****************************************************************************/
+static void
+getparms(char *command, char **parms)
+{
+ static char strg0[256];
+ int i = 0, j = 0, k = 0; /* A bunch of indices */
+
+ while (command[j] != NUL) { /* Loop on string characters */
+ parms[k++] = strg0 + i;
+ while (command[j] == ' ')
+ ++j;
+ while (command[j] != ' ' && command[j] != NUL) {
+ if (command[j] == '"') { /* Get quoted string */
+ do {
+ strg0[i++] = command[j++];
+ } while (command[j] != '"' && command[j] != NUL);
+ }
+ strg0[i++] = command[j++];
+ }
+ if (strg0[i] != NUL)
+ strg0[i++] = NUL; /* NUL terminate every token */
+ }
+ parms[k] = NUL;
+
+ /* Convert to lower case */
+ /* FIXME HBB 20010621: do we really want to stop on char *before*
+ * the actual end of the string strg0[]? */
+ for (k=0; strg0[k+1] != NUL; k++)
+ if (strg0[k] >= 'A' && (strg0[k] <= 'Z'))
+ strg0[k] += ('a' - 'A');
+}
+
+# endif /* AMIGA_AC_5 */
+
+
+# if defined(READLINE) || defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE)
+/* keep some compilers happy */
+static char *rlgets __PROTO((char *s, size_t n, const char *prompt));
+
+static char *
+rlgets(char *s, size_t n, const char *prompt)
+{
+ static char *line = (char *) NULL;
+ static int leftover = -1; /* index of 1st char leftover from last call */
+
+ if (leftover == -1) {
+ /* If we already have a line, first free it */
+ if (line != (char *) NULL) {
+ free(line);
+ line = NULL;
+ /* so that ^C or int_error during readline() does
+ * not result in line being free-ed twice */
+ }
+ line = readline_ipc((interactive) ? prompt : "");
+ leftover = 0;
+ /* If it's not an EOF */
+ if (line && *line) {
+#if defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE)
+ int found;
+ /* Initialize readline history functions */
+ using_history();
+
+ /* search in the history for entries containing line.
+ * They may have other tokens before and after line, hence
+ * the check on strcmp below. */
+ found = history_search(line, -1);
+ if (found != -1 && !strcmp(current_history()->line,line)) {
+ /* this line is already in the history, remove the earlier entry */
+#if defined(HAVE_LIBREADLINE)
+ HIST_ENTRY *removed = remove_history(where_history());
+ /* according to history docs we are supposed to free the stuff */
+ if (removed->line) free(removed->line);
+ if (removed->data) free(removed->data);
+ free(removed);
+#else
+ remove_history(where_history());
+#endif /* !HAVE_LIBREADLINE */
+ }
+ add_history(line);
+# else /* !HAVE_LIBREADLINE && !HAVE_LIBEDITLINE */
+ add_history(line);
+# endif
+ }
+ }
+ if (line) {
+ /* s will be NUL-terminated here */
+ safe_strncpy(s, line + leftover, n);
+ leftover += strlen(s);
+ if (line[leftover] == NUL)
+ leftover = -1;
+ return s;
+ }
+ return NULL;
+}
+# endif /* READLINE || HAVE_LIBREADLINE */
+
+
+# if defined(MSDOS) || defined(_Windows) || defined(DOS386)
+void
+do_shell()
+{
+ screen_ok = FALSE;
+ c_token++;
+
+ if (user_shell) {
+# if defined(_Windows)
+ if (WinExec(user_shell, SW_SHOWNORMAL) <= 32)
+# elif defined(DJGPP)
+ if (system(user_shell) == -1)
+# else
+ if (spawnl(P_WAIT, user_shell, NULL) == -1)
+# endif /* !(_Windows || DJGPP) */
+ os_error(NO_CARET, "unable to spawn shell");
+ }
+}
+
+# elif defined(AMIGA_SC_6_1)
+
+void
+do_shell()
+{
+ screen_ok = FALSE;
+ c_token++;
+
+ if (user_shell) {
+ if (system(user_shell))
+ os_error(NO_CARET, "system() failed");
+ }
+ (void) putc('\n', stderr);
+}
+
+# elif defined(OS2)
+
+void
+do_shell()
+{
+ screen_ok = FALSE;
+ c_token++;
+
+ if (user_shell) {
+ if (system(user_shell) == -1)
+ os_error(NO_CARET, "system() failed");
+
+ }
+ (void) putc('\n', stderr);
+}
+
+# else /* !OS2 */
+
+/* plain old Unix */
+
+#define EXEC "exec "
+void
+do_shell()
+{
+ static char exec[100] = EXEC;
+
+ screen_ok = FALSE;
+ c_token++;
+
+ if (user_shell) {
+ if (system(safe_strncpy(&exec[sizeof(EXEC) - 1], user_shell,
+ sizeof(exec) - sizeof(EXEC) - 1)))
+ os_error(NO_CARET, "system() failed");
+ }
+ (void) putc('\n', stderr);
+}
+
+# endif /* !MSDOS */
+
+/* read from stdin, everything except VMS */
+
+# if !defined(READLINE) && !defined(HAVE_LIBREADLINE) && !defined(HAVE_LIBEDITLINE)
+# if (defined(MSDOS) || defined(DOS386)) && !defined(_Windows) && !defined(__EMX__) && !defined(DJGPP)
+
+/* if interactive use console IO so CED will work */
+
+#define PUT_STRING(s) cputs(s)
+#define GET_STRING(s,l) ((interactive) ? cgets_emu(s,l) : fgets(s,l,stdin))
+
+# ifdef __TURBOC__
+/* cgets implemented using dos functions */
+/* Maurice Castro 22/5/91 */
+static char *doscgets __PROTO((char *));
+
+static char *
+doscgets(char *s)
+{
+ long datseg;
+
+ /* protect and preserve segments - call dos to do the dirty work */
+ datseg = _DS;
+
+ _DX = FP_OFF(s);
+ _DS = FP_SEG(s);
+ _AH = 0x0A;
+ geninterrupt(33);
+ _DS = datseg;
+
+ /* check for a carriage return and then clobber it with a null */
+ if (s[s[1] + 2] == '\r')
+ s[s[1] + 2] = 0;
+
+ /* return the input string */
+ return (&(s[2]));
+}
+# endif /* __TURBOC__ */
+
+# ifdef __ZTC__
+void
+cputs(char *s)
+{
+ int i = 0;
+ while (s[i] != NUL)
+ bdos(0x02, s[i++], NULL);
+}
+
+char *
+cgets(char *s)
+{
+ bdosx(0x0A, s, NULL);
+
+ if (s[s[1] + 2] == '\r')
+ s[s[1] + 2] = 0;
+
+ /* return the input string */
+ return (&(s[2]));
+}
+# endif /* __ZTC__ */
+
+/* emulate a fgets like input function with DOS cgets */
+char *
+cgets_emu(char *str, int len)
+{
+ static char buffer[128] = "";
+ static int leftover = 0;
+
+ if (buffer[leftover] == NUL) {
+ buffer[0] = 126;
+# ifdef __TURBOC__
+ doscgets(buffer);
+# else
+ cgets(buffer);
+# endif
+ fputc('\n', stderr);
+ if (buffer[2] == 26)
+ return NULL;
+ leftover = 2;
+ }
+ safe_strncpy(str, buffer + leftover, len);
+ leftover += strlen(str);
+ return str;
+}
+# else /* !plain DOS */
+
+# define PUT_STRING(s) fputs(s, stderr)
+# define GET_STRING(s,l) fgets(s, l, stdin)
+
+# endif /* !plain DOS */
+# endif /* !READLINE && !HAVE_LIBREADLINE) */
+
+/* this function is called for non-interactive operation. Its usage is
+ * like fgets(), but additionally it checks for ipc events from the
+ * terminals waitforinput() (if USE_MOUSE, and terminal is
+ * mouseable). This function will be used when reading from a pipe.
+ * fgets() reads in at most one less than size characters from stream and
+ * stores them into the buffer pointed to by s.
+ * Reading stops after an EOF or a newline. If a newline is read, it is
+ * stored into the buffer. A '\0' is stored after the last character in
+ * the buffer. */
+static char*
+fgets_ipc(
+ char *dest, /* string to fill */
+ int len) /* size of it */
+{
+#ifdef USE_MOUSE
+ if (term && term->waitforinput) {
+ /* This a mouseable terminal --- must expect input from it */
+ int c; /* char got from waitforinput() */
+ size_t i=0; /* position inside dest */
+
+ dest[0] = '\0';
+ for (i=0; i < len-1; i++) {
+ c = term->waitforinput();
+ if ('\n' == c) {
+ dest[i] = '\n';
+ i++;
+ break;
+ } else if (EOF == c) {
+ dest[i] = '\0';
+ return (char*) 0;
+ } else {
+ dest[i] = c;
+ }
+ }
+ dest[i] = '\0';
+ return dest;
+ } else
+#endif
+ return fgets(dest, len, stdin);
+}
+
+/* Non-VMS version */
+static int
+read_line(const char *prompt)
+{
+ int start = 0;
+ TBOOLEAN more = FALSE;
+ int last = 0;
+
+ current_prompt = prompt; /* HBB NEW 20040727 */
+
+# if !defined(READLINE) && !defined(HAVE_LIBREADLINE) && !defined(HAVE_LIBEDITLINE)
+ if (interactive)
+ PUT_STRING(prompt);
+# endif /* no READLINE */
+
+ do {
+ /* grab some input */
+# if defined(READLINE) || defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE)
+ if (((interactive)
+ ? rlgets(gp_input_line + start, gp_input_line_len - start,
+ ((more) ? "> " : prompt))
+ : fgets_ipc(gp_input_line + start, gp_input_line_len - start)
+ ) == (char *) NULL)
+# else /* !(READLINE || HAVE_LIBREADLINE) */
+ if (GET_STRING(gp_input_line + start, gp_input_line_len - start)
+ == (char *) NULL)
+# endif /* !(READLINE || HAVE_LIBREADLINE) */
+ {
+ /* end-of-file */
+ if (interactive)
+ (void) putc('\n', stderr);
+ gp_input_line[start] = NUL;
+ inline_num++;
+ if (start > 0) /* don't quit yet - process what we have */
+ more = FALSE;
+ else
+ return (1); /* exit gnuplot */
+ } else {
+ /* normal line input */
+ /* gp_input_line must be NUL-terminated for strlen not to pass the
+ * the bounds of this array */
+ last = strlen(gp_input_line) - 1;
+ if (last >= 0) {
+ if (gp_input_line[last] == '\n') { /* remove any newline */
+ gp_input_line[last] = NUL;
+ /* Watch out that we don't backup beyond 0 (1-1-1) */
+ if (last > 0)
+ --last;
+ } else if (last + 2 >= gp_input_line_len) {
+ extend_input_line();
+ /* read rest of line, don't print "> " */
+ start = last + 1;
+ more = TRUE;
+ continue;
+ /* else fall through to continuation handling */
+ } /* if(grow buffer?) */
+ if (gp_input_line[last] == '\\') {
+ /* line continuation */
+ start = last;
+ more = TRUE;
+ } else
+ more = FALSE;
+ } else
+ more = FALSE;
+ }
+# if !defined(READLINE) && !defined(HAVE_LIBREADLINE) && !defined(HAVE_LIBEDITLINE)
+ if (more && interactive)
+ PUT_STRING("> ");
+# endif
+ } while (more);
+ return (0);
+}
+
+#endif /* !VMS */
+
+#if defined(_Windows)
+# if defined(USE_OWN_WINSYSTEM_FUNCTION)
+/* there is a system like call on MS Windows but it is a bit difficult to
+ use, so we will invoke the command interpreter and use it to execute the
+ commands */
+static int
+winsystem(const char *s)
+{
+ LPSTR comspec;
+ LPSTR execstr;
+ LPCSTR p;
+
+ /* get COMSPEC environment variable */
+# ifdef WIN32
+ char envbuf[81];
+ GetEnvironmentVariable("COMSPEC", envbuf, 80);
+ if (*envbuf == NUL)
+ comspec = "\\command.com";
+ else
+ comspec = envbuf;
+# else
+ p = GetDOSEnvironment();
+ comspec = "\\command.com";
+ while (*p) {
+ if (!strncmp(p, "COMSPEC=", 8)) {
+ comspec = p + 8;
+ break;
+ }
+ p += strlen(p) + 1;
+ }
+# endif
+ /* if the command is blank we must use command.com */
+ p = s;
+ while ((*p == ' ') || (*p == '\n') || (*p == '\r'))
+ p++;
+ if (*p == NUL) {
+ WinExec(comspec, SW_SHOWNORMAL);
+ } else {
+ /* attempt to run the windows/dos program via windows */
+ if (WinExec(s, SW_SHOWNORMAL) <= 32) {
+ /* attempt to run it as a dos program from command line */
+ execstr = gp_alloc(strlen(s) + strlen(comspec) + 6,
+ "winsystem cmdline");
+ strcpy(execstr, comspec);
+ strcat(execstr, " /c ");
+ strcat(execstr, s);
+ WinExec(execstr, SW_SHOWNORMAL);
+ free(execstr);
+ }
+ }
+
+ /* regardless of the reality return OK - the consequences of */
+ /* failure include shutting down Windows */
+ return (0); /* success */
+}
+# endif /* USE_OWN_WINSYSTEM_FUNCTION */
+
+void
+call_kill_pending_Pause_dialog()
+{
+ kill_pending_Pause_dialog();
+}
+#endif /* _Windows */
+
+#ifdef GP_MACROS
+/*
+ * Walk through the input line looking for string variables preceded by @.
+ * Replace the characters @<varname> with the contents of the string.
+ * Anything inside quotes is not expanded.
+ */
+
+#define COPY_CHAR gp_input_line[o++] = *c; \
+ after_backslash = FALSE;
+static int
+string_expand()
+{
+ TBOOLEAN in_squote = FALSE;
+ TBOOLEAN in_dquote = FALSE;
+ TBOOLEAN after_backslash = FALSE;
+ TBOOLEAN in_comment= FALSE;
+ int len;
+ int o = 0;
+ int nfound = 0;
+ char *c;
+ char *temp_string;
+ char temp_char;
+ char *m;
+ struct udvt_entry *udv;
+
+ /* Most lines have no macros */
+ if (!strchr(gp_input_line,'@'))
+ return(0);
+
+ temp_string = gp_alloc(gp_input_line_len,"string variable");
+ len = strlen(gp_input_line);
+ if (len >= gp_input_line_len) len = gp_input_line_len-1;
+ strncpy(temp_string,gp_input_line,len);
+ temp_string[len] = '\0';
+
+ for (c=temp_string; len && c && *c; c++, len--) {
+ switch (*c) {
+ case '@': /* The only tricky bit */
+ if (!in_squote && !in_dquote && !in_comment && isalpha(c[1])) {
+ /* Isolate the udv key as a null-terminated substring */
+ m = ++c;
+ while (isalnum(*c) || (*c=='_')) c++;
+ temp_char = *c; *c = '\0';
+ /* Look up the key and restore the original following char */
+ udv = add_udv_by_name(m);
+ if (udv && udv->udv_value.type == STRING) {
+ nfound++;
+ m = udv->udv_value.v.string_val;
+ FPRINTF((stderr,"Replacing @%s with \"%s\"\n",udv->udv_name,m));
+ while (strlen(m) + o + len > gp_input_line_len)
+ extend_input_line();
+ while (*m)
+ gp_input_line[o++] = (*m++);
+ } else {
+ int_warn( NO_CARET, "%s is not a string variable",m);
+ }
+ *c-- = temp_char;
+ } else
+ COPY_CHAR;
+ break;
+
+ case '"':
+ if (!after_backslash)
+ in_dquote = !in_dquote;
+ COPY_CHAR; break;
+ case '\'':
+ in_squote = !in_squote;
+ COPY_CHAR; break;
+ case '\\':
+ if (in_dquote)
+ after_backslash = !after_backslash;
+ gp_input_line[o++] = *c; break;
+ case '#':
+ if (!in_squote && !in_dquote)
+ in_comment = TRUE;
+ default :
+ COPY_CHAR; break;
+ }
+ }
+ gp_input_line[o] = '\0';
+ free(temp_string);
+
+ if (nfound)
+ FPRINTF((stderr,
+ "After string substitution command line is:\n\t%s\n",
+ gp_input_line));
+
+ return(nfound);
+}
+#endif
+
+/* much more than what can be useful */
+#define MAX_TOTAL_LINE_LEN (1024 * MAX_LINE_LEN)
+
+int
+do_system_func(const char *cmd, char **output)
+{
+
+#if defined(VMS) || defined(PIPES) || (defined(ATARI) || defined(MTOS)) && defined(__PUREC__)
+ int c;
+ FILE *f;
+ size_t cmd_len;
+ int result_allocated, result_pos;
+ char* result;
+ int ierr = 0;
+# ifdef AMIGA_AC_5
+ int fd;
+# elif (defined(ATARI) || defined(MTOS)) && defined(__PUREC__)
+ char *atari_tmpfile, *atari_cmd;
+# elif defined(VMS)
+ int chan, one = 1;
+ struct dsc$descriptor_s pgmdsc = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
+ static $DESCRIPTOR(lognamedsc, "PLOT$MAILBOX");
+# endif /* VMS */
+
+ cmd_len = strlen(cmd);
+
+ /* open stream */
+# ifdef VMS
+ pgmdsc.dsc$a_pointer = cmd;
+ pgmdsc.dsc$w_length = cmd_len;
+ if (!((vaxc$errno = sys$crembx(0, &chan, 0, 0, 0, 0, &lognamedsc)) & 1))
+ os_error(NO_CARET, "sys$crembx failed");
+
+ if (!((vaxc$errno = lib$spawn(&pgmdsc, 0, &lognamedsc, &one)) & 1))
+ os_error(NO_CARET, "lib$spawn failed");
+
+ if ((f = fopen("PLOT$MAILBOX", "r")) == NULL)
+ os_error(NO_CARET, "mailbox open failed");
+# elif (defined(ATARI) || defined(MTOS)) && defined(__PUREC__)
+ if (system(NULL) == 0)
+ os_error(NO_CARET, "no command shell");
+ atari_tmpfile = tmpnam(NULL);
+ atari_cmd = gp_alloc(cmd_len + 5 + strlen(atari_tmpfile),
+ "command string");
+ strcpy(atari_cmd, cmd);
+ strcat(atari_cmd, " >> ");
+ strcat(atari_cmd, atari_tmpfile);
+ system(atari_cmd);
+ free(atari_cmd);
+ if ((f = fopen(atari_tmpfile, "r")) == NULL)
+# elif defined(AMIGA_AC_5)
+ if ((fd = open(cmd, "O_RDONLY")) == -1)
+# else /* everyone else */
+ if ((f = popen(cmd, "r")) == NULL)
+ os_error(NO_CARET, "popen failed");
+# endif /* everyone else */
+
+ /* get output */
+ result_pos = 0;
+ result_allocated = MAX_LINE_LEN;
+ result = gp_alloc(MAX_LINE_LEN, "do_system_func");
+ result[0] = NUL;
+ while (1) {
+# if defined(AMIGA_AC_5)
+ char ch;
+ if (read(fd, &ch, 1) != 1)
+ break;
+ c = ch;
+# else
+ if ((c = getc(f)) == EOF)
+ break;
+# endif /* !AMIGA_AC_5 */
+ /* result <- c */
+ result[result_pos++] = c;
+ if ( result_pos == result_allocated ) {
+ if ( result_pos >= MAX_TOTAL_LINE_LEN ) {
+ result_pos--;
+ int_warn(NO_CARET,
+ "*very* long system call output has been truncated");
+ break;
+ } else {
+ result = gp_realloc(result, result_allocated + MAX_LINE_LEN,
+ "extend in do_system_func");
+ result_allocated += MAX_LINE_LEN;
+ }
+ }
+ }
+ result[result_pos] = NUL;
+
+ /* close stream */
+# ifdef AMIGA_AC_5
+ (void) close(fd);
+# elif (defined(ATARI) || defined(MTOS)) && defined(__PUREC__)
+ (void) fclose(f);
+ (void) unlink(atari_tmpfile);
+# else /* Rest of the world */
+ ierr = pclose(f);
+# endif
+
+ result = gp_realloc(result, strlen(result)+1, "do_system_func");
+ *output = result;
+ return ierr;
+
+#else /* VMS || PIPES || ATARI && PUREC */
+
+ int_warn(NO_CARET, "system evaluation not supported by %s", OS);
+ *output = gp_strdup("");
+ return 0;
+
+#endif /* VMS || PIPES || ATARI && PUREC */
+
+}
projects / gnuplot / blobdiff