arno
26 years ago
67 changed files with 185 additions and 3199 deletions
-
6ChangeLog
-
1src/Makefile.am
-
2src/circuit/Makefile.am
-
18src/circuit/ifnewuid.c
-
27src/frontend/Makefile.am
-
4src/frontend/aspice.c
-
32src/frontend/circuits.h
-
3src/frontend/com_display.c
-
1src/frontend/com_hardcopy.c
-
15src/frontend/commands.c
-
3src/frontend/commands.h
-
1src/frontend/cpitf.c
-
2src/frontend/debugcom.c
-
4src/frontend/device.c
-
1src/frontend/diff.c
-
2src/frontend/display.c
-
2src/frontend/dotcards.c
-
2src/frontend/fourier.c
-
3src/frontend/inp.c
-
3src/frontend/inpcom.c
-
2src/frontend/linear.c
-
233src/frontend/misccoms.c
-
4src/frontend/mw_coms.c
-
3src/frontend/nutinp.c
-
4src/frontend/options.c
-
3src/frontend/outitf.c
-
4src/frontend/parse.c
-
2src/frontend/plotting/Makefile.am
-
2src/frontend/plotting/agraf.c
-
1src/frontend/plotting/graf.c
-
1src/frontend/plotting/plotcurv.c
-
3src/frontend/plotting/plotit.c
-
1src/frontend/plotting/x11.c
-
1src/frontend/plotting/xgraph.c
-
1src/frontend/postcoms.c
-
3src/frontend/postsc.c
-
3src/frontend/rawfile.c
-
6src/frontend/resource.c
-
4src/frontend/runcoms.c
-
4src/frontend/runcoms2.c
-
2src/frontend/shyu.c
-
2src/frontend/spec.c
-
4src/frontend/spiceif.c
-
3src/frontend/subckt.c
-
4src/frontend/vectors.c
-
3src/frontend/where.c
-
2src/help.c
-
3src/include/Makefile.am
-
6src/include/cpdefs.h
-
5src/include/cpextern.h
-
29src/include/ftedefs.h
-
22src/include/ftehelp.h
-
1src/include/plot.h
-
36src/include/variable.h
-
1src/main.c
-
35src/maths/cmaths/cmath4.c
-
326src/misc/terminal.c
-
16src/misc/terminal.h
-
21src/parser/cshpar.c
-
951src/parser/front.c
-
40src/parser/front.h
-
489src/parser/history.c
-
16src/parser/history.h
-
38src/parser/modify.c
-
478src/parser/var2.c
-
5src/parser/var2.h
-
429src/parser/variable.c
@ -1,22 +0,0 @@ |
|||||
/********** |
|
||||
Copyright 1990 Regents of the University of California. All rights reserved. |
|
||||
Author: 1987 Jeffrey M. Hsu |
|
||||
**********/ |
|
||||
|
|
||||
/* |
|
||||
|
|
||||
Defines for help. |
|
||||
*/ |
|
||||
|
|
||||
#define E_HASPLOTS 1 |
|
||||
#define E_NOPLOTS 2 |
|
||||
#define E_HASGRAPHS 4 |
|
||||
#define E_MENUMODE 8 |
|
||||
|
|
||||
#define E_BEGINNING 4096 |
|
||||
#define E_INTERMED 8192 |
|
||||
#define E_ADVANCED 16384 |
|
||||
#define E_ALWAYS 32768 |
|
||||
|
|
||||
/* default is intermediate level */ |
|
||||
#define E_DEFHMASK 8192 |
|
||||
@ -1,36 +0,0 @@ |
|||||
#ifndef _VARIABLE_H |
|
||||
#define _VARIABLE_H |
|
||||
|
|
||||
/* Variables that are accessible to the parser via $varname expansions. |
|
||||
* If the type is VT_LIST the value is a pointer to a list of the elements. |
|
||||
*/ |
|
||||
|
|
||||
struct variable { |
|
||||
char va_type; |
|
||||
char *va_name; |
|
||||
union { |
|
||||
bool vV_bool; |
|
||||
int vV_num; |
|
||||
double vV_real; |
|
||||
char *vV_string; |
|
||||
struct variable *vV_list; |
|
||||
} va_V; |
|
||||
struct variable *va_next; /* Link. */ |
|
||||
} ; |
|
||||
|
|
||||
#define va_bool va_V.vV_bool |
|
||||
#define va_num va_V.vV_num |
|
||||
#define va_real va_V.vV_real |
|
||||
#define va_string va_V.vV_string |
|
||||
#define va_vlist va_V.vV_list |
|
||||
|
|
||||
enum vt_types { |
|
||||
VT_BOOL, |
|
||||
VT_NUM, |
|
||||
VT_REAL, |
|
||||
VT_STRING, |
|
||||
VT_LIST |
|
||||
}; |
|
||||
|
|
||||
|
|
||||
#endif |
|
||||
@ -1,326 +0,0 @@ |
|||||
/********** |
|
||||
Copyright 1990 Regents of the University of California. All rights reserved. |
|
||||
Author: 1986 Wayne A. Christopher, U. C. Berkeley CAD Group |
|
||||
**********/ |
|
||||
|
|
||||
/* |
|
||||
* Routines to handle "more"d output. There are some serious system |
|
||||
* dependencies in here, and it isn't clear that versions of this stuff |
|
||||
* can be written for every possible machine... |
|
||||
*/ |
|
||||
#include <config.h> |
|
||||
|
|
||||
#ifdef HAVE_SGTTY_H |
|
||||
#include <sgtty.h> |
|
||||
#endif |
|
||||
|
|
||||
#if 0 |
|
||||
/* Bad interaction with bool type in bool.h because curses also |
|
||||
defines this symbol. */ |
|
||||
#ifdef HAVE_TERMCAP |
|
||||
#include <curses.h> |
|
||||
#include <term.h> |
|
||||
#endif |
|
||||
#endif |
|
||||
|
|
||||
#include "ngspice.h" |
|
||||
#include "cpdefs.h" |
|
||||
|
|
||||
|
|
||||
#include "terminal.h" |
|
||||
|
|
||||
static char *motion_chars; |
|
||||
static char *clear_chars; |
|
||||
static char *home_chars; |
|
||||
static char *cleol_chars; |
|
||||
|
|
||||
|
|
||||
#define DEF_SCRHEIGHT 24 |
|
||||
#define DEF_SCRWIDTH 80 |
|
||||
|
|
||||
bool out_moremode = TRUE; |
|
||||
bool out_isatty = TRUE; |
|
||||
|
|
||||
static int xsize, ysize; |
|
||||
static int xpos, ypos; |
|
||||
static bool noprint, nopause; |
|
||||
|
|
||||
|
|
||||
/* out_printf doesn't handle double arguments correctly, so we |
|
||||
sprintf into this buf and call out_send w/ it */ |
|
||||
char out_pbuf[BSIZE_SP]; |
|
||||
|
|
||||
/* Start output... */ |
|
||||
|
|
||||
void |
|
||||
out_init(void) |
|
||||
{ |
|
||||
#ifdef TIOCGWINSZ |
|
||||
struct winsize ws; |
|
||||
#endif |
|
||||
bool moremode; |
|
||||
|
|
||||
noprint = nopause = FALSE; |
|
||||
|
|
||||
if (cp_getvar("nomoremode", VT_BOOL, (char *) &moremode)) |
|
||||
out_moremode = FALSE; |
|
||||
else |
|
||||
out_moremode = TRUE; |
|
||||
if (!out_moremode || !cp_interactive) |
|
||||
out_isatty = FALSE; |
|
||||
|
|
||||
if (!out_isatty) |
|
||||
return; |
|
||||
|
|
||||
xsize = ysize = 0; |
|
||||
|
|
||||
/* Figure out the screen size. We try, in order, TIOCGSIZE, |
|
||||
* tgetent(), and cp_getvar(height). Default is 24 x 80. |
|
||||
*/ |
|
||||
|
|
||||
#ifdef TIOCGWINSZ |
|
||||
if (!xsize || !ysize) { |
|
||||
(void) ioctl(fileno(stdout), TIOCGWINSZ, (char *) &ws); |
|
||||
xsize = ws.ws_col; |
|
||||
ysize = ws.ws_row; |
|
||||
} |
|
||||
#endif |
|
||||
|
|
||||
if (!xsize) |
|
||||
(void) cp_getvar("width", VT_NUM, (char *) &xsize); |
|
||||
if (!ysize) |
|
||||
(void) cp_getvar("height", VT_NUM, (char *) &ysize); |
|
||||
|
|
||||
if (!xsize) |
|
||||
xsize = DEF_SCRWIDTH; |
|
||||
if (!ysize) |
|
||||
ysize = DEF_SCRHEIGHT; |
|
||||
ysize -= 2; /* Fudge room... */ |
|
||||
xpos = ypos = 0; |
|
||||
|
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
/* Putc may not be buffered (sp?), so we do it ourselves. */ |
|
||||
|
|
||||
static char staticbuf[BUFSIZ]; |
|
||||
struct { |
|
||||
int count; |
|
||||
char *ptr; |
|
||||
} ourbuf = { BUFSIZ, staticbuf }; |
|
||||
|
|
||||
/* send buffer out */ |
|
||||
void |
|
||||
outbufputc(void) |
|
||||
{ |
|
||||
|
|
||||
if (ourbuf.count != BUFSIZ) { |
|
||||
fputs(staticbuf, cp_out); |
|
||||
memset(staticbuf, 0, BUFSIZ-ourbuf.count); |
|
||||
ourbuf.count = BUFSIZ; |
|
||||
ourbuf.ptr = staticbuf; |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
|
|
||||
static void |
|
||||
bufputc(char c) |
|
||||
{ |
|
||||
if (--ourbuf.count >= 0) { |
|
||||
*ourbuf.ptr++ = c; |
|
||||
} else { |
|
||||
/* Flush and reset the buffer */ |
|
||||
outbufputc(); |
|
||||
/* and store the character. */ |
|
||||
ourbuf.count--; |
|
||||
*ourbuf.ptr++ = c; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* prompt for a return */ |
|
||||
void |
|
||||
promptreturn(void) |
|
||||
{ |
|
||||
char buf[16]; |
|
||||
moe: |
|
||||
fprintf(cp_out, |
|
||||
"\n\t-- hit return for more, ? for help -- "); |
|
||||
if (!fgets(buf, 16, cp_in)) { |
|
||||
clearerr(cp_in); |
|
||||
*buf = 'q'; |
|
||||
} |
|
||||
switch (*buf) { |
|
||||
case '\n': |
|
||||
break; |
|
||||
case 'q': |
|
||||
noprint = TRUE; |
|
||||
break; |
|
||||
case 'c': |
|
||||
nopause = TRUE; |
|
||||
break; |
|
||||
case ' ': |
|
||||
break; |
|
||||
case '?': |
|
||||
fprintf(cp_out, |
|
||||
"\nPossible responses:\n\ |
|
||||
\t<cr> : Print another screenful\n\ |
|
||||
\tq <cr> : Discard the rest of the output\n\ |
|
||||
\tc <cr> : Continuously print the rest of the output\n\ |
|
||||
\t? <cr> : Print this help message\n"); |
|
||||
goto moe; |
|
||||
default: |
|
||||
fprintf(cp_out, "Character %d is no good\n", *buf); |
|
||||
goto moe; |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
|
|
||||
/* Print a string to the output. If this would cause the screen to scroll, |
|
||||
* print "more". |
|
||||
*/ |
|
||||
|
|
||||
void |
|
||||
out_send(char *string) |
|
||||
{ |
|
||||
|
|
||||
if (noprint) |
|
||||
return; |
|
||||
if (!out_isatty || nopause) { |
|
||||
fputs(string, cp_out); |
|
||||
return; |
|
||||
} |
|
||||
while (*string) { |
|
||||
switch (*string) { |
|
||||
case '\n': |
|
||||
xpos = 0; |
|
||||
ypos++; |
|
||||
break; |
|
||||
case '\f': |
|
||||
ypos = ysize; |
|
||||
xpos = 0; |
|
||||
break; |
|
||||
case '\t': |
|
||||
xpos = xpos / 8 + 1; |
|
||||
xpos *= 8; |
|
||||
break; |
|
||||
default: |
|
||||
xpos++; |
|
||||
break; |
|
||||
} |
|
||||
while (xpos >= xsize) { |
|
||||
xpos -= xsize; |
|
||||
ypos++; |
|
||||
} |
|
||||
if (ypos >= ysize) { |
|
||||
outbufputc(); /* out goes buffer */ |
|
||||
promptreturn(); |
|
||||
(void) fflush(cp_out); |
|
||||
ypos = xpos = 0; |
|
||||
} |
|
||||
bufputc(*string); /* we need to buffer these */ |
|
||||
string++; |
|
||||
} |
|
||||
(void) outbufputc(); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
/* Printf some stuff using more mode. */ |
|
||||
|
|
||||
#define MAXLEN 4096 |
|
||||
|
|
||||
|
|
||||
void |
|
||||
out_printf(char *fmt, char *s1, char *s2, char *s3, char *s4, char *s5, char *s6, char *s7, char *s8, char *s9, char *s10) |
|
||||
{ |
|
||||
char buf[MAXLEN]; |
|
||||
|
|
||||
sprintf(buf, fmt, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10); |
|
||||
|
|
||||
out_send(buf); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
static int |
|
||||
outfn(int c) |
|
||||
{ |
|
||||
putc(c, stdout); |
|
||||
return c; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void |
|
||||
tcap_init(void) |
|
||||
{ |
|
||||
char *s; |
|
||||
#ifdef HAVE_TERMCAP |
|
||||
char tbuf[1025]; |
|
||||
static char buf2[100]; |
|
||||
char *charbuf; |
|
||||
|
|
||||
charbuf = buf2; |
|
||||
|
|
||||
if ((s = getenv("TERM"))) { |
|
||||
if (tgetent(tbuf, s) != -1) { |
|
||||
xsize = tgetnum("co"); |
|
||||
ysize = tgetnum("li"); |
|
||||
if ((xsize <= 0) || (ysize <= 0)) |
|
||||
xsize = ysize = 0; |
|
||||
clear_chars = (char *) tgetstr("cl", &charbuf); |
|
||||
motion_chars = (char *) tgetstr("cm", &charbuf); |
|
||||
home_chars = (char *) tgetstr("ho", &charbuf); |
|
||||
cleol_chars = (char *) tgetstr("ce", &charbuf); |
|
||||
} |
|
||||
} |
|
||||
#endif |
|
||||
|
|
||||
if (!xsize) { |
|
||||
if ((s = getenv("COLS"))) |
|
||||
xsize = atoi(s); |
|
||||
if (xsize <= 0) |
|
||||
xsize = 0; |
|
||||
} |
|
||||
|
|
||||
if (!ysize) { |
|
||||
if ((s = getenv("LINES"))) |
|
||||
ysize = atoi(s); |
|
||||
if (ysize <= 0) |
|
||||
ysize = 0; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void |
|
||||
term_clear(void) |
|
||||
{ |
|
||||
#ifdef HAVE_TERMCAP |
|
||||
if (*clear_chars) |
|
||||
tputs(clear_chars, 1, outfn); |
|
||||
else |
|
||||
fputs("\n", stdout); |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void |
|
||||
term_home(void) |
|
||||
{ |
|
||||
#ifdef HAVE_TERMCAP |
|
||||
if (*home_chars) |
|
||||
tputs(home_chars, 1, outfn); |
|
||||
else if (*motion_chars) |
|
||||
tputs(tgoto(motion_chars, 1, 1), 1, outfn); |
|
||||
else |
|
||||
fputs("\n", stdout); |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void |
|
||||
term_cleol(void) |
|
||||
{ |
|
||||
#ifdef HAVE_TERMCAP |
|
||||
if (*cleol_chars) |
|
||||
tputs(cleol_chars, 1, outfn); |
|
||||
#endif |
|
||||
} |
|
||||
@ -1,16 +0,0 @@ |
|||||
#ifndef _TERMINAL_H |
|
||||
#define _TERMINAL_H |
|
||||
|
|
||||
void out_init(void); |
|
||||
void outbufputc(void); |
|
||||
void promptreturn(void); |
|
||||
void out_send(char *string); |
|
||||
void out_printf(char *fmt, char *s1, char *s2, char *s3, |
|
||||
char *s4, char *s5, char *s6, |
|
||||
char *s7, char *s8, char *s9, char *s10); |
|
||||
void term_clear(void); |
|
||||
void term_home(void); |
|
||||
void term_cleol(void); |
|
||||
void tcap_init(void); |
|
||||
|
|
||||
#endif |
|
||||
@ -1,951 +0,0 @@ |
|||||
/********** |
|
||||
Copyright 1990 Regents of the University of California. All rights reserved. |
|
||||
Author: 1985 Wayne A. Christopher, U. C. Berkeley CAD Group |
|
||||
**********/ |
|
||||
|
|
||||
/* |
|
||||
* The front-end command loop. |
|
||||
*/ |
|
||||
|
|
||||
#include "ngspice.h" |
|
||||
#include "cpdefs.h" |
|
||||
#include "front.h" |
|
||||
|
|
||||
/* Return values from doblock(). I am assuming that nobody will use |
|
||||
* these characters in a string. */ |
|
||||
#define NORMAL '\001' |
|
||||
#define BROKEN '\002' |
|
||||
#define CONTINUED '\003' |
|
||||
#define NORMAL_STR "\001" |
|
||||
#define BROKEN_STR "\002" |
|
||||
#define CONTINUED_STR "\003" |
|
||||
|
|
||||
/* Are we waiting for a command? This lets signal handling be |
|
||||
* more clever. */ |
|
||||
|
|
||||
bool cp_cwait = FALSE; |
|
||||
char *cp_csep = ";"; |
|
||||
|
|
||||
bool cp_dounixcom = FALSE; |
|
||||
|
|
||||
|
|
||||
|
|
||||
enum co_command { |
|
||||
CO_UNFILLED, |
|
||||
CO_STATEMENT, |
|
||||
CO_WHILE, |
|
||||
CO_DOWHILE, |
|
||||
CO_IF, |
|
||||
CO_FOREACH, |
|
||||
CO_BREAK, |
|
||||
CO_CONTINUE, |
|
||||
CO_LABEL, |
|
||||
CO_GOTO, |
|
||||
CO_REPEAT |
|
||||
}; |
|
||||
|
|
||||
/* We have to keep the control structures in a stack, so that when we do |
|
||||
* a 'source', we can push a fresh set onto the top... Actually there have |
|
||||
* to be two stacks -- one for the pointer to the list of control structs, |
|
||||
* and one for the 'current command' pointer... |
|
||||
*/ |
|
||||
|
|
||||
#define CONTROLSTACKSIZE 256 /* Better be enough. */ |
|
||||
static struct control *control[CONTROLSTACKSIZE], *cend[CONTROLSTACKSIZE]; |
|
||||
|
|
||||
|
|
||||
/* static declarations */ |
|
||||
static char * doblock(struct control *bl, int *num); |
|
||||
static struct control * findlabel(char *s, struct control *ct); |
|
||||
static void docommand(register wordlist *wlist); |
|
||||
static wordlist * getcommand(char *string); |
|
||||
static void pwlist(wordlist *wlist, char *name); |
|
||||
static void dodump(struct control *cc); |
|
||||
|
|
||||
|
|
||||
static int stackp = 0; |
|
||||
|
|
||||
/* If there is an argument, give this to cshpar to use instead of |
|
||||
* stdin. In a few places, we call cp_evloop again if it returns 1 and |
|
||||
* exit (or close a file) if it returns 0... Because of the way |
|
||||
* sources are done, we can't allow the control structures to get |
|
||||
* blown away every time we return -- probably every time we type |
|
||||
* source at the keyboard and every time a source returns to keyboard |
|
||||
* input is ok though -- use ft_controlreset. */ |
|
||||
|
|
||||
static char *noredirect[] = { "stop", NULL } ; /* Only one?? */ |
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
|
|
||||
int |
|
||||
cp_evloop(char *string) |
|
||||
{ |
|
||||
wordlist *wlist, *ww; |
|
||||
struct control *x; |
|
||||
char *i; |
|
||||
int nn; |
|
||||
|
|
||||
#define newblock cend[stackp]->co_children = alloc(struct control); \ |
|
||||
ZERO(cend[stackp]->co_children,struct control), \ |
|
||||
cend[stackp]->co_children->co_parent = cend[stackp]; \ |
|
||||
cend[stackp] = cend[stackp]->co_children; \ |
|
||||
cend[stackp]->co_type = CO_UNFILLED; |
|
||||
|
|
||||
for (;;) { |
|
||||
wlist = getcommand(string); |
|
||||
if (wlist == NULL) { /* End of file or end of user input. */ |
|
||||
if (cend[stackp]->co_parent && !string) { |
|
||||
cp_resetcontrol(); |
|
||||
continue; |
|
||||
} else |
|
||||
return (0); |
|
||||
} |
|
||||
if ((wlist->wl_word == NULL) || (*wlist->wl_word == '\0')) { |
|
||||
/* User just typed return. */ |
|
||||
if (string) |
|
||||
return (1); |
|
||||
else { |
|
||||
cp_event--; |
|
||||
continue; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/* Just a check... */ |
|
||||
for (ww = wlist; ww; ww = ww->wl_next) |
|
||||
if (!ww->wl_word) { |
|
||||
fprintf(cp_err, |
|
||||
"cp_evloop: Internal Error: NULL word pointer\n"); |
|
||||
continue; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* Add this to the control structure list. If cend->co_type is |
|
||||
* CO_UNFILLED, the last line was the beginning of a block, |
|
||||
* and this is the unfilled first statement. */ |
|
||||
if (cend[stackp] && (cend[stackp]->co_type != CO_UNFILLED)) { |
|
||||
cend[stackp]->co_next = alloc(struct control); |
|
||||
ZERO(cend[stackp]->co_next, struct control); |
|
||||
cend[stackp]->co_next->co_prev = cend[stackp]; |
|
||||
cend[stackp]->co_next->co_parent = |
|
||||
cend[stackp]->co_parent; |
|
||||
cend[stackp] = cend[stackp]->co_next; |
|
||||
} else if (!cend[stackp]) { |
|
||||
control[stackp] = cend[stackp] = alloc(struct control); |
|
||||
ZERO(cend[stackp], struct control); |
|
||||
} |
|
||||
|
|
||||
if (eq(wlist->wl_word, "while")) { |
|
||||
cend[stackp]->co_type = CO_WHILE; |
|
||||
cend[stackp]->co_cond = wlist->wl_next; |
|
||||
if (!cend[stackp]->co_cond) { |
|
||||
fprintf(stderr, |
|
||||
"Error: missing while condition.\n"); |
|
||||
} |
|
||||
newblock; |
|
||||
} else if (eq(wlist->wl_word, "dowhile")) { |
|
||||
cend[stackp]->co_type = CO_DOWHILE; |
|
||||
cend[stackp]->co_cond = wlist->wl_next; |
|
||||
if (!cend[stackp]->co_cond) { |
|
||||
fprintf(stderr, |
|
||||
"Error: missing dowhile condition.\n"); |
|
||||
} |
|
||||
newblock; |
|
||||
} else if (eq(wlist->wl_word, "repeat")) { |
|
||||
cend[stackp]->co_type = CO_REPEAT; |
|
||||
if (!wlist->wl_next) { |
|
||||
cend[stackp]->co_numtimes = -1; |
|
||||
} else { |
|
||||
char *s; |
|
||||
double *dd; |
|
||||
wlist = cp_variablesubst(cp_bquote( |
|
||||
cp_doglob(wl_copy(wlist)))); |
|
||||
s = wlist->wl_next->wl_word; |
|
||||
|
|
||||
dd = ft_numparse(&s, FALSE); |
|
||||
if (dd) { |
|
||||
if (*dd < 0) { |
|
||||
fprintf(cp_err, |
|
||||
"Error: can't repeat a negative number of times\n"); |
|
||||
*dd = 0.0; |
|
||||
} |
|
||||
cend[stackp]->co_numtimes = (int) *dd; |
|
||||
} else |
|
||||
fprintf(cp_err, |
|
||||
"Error: bad repeat argument %s\n", |
|
||||
wlist->wl_next->wl_word); |
|
||||
} |
|
||||
newblock; |
|
||||
} else if (eq(wlist->wl_word, "if")) { |
|
||||
cend[stackp]->co_type = CO_IF; |
|
||||
cend[stackp]->co_cond = wlist->wl_next; |
|
||||
if (!cend[stackp]->co_cond) { |
|
||||
fprintf(stderr, |
|
||||
"Error: missing if condition.\n"); |
|
||||
} |
|
||||
newblock; |
|
||||
} else if (eq(wlist->wl_word, "foreach")) { |
|
||||
cend[stackp]->co_type = CO_FOREACH; |
|
||||
if (wlist->wl_next) { |
|
||||
wlist = wlist->wl_next; |
|
||||
cend[stackp]->co_foreachvar = |
|
||||
copy(wlist->wl_word); |
|
||||
wlist = wlist->wl_next; |
|
||||
} else |
|
||||
fprintf(stderr, |
|
||||
"Error: missing foreach variable.\n"); |
|
||||
wlist = cp_doglob(wlist); |
|
||||
cend[stackp]->co_text = wl_copy(wlist); |
|
||||
newblock; |
|
||||
} else if (eq(wlist->wl_word, "label")) { |
|
||||
cend[stackp]->co_type = CO_LABEL; |
|
||||
if (wlist->wl_next) { |
|
||||
cend[stackp]->co_text = wl_copy(wlist->wl_next); |
|
||||
/* I think of everything, don't I? */ |
|
||||
cp_addkword(CT_LABEL, wlist->wl_next->wl_word); |
|
||||
if (wlist->wl_next->wl_next) |
|
||||
fprintf(cp_err, |
|
||||
"Warning: ignored extra junk after label.\n"); |
|
||||
} else |
|
||||
fprintf(stderr, "Error: missing label.\n"); |
|
||||
} else if (eq(wlist->wl_word, "goto")) { |
|
||||
/* Incidentally, this won't work if the values 1 and 2 ever get |
|
||||
* to be valid character pointers -- I think it's reasonably |
|
||||
* safe to assume they aren't... */ |
|
||||
cend[stackp]->co_type = CO_GOTO; |
|
||||
if (wlist->wl_next) { |
|
||||
cend[stackp]->co_text = wl_copy(wlist->wl_next); |
|
||||
if (wlist->wl_next->wl_next) |
|
||||
fprintf(cp_err, |
|
||||
"Warning: ignored extra junk after goto.\n"); |
|
||||
} else |
|
||||
fprintf(stderr, "Error: missing label.\n"); |
|
||||
} else if (eq(wlist->wl_word, "continue")) { |
|
||||
cend[stackp]->co_type = CO_CONTINUE; |
|
||||
if (wlist->wl_next) { |
|
||||
cend[stackp]->co_numtimes = scannum(wlist-> |
|
||||
wl_next->wl_word); |
|
||||
if (wlist->wl_next->wl_next) |
|
||||
fprintf(cp_err, |
|
||||
"Warning: ignored extra junk after continue %d.\n", |
|
||||
cend[stackp]->co_numtimes); |
|
||||
} else |
|
||||
cend[stackp]->co_numtimes = 1; |
|
||||
} else if (eq(wlist->wl_word, "break")) { |
|
||||
cend[stackp]->co_type = CO_BREAK; |
|
||||
if (wlist->wl_next) { |
|
||||
cend[stackp]->co_numtimes = scannum(wlist-> |
|
||||
wl_next->wl_word); |
|
||||
if (wlist->wl_next->wl_next) |
|
||||
fprintf(cp_err, |
|
||||
"Warning: ignored extra junk after break %d.\n", |
|
||||
cend[stackp]->co_numtimes); |
|
||||
} else |
|
||||
cend[stackp]->co_numtimes = 1; |
|
||||
} else if (eq(wlist->wl_word, "end")) { |
|
||||
/* Throw away this thing. */ |
|
||||
if (!cend[stackp]->co_parent) { |
|
||||
fprintf(stderr, "Error: no block to end.\n"); |
|
||||
cend[stackp]->co_type = CO_UNFILLED; |
|
||||
} else if (cend[stackp]->co_prev) { |
|
||||
cend[stackp]->co_prev->co_next = NULL; |
|
||||
x = cend[stackp]; |
|
||||
cend[stackp] = cend[stackp]->co_parent; |
|
||||
tfree(x); |
|
||||
} else { |
|
||||
x = cend[stackp]; |
|
||||
cend[stackp] = cend[stackp]->co_parent; |
|
||||
cend[stackp]->co_children = NULL; |
|
||||
tfree(x); |
|
||||
} |
|
||||
} else if (eq(wlist->wl_word, "else")) { |
|
||||
if (!cend[stackp]->co_parent || |
|
||||
(cend[stackp]->co_parent->co_type != |
|
||||
CO_IF)) { |
|
||||
fprintf(stderr, "Error: misplaced else.\n"); |
|
||||
cend[stackp]->co_type = CO_UNFILLED; |
|
||||
} else { |
|
||||
if (cend[stackp]->co_prev) |
|
||||
cend[stackp]->co_prev->co_next = NULL; |
|
||||
else |
|
||||
cend[stackp]->co_parent->co_children = NULL; |
|
||||
cend[stackp]->co_parent->co_elseblock = cend[stackp]; |
|
||||
cend[stackp]->co_prev = NULL; |
|
||||
} |
|
||||
} else { |
|
||||
cend[stackp]->co_type = CO_STATEMENT; |
|
||||
cend[stackp]->co_text = wlist; |
|
||||
} |
|
||||
if (!cend[stackp]->co_parent) { |
|
||||
x = cend[stackp]; |
|
||||
/* We have to toss this do-while loop in here so |
|
||||
* that gotos at the top level will work. |
|
||||
*/ |
|
||||
do { |
|
||||
i = doblock(x, &nn); |
|
||||
switch (*i) { |
|
||||
case NORMAL: |
|
||||
break; |
|
||||
case BROKEN: |
|
||||
fprintf(cp_err, |
|
||||
"Error: break not in loop or too many break levels given\n"); |
|
||||
break; |
|
||||
case CONTINUED: |
|
||||
fprintf(cp_err, |
|
||||
"Error: continue not in loop or too many continue levels given\n"); |
|
||||
break; |
|
||||
default: |
|
||||
x = findlabel(i, control[stackp]); |
|
||||
if (!x) |
|
||||
fprintf(cp_err, "Error: label %s not found\n", i); |
|
||||
} |
|
||||
if (x) |
|
||||
x = x->co_next; |
|
||||
} while (x); |
|
||||
} |
|
||||
if (string) |
|
||||
return (1); /* The return value is irrelevant. */ |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/* Execute a block. There can be a number of return values from this routine. |
|
||||
* NORMAL indicates a normal termination |
|
||||
* BROKEN indicates a break -- if the caller is a breakable loop, |
|
||||
* terminate it, otherwise pass the break upwards |
|
||||
* CONTINUED indicates a continue -- if the caller is a continuable loop, |
|
||||
* continue, else pass the continue upwards |
|
||||
* Any other return code is considered a pointer to a string which is |
|
||||
* a label somewhere -- if this label is present in the block, |
|
||||
* goto it, otherwise pass it up. Note that this prevents jumping |
|
||||
* into a loop, which is good. |
|
||||
* Note that here is where we expand variables, ``, and globs for controls. |
|
||||
* The 'num' argument is used by break n and continue n. |
|
||||
*/ |
|
||||
|
|
||||
static char * |
|
||||
doblock(struct control *bl, int *num) |
|
||||
{ |
|
||||
struct control *ch, *cn = NULL; |
|
||||
wordlist *wl; |
|
||||
char *i; |
|
||||
int nn; |
|
||||
|
|
||||
switch (bl->co_type) { |
|
||||
case CO_WHILE: |
|
||||
while (bl->co_cond && cp_isTRUE(bl->co_cond)) { |
|
||||
for (ch = bl->co_children; ch; ch = cn) { |
|
||||
cn = ch->co_next; |
|
||||
i = doblock(ch, &nn); |
|
||||
switch (*i) { |
|
||||
|
|
||||
case NORMAL: |
|
||||
break; |
|
||||
|
|
||||
case BROKEN: /* Break. */ |
|
||||
if (nn < 2) |
|
||||
return (NORMAL_STR); |
|
||||
else { |
|
||||
*num = nn - 1; |
|
||||
return (BROKEN_STR); |
|
||||
} |
|
||||
|
|
||||
case CONTINUED: /* Continue. */ |
|
||||
if (nn < 2) { |
|
||||
cn = NULL; |
|
||||
break; |
|
||||
} else { |
|
||||
*num = nn - 1; |
|
||||
return (CONTINUED_STR); |
|
||||
} |
|
||||
|
|
||||
default: |
|
||||
cn = findlabel(i, bl->co_children); |
|
||||
if (!cn) |
|
||||
return (i); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case CO_DOWHILE: |
|
||||
do { |
|
||||
for (ch = bl->co_children; ch; ch = cn) { |
|
||||
cn = ch->co_next; |
|
||||
i = doblock(ch, &nn); |
|
||||
switch (*i) { |
|
||||
|
|
||||
case NORMAL: |
|
||||
break; |
|
||||
|
|
||||
case BROKEN: /* Break. */ |
|
||||
if (nn < 2) |
|
||||
return (NORMAL_STR); |
|
||||
else { |
|
||||
*num = nn - 1; |
|
||||
return (BROKEN_STR); |
|
||||
} |
|
||||
|
|
||||
case CONTINUED: /* Continue. */ |
|
||||
if (nn < 2) { |
|
||||
cn = NULL; |
|
||||
break; |
|
||||
} else { |
|
||||
*num = nn - 1; |
|
||||
return (CONTINUED_STR); |
|
||||
} |
|
||||
|
|
||||
default: |
|
||||
cn = findlabel(i, bl->co_children); |
|
||||
if (!cn) |
|
||||
return (i); |
|
||||
} |
|
||||
} |
|
||||
} while (bl->co_cond && cp_isTRUE(bl->co_cond)); |
|
||||
break; |
|
||||
|
|
||||
case CO_REPEAT: |
|
||||
while ((bl->co_numtimes > 0) || |
|
||||
(bl->co_numtimes == -1)) { |
|
||||
if (bl->co_numtimes != -1) |
|
||||
bl->co_numtimes--; |
|
||||
for (ch = bl->co_children; ch; ch = cn) { |
|
||||
cn = ch->co_next; |
|
||||
i = doblock(ch, &nn); |
|
||||
switch (*i) { |
|
||||
|
|
||||
case NORMAL: |
|
||||
break; |
|
||||
|
|
||||
case BROKEN: /* Break. */ |
|
||||
if (nn < 2) |
|
||||
return (NORMAL_STR); |
|
||||
else { |
|
||||
*num = nn - 1; |
|
||||
return (BROKEN_STR); |
|
||||
} |
|
||||
|
|
||||
case CONTINUED: /* Continue. */ |
|
||||
if (nn < 2) { |
|
||||
cn = NULL; |
|
||||
break; |
|
||||
} else { |
|
||||
*num = nn - 1; |
|
||||
return (CONTINUED_STR); |
|
||||
} |
|
||||
|
|
||||
default: |
|
||||
cn = findlabel(i, bl->co_children); |
|
||||
if (!cn) |
|
||||
return (i); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case CO_IF: |
|
||||
if (bl->co_cond && cp_isTRUE(bl->co_cond)) { |
|
||||
for (ch = bl->co_children; ch; ch = cn) { |
|
||||
cn = ch->co_next; |
|
||||
i = doblock(ch, &nn); |
|
||||
if (*i > 2) { |
|
||||
cn = findlabel(i, |
|
||||
bl->co_children); |
|
||||
if (!cn) |
|
||||
return (i); |
|
||||
} else if (*i != NORMAL) { |
|
||||
*num = nn; |
|
||||
return (i); |
|
||||
} |
|
||||
} |
|
||||
} else { |
|
||||
for (ch = bl->co_elseblock; ch; ch = cn) { |
|
||||
cn = ch->co_next; |
|
||||
i = doblock(ch, &nn); |
|
||||
if (*i > 2) { |
|
||||
cn = findlabel(i, |
|
||||
bl->co_elseblock); |
|
||||
if (!cn) |
|
||||
return (i); |
|
||||
} else if (*i != NORMAL) { |
|
||||
*num = nn; |
|
||||
return (i); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case CO_FOREACH: |
|
||||
for (wl = cp_variablesubst(cp_bquote(cp_doglob(wl_copy(bl->co_text)))); |
|
||||
wl; |
|
||||
wl = wl->wl_next) { |
|
||||
cp_vset(bl->co_foreachvar, VT_STRING, wl->wl_word); |
|
||||
for (ch = bl->co_children; ch; ch = cn) { |
|
||||
cn = ch->co_next; |
|
||||
i = doblock(ch, &nn); |
|
||||
switch (*i) { |
|
||||
|
|
||||
case NORMAL: |
|
||||
break; |
|
||||
|
|
||||
case BROKEN: /* Break. */ |
|
||||
if (nn < 2) |
|
||||
return (NORMAL_STR); |
|
||||
else { |
|
||||
*num = nn - 1; |
|
||||
return (BROKEN_STR); |
|
||||
} |
|
||||
|
|
||||
case CONTINUED: /* Continue. */ |
|
||||
if (nn < 2) { |
|
||||
cn = NULL; |
|
||||
break; |
|
||||
} else { |
|
||||
*num = nn - 1; |
|
||||
return (CONTINUED_STR); |
|
||||
} |
|
||||
|
|
||||
default: |
|
||||
cn = findlabel(i, bl->co_children); |
|
||||
if (!cn) |
|
||||
return (i); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case CO_BREAK: |
|
||||
if (bl->co_numtimes > 0) { |
|
||||
*num = bl->co_numtimes; |
|
||||
return (BROKEN_STR); |
|
||||
} else { |
|
||||
fprintf(cp_err, "Warning: break %d a no-op\n", |
|
||||
bl->co_numtimes); |
|
||||
return (NORMAL_STR); |
|
||||
} |
|
||||
|
|
||||
case CO_CONTINUE: |
|
||||
if (bl->co_numtimes > 0) { |
|
||||
*num = bl->co_numtimes; |
|
||||
return (CONTINUED_STR); |
|
||||
} else { |
|
||||
fprintf(cp_err, "Warning: continue %d a no-op\n", |
|
||||
bl->co_numtimes); |
|
||||
return (NORMAL_STR); |
|
||||
} |
|
||||
|
|
||||
case CO_GOTO: |
|
||||
wl = cp_variablesubst(cp_bquote(cp_doglob( |
|
||||
wl_copy(bl->co_text)))); |
|
||||
return (wl->wl_word); |
|
||||
|
|
||||
case CO_LABEL: |
|
||||
/* Do nothing. */ |
|
||||
break; |
|
||||
|
|
||||
case CO_STATEMENT: |
|
||||
docommand(wl_copy(bl->co_text)); |
|
||||
break; |
|
||||
|
|
||||
case CO_UNFILLED: |
|
||||
/* There was probably an error here... */ |
|
||||
fprintf(cp_err, "Warning: ignoring previous error\n"); |
|
||||
break; |
|
||||
|
|
||||
default: |
|
||||
fprintf(cp_err, |
|
||||
"doblock: Internal Error: bad block type %d\n", |
|
||||
bl->co_type); |
|
||||
return (NORMAL_STR); |
|
||||
} |
|
||||
return (NORMAL_STR); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
static struct control * |
|
||||
findlabel(char *s, struct control *ct) |
|
||||
{ |
|
||||
while (ct) { |
|
||||
if ((ct->co_type == CO_LABEL) && eq(s, ct->co_text->wl_word)) |
|
||||
break; |
|
||||
ct = ct->co_next; |
|
||||
} |
|
||||
return (ct); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* This blows away the control structures... */ |
|
||||
void |
|
||||
cp_resetcontrol(void) |
|
||||
{ |
|
||||
if (cend[stackp] && cend[stackp]->co_parent) |
|
||||
fprintf(cp_err, "Warning: EOF before block terminated\n"); |
|
||||
/* We probably should free the control structures... */ |
|
||||
control[0] = cend[0] = NULL; |
|
||||
stackp = 0; |
|
||||
cp_kwswitch(CT_LABEL, (char *) NULL); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* Push or pop a new control structure set... */ |
|
||||
void |
|
||||
cp_popcontrol(void) |
|
||||
{ |
|
||||
if (cp_debug) |
|
||||
fprintf(cp_err, "pop: stackp: %d -> %d\n", stackp, stackp - 1); |
|
||||
if (stackp < 1) |
|
||||
fprintf(cp_err, "cp_popcontrol: Internal Error: stack empty\n"); |
|
||||
else |
|
||||
stackp--; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
void |
|
||||
cp_pushcontrol(void) |
|
||||
{ |
|
||||
if (cp_debug) |
|
||||
fprintf(cp_err, "push: stackp: %d -> %d\n", stackp, stackp + 1); |
|
||||
if (stackp > CONTROLSTACKSIZE - 2) { |
|
||||
fprintf(cp_err, "Error: stack overflow -- max depth = %d\n", |
|
||||
CONTROLSTACKSIZE); |
|
||||
stackp = 0; |
|
||||
} else { |
|
||||
stackp++; |
|
||||
control[stackp] = cend[stackp] = NULL; |
|
||||
} |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* And this returns to the top level (for use in the interrupt handlers). */ |
|
||||
void |
|
||||
cp_toplevel(void) |
|
||||
{ |
|
||||
stackp = 0; |
|
||||
if (cend[stackp]) |
|
||||
while (cend[stackp]->co_parent) |
|
||||
cend[stackp] = cend[stackp]->co_parent; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* Note that we only do io redirection when we get to here - we also |
|
||||
* postpone some other things until now. */ |
|
||||
static void |
|
||||
docommand(register wordlist *wlist) |
|
||||
{ |
|
||||
register char *r, *s, *t; |
|
||||
char *lcom; |
|
||||
int nargs; |
|
||||
register int i; |
|
||||
struct comm *command; |
|
||||
wordlist *wl, *nextc, *ee, *rwlist; |
|
||||
|
|
||||
if (cp_debug) { |
|
||||
printf("docommand "); |
|
||||
wl_print(wlist, stdout); |
|
||||
putc('\n', stdout); |
|
||||
} |
|
||||
|
|
||||
/* Do all the things that used to be done by cshpar when the line |
|
||||
* was read... */ |
|
||||
wlist = cp_variablesubst(wlist); |
|
||||
pwlist(wlist, "After variable substitution"); |
|
||||
|
|
||||
wlist = cp_bquote(wlist); |
|
||||
pwlist(wlist, "After backquote substitution"); |
|
||||
|
|
||||
wlist = cp_doglob(wlist); |
|
||||
pwlist(wlist, "After globbing"); |
|
||||
|
|
||||
if (!wlist || !wlist->wl_word) |
|
||||
return; |
|
||||
|
|
||||
/* Now loop through all of the commands given. */ |
|
||||
rwlist = wlist; |
|
||||
do { |
|
||||
for (nextc = wlist; nextc; nextc = nextc->wl_next) |
|
||||
if (eq(nextc->wl_word, cp_csep)) |
|
||||
break; |
|
||||
|
|
||||
/* Temporarily hide the rest of the command... */ |
|
||||
if (nextc && nextc->wl_prev) |
|
||||
nextc->wl_prev->wl_next = NULL; |
|
||||
ee = wlist->wl_prev; |
|
||||
if (ee) |
|
||||
wlist->wl_prev = NULL; |
|
||||
|
|
||||
if (nextc == wlist) { |
|
||||
/* There was no text... */ |
|
||||
goto out; |
|
||||
} |
|
||||
|
|
||||
/* And do the redirection. */ |
|
||||
cp_ioreset(); |
|
||||
for (i = 0; noredirect[i]; i++) |
|
||||
if (eq(wlist->wl_word, noredirect[i])) |
|
||||
break; |
|
||||
if (!noredirect[i]) { |
|
||||
if (!(wlist = cp_redirect(wlist))) { |
|
||||
cp_ioreset(); |
|
||||
return; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/* Get rid of all the 8th bits now... */ |
|
||||
cp_striplist(wlist); |
|
||||
|
|
||||
s = wlist->wl_word; |
|
||||
|
|
||||
/* Look for the command in the command list. */ |
|
||||
for (i = 0; cp_coms[i].co_comname; i++) { |
|
||||
/* strcmp(cp_coms[i].co_comname, s) ... */ |
|
||||
for (t = cp_coms[i].co_comname, r = s; *t && *r; |
|
||||
t++, r++) |
|
||||
if (*t != *r) |
|
||||
break; |
|
||||
if (!*t && !*r) |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
/* Now give the user-supplied command routine a try... */ |
|
||||
if (!cp_coms[i].co_func && cp_oddcomm(s, wlist->wl_next)) |
|
||||
goto out; |
|
||||
|
|
||||
/* If it's not there, try it as a unix command. */ |
|
||||
if (!cp_coms[i].co_comname) { |
|
||||
if (cp_dounixcom && cp_unixcom(wlist)) |
|
||||
goto out; |
|
||||
fprintf(cp_err,"%s: no such command available in %s\n", |
|
||||
s, cp_program); |
|
||||
goto out; |
|
||||
|
|
||||
/* If it's there but spiceonly, and this is nutmeg, error. */ |
|
||||
} else if (!cp_coms[i].co_func && ft_nutmeg && |
|
||||
(cp_coms[i].co_spiceonly)) { |
|
||||
fprintf(cp_err,"%s: command available only in spice\n", |
|
||||
s); |
|
||||
goto out; |
|
||||
} |
|
||||
|
|
||||
/* The command was a valid spice/nutmeg command. */ |
|
||||
command = &cp_coms[i]; |
|
||||
nargs = 0; |
|
||||
for (wl = wlist->wl_next; wl; wl = wl->wl_next) |
|
||||
nargs++; |
|
||||
if (command->co_stringargs) { |
|
||||
lcom = wl_flatten(wlist->wl_next); |
|
||||
(*command->co_func) (lcom); |
|
||||
} else { |
|
||||
if (nargs < command->co_minargs) { |
|
||||
if (command->co_argfn) { |
|
||||
(*command->co_argfn) (wlist->wl_next, command); |
|
||||
} else { |
|
||||
fprintf(cp_err, "%s: too few args.\n", s); |
|
||||
} |
|
||||
} else if (nargs > command->co_maxargs) { |
|
||||
fprintf(cp_err, "%s: too many args.\n", s); |
|
||||
} else |
|
||||
(*command->co_func) (wlist->wl_next); |
|
||||
} |
|
||||
|
|
||||
/* Now fix the pointers and advance wlist. */ |
|
||||
out: wlist->wl_prev = ee; |
|
||||
if (nextc) { |
|
||||
if (nextc->wl_prev) |
|
||||
nextc->wl_prev->wl_next = nextc; |
|
||||
wlist = nextc->wl_next; |
|
||||
} |
|
||||
} while (nextc && wlist); |
|
||||
|
|
||||
wl_free(rwlist); |
|
||||
|
|
||||
/* Do periodic sorts of things... */ |
|
||||
cp_periodic(); |
|
||||
|
|
||||
cp_ioreset(); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* Get a command. This does all the bookkeeping things like turning |
|
||||
* command completion on and off... */ |
|
||||
static wordlist * |
|
||||
getcommand(char *string) |
|
||||
{ |
|
||||
wordlist *wlist; |
|
||||
int i = 0, j; |
|
||||
static char buf[64]; |
|
||||
struct control *c; |
|
||||
|
|
||||
if (cp_debug) |
|
||||
fprintf(cp_err, "calling getcommand %s\n", |
|
||||
string ? string : ""); |
|
||||
if (cend[stackp]) { |
|
||||
for (c = cend[stackp]->co_parent; c; c = c->co_parent) |
|
||||
i++; |
|
||||
if (i) { |
|
||||
for (j = 0; j < i; j++) |
|
||||
buf[j] = '>'; |
|
||||
buf[j] = ' '; |
|
||||
buf[j + 1] = '\0'; |
|
||||
cp_altprompt = buf; |
|
||||
} else |
|
||||
cp_altprompt = NULL; |
|
||||
} else |
|
||||
cp_altprompt = NULL; |
|
||||
|
|
||||
cp_cwait = TRUE; |
|
||||
wlist = cp_parse(string); |
|
||||
cp_cwait = FALSE; |
|
||||
if (cp_debug) { |
|
||||
printf("getcommand "); |
|
||||
wl_print(wlist, stdout); |
|
||||
putc('\n', stdout); |
|
||||
} |
|
||||
return (wlist); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
/* This is also in cshpar.c ... */ |
|
||||
static void |
|
||||
pwlist(wordlist *wlist, char *name) |
|
||||
{ |
|
||||
wordlist *wl; |
|
||||
|
|
||||
if (!cp_debug) |
|
||||
return; |
|
||||
fprintf(cp_err, "%s : [ ", name); |
|
||||
for (wl = wlist; wl; wl = wl->wl_next) |
|
||||
fprintf(cp_err, "%s ", wl->wl_word); |
|
||||
fprintf(cp_err, "]\n"); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
static int indent; |
|
||||
|
|
||||
|
|
||||
void |
|
||||
com_cdump(wordlist *wl) |
|
||||
{ |
|
||||
struct control *c; |
|
||||
|
|
||||
indent = 0; |
|
||||
for (c = control[stackp]; c; c = c->co_next) |
|
||||
dodump(c); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
#define tab(num) for (i = 0; i < num; i++) putc(' ', cp_out); |
|
||||
|
|
||||
static void |
|
||||
dodump(struct control *cc) |
|
||||
{ |
|
||||
int i; |
|
||||
struct control *tc; |
|
||||
|
|
||||
switch (cc->co_type) { |
|
||||
case CO_UNFILLED: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "(unfilled)\n"); |
|
||||
break; |
|
||||
case CO_STATEMENT: |
|
||||
tab(indent); |
|
||||
wl_print(cc->co_text, cp_out); |
|
||||
putc('\n', cp_out); |
|
||||
break; |
|
||||
case CO_WHILE: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "while "); |
|
||||
wl_print(cc->co_cond, cp_out); |
|
||||
putc('\n', cp_out); |
|
||||
indent += 8; |
|
||||
for (tc = cc->co_children; tc; tc = tc->co_next) |
|
||||
dodump(tc); |
|
||||
indent -= 8; |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "end\n"); |
|
||||
break; |
|
||||
case CO_REPEAT: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "repeat "); |
|
||||
if (cc->co_numtimes != -1) |
|
||||
fprintf(cp_out, "%d\n", cc->co_numtimes); |
|
||||
else |
|
||||
putc('\n', cp_out); |
|
||||
indent += 8; |
|
||||
for (tc = cc->co_children; tc; tc = tc->co_next) |
|
||||
dodump(tc); |
|
||||
indent -= 8; |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "end\n"); |
|
||||
break; |
|
||||
case CO_DOWHILE: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "dowhile "); |
|
||||
wl_print(cc->co_cond, cp_out); |
|
||||
putc('\n', cp_out); |
|
||||
indent += 8; |
|
||||
for (tc = cc->co_children; tc; tc = tc->co_next) |
|
||||
dodump(tc); |
|
||||
indent -= 8; |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "end\n"); |
|
||||
break; |
|
||||
case CO_IF: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "if "); |
|
||||
wl_print(cc->co_cond, cp_out); |
|
||||
putc('\n', cp_out); |
|
||||
indent += 8; |
|
||||
for (tc = cc->co_children; tc; tc = tc->co_next) |
|
||||
dodump(tc); |
|
||||
indent -= 8; |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "end\n"); |
|
||||
break; |
|
||||
case CO_FOREACH: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "foreach %s ", cc->co_foreachvar); |
|
||||
wl_print(cc->co_text, cp_out); |
|
||||
putc('\n', cp_out); |
|
||||
indent += 8; |
|
||||
for (tc = cc->co_children; tc; tc = tc->co_next) |
|
||||
dodump(tc); |
|
||||
indent -= 8; |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "end\n"); |
|
||||
break; |
|
||||
case CO_BREAK: |
|
||||
tab(indent); |
|
||||
if (cc->co_numtimes != 1) |
|
||||
fprintf(cp_out, "break %d\n", cc->co_numtimes); |
|
||||
else |
|
||||
fprintf(cp_out, "break\n"); |
|
||||
break; |
|
||||
case CO_CONTINUE: |
|
||||
tab(indent); |
|
||||
if (cc->co_numtimes != 1) |
|
||||
fprintf(cp_out, "continue %d\n", |
|
||||
cc->co_numtimes); |
|
||||
else |
|
||||
fprintf(cp_out, "continue\n"); |
|
||||
break; |
|
||||
case CO_LABEL: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "label %s\n", cc->co_text->wl_word); |
|
||||
break; |
|
||||
case CO_GOTO: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "goto %s\n", cc->co_text->wl_word); |
|
||||
break; |
|
||||
default: |
|
||||
tab(indent); |
|
||||
fprintf(cp_out, "bad type %d\n", cc->co_type); |
|
||||
break; |
|
||||
} |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
@ -1,40 +0,0 @@ |
|||||
/************* |
|
||||
* Header file for front.c |
|
||||
* 1999 E. Rouat |
|
||||
************/ |
|
||||
|
|
||||
#ifndef FRONT_H_INCLUDED |
|
||||
#define FRONT_H_INCLUDED |
|
||||
|
|
||||
/* Stuff to do control structures. We keep a history (seperate from the |
|
||||
* cshpar history, for now at least) of commands and their event numbers, |
|
||||
* with a block considered as a statement. In a goto, the first word in |
|
||||
* co_text is where to go, likewise for label. For conditional controls, |
|
||||
* we have to call ft_getpnames and ft_evaluate each time, since the |
|
||||
* dvec pointers will change... Also we should do variable and backquote |
|
||||
* substitution each time... |
|
||||
*/ |
|
||||
|
|
||||
struct control { |
|
||||
int co_type; /* One of CO_* ... */ |
|
||||
wordlist *co_cond; /* if, while, dowhile */ |
|
||||
char *co_foreachvar; /* foreach */ |
|
||||
int co_numtimes; /* repeat, break & continue levels */ |
|
||||
wordlist *co_text; /* Ordinary text and foreach values. */ |
|
||||
struct control *co_parent; /* If this is inside a block. */ |
|
||||
struct control *co_children; /* The contents of this block. */ |
|
||||
struct control *co_elseblock; /* For if-then-else. */ |
|
||||
struct control *co_next; |
|
||||
struct control *co_prev; |
|
||||
} ; |
|
||||
|
|
||||
int cp_evloop(char *string); |
|
||||
void cp_resetcontrol(void); |
|
||||
void cp_popcontrol(void); |
|
||||
void cp_pushcontrol(void); |
|
||||
void cp_toplevel(void); |
|
||||
void com_cdump(wordlist *wl); |
|
||||
|
|
||||
|
|
||||
|
|
||||
#endif |
|
||||
@ -1,489 +0,0 @@ |
|||||
/********** |
|
||||
Copyright 1990 Regents of the University of California. All rights reserved. |
|
||||
Author: 1985 Wayne A. Christopher, U. C. Berkeley CAD Group |
|
||||
**********/ |
|
||||
|
|
||||
/* |
|
||||
* Do history substitutions. |
|
||||
*/ |
|
||||
|
|
||||
#include "ngspice.h" |
|
||||
#include "cpdefs.h" |
|
||||
#include "history.h" |
|
||||
|
|
||||
|
|
||||
/* static declarations */ |
|
||||
static wordlist * dohsubst(char *string); |
|
||||
static wordlist * dohmod(char **string, wordlist *wl); |
|
||||
static wordlist * hpattern(char *buf); |
|
||||
static wordlist * hprefix(char *buf); |
|
||||
static wordlist * getevent(int num); |
|
||||
static void freehist(int num); |
|
||||
static char * dohs(char *pat, char *str); |
|
||||
|
|
||||
|
|
||||
struct histent *cp_lastone = NULL; |
|
||||
int cp_maxhistlength = 10000; /* Chris Inbody */ |
|
||||
char cp_hat = '^'; |
|
||||
char cp_bang = '!'; |
|
||||
bool cp_didhsubst; |
|
||||
|
|
||||
static struct histent *histlist = NULL; |
|
||||
static int histlength = 0; |
|
||||
|
|
||||
/* First check for a ^ at the beginning |
|
||||
* of the line, and then search each word for !. Following this can be any |
|
||||
* of string, number, ?string, -number ; then there may be a word specifier, |
|
||||
* the same as csh, and then the : modifiers. For the :s modifier, |
|
||||
* the syntax is :sXoooXnnnX, where X is any character, and ooo and nnn are |
|
||||
* strings not containing X. |
|
||||
*/ |
|
||||
|
|
||||
wordlist * |
|
||||
cp_histsubst(wordlist *wlist) |
|
||||
{ |
|
||||
wordlist *nwl, *w, *n; |
|
||||
char buf[BSIZE_SP], *s, *b; |
|
||||
|
|
||||
/* Replace ^old^new with !:s^old^new. */ |
|
||||
|
|
||||
cp_didhsubst = FALSE; |
|
||||
if (*wlist->wl_word == cp_hat) { |
|
||||
(void) sprintf(buf, "%c%c:s%s", cp_bang, cp_bang, |
|
||||
wlist->wl_word); |
|
||||
tfree(wlist->wl_word); |
|
||||
wlist->wl_word = copy(buf); |
|
||||
} |
|
||||
for (w = wlist; w; w = w->wl_next) { |
|
||||
b = w->wl_word; |
|
||||
for (s = b; *s; s++) |
|
||||
if (*s == cp_bang) { |
|
||||
cp_didhsubst = TRUE; |
|
||||
n = dohsubst(s + 1); |
|
||||
if (!n) { |
|
||||
wlist->wl_word = NULL; |
|
||||
return (wlist); |
|
||||
} |
|
||||
if (b < s) { |
|
||||
(void) sprintf(buf, "%.*s%s", s - b, b, |
|
||||
n->wl_word); |
|
||||
tfree(n->wl_word); |
|
||||
n->wl_word = copy(buf); |
|
||||
} |
|
||||
nwl = wl_splice(w, n); |
|
||||
if (wlist == w) |
|
||||
wlist = n; |
|
||||
w = nwl; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
return (wlist); |
|
||||
} |
|
||||
|
|
||||
/* Do a history substitution on one word. Figure out which event is |
|
||||
* being referenced, then do word selections and modifications, and |
|
||||
* then stick anything left over on the end of the last word. |
|
||||
*/ |
|
||||
|
|
||||
static wordlist * |
|
||||
dohsubst(char *string) |
|
||||
{ |
|
||||
wordlist *wl, *nwl; |
|
||||
char buf[BSIZE_SP], *s, *r = NULL, *t; |
|
||||
|
|
||||
if (*string == cp_bang) { |
|
||||
if (cp_lastone) { |
|
||||
wl = cp_lastone->hi_wlist; |
|
||||
string++; |
|
||||
} else { |
|
||||
fprintf(cp_err, "0: event not found.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
} else { |
|
||||
switch(*string) { |
|
||||
|
|
||||
case '-': |
|
||||
wl = getevent(cp_event - scannum(++string)); |
|
||||
if (!wl) |
|
||||
return (NULL); |
|
||||
while (isdigit(*string)) |
|
||||
string++; |
|
||||
break; |
|
||||
|
|
||||
case '?': |
|
||||
(void) strcpy(buf, string + 1); |
|
||||
if ((s =strchr(buf, '?'))) |
|
||||
*s = '\0'; |
|
||||
wl = hpattern(buf); |
|
||||
if (!wl) |
|
||||
return (NULL); |
|
||||
if (s == NULL) /* No modifiers on this one. */ |
|
||||
return (wl_copy(wl)); |
|
||||
break; |
|
||||
|
|
||||
case '\0': /* Maybe this should be cp_event. */ |
|
||||
wl = alloc(struct wordlist); |
|
||||
wl->wl_word = copy("!"); |
|
||||
wl->wl_next = NULL; |
|
||||
wl->wl_prev = NULL; |
|
||||
cp_didhsubst = FALSE; |
|
||||
return (wl); |
|
||||
|
|
||||
default: |
|
||||
if (isdigit(*string)) { |
|
||||
wl = getevent(scannum(string)); |
|
||||
if (!wl) |
|
||||
return (NULL); |
|
||||
while (isdigit(*string)) |
|
||||
string++; |
|
||||
} else { |
|
||||
(void) strcpy(buf, string); |
|
||||
for (s = ":^$*-%"; *s; s++) { |
|
||||
t =strchr(buf, *s); |
|
||||
if (t && ((t < r) || !r)) { |
|
||||
r = t; |
|
||||
string += r - buf; |
|
||||
} |
|
||||
} |
|
||||
if (r) |
|
||||
*r = '\0'; |
|
||||
else |
|
||||
while (*string) |
|
||||
string++; |
|
||||
if ((buf[0] == '\0') && cp_lastone) |
|
||||
wl = cp_lastone->hi_wlist; |
|
||||
else |
|
||||
wl = hprefix(buf); |
|
||||
if (!wl) |
|
||||
return (NULL); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
if (wl == NULL) { /* Shouldn't happen. */ |
|
||||
fprintf(cp_err, "Event not found.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
nwl = dohmod(&string, wl_copy(wl)); |
|
||||
if (!nwl) |
|
||||
return (NULL); |
|
||||
if (*string) { |
|
||||
for (wl = nwl; wl->wl_next; wl = wl->wl_next) |
|
||||
; |
|
||||
(void) sprintf(buf, "%s%s", wl->wl_word, string); |
|
||||
tfree(wl->wl_word); |
|
||||
wl->wl_word = copy(buf); |
|
||||
} |
|
||||
return (nwl); |
|
||||
} |
|
||||
|
|
||||
static wordlist * |
|
||||
dohmod(char **string, wordlist *wl) |
|
||||
{ |
|
||||
wordlist *w; |
|
||||
char *s; |
|
||||
char *r = NULL, *t; |
|
||||
int numwords, eventlo, eventhi, i; |
|
||||
bool globalsubst; |
|
||||
|
|
||||
anothermod: |
|
||||
numwords = wl_length(wl); |
|
||||
globalsubst = FALSE; |
|
||||
eventlo = 0; |
|
||||
eventhi = numwords - 1; |
|
||||
|
|
||||
/* Now we know what wordlist we want. Take care of modifiers now. */ |
|
||||
r = NULL; |
|
||||
for (s = ":^$*-%"; *s; s++) { |
|
||||
t =strchr(*string, *s); |
|
||||
if (t && ((t < r) || (r == NULL))) |
|
||||
r = t; |
|
||||
} |
|
||||
if (!r) /* No more modifiers. */ |
|
||||
return (wl); |
|
||||
|
|
||||
*string = r; |
|
||||
if (**string == ':') |
|
||||
(*string)++; |
|
||||
|
|
||||
switch(**string) { |
|
||||
case '$': /* Last word. */ |
|
||||
eventhi = eventlo = numwords - 1; |
|
||||
break; |
|
||||
case '*': /* Words 1 through $ */ |
|
||||
if (numwords == 1) |
|
||||
return (NULL); |
|
||||
eventlo = 1; |
|
||||
eventhi = numwords - 1; |
|
||||
break; |
|
||||
case '-': /* Words 0 through ... */ |
|
||||
eventlo = 0; |
|
||||
if (*(*string + 1)) |
|
||||
eventhi = scannum(*string + 1); |
|
||||
else |
|
||||
eventhi = numwords - 1; |
|
||||
if (eventhi > numwords - 1) |
|
||||
eventhi = numwords - 1; |
|
||||
break; |
|
||||
case 'p': /* Print the command and don't execute it. |
|
||||
* This doesn't work quite like csh. |
|
||||
*/ |
|
||||
wl_print(wl, cp_out); |
|
||||
(void) putc('\n', cp_out); |
|
||||
return (NULL); |
|
||||
case 's': /* Do a substitution. */ |
|
||||
for (w = wl; w; w = w->wl_next) { |
|
||||
s = dohs(*string + 1, w->wl_word); |
|
||||
if (s) { |
|
||||
tfree(w->wl_word); |
|
||||
w->wl_word = s; |
|
||||
if (globalsubst == FALSE) { |
|
||||
while (**string) |
|
||||
(*string)++; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
/* In case globalsubst is TRUE... */ |
|
||||
while (**string) |
|
||||
(*string)++; |
|
||||
break; |
|
||||
default: |
|
||||
if (!isdigit(**string)) { |
|
||||
fprintf(cp_err, "Error: %s: bad modifier.\n", |
|
||||
*string); |
|
||||
return (NULL); |
|
||||
} |
|
||||
i = scannum(*string); |
|
||||
if (i > eventhi) { |
|
||||
fprintf(cp_err, "Error: bad event number %d\n", |
|
||||
i); |
|
||||
return (NULL); |
|
||||
} |
|
||||
eventhi = eventlo = i; |
|
||||
while (isdigit(**string)) |
|
||||
(*string)++; |
|
||||
if (**string == '*') |
|
||||
eventhi = numwords - 1; |
|
||||
if (**string == '-') { |
|
||||
if (!isdigit(*(*string + 1))) |
|
||||
eventhi = numwords - 1; |
|
||||
else { |
|
||||
eventhi = scannum(++*string); |
|
||||
while (isdigit(**string)) |
|
||||
(*string)++; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
/* Now change the word list accordingly and make another pass |
|
||||
* if there is more of the substitute left. |
|
||||
*/ |
|
||||
|
|
||||
wl = wl_range(wl, eventlo, eventhi); |
|
||||
numwords = wl_length(wl); |
|
||||
if (**string && *++*string) |
|
||||
goto anothermod; |
|
||||
return (wl); |
|
||||
} |
|
||||
|
|
||||
/* Look for an event with a pattern in it... */ |
|
||||
|
|
||||
static wordlist * |
|
||||
hpattern(char *buf) |
|
||||
{ |
|
||||
struct histent *hi; |
|
||||
wordlist *wl; |
|
||||
|
|
||||
if (*buf == '\0') { |
|
||||
fprintf(cp_err, "Bad pattern specification.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
for (hi = cp_lastone; hi; hi = hi->hi_prev) |
|
||||
for (wl = hi->hi_wlist; wl; wl = wl->wl_next) |
|
||||
if (substring(buf, wl->wl_word)) |
|
||||
return (hi->hi_wlist); |
|
||||
fprintf(cp_err, "%s: event not found.\n", buf); |
|
||||
return (NULL); |
|
||||
} |
|
||||
|
|
||||
static wordlist * |
|
||||
hprefix(char *buf) |
|
||||
{ |
|
||||
struct histent *hi; |
|
||||
|
|
||||
if (*buf == '\0') { |
|
||||
fprintf(cp_err, "Bad pattern specification.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
for (hi = cp_lastone; hi; hi = hi->hi_prev) |
|
||||
if (hi->hi_wlist && prefix(buf, hi->hi_wlist->wl_word)) |
|
||||
return (hi->hi_wlist); |
|
||||
fprintf(cp_err, "%s: event not found.\n", buf); |
|
||||
return (NULL); |
|
||||
} |
|
||||
|
|
||||
/* Add a wordlist to the history list. (Done after the first parse.) Note |
|
||||
* that if event numbers are given in a random order that's how they'll |
|
||||
* show up in the history list. |
|
||||
*/ |
|
||||
|
|
||||
void |
|
||||
cp_addhistent(int event, wordlist *wlist) |
|
||||
{ |
|
||||
if (cp_lastone && !cp_lastone->hi_wlist) |
|
||||
fprintf(cp_err, "Internal error: bad history list\n"); |
|
||||
if (cp_lastone == NULL) { |
|
||||
cp_lastone = histlist = alloc(struct histent); |
|
||||
cp_lastone->hi_prev = NULL; |
|
||||
} else { |
|
||||
cp_lastone->hi_next = alloc(struct histent); |
|
||||
cp_lastone->hi_next->hi_prev = cp_lastone; |
|
||||
cp_lastone = cp_lastone->hi_next; |
|
||||
} |
|
||||
cp_lastone->hi_next = NULL; |
|
||||
cp_lastone->hi_event = event; |
|
||||
cp_lastone->hi_wlist = wl_copy(wlist); |
|
||||
freehist(histlength - cp_maxhistlength); |
|
||||
histlength++; |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
/* Get a copy of the wordlist associated with an event. Error if out |
|
||||
* of range. |
|
||||
*/ |
|
||||
|
|
||||
static wordlist * |
|
||||
getevent(int num) |
|
||||
{ |
|
||||
struct histent *hi; |
|
||||
|
|
||||
for (hi = histlist; hi; hi = hi->hi_next) |
|
||||
if (hi->hi_event == num) |
|
||||
break; |
|
||||
if (hi == NULL) { |
|
||||
fprintf(cp_err, "%d: event not found.\n", num); |
|
||||
return (NULL); |
|
||||
} |
|
||||
return (wl_copy(hi->hi_wlist)); |
|
||||
} |
|
||||
|
|
||||
/* Print out history between eventhi and eventlo. |
|
||||
* This doesn't remember quoting, so 'hodedo' prints as hodedo. |
|
||||
*/ |
|
||||
|
|
||||
void |
|
||||
cp_hprint(int eventhi, int eventlo, bool rev) |
|
||||
{ |
|
||||
struct histent *hi; |
|
||||
|
|
||||
if (rev) { |
|
||||
for (hi = histlist; hi->hi_next; hi = hi->hi_next) |
|
||||
; |
|
||||
for (; hi; hi = hi->hi_prev) |
|
||||
if ((hi->hi_event <= eventhi) && |
|
||||
(hi->hi_event >= eventlo) && |
|
||||
hi->hi_wlist) { |
|
||||
fprintf(cp_out, "%d\t", hi->hi_event); |
|
||||
wl_print(hi->hi_wlist, cp_out); |
|
||||
(void) putc('\n', cp_out); |
|
||||
} |
|
||||
} else { |
|
||||
for (hi = histlist; hi; hi = hi->hi_next) |
|
||||
if ((hi->hi_event <= eventhi) && |
|
||||
(hi->hi_event >= eventlo) && |
|
||||
hi->hi_wlist) { |
|
||||
fprintf(cp_out, "%d\t", hi->hi_event); |
|
||||
wl_print(hi->hi_wlist, cp_out); |
|
||||
(void) putc('\n', cp_out); |
|
||||
} |
|
||||
} |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
/* This just gets rid of the first num entries on the history list, and |
|
||||
* decrements histlength. |
|
||||
*/ |
|
||||
|
|
||||
static void |
|
||||
freehist(int num) |
|
||||
{ |
|
||||
struct histent *hi; |
|
||||
|
|
||||
if (num < 1) |
|
||||
return; |
|
||||
histlength -= num; |
|
||||
hi = histlist; |
|
||||
while (num-- && histlist->hi_next) |
|
||||
histlist = histlist->hi_next; |
|
||||
if (histlist->hi_prev) { |
|
||||
histlist->hi_prev->hi_next = NULL; |
|
||||
histlist->hi_prev = NULL; |
|
||||
} else |
|
||||
{ |
|
||||
fprintf(cp_err, "Internal error: history list mangled\n"); |
|
||||
exit(0); /* Chris Inbody */ |
|
||||
} |
|
||||
while (hi->hi_next) { |
|
||||
wl_free(hi->hi_wlist); |
|
||||
hi = hi->hi_next; |
|
||||
tfree(hi->hi_prev); |
|
||||
} |
|
||||
wl_free(hi->hi_wlist); |
|
||||
tfree(hi); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
/* Do a :s substitution. */ |
|
||||
|
|
||||
static char * |
|
||||
dohs(char *pat, char *str) |
|
||||
{ |
|
||||
char schar, *s, *p, buf[BSIZE_SP]; |
|
||||
int i = 0, plen; |
|
||||
bool ok = FALSE; |
|
||||
|
|
||||
pat = copy(pat); /* Don't want to mangle anything. */ |
|
||||
schar = *pat++; |
|
||||
s =strchr(pat, schar); |
|
||||
if (s == NULL) { |
|
||||
fprintf(cp_err, "Bad substitute.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
*s++ = '\0'; |
|
||||
p =strchr(s, schar); |
|
||||
if (p) |
|
||||
*p = '\0'; |
|
||||
plen = strlen(pat) - 1; |
|
||||
for (i = 0; *str; str++) { |
|
||||
if ((*str == *pat) && prefix(pat, str) && (ok == FALSE)) { |
|
||||
for (p = s; *p; p++) |
|
||||
buf[i++] = *p; |
|
||||
str += plen; |
|
||||
ok = TRUE; |
|
||||
} else |
|
||||
buf[i++] = *str; |
|
||||
} |
|
||||
buf[i] = '\0'; |
|
||||
if (ok) |
|
||||
return (copy(buf)); |
|
||||
else |
|
||||
return (NULL); |
|
||||
} |
|
||||
|
|
||||
/* The "history" command. history [-r] [number] */ |
|
||||
|
|
||||
void |
|
||||
com_history(wordlist *wl) |
|
||||
{ |
|
||||
bool rev = FALSE; |
|
||||
|
|
||||
if (wl && eq(wl->wl_word, "-r")) { |
|
||||
wl = wl->wl_next; |
|
||||
rev = TRUE; |
|
||||
} |
|
||||
if (wl == NULL) |
|
||||
cp_hprint(cp_event - 1, cp_event - histlength, rev); |
|
||||
else |
|
||||
cp_hprint(cp_event - 1, cp_event - 1 - atoi(wl->wl_word), rev); |
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
@ -1,16 +0,0 @@ |
|||||
/************* |
|
||||
* Header file for history.c |
|
||||
* 1999 E. Rouat |
|
||||
************/ |
|
||||
|
|
||||
#ifndef HISTORY_H_INCLUDED |
|
||||
#define HISTORY_H_INCLUDED |
|
||||
|
|
||||
wordlist * cp_histsubst(wordlist *wlist); |
|
||||
void cp_addhistent(int event, wordlist *wlist); |
|
||||
void cp_hprint(int eventhi, int eventlo, bool rev); |
|
||||
void com_history(wordlist *wl); |
|
||||
|
|
||||
|
|
||||
|
|
||||
#endif |
|
||||
@ -1,38 +0,0 @@ |
|||||
/********** |
|
||||
Copyright 1990 Regents of the University of California. All rights reserved. |
|
||||
Author: 1985 Wayne A. Christopher, U. C. Berkeley CAD Group |
|
||||
**********/ |
|
||||
|
|
||||
/* |
|
||||
*/ |
|
||||
|
|
||||
#include "ngspice.h" |
|
||||
#include "cpdefs.h" |
|
||||
#include "modify.h" |
|
||||
|
|
||||
|
|
||||
char cp_chars[128]; |
|
||||
|
|
||||
static char *singlec = "<>;&"; |
|
||||
|
|
||||
/* Initialize stuff. */ |
|
||||
|
|
||||
void |
|
||||
cp_init(void) |
|
||||
{ |
|
||||
char *s, *getenv(const char *); |
|
||||
|
|
||||
bzero(cp_chars, 128); |
|
||||
for (s = singlec; *s; s++) |
|
||||
cp_chars[(int) *s] = (CPC_BRR | CPC_BRL); |
|
||||
cp_vset("history", VT_NUM, (char *) &cp_maxhistlength); |
|
||||
|
|
||||
cp_curin = stdin; |
|
||||
cp_curout = stdout; |
|
||||
cp_curerr = stderr; |
|
||||
|
|
||||
cp_ioreset(); |
|
||||
|
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
@ -1,429 +0,0 @@ |
|||||
/********** |
|
||||
Copyright 1990 Regents of the University of California. All rights reserved. |
|
||||
Author: 1985 Wayne A. Christopher, U. C. Berkeley CAD Group |
|
||||
**********/ |
|
||||
|
|
||||
#include "ngspice.h" |
|
||||
#include "cpdefs.h" |
|
||||
#include "fteext.h" |
|
||||
#include "ftedefs.h" |
|
||||
#include "variable.h" |
|
||||
|
|
||||
|
|
||||
bool cp_noglob = TRUE; |
|
||||
bool cp_nonomatch = FALSE; |
|
||||
bool cp_noclobber = FALSE; |
|
||||
bool cp_ignoreeof = FALSE; |
|
||||
|
|
||||
struct variable *variables = NULL; |
|
||||
|
|
||||
wordlist * |
|
||||
cp_varwl(struct variable *var) |
|
||||
{ |
|
||||
wordlist *wl = NULL, *w, *wx = NULL; |
|
||||
char buf[BSIZE_SP]; |
|
||||
struct variable *vt; |
|
||||
|
|
||||
switch(var->va_type) { |
|
||||
case VT_BOOL: |
|
||||
/* Can't ever be FALSE. */ |
|
||||
(void) sprintf(buf, "%s", var->va_bool ? "TRUE" : |
|
||||
"FALSE"); |
|
||||
break; |
|
||||
case VT_NUM: |
|
||||
(void) sprintf(buf, "%d", var->va_num); |
|
||||
break; |
|
||||
case VT_REAL: |
|
||||
/* This is a case where printnum isn't too good... */ |
|
||||
(void) sprintf(buf, "%G", var->va_real); |
|
||||
break; |
|
||||
case VT_STRING: |
|
||||
(void) strcpy(buf, cp_unquote(var->va_string)); |
|
||||
break; |
|
||||
case VT_LIST: /* The tricky case. */ |
|
||||
for (vt = var->va_vlist; vt; vt = vt->va_next) { |
|
||||
w = cp_varwl(vt); |
|
||||
if (wl == NULL) |
|
||||
wl = wx = w; |
|
||||
else { |
|
||||
wx->wl_next = w; |
|
||||
w->wl_prev = wx; |
|
||||
wx = w; |
|
||||
} |
|
||||
} |
|
||||
return (wl); |
|
||||
default: |
|
||||
fprintf(cp_err, |
|
||||
"cp_varwl: Internal Error: bad variable type %d\n", |
|
||||
var->va_type); |
|
||||
return (NULL); |
|
||||
} |
|
||||
wl = alloc(struct wordlist); |
|
||||
wl->wl_next = wl->wl_prev = NULL; |
|
||||
wl->wl_word = copy(buf); |
|
||||
return (wl); |
|
||||
} |
|
||||
|
|
||||
/* Set a variable. */ |
|
||||
|
|
||||
void |
|
||||
cp_vset(char *varname, char type, char *value) |
|
||||
{ |
|
||||
struct variable *v, *u, *w; |
|
||||
int i; |
|
||||
bool alreadythere = FALSE; |
|
||||
|
|
||||
/* for (v = variables; v; v = v->va_next) ; printf("ok while setting %s\n", |
|
||||
varname);*/ |
|
||||
varname = cp_unquote(varname); |
|
||||
w = NULL; |
|
||||
for (v = variables; v; v = v->va_next) { |
|
||||
if (eq(varname, v->va_name)) { |
|
||||
alreadythere = TRUE; |
|
||||
break; |
|
||||
} |
|
||||
w = v; |
|
||||
} |
|
||||
if (!v) { |
|
||||
v = alloc(struct variable); |
|
||||
v->va_name = copy(varname); |
|
||||
v->va_next = NULL; |
|
||||
} |
|
||||
switch (type) { |
|
||||
case VT_BOOL: |
|
||||
if (* ((bool *) value) == FALSE) { |
|
||||
cp_remvar(varname); |
|
||||
return; |
|
||||
} else |
|
||||
v->va_bool = TRUE; |
|
||||
break; |
|
||||
|
|
||||
case VT_NUM: |
|
||||
v->va_num = * (int *) value; |
|
||||
break; |
|
||||
|
|
||||
case VT_REAL: |
|
||||
v->va_real = * (double *) value; |
|
||||
break; |
|
||||
|
|
||||
case VT_STRING: |
|
||||
v->va_string = copy(value); |
|
||||
break; |
|
||||
|
|
||||
case VT_LIST: |
|
||||
v->va_vlist = (struct variable *) value; |
|
||||
break; |
|
||||
|
|
||||
default: |
|
||||
fprintf(cp_err, |
|
||||
"cp_vset: Internal Error: bad variable type %d.\n", |
|
||||
type); |
|
||||
return; |
|
||||
} |
|
||||
v->va_type = type; |
|
||||
|
|
||||
/* Now, see if there is anything interesting going on. We recognise |
|
||||
* these special variables: noglob, nonomatch, history, echo, |
|
||||
* noclobber, prompt, and verbose. cp_remvar looks for these variables |
|
||||
* too. The host program will get any others. |
|
||||
*/ |
|
||||
|
|
||||
if (eq(varname, "noglob")) |
|
||||
cp_noglob = TRUE; |
|
||||
else if (eq(varname, "nonomatch")) |
|
||||
cp_nonomatch = TRUE; |
|
||||
else if (eq(varname, "history") && (type == VT_NUM)) |
|
||||
cp_maxhistlength = v->va_num; |
|
||||
else if (eq(varname, "history") && (type == VT_REAL)) |
|
||||
cp_maxhistlength = v->va_real; |
|
||||
else if (eq(varname, "noclobber")) |
|
||||
cp_noclobber = TRUE; |
|
||||
else if (eq(varname, "prompt") && (type == VT_STRING)) |
|
||||
cp_promptstring = copy(v->va_string); |
|
||||
else if (eq(varname, "ignoreeof")) |
|
||||
cp_ignoreeof = TRUE; |
|
||||
else if (eq(varname, "cpdebug")) { |
|
||||
cp_debug = TRUE; |
|
||||
#ifndef CPDEBUG |
|
||||
fprintf(cp_err, |
|
||||
"Warning: program not compiled with cshpar debug messages\n"); |
|
||||
#endif |
|
||||
} |
|
||||
|
|
||||
switch (i = cp_usrset(v, TRUE)) { |
|
||||
|
|
||||
case US_OK: |
|
||||
/* Normal case. */ |
|
||||
if (!alreadythere) { |
|
||||
v->va_next = variables; |
|
||||
variables = v; |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case US_DONTRECORD: |
|
||||
/* Do nothing... */ |
|
||||
if (alreadythere) { |
|
||||
fprintf(cp_err, |
|
||||
"cp_vset: Internal Error: %s already there, but 'dont record'\n", |
|
||||
v->va_name); |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case US_READONLY: |
|
||||
fprintf(cp_err, "Error: %s is a read-only variable.\n", |
|
||||
v->va_name); |
|
||||
if (alreadythere) |
|
||||
fprintf(cp_err, |
|
||||
"cp_vset: Internal Error: it was already there too!!\n"); |
|
||||
break; |
|
||||
|
|
||||
case US_SIMVAR: |
|
||||
if (alreadythere) { |
|
||||
/* somehow it got into the front-end list of variables */ |
|
||||
if (w) { |
|
||||
w->va_next = v->va_next; |
|
||||
} else { |
|
||||
variables = v->va_next; |
|
||||
} |
|
||||
} |
|
||||
alreadythere = FALSE; |
|
||||
if (ft_curckt) { |
|
||||
for (u = ft_curckt->ci_vars; u; u = u->va_next) |
|
||||
if (eq(varname, u->va_name)) { |
|
||||
alreadythere = TRUE; |
|
||||
break; |
|
||||
} |
|
||||
if (!alreadythere) { |
|
||||
v->va_next = ft_curckt->ci_vars; |
|
||||
ft_curckt->ci_vars = v; |
|
||||
} else { |
|
||||
w = u->va_next; |
|
||||
bcopy(v, u, sizeof(*u)); |
|
||||
u->va_next = w; |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case US_NOSIMVAR: |
|
||||
/* What do you do? */ |
|
||||
tfree(v); |
|
||||
break; |
|
||||
|
|
||||
default: |
|
||||
fprintf(cp_err, "cp_vset: Internal Error: bad US val %d\n", i); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
return; |
|
||||
} |
|
||||
|
|
||||
struct variable * |
|
||||
cp_setparse(wordlist *wl) |
|
||||
{ |
|
||||
char *name, *val, *s, *ss; |
|
||||
double *td; |
|
||||
struct variable *listv = NULL, *vv, *lv = NULL; |
|
||||
struct variable *vars = NULL; |
|
||||
int balance; |
|
||||
|
|
||||
while (wl) { |
|
||||
name = cp_unquote(wl->wl_word); |
|
||||
wl = wl->wl_next; |
|
||||
if (((wl == NULL) || (*wl->wl_word != '=')) && |
|
||||
strchr(name, '=') == NULL) { |
|
||||
vv = alloc(struct variable); |
|
||||
vv->va_name = copy(name); |
|
||||
vv->va_type = VT_BOOL; |
|
||||
vv->va_bool = TRUE; |
|
||||
vv->va_next = vars; |
|
||||
vars = vv; |
|
||||
continue; |
|
||||
} |
|
||||
if (wl && eq(wl->wl_word, "=")) { |
|
||||
wl = wl->wl_next; |
|
||||
if (wl == NULL) { |
|
||||
fprintf(cp_err, "Error: bad set form.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
val = wl->wl_word; |
|
||||
wl = wl->wl_next; |
|
||||
} else if (wl && (*wl->wl_word == '=')) { |
|
||||
val = wl->wl_word + 1; |
|
||||
wl = wl->wl_next; |
|
||||
} else if ((s =strchr(name, '='))) { |
|
||||
val = s + 1; |
|
||||
*s = '\0'; |
|
||||
if (*val == '\0') { |
|
||||
if (!wl) { |
|
||||
fprintf(cp_err, |
|
||||
"Error: %s equals what?.\n", |
|
||||
name); |
|
||||
return (NULL); |
|
||||
} else { |
|
||||
val = wl->wl_word; |
|
||||
wl = wl->wl_next; |
|
||||
} |
|
||||
} |
|
||||
} else { |
|
||||
fprintf(cp_err, "Error: bad set form.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
val = cp_unquote(val); |
|
||||
if (eq(val, "(")) { /* ) */ |
|
||||
/* The beginning of a list... We have to walk down |
|
||||
* the list until we find a close paren... If there |
|
||||
* are nested ()'s, treat them as tokens... |
|
||||
*/ |
|
||||
balance = 1; |
|
||||
while (wl && wl->wl_word) { |
|
||||
if (eq(wl->wl_word, "(")) { /* ) ( */ |
|
||||
balance++; |
|
||||
} else if (eq(wl->wl_word, ")")) { |
|
||||
if (!--balance) |
|
||||
break; |
|
||||
} |
|
||||
vv = alloc(struct variable); |
|
||||
vv->va_next = NULL; |
|
||||
ss = cp_unquote(wl->wl_word); |
|
||||
td = ft_numparse(&ss, FALSE); |
|
||||
if (td) { |
|
||||
vv->va_type = VT_REAL; |
|
||||
vv->va_real = *td; |
|
||||
} else { |
|
||||
vv->va_type = VT_STRING; |
|
||||
vv->va_string = copy(ss); |
|
||||
} |
|
||||
if (listv) { |
|
||||
lv->va_next = vv; |
|
||||
lv = vv; |
|
||||
} else |
|
||||
listv = lv = vv; |
|
||||
wl = wl->wl_next; |
|
||||
} |
|
||||
if (balance && !wl) { |
|
||||
fprintf(cp_err, "Error: bad set form.\n"); |
|
||||
return (NULL); |
|
||||
} |
|
||||
|
|
||||
vv = alloc(struct variable); |
|
||||
vv->va_name = copy(name); |
|
||||
vv->va_type = VT_LIST; |
|
||||
vv->va_vlist = listv; |
|
||||
vv->va_next = vars; |
|
||||
vars = vv; |
|
||||
|
|
||||
wl = wl->wl_next; |
|
||||
continue; |
|
||||
} |
|
||||
|
|
||||
ss = cp_unquote(val); |
|
||||
td = ft_numparse(&ss, FALSE); |
|
||||
vv = alloc(struct variable); |
|
||||
vv->va_name = copy(name); |
|
||||
vv->va_next = vars; |
|
||||
vars = vv; |
|
||||
if (td) { |
|
||||
/*** We should try to get VT_NUM's... */ |
|
||||
vv->va_type = VT_REAL; |
|
||||
vv->va_real = *td; |
|
||||
} else { |
|
||||
vv->va_type = VT_STRING; |
|
||||
vv->va_string = copy(val); |
|
||||
} |
|
||||
} |
|
||||
return (vars); |
|
||||
} |
|
||||
|
|
||||
void |
|
||||
cp_remvar(char *varname) |
|
||||
{ |
|
||||
struct variable *v, *u, *lv = NULL; |
|
||||
bool found = TRUE; |
|
||||
int i; |
|
||||
|
|
||||
for (v = variables; v; v = v->va_next) { |
|
||||
if (eq(v->va_name, varname)) |
|
||||
break; |
|
||||
lv = v; |
|
||||
} |
|
||||
if (!v) { |
|
||||
/* Gotta make up a var struct for cp_usrset()... */ |
|
||||
v = alloc(struct variable); |
|
||||
ZERO(v, struct variable); |
|
||||
v->va_name = varname; |
|
||||
v->va_type = VT_NUM; |
|
||||
v->va_bool = 0; |
|
||||
found = FALSE; |
|
||||
} |
|
||||
|
|
||||
/* Note that 'unset history' doesn't do anything here... Causes |
|
||||
* trouble... |
|
||||
*/ |
|
||||
if (eq(varname, "noglob")) |
|
||||
cp_noglob = FALSE; |
|
||||
else if (eq(varname, "nonomatch")) |
|
||||
cp_nonomatch = FALSE; |
|
||||
else if (eq(varname, "noclobber")) |
|
||||
cp_noclobber = FALSE; |
|
||||
else if (eq(varname, "prompt")) |
|
||||
cp_promptstring = ""; |
|
||||
else if (eq(varname, "cpdebug")) |
|
||||
cp_debug = FALSE; |
|
||||
else if (eq(varname, "ignoreeof")) |
|
||||
cp_ignoreeof = FALSE; |
|
||||
|
|
||||
switch (i = cp_usrset(v, FALSE)) { |
|
||||
|
|
||||
case US_OK: |
|
||||
/* Normal case. */ |
|
||||
if (found) { |
|
||||
if (lv) |
|
||||
lv->va_next = v->va_next; |
|
||||
else |
|
||||
variables = v->va_next; |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
case US_DONTRECORD: |
|
||||
/* Do nothing... */ |
|
||||
if (found) |
|
||||
fprintf(cp_err, |
|
||||
"cp_remvar: Internal Error: var %d\n", *varname); |
|
||||
break; |
|
||||
|
|
||||
case US_READONLY: |
|
||||
/* Badness... */ |
|
||||
fprintf(cp_err, "Error: %s is read-only.\n", |
|
||||
v->va_name); |
|
||||
if (found) |
|
||||
fprintf(cp_err, |
|
||||
"cp_remvar: Internal Error: var %d\n", *varname); |
|
||||
break; |
|
||||
|
|
||||
case US_SIMVAR: |
|
||||
lv = NULL; |
|
||||
if (ft_curckt) { |
|
||||
for (u = ft_curckt->ci_vars; u; u = u->va_next) { |
|
||||
if (eq(varname, u->va_name)) { |
|
||||
break; |
|
||||
} |
|
||||
lv = u; |
|
||||
} |
|
||||
if (u) { |
|
||||
if (lv) |
|
||||
lv->va_next = u->va_next; |
|
||||
else |
|
||||
ft_curckt->ci_vars = u->va_next; |
|
||||
tfree(u); |
|
||||
} |
|
||||
} |
|
||||
break; |
|
||||
|
|
||||
default: |
|
||||
fprintf(cp_err, "cp_remvar: Internal Error: US val %d\n", i); |
|
||||
break; |
|
||||
} |
|
||||
|
|
||||
tfree(v); |
|
||||
return; |
|
||||
} |
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue