#ifndef lint

static char *RCSid() { return RCSid("$Id: command.c,v 1.47.2.1 2001/03/03 21:40:17 joze Exp $"); }

#include "command.h"

#include "alloc.h"

#include "eval.h"

#include "fit.h"

#include "binary.h"

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

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

#include "ipc.h"

#ifndef _Windows

# include "help.h"

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

#endif /* _Windows */

#ifdef _Windows

# include <windows.h>

# ifdef __MSC__

# include <malloc.h>

# include <alloc.h>

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

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

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

#ifdef USE_MOUSE

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

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

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

#ifdef AMIGA_AC_5

static void getparms __PROTO((char *, char **));

struct lexical_unit *token;

int token_table_size;

char *input_line;

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

TBOOLEAN is_3d_plot = FALSE;

#ifdef AMIGA_SC_6_1

__far int num_tokens, c_token;

int num_tokens, c_token;

static int if_depth = 0;

static TBOOLEAN if_condition = FALSE;

static int command_exit_status = 0;

extend_input_line()

{

if (input_line_len == 0) {

/* first time */

input_line = gp_alloc(MAX_LINE_LEN, "input_line");

input_line_len = MAX_LINE_LEN;

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 {

input_line = gp_realloc(input_line, input_line_len + MAX_LINE_LEN, "extend input line");

input_line_len += MAX_LINE_LEN;

FPRINTF((stderr, "extending input line to %d chars\n", 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) );

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

return (1);

} else {

#ifndef USE_MOUSE

if (read_line(PROMPT))

return (1);

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

strcpy(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,

screen_ok = interactive;

if (do_line())

return (1);

else

return (0);

}

do_line()

{

/* Line continuation has already been handled

char *inlptr = input_line;

/* Skip leading whitespace */

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

inlptr++;

if (inlptr != input_line) {

/* If there was leading whitespace, copy the actual

memmove(input_line, inlptr, strlen(inlptr));

/* Terminate resulting string */

input_line[strlen(inlptr)] = NUL;

}

FPRINTF((stderr, "Input line: \"%s\"\n", input_line));

/* also used in load_file */

if (is_system(input_line[0])) {

do_system(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(&input_line, &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);

}

#ifdef USE_MOUSE

toggle_display_of_ipc_commands(void)

{

if (mouse_setting.verbose)

mouse_setting.verbose = 0;

else

mouse_setting.verbose = 1;

}

display_ipc_commands(void)

{

return mouse_setting.verbose;

}

do_string(s)

char *s;

{

char *orig_input_line;

static char buf[256];

if (display_ipc_commands())

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

orig_input_line=input_line;

input_line=buf;

strcpy(buf,s);

do_line();

input_line=orig_input_line;

}

do_string_replot(s)

char *s;

{

char *orig_input_line;

static char buf[256];

orig_input_line = input_line;

input_line = buf;

strcpy(buf,s);

if (!replot_disabled)

strcat(buf,"; replot");

if (display_ipc_commands())

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

do_line();

input_line = orig_input_line;

}

restore_prompt(void)

{

if (interactive) {

#if defined(HAVE_LIBREADLINE)

rl_forced_update_display();

fputs(PROMPT, stderr);

fflush(stderr);

}

}

#endif /* USE_MOUSE */

define()

{

register int start_token; /* the 1st token in the function definition */

register struct udvt_entry *udv;

register struct udft_entry *udf;

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

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((char *) 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 ! */

start_token = c_token;

c_token += 2;

udv = add_udv(start_token);

(void) const_express(&(udv->udv_value));

udv->udv_undef = FALSE;

}

}

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;

}

#ifdef USE_MOUSE

#define WHITE_AFTER_TOKEN(x) \

(' ' == input_line[token[x].start_index + token[x].length] \

|| '\t' == input_line[token[x].start_index + token[x].length] \

|| '\0' == input_line[token[x].start_index + token[x].length])

bind_command()

{

char* lhs = (char*) 0;

char* rhs = (char*) 0;

++c_token;

if (!END_OF_COMMAND && equals(c_token,"!")) {

bind_remove_all();

++c_token;

return;

}

/* get left hand side: the key or key sequence */

if (!END_OF_COMMAND) {

char* first = 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(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));

#if 0

if (!END_OF_COMMAND) {

int_error(c_token, "usage: bind \"<lhs>\" \"<rhs>\"");

}

/* bind_process() will eventually free lhs / rhs ! */

bind_process(lhs, rhs);

}

#endif /* USE_MOUSE */

call_command()

{

char *save_file = NULL;

if (!isstring(++c_token))

int_error(c_token, "expecting filename");

else {

m_quote_capture(&save_file, c_token, c_token);

gp_expand_tilde(&save_file);

/* Argument list follows filename */

load_file(loadpath_fopen(save_file, "r"), save_file, TRUE);

/* input_line[] and token[] now destroyed! */

c_token = 0;

num_tokens = 0;

free(save_file);

}

}

changedir_command()

{

char *save_file = NULL;

if (!isstring(++c_token))

int_error(c_token, "expecting directory name");

else {

m_quote_capture(&save_file, c_token, c_token);

gp_expand_tilde(&save_file);

if (changedir(save_file)) {

int_error(c_token, "Can't change to this directory");

}

c_token++;

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

}

exit_command()

{

/* graphics will be tidied up in main */

command_exit_status = 1;

}

history_command()

{

#if defined(READLINE) && !defined(HAVE_LIBREADLINE)

struct value a;

char *name = NULL; /* name of the output file; NULL for stdout */

int n = 0; /* print only <last> entries */

c_token++;

if (!END_OF_COMMAND && equals(c_token,"?")) {

/* find and show the entries */

c_token++;

m_capture(&name, c_token, c_token);

printf ("history ?%s\n", name);

if (!history_find_all(name))

int_error(c_token,"not in history");

c_token++;

} else if (!END_OF_COMMAND && equals(c_token,"!")) {

/* execute the entry */

static char flag = 0;

static char *save_input_line;

static int save_c_token, save_input_line_len;

if (flag) {

flag = 0;

input_line = save_input_line;

c_token = save_c_token;

input_line_len = save_input_line_len;

num_tokens = scanner(&input_line, &input_line_len);

int_error(c_token,"recurrency forbidden");

}

c_token++;

m_capture(&name, c_token, c_token);

name = history_find(name);

if (name == NULL)

int_error(c_token,"not in history");

else {

/* execute the command "name" */

save_input_line = input_line;

save_c_token = c_token;

save_input_line_len = input_line_len;

flag = 1;

input_line = name;

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

do_line();

input_line = save_input_line;

c_token = save_c_token;

input_line_len = save_input_line_len;

num_tokens = scanner(&input_line, &input_line_len);

flag = 0;

}

c_token++;

} else {

/* show history entries */

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

n = (int)real(const_express(&a));

}

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

m_quote_capture(&name, c_token, c_token);

c_token++;

}

write_history_n(n, name);

}

c_token++;

int_warn(NO_CARET, "history command requires some form of readline support");

#endif /* READLINE && !HAVE_LIBREADLINE */

}

#define REPLACE_ELSE(tok) \

do { \

int idx = token[tok].start_index; \

token[tok].length = 1; \

input_line[idx++] = ';'; /* e */ \

input_line[idx++] = ' '; /* l */ \

input_line[idx++] = ' '; /* s */ \

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 && input_line[i]; i++) { \

fputc(input_line[i], stderr); \

} \

fputc('\n', stderr); \

fflush(stderr); \

} while (0)

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;

input_line[eolpos + 2] = ';';

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;

}

}

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

c_token = num_tokens = 0;

} else {

REPLACE_ELSE(c_token);

if_condition = TRUE;

}

}

load_command()

{

FILE *fp;

char *save_file = NULL;

if (!isstring(++c_token))

int_error(c_token, "expecting filename");

else {

/* load_file(fp=fopen(save_file, "r"), save_file, FALSE); OLD

CAPTURE_FILENAME_AND_FOPEN("r");

load_file(fp, save_file, FALSE);

/* input_line[] and token[] now destroyed! */

c_token = num_tokens = 0;

free(save_file);

}

}

null_command()

{

return;

}

pause_command()

{

struct value a;

int sleep_time, text = 0;

char *buf = gp_alloc(MAX_LINE_LEN+1, "pause argument");

c_token++;

*buf = NUL;

sleep_time = (int) 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 (!Pause(buf)) {

free(buf);

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)

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(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,

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

}

plot_command()

{

plot_token = c_token++;

plotted_data_from_stdin = FALSE;

SET_CURSOR_WAIT;

#ifdef USE_MOUSE

plot_mode(MODE_PLOT);

plotrequest();

SET_CURSOR_ARROW;

}

print_command()

{

struct value a;

char *s;

/* space printed between two expressions only */

int need_space = 0;

screen_ok = FALSE;

do {

++c_token;

if (isstring(c_token)) {

s = NULL;

m_quote_capture(&s, c_token, c_token);

fputs(s, stderr);

need_space = 0;

free(s);

++c_token;

} else {

(void) const_express(&a);

if (need_space)

putc(' ', stderr);