#ifndef lint

static char *RCSid() { return RCSid("$Id: command.c,v 1.225 2011/09/08 05:19:07 sfeam Exp $"); }

#include "command.h"

#include "axis.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"

int paused_for_mouse = 0;

#define PROMPT "gnuplot> "

#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"

# ifdef USE_OWN_WINSYSTEM_FUNCTION

static int winsystem __PROTO((const char *));

#endif /* _Windows */

#ifdef _Windows

# include <windows.h>

# ifdef __MSC__

# include <malloc.h>

# include <direct.h> /* getcwd() */

# include <alloc.h>

# ifndef __WATCOMC__

# include <dir.h> /* setdisk() */

# endif /* !MSC */

# ifdef WITH_HTML_HELP

# include <htmlhelp.h>

# 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 void command __PROTO((void));

static int changedir __PROTO((char *path));

static char* fgets_ipc __PROTO((char* dest, int len));

static char* gp_get_string __PROTO((char *, size_t, const char *));

static int read_line __PROTO((const char *prompt, int start));

static void do_system __PROTO((const char *));

static void test_palette_subcommand __PROTO((void));

static void test_time_subcommand __PROTO((void));

static int find_clause __PROTO((int *, int *));

#ifdef GP_MACROS

TBOOLEAN expand_macros = FALSE;

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;

char *replot_line;

int plot_token; /* start of 'plot' command */

TBOOLEAN replot_disabled = FALSE;

FILE *print_out = NULL;

char *print_out_name = NULL;

int num_tokens, c_token;

int if_depth = 0;

TBOOLEAN if_condition = FALSE;

TBOOLEAN if_open_for_else = FALSE;

static int clause_depth = 0;

static int command_exit_status = 0;

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));

}

}

#define MAX_TOKENS 400

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, 0) );

thread_rl_Running = 0;

DosPostEventSem(semInputReady);

}

#endif /* OS2_IPC */

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> ", 0))

return (1);

} else {

#if defined(OS2_IPC) && defined(USE_MOUSE)

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);

}

strcpy(gp_input_line, input_line_SharedMem);

input_line_SharedMem[0] = 0;

thread_rl_RetCode = 0;

}

if (thread_rl_RetCode)

return (1);

#else /* The normal case */

if (read_line(PROMPT, 0))

return (1);

#endif /* defined(OS2_IPC) && defined(USE_MOUSE) */

}

/* So we can flag any new output: if false at time of error,

screen_ok = interactive;

if (do_line())

return (1);

else

return (0);

}

do_line()

{

/* Line continuation has already been handled by read_line() */

char *inlptr;

#ifdef GP_MACROS

/* Expand any string variables in the current input line.

if (expand_macros)

if (string_expand_macros() && string_expand_macros()

&& string_expand_macros() && string_expand_macros())

int_error(NO_CARET, "Too many levels of nested macros");

/* Skip leading whitespace */

inlptr = gp_input_line;

while (isspace((unsigned char) *inlptr))

inlptr++;

/* Strip off trailing comment */

FPRINTF((stderr,"doline( \"%s\" )\n", gp_input_line));

if (strchr(inlptr, '#')) {

num_tokens = scanner(&gp_input_line, &gp_input_line_len);

if (gp_input_line[token[num_tokens].start_index] == '#')

gp_input_line[token[num_tokens].start_index] = NUL;

}

if (inlptr != gp_input_line) {

/* If there was leading whitespace, copy the actual

memmove(gp_input_line, inlptr, strlen(inlptr));

/* Terminate resulting string */

gp_input_line[strlen(inlptr)] = NUL;

}

FPRINTF((stderr, " echo: \"%s\"\n", gp_input_line));

/* EAM May 2011 - This will not work in a bracketed clause. Should it? */

if (is_system(gp_input_line[0])) {

do_system(gp_input_line + 1);

return (0);

}

#if 0

/* EAM May 2011 */

/* Resetting here prevents handling "else" on a separate line */

if_condition = TRUE;

if_depth = 0;

num_tokens = scanner(&gp_input_line, &gp_input_line_len);

/*

if (curly_brace_count < 0)

int_error(NO_CARET,"Unexpected }");

while (curly_brace_count > 0) {

strcat(gp_input_line,";");

read_line("more> ", strlen(gp_input_line));

num_tokens = scanner(&gp_input_line, &gp_input_line_len);

if (gp_input_line[token[num_tokens].start_index] == '#')

gp_input_line[token[num_tokens].start_index] = NUL;

}

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 if (equals(c_token, "{")) {

begin_clause();

} else if (equals(c_token, "}")) {

end_clause();

} else

int_error(c_token, "';' expected");

}

}

return (0);

}

do_string(const char *s)

{

char *cmdline = gp_strdup(s);

do_string_and_free(cmdline);

}

do_string_and_free(char *cmdline)

{

#ifdef USE_MOUSE

if (display_ipc_commands())

fprintf(stderr, "%s\n", cmdline);

lf_push(NULL, NULL, cmdline); /* save state for errors and recursion */

while (gp_input_line_len < strlen(cmdline) + 1)

extend_input_line();

strcpy(gp_input_line, cmdline);

screen_ok = FALSE;

do_line();

/* We don't know if screen_ok is appropriate so leave it FALSE. */

lf_pop();

}

#ifdef USE_MOUSE

toggle_display_of_ipc_commands()

{

if (mouse_setting.verbose)

mouse_setting.verbose = 0;

else

mouse_setting.verbose = 1;

}

display_ipc_commands()

{

return mouse_setting.verbose;

}

do_string_replot(const char *s)

{

do_string(s);

#ifdef VOLATILE_REFRESH

if (volatile_data && refresh_ok) {

if (display_ipc_commands())

fprintf(stderr, "refresh\n");

refresh_request();

} else

if (!replot_disabled)

replotrequest();

else

int_warn(NO_CARET, "refresh not possible and replot is disabled");

}

restore_prompt()

{

if (interactive) {

#if defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDITLINE)

# if !defined(MISSING_RL_FORCED_UPDATE_DISPLAY)

rl_forced_update_display();

rl_redisplay();

fputs(PROMPT, stderr);

fflush(stderr);

}

}

#endif /* USE_MOUSE */

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 */

/* Save function definition in a user-accessible variable */

if (1) {

char *tmpnam = gp_alloc(8+strlen(udf->udf_name), "varname");

strcpy(tmpnam, "GPFUN_");

strcat(tmpnam, udf->udf_name);

fill_gpval_string(tmpnam, udf->definition);

free(tmpnam);

}

} 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);

/* Prevents memory leak if the variable name is re-used */

if (!udv->udv_undef)

gpfree_string(&udv->udv_value);

udv->udv_value = result;

udv->udv_undef = FALSE;

}

}

undefine_command()

{

char key[MAX_ID_LEN+1];

TBOOLEAN wildcard;

c_token++; /* consume the command name */

while (!END_OF_COMMAND) {

/* copy next var name into key */

copy_str(key, c_token, MAX_ID_LEN);

/* Peek ahead - must do this, because a '*' is returned as a

wildcard = equals(c_token+1,"*");

if (wildcard)

c_token++;

/* ignore internal variables */

if (strncmp(key, "GPVAL_", 6) && strncmp(key, "MOUSE_", 6))

del_udv_by_name( key, wildcard );

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;

}

raise_lower_command(int lower)

{

++c_token;

if (END_OF_COMMAND) {

if (lower) {

#ifdef OS2

pm_lower_terminal_window();

#ifdef X11

x11_lower_terminal_group();

#ifdef _Windows

win_lower_terminal_group();

#ifdef WXWIDGETS

wxt_lower_terminal_group();

} else {

#ifdef OS2

pm_raise_terminal_window();

#ifdef X11

x11_raise_terminal_group();

#ifdef _Windows

win_raise_terminal_group();

#ifdef WXWIDGETS

wxt_raise_terminal_group();

}

return;

} else {

int number;

int negative = equals(c_token, "-");

if (negative || equals(c_token, "+")) c_token++;

if (!END_OF_COMMAND && isanumber(c_token)) {

number = real_expression();

if (negative)

number = -number;

if (lower) {

#ifdef OS2

pm_lower_terminal_window();

#ifdef X11

x11_lower_terminal_window(number);

#ifdef _Windows

win_lower_terminal_window(number);

#ifdef WXWIDGETS

wxt_lower_terminal_window(number);

} else {

#ifdef OS2

pm_raise_terminal_window();

#ifdef X11

x11_raise_terminal_window(number);

#ifdef _Windows

win_raise_terminal_window(number);

#ifdef WXWIDGETS

wxt_raise_terminal_window(number);

}

++c_token;

return;

}

}

if (lower)

int_error(c_token, "usage: lower {plot_id}");

else

int_error(c_token, "usage: raise {plot_id}");

}

raise_command(void)

{

raise_lower_command(0);

}

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])

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

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 */

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);

}

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");

else

update_gpval_variables(5);

free(save_file);

}

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++;

}

eval_command()

{

char *command;

c_token++;

command = try_to_get_string();

if (!command)

int_error(c_token, "Expected command string");

do_string_and_free(command);

}

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;

}

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 */

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");

printf(" Executing:\n\t%s\n", line_to_do);

do_string(line_to_do);

c_token++;

} else {

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_expression();

}

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"));

}

c_token++;

int_warn(NO_CARET, "You have to compile gnuplot with builtin readline or GNU readline or BSD editline 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)

if_command()

{

double exprval;

if (!equals(++c_token, "(")) /* no expression */

int_error(c_token, "expecting (expression)");

exprval = real_expression();

/*

if (equals(c_token,"{")) {

/* Identify start and end position of the clause substring */

char *clause = NULL;

int if_start, if_end, else_start=0, else_end=0;

int clause_start, clause_end;

c_token = find_clause(&if_start, &if_end);

if (equals(c_token,"else")) {

if (!equals(++c_token,"{"))

int_error(c_token,"expected {else-clause}");

c_token = find_clause(&else_start, &else_end);

}

if (exprval != 0) {