[unix-history] / usr / src / contrib / sc / lex.c

/*	SC	A Spreadsheet Calculator
 *		Lexical analyser
 *
 *		original by James Gosling, September 1982
 *		modifications by Mark Weiser and Bruce Israel,
 *			University of Maryland
 *
 *              More mods Robert Bond, 12/86
 *		More mods by Alan Silverstein, 3/88, see list of changes.
 *		$Revision: 6.8 $
 *
 */


#if defined(BSD42) || defined(BSD43)
#include <sys/ioctl.h>
#endif 

#ifdef IEEE_MATH
#include <ieeefp.h>
#endif /* IEEE_MATH */

#include <curses.h>
#include <signal.h>
#include <setjmp.h>
#include "sc.h"
#include <ctype.h>

#ifdef BSD42
#include <strings.h>
#else
#ifndef SYSIII
#include <string.h>
#endif
#endif

#ifdef VMS
#include "gram_tab.h"
typedef union {
    int ival;
    double fval;
    struct ent *ent;
    struct enode *enode;
    char *sval;
    struct range_s rval;
} YYSTYPE;
extern YYSTYPE yylval;
extern int VMS_read_raw;   /*sigh*/
#else	/* VMS */
#include "y.tab.h"
#endif /* VMS */

char *strtof();

jmp_buf wakeup;
jmp_buf fpe_buf;

struct key {
    char *key;
    int val;
};

struct key experres[] = {
#include "experres.h"
    0, 0};

struct key statres[] = {
#include "statres.h"
    0, 0};

yylex ()
{
    register char *p = line+linelim;
    int ret;
    while (isspace(*p)) p++;
    if (*p == '\0') ret = -1;
    else if (isalpha(*p)) {
	char *tokenst = p;
	register tokenl;
	register struct key *tblp;
	tokenl = 0;
	/*
	 * This picks up either 1 or 2 alpha characters (a column) or
	 * tokens with at least three leading alphas and '_' or digits
	 * (a function or token or command or a range name)
	*/
	while (isalpha(*p) || ((*p == '_') || isdigit(*p)) && (tokenl > 2)) {
	    p++;
	    tokenl++;
	}
	if (tokenl <= 2) { /* a COL is 1 or 2 char alpha
		(but not pi, ln, fv, pv, if -- this should be fixed!) */
	    if (tokenl == 2 && tokenst[0] == 'p' && tokenst[1] == 'i') {
		ret = K_PI;
	    } else if (tokenl == 2 && tokenst[0] == 'l' && tokenst[1] == 'n') {
		ret = K_LN;
	    } else if (tokenl == 2 && tokenst[0] == 'f' && tokenst[1] == 'v') {
		ret = K_FV;
	    } else if (tokenl == 2 && tokenst[0] == 'p' && tokenst[1] == 'v') {
		ret = K_PV;
	    } else if (tokenl == 2 && tokenst[0] == 'i' && tokenst[1] == 'f') {
		ret = K_IF;

	    } else {
		ret = COL;
		yylval.ival = atocol (tokenst, tokenl);
	    }
	} else {
	    ret = WORD;
	    for (tblp = linelim ? experres : statres; tblp->key; tblp++)
		    if (((tblp->key[0]^tokenst[0])&0137)==0
		     && tblp->key[tokenl]==0) {
			register i = 1;
			while (i<tokenl && ((tokenst[i]^tblp->key[i])&0137)==0)
			    i++;
			if (i>=tokenl) {
			    ret = tblp->val;
			    break;
			}
		    }
	    if (ret==WORD) { 
		struct range *r;
		if (r = find_range(tokenst, tokenl,
				   (struct ent *)0, (struct ent *)0)) {
		    yylval.rval.left = r->r_left;
		    yylval.rval.right = r->r_right;
		    if (r->r_is_range)
		        ret = RANGE;
		    else
			ret = VAR;
		} else {
		    linelim = p-line;
		    yyerror ("Unintelligible word");
		}
	    }
	}
    } else if ((*p == '.') || isdigit(*p)) {
	double v = 0;
	int temp;
	char *nstart = p;
	if (*p != '.') {
	    do v = v*10 + (double)(*p-'0');
	    while (isdigit(*++p));
	}
	if (*p=='.' || *p == 'e' || *p == 'E') {
	    ret = FNUMBER;
	    p = strtof(nstart, &yylval.fval);
	} else {
	    /* A NUMBER must hold at least MAXROW and MAXCOL */
	    /* This is consistent with a short row and col in struct ent */
	    if (v > (double)32767 || v < (double)-32768) {
		ret = FNUMBER;
		yylval.fval = v;
	    } else {
		temp = (int)v;
		if((double)temp != v) {
		    ret = FNUMBER;
		    yylval.fval = v;
		} else {
		    ret = NUMBER;
		    yylval.ival = temp;
		}
	    }
	}
    } else if (*p=='"') {
	char *ptr;
        ptr = p+1;
        while(*ptr && *ptr++ != '"');
        ptr = xmalloc((unsigned)(ptr-p));
	yylval.sval = ptr;
	p += 1;
	while (*p && *p!='"') *ptr++ = *p++;
	*ptr = 0;
	if (*p) p += 1;
	ret = STRING;
    } else if (*p=='[') {
	while (*p && *p!=']') p++;
	if (*p) p++;
	linelim = p-line;
	return yylex();
    } else ret = *p++;
    linelim = p-line;
    return ret;
}


/*
 * Given a token string starting with a symbolic column name and its valid
 * length, convert column name ("A"-"Z" or "AA"-"ZZ") to a column number (0-N).
 * Never mind if the column number is illegal (too high).  The procedure's name
 * and function are the inverse of coltoa().
 * 
 * Case-insensitivity is done crudely, by ignoring the 040 bit.
 */

int
atocol (string, len)
	char	*string;
	int	len;
{
	register int col;

	col = (string [0] & 0137) - 'A';

	if (len == 2)		/* has second char */
	    col = ((col + 1) * 26) + ((string [1] & 0137) - 'A');

	return (col);
}


#ifdef SIMPLE

initkbd()
{}

kbd_again()
{}

resetkbd()
{}

#ifndef VMS

nmgetch()
{
    return (toascii(getchar()));
}

#else /* VMS */

nmgetch()
/*
   This is not perfect, it doesn't move the cursor when goraw changes
   over to deraw, but it works well enough since the whole sc package
   is incredibly stable (loop constantly positions cursor).

   Question, why didn't the VMS people just implement cbreak?

   NOTE: During testing it was discovered that the DEBUGGER and curses
   and this method of reading would collide (the screen was not updated
   when continuing from screen mode in the debugger).
*/
{
    short c;
    static int key_id=0;
    int status;
#define VMScheck(a) {if (~(status = (a)) & 1) VMS_MSG (status);}

    if (VMS_read_raw) {
      VMScheck(smg$read_keystroke (&stdkb->_id, &c, 0, 0, 0));
    }
    else
       c = getchar();

    switch (c) {
    case SMG$K_TRM_LEFT:  c = ctl('b'); break;
    case SMG$K_TRM_RIGHT: c = ctl('f'); break;
    case SMG$K_TRM_UP:    c = ctl('p'); break;
    case SMG$K_TRM_DOWN:  c = ctl('n'); break;
    default:   c = c & 0x7f;
    }
    return (c);
}


VMS_MSG (status)
int status;
/*
   Routine to put out the VMS operating system error (if one occurs).
*/
{
#include <descrip.h>
   char errstr[81], buf[120];
   $DESCRIPTOR(errdesc, errstr);
   short int length;
#define err_out(msg) fprintf (stderr,msg)

/* Check for no error or standard error */

   if (~status & 1) {
      status = status & 0x8000 ? status & 0xFFFFFFF : status & 0xFFFF;
      if (SYS$GETMSG(status, &length, &errdesc, 1, 0) == SS$_NORMAL) {
         errstr[length] = '\0';
         sprintf (buf, "<0x%x> %s", status, errdesc.dsc$a_pointer);
         err_out (buf);
      }
      else
         err_out ("System error");
   }
}
#endif /* VMS */

#else /*SIMPLE*/

#if defined(BSD42) || defined (SYSIII) || defined(BSD43)

#define N_KEY 4

struct key_map {
    char *k_str;
    char k_val;
    char k_index;
}; 

struct key_map km[N_KEY];

char keyarea[N_KEY*30];

char *tgetstr();
char *getenv();
char *ks;
char ks_buf[20];
char *ke;
char ke_buf[20];

#ifdef TIOCSLTC
struct ltchars old_chars, new_chars;
#endif

char dont_use[] = {
	ctl('['), ctl('a'), ctl('b'), ctl('c'), ctl('e'), ctl('f'), ctl('g'), ctl('h'),
	ctl('i'), ctl('j'),  ctl('l'), ctl('m'), ctl('n'), ctl('p'), ctl('q'),
	ctl('r'), ctl('s'), ctl('t'), ctl('u'), ctl('v'),  ctl('w'), ctl('x'),
	ctl('z'), 0
};

charout(c)
int c;
{
	(void)putchar(c);
}

initkbd()
{
    register struct key_map *kp;
    register i,j;
    char *p = keyarea;
    char *ktmp;
    static char buf[1024]; /* Why do I have to do this again? */

    if (tgetent(buf, getenv("TERM")) <= 0)
	return;

    km[0].k_str = tgetstr("kl", &p); km[0].k_val = ctl('b');
    km[1].k_str = tgetstr("kr", &p); km[1].k_val = ctl('f');
    km[2].k_str = tgetstr("ku", &p); km[2].k_val = ctl('p');
    km[3].k_str = tgetstr("kd", &p); km[3].k_val = ctl('n');
    ktmp = tgetstr("ks",&p);
    if (ktmp)  {
	(void) strcpy(ks_buf, ktmp);
	ks = ks_buf;
	tputs(ks, 1, charout);
    }
    ktmp = tgetstr("ke",&p);
    if (ktmp)  {
	(void) strcpy(ke_buf, ktmp);
	ke = ke_buf;
    }

    /* Unmap arrow keys which conflict with our ctl keys   */
    /* Ignore unset, longer than length 1, and 1-1 mapped keys */

    for (i = 0; i < N_KEY; i++) {
	kp = &km[i];
	if (kp->k_str && (kp->k_str[1] == 0) && (kp->k_str[0] != kp->k_val))
	    for (j = 0; dont_use[j] != 0; j++)
	        if (kp->k_str[0] == dont_use[j]) {
		     kp->k_str = (char *)0;
		     break;
		}
    }


#ifdef TIOCSLTC
    (void)ioctl(fileno(stdin), TIOCGLTC, (char *)&old_chars);
    new_chars = old_chars;
    if (old_chars.t_lnextc == ctl('v'))
	new_chars.t_lnextc = -1;
    if (old_chars.t_rprntc == ctl('r'))
	new_chars.t_rprntc = -1;
    (void)ioctl(fileno(stdin), TIOCSLTC, (char *)&new_chars);
#endif
}

void
kbd_again()
{
    if (ks) 
	tputs(ks, 1, charout);

#ifdef TIOCSLTC
    (void)ioctl(fileno(stdin), TIOCSLTC, (char *)&new_chars);
#endif
}

void
resetkbd()
{
    if (ke) 
	tputs(ke, 1, charout);

#ifdef TIOCSLTC
    (void)ioctl(fileno(stdin), TIOCSLTC, (char *)&old_chars);
#endif
}

nmgetch() 
{
    register int c;
    register struct key_map *kp;
    register struct key_map *biggest;
    register int i;
    int almost;
    int maybe;

    static char dumpbuf[10];
    static char *dumpindex;

#ifdef SIGVOID
    void time_out();
#else
    int time_out();
#endif

    if (dumpindex && *dumpindex)
	    return (*dumpindex++);

    c = toascii(getchar());
    biggest = 0;
    almost = 0;

    for (kp = &km[0]; kp < &km[N_KEY]; kp++) {
	if (!kp->k_str)
	    continue;
	if (c == kp->k_str[kp->k_index]) {
	    almost = 1;
	    kp->k_index++;
	    if (kp->k_str[kp->k_index] == 0) {
		c = kp->k_val;
	        for (kp = &km[0]; kp < &km[N_KEY]; kp++)
	            kp->k_index = 0;
	        return(c);
	    }
	}
	if (!biggest && kp->k_index)
	    biggest = kp;
        else if (kp->k_index && biggest->k_index < kp->k_index)
	    biggest = kp;
    }

    if (almost) { 
        (void) signal(SIGALRM, time_out);
        (void) alarm(1);

	if (setjmp(wakeup) == 0) { 
	    maybe = nmgetch();
	    (void) alarm(0);
	    return(maybe);
	}
    }
    
    if (biggest) {
	for (i = 0; i<biggest->k_index; i++) 
	    dumpbuf[i] = biggest->k_str[i];
	if (!almost)
	    dumpbuf[i++] = c;
	dumpbuf[i] = '\0';
	dumpindex = &dumpbuf[1];
	for (kp = &km[0]; kp < &km[N_KEY]; kp++)
	    kp->k_index = 0;
	return (dumpbuf[0]);
    }

    return(c);
}

#endif

#if defined(SYSV2) || defined(SYSV3)

initkbd()
{
    keypad(stdscr, TRUE);
}

void
kbd_again()
{
    keypad(stdscr, TRUE);
}

void
resetkbd()
{
    keypad(stdscr, FALSE);
}

nmgetch()
{
    register int c;

    c = getch();
    switch (c) {
    case KEY_LEFT:  c = ctl('b'); break;
    case KEY_RIGHT: c = ctl('f'); break;
    case KEY_UP:    c = ctl('p'); break;
    case KEY_DOWN:  c = ctl('n'); break;
#ifdef KEY_C1
/* This stuff works for a wyse wy75 in ANSI mode under 5.3.  Good luck. */
/* It is supposed to map the curses keypad back to the numeric equiv. */
    case KEY_C1:    c = '0'; break;
    case KEY_A1:    c = '1'; break;
    case KEY_B2:    c = '2'; break;
    case KEY_A3:    c = '3'; break;
    case KEY_F(5):  c = '4'; break;
    case KEY_F(6):  c = '5'; break;
    case KEY_F(7):  c = '6'; break;
    case KEY_F(9):  c = '7'; break;
    case KEY_F(10): c = '8'; break;
    case KEY_F0:    c = '9'; break;
    case KEY_C3:    c = '.'; break;
    case KEY_ENTER: c = ctl('m'); break;
#endif
    default:   c = toascii(c); 
    break;
    }
    return (c);
}

#endif /* SYSV2 || SYSV3 */

#endif /* SIMPLE */

#ifdef SIGVOID
void
#endif
time_out(signo)
int signo;
{
#ifdef IEEE_MATH
	(void)fpsetsticky((fp_except)0); 		/* Clear exception */
#endif /* IEEE_MATH */
    longjmp(wakeup, -1);
}

#ifdef SIGVOID
void
#endif
fpe_trap(signo)
int signo;
{
    longjmp(fpe_buf, 1);
}

/*
 * This converts a floating point number of the form
 * [s]ddd[.d*][esd*]  where s can be a + or - and e is E or e.
 * to floating point. 
 * p is advanced.
 */

char *
strtof(p, res)
register char *p;
double *res;
{
    double acc;
    int sign;
    double fpos;
    int exp;
    int exps;
#ifdef SIGVOID
    void (*sig_save)();
#else
    int (*sig_save)();
#endif

    sig_save = signal(SIGFPE, fpe_trap);
    if (setjmp(fpe_buf)) {
	error("Floating point exception\n");
	*res = 0.0; 
        (void) signal(SIGFPE, sig_save);
	return(p);
    }
    acc = 0.0;
    sign = 1;
    exp = 0;
    exps = 1;
    if (*p == '+')
        p++;
    else if (*p == '-') {
        p++;
        sign = -1;
    }
    while (isdigit(*p)) {
        acc = acc * 10.0 + (double)(*p - '0');
        p++;
    }
    if (*p == 'e' || *p == 'E') {
	    p++;
        if (*p == '+')
	    p++;
        else if (*p == '-') {
	    p++;
	    exps = -1;
        }
        while(isdigit(*p)) {
	    exp = exp * 10 + (*p - '0');
	    p++;
        }
    }
    if (*p == '.') {
	fpos = 1.0/10.0;
	p++;
	while(isdigit(*p)) {
	    acc += (*p - '0') * fpos;
	    fpos *= 1.0/10.0;
	    p++;
	}
    }
    if (*p == 'e' || *p == 'E') {
	exp = 0;
	exps = 1;
        p++;
	if (*p == '+')
	    p++;
	else if (*p == '-') {
	    p++;
	    exps = -1;
	}
	while(isdigit(*p)) {
	    exp = exp * 10 + (*p - '0');
	    p++;
	}
    }
    if (exp) {
	if (exps > 0)
	    while (exp--)
		acc *= 10.0;
	else
	    while (exp--)
		acc *= 1.0/10.0;
    }
    if (sign > 0)
        *res = acc;
    else
	*res = -acc;

    (void) signal(SIGFPE, sig_save);
    return(p);
}
Commit	Line	Data
4978d704 KB	1	/* SC A Spreadsheet Calculator
	2	* Lexical analyser
	3	*
	4	* original by James Gosling, September 1982
	5	* modifications by Mark Weiser and Bruce Israel,
	6	* University of Maryland
	7	*
	8	* More mods Robert Bond, 12/86
	9	* More mods by Alan Silverstein, 3/88, see list of changes.
	10	* $Revision: 6.8 $
	11	*
	12	*/
	13
	14
	15
	16	#if defined(BSD42) \|\| defined(BSD43)
	17	#include <sys/ioctl.h>
	18	#endif
	19
	20	#ifdef IEEE_MATH
	21	#include <ieeefp.h>
	22	#endif /* IEEE_MATH */
	23
	24	#include <curses.h>
	25	#include <signal.h>
	26	#include <setjmp.h>
	27	#include "sc.h"
	28	#include <ctype.h>
	29
	30	#ifdef BSD42
	31	#include <strings.h>
	32	#else
	33	#ifndef SYSIII
	34	#include <string.h>
	35	#endif
	36	#endif
	37
	38	#ifdef VMS
	39	#include "gram_tab.h"
	40	typedef union {
	41	int ival;
	42	double fval;
	43	struct ent *ent;
	44	struct enode *enode;
	45	char *sval;
	46	struct range_s rval;
	47	} YYSTYPE;
	48	extern YYSTYPE yylval;
	49	extern int VMS_read_raw; /sigh/
	50	#else /* VMS */
	51	#include "y.tab.h"
	52	#endif /* VMS */
	53
	54	char *strtof();
	55
	56	jmp_buf wakeup;
	57	jmp_buf fpe_buf;
	58
	59	struct key {
	60	char *key;
	61	int val;
	62	};
	63
	64	struct key experres[] = {
65	#include "experres.h"
66	0, 0};
67
68	struct key statres[] = {
69	#include "statres.h"
70	0, 0};
71
72	yylex ()
73	{
74	register char *p = line+linelim;
75	int ret;
76	while (isspace(*p)) p++;
77	if (*p == '\0') ret = -1;
78	else if (isalpha(*p)) {
79	char *tokenst = p;
80	register tokenl;
81	register struct key *tblp;
82	tokenl = 0;
83	/*
84	* This picks up either 1 or 2 alpha characters (a column) or
85	* tokens with at least three leading alphas and '_' or digits
86	* (a function or token or command or a range name)
87	*/
88	while (isalpha(p) \|\| ((p == '_') \|\| isdigit(*p)) && (tokenl > 2)) {
89	p++;
90	tokenl++;
91	}
92	if (tokenl <= 2) { /* a COL is 1 or 2 char alpha
93	(but not pi, ln, fv, pv, if -- this should be fixed!) */
94	if (tokenl == 2 && tokenst[0] == 'p' && tokenst[1] == 'i') {
95	ret = K_PI;
96	} else if (tokenl == 2 && tokenst[0] == 'l' && tokenst[1] == 'n') {
97	ret = K_LN;
98	} else if (tokenl == 2 && tokenst[0] == 'f' && tokenst[1] == 'v') {
99	ret = K_FV;
100	} else if (tokenl == 2 && tokenst[0] == 'p' && tokenst[1] == 'v') {
101	ret = K_PV;
102	} else if (tokenl == 2 && tokenst[0] == 'i' && tokenst[1] == 'f') {
103	ret = K_IF;
104
105	} else {
106	ret = COL;
107	yylval.ival = atocol (tokenst, tokenl);
108	}
109	} else {
110	ret = WORD;
111	for (tblp = linelim ? experres : statres; tblp->key; tblp++)
112	if (((tblp->key[0]^tokenst[0])&0137)==0
113	&& tblp->key[tokenl]==0) {
114	register i = 1;
115	while (i<tokenl && ((tokenst[i]^tblp->key[i])&0137)==0)
116	i++;
117	if (i>=tokenl) {
118	ret = tblp->val;
119	break;
120	}
121	}
122	if (ret==WORD) {
123	struct range *r;
124	if (r = find_range(tokenst, tokenl,
125	(struct ent )0, (struct ent )0)) {
126	yylval.rval.left = r->r_left;
127	yylval.rval.right = r->r_right;
128	if (r->r_is_range)
129	ret = RANGE;
130	else
131	ret = VAR;
132	} else {
133	linelim = p-line;
134	yyerror ("Unintelligible word");
135	}
136	}
137	}
138	} else if ((p == '.') \|\| isdigit(p)) {
139	double v = 0;
140	int temp;
141	char *nstart = p;
142	if (*p != '.') {
143	do v = v10 + (double)(p-'0');
144	while (isdigit(*++p));
145	}
146	if (p=='.' \|\| p == 'e' \|\| *p == 'E') {
147	ret = FNUMBER;
148	p = strtof(nstart, &yylval.fval);
149	} else {
150	/* A NUMBER must hold at least MAXROW and MAXCOL */
151	/* This is consistent with a short row and col in struct ent */
152	if (v > (double)32767 \|\| v < (double)-32768) {
153	ret = FNUMBER;
154	yylval.fval = v;
155	} else {
156	temp = (int)v;
157	if((double)temp != v) {
158	ret = FNUMBER;
159	yylval.fval = v;
160	} else {
161	ret = NUMBER;
162	yylval.ival = temp;
163	}
164	}
165	}
166	} else if (*p=='"') {
167	char *ptr;
168	ptr = p+1;
169	while(ptr && ptr++ != '"');
170	ptr = xmalloc((unsigned)(ptr-p));
171	yylval.sval = ptr;
172	p += 1;
173	while (p && p!='"') ptr++ = p++;
174	*ptr = 0;
175	if (*p) p += 1;
176	ret = STRING;
177	} else if (*p=='[') {
178	while (p && p!=']') p++;
179	if (*p) p++;
180	linelim = p-line;
181	return yylex();
182	} else ret = *p++;
183	linelim = p-line;
184	return ret;
185	}
186
187
188	/*
189	* Given a token string starting with a symbolic column name and its valid
190	* length, convert column name ("A"-"Z" or "AA"-"ZZ") to a column number (0-N).
191	* Never mind if the column number is illegal (too high). The procedure's name
192	* and function are the inverse of coltoa().
193	*
194	* Case-insensitivity is done crudely, by ignoring the 040 bit.
195	*/
196
197	int
198	atocol (string, len)
199	char *string;
200	int len;
201	{
202	register int col;
203
204	col = (string [0] & 0137) - 'A';
205
206	if (len == 2) /* has second char */
207	col = ((col + 1) * 26) + ((string [1] & 0137) - 'A');
208
209	return (col);
210	}
211
212
213	#ifdef SIMPLE
214
215	initkbd()
216	{}
217
218	kbd_again()
219	{}
220
221	resetkbd()
222	{}
223
224	#ifndef VMS
225
226	nmgetch()
227	{
228	return (toascii(getchar()));
229	}
230
231	#else /* VMS */
232
233	nmgetch()
234	/*
235	This is not perfect, it doesn't move the cursor when goraw changes
236	over to deraw, but it works well enough since the whole sc package
237	is incredibly stable (loop constantly positions cursor).
238
239	Question, why didn't the VMS people just implement cbreak?
240
241	NOTE: During testing it was discovered that the DEBUGGER and curses
242	and this method of reading would collide (the screen was not updated
243	when continuing from screen mode in the debugger).
244	*/
245	{
246	short c;
247	static int key_id=0;
248	int status;
249	#define VMScheck(a) {if (~(status = (a)) & 1) VMS_MSG (status);}
250
251	if (VMS_read_raw) {
252	VMScheck(smg$read_keystroke (&stdkb->_id, &c, 0, 0, 0));
253	}
254	else
255	c = getchar();
256
257	switch (c) {
258	case SMG$K_TRM_LEFT: c = ctl('b'); break;
259	case SMG$K_TRM_RIGHT: c = ctl('f'); break;
260	case SMG$K_TRM_UP: c = ctl('p'); break;
261	case SMG$K_TRM_DOWN: c = ctl('n'); break;
262	default: c = c & 0x7f;
263	}
264	return (c);
265	}
266
267
268	VMS_MSG (status)
269	int status;
270	/*
271	Routine to put out the VMS operating system error (if one occurs).
272	*/
273	{
274	#include <descrip.h>
275	char errstr[81], buf[120];
276	$DESCRIPTOR(errdesc, errstr);
277	short int length;
278	#define err_out(msg) fprintf (stderr,msg)
279
280	/* Check for no error or standard error */
281
282	if (~status & 1) {
283	status = status & 0x8000 ? status & 0xFFFFFFF : status & 0xFFFF;
284	if (SYS$GETMSG(status, &length, &errdesc, 1, 0) == SS$_NORMAL) {
285	errstr[length] = '\0';
286	sprintf (buf, "<0x%x> %s", status, errdesc.dsc$a_pointer);
287	err_out (buf);
288	}
289	else
290	err_out ("System error");
291	}
292	}
293	#endif /* VMS */
294
295	#else /SIMPLE/
296
297	#if defined(BSD42) \|\| defined (SYSIII) \|\| defined(BSD43)
298
299	#define N_KEY 4
300
301	struct key_map {
302	char *k_str;
303	char k_val;
304	char k_index;
305	};
306
307	struct key_map km[N_KEY];
308
309	char keyarea[N_KEY*30];
310
311	char *tgetstr();
312	char *getenv();
313	char *ks;
314	char ks_buf[20];
315	char *ke;
316	char ke_buf[20];
317
318	#ifdef TIOCSLTC
319	struct ltchars old_chars, new_chars;
320	#endif
321
322	char dont_use[] = {
323	ctl('['), ctl('a'), ctl('b'), ctl('c'), ctl('e'), ctl('f'), ctl('g'), ctl('h'),
324	ctl('i'), ctl('j'), ctl('l'), ctl('m'), ctl('n'), ctl('p'), ctl('q'),
325	ctl('r'), ctl('s'), ctl('t'), ctl('u'), ctl('v'), ctl('w'), ctl('x'),
326	ctl('z'), 0
327	};
328
329	charout(c)
330	int c;
331	{
332	(void)putchar(c);
333	}
334
335	initkbd()
336	{
337	register struct key_map *kp;
338	register i,j;
339	char *p = keyarea;
340	char *ktmp;
341	static char buf[1024]; /* Why do I have to do this again? */
342
343	if (tgetent(buf, getenv("TERM")) <= 0)
344	return;
345
346	km[0].k_str = tgetstr("kl", &p); km[0].k_val = ctl('b');
347	km[1].k_str = tgetstr("kr", &p); km[1].k_val = ctl('f');
348	km[2].k_str = tgetstr("ku", &p); km[2].k_val = ctl('p');
349	km[3].k_str = tgetstr("kd", &p); km[3].k_val = ctl('n');
350	ktmp = tgetstr("ks",&p);
351	if (ktmp) {
352	(void) strcpy(ks_buf, ktmp);
353	ks = ks_buf;
354	tputs(ks, 1, charout);
355	}
356	ktmp = tgetstr("ke",&p);
357	if (ktmp) {
358	(void) strcpy(ke_buf, ktmp);
359	ke = ke_buf;
360	}
361
362	/* Unmap arrow keys which conflict with our ctl keys */
363	/* Ignore unset, longer than length 1, and 1-1 mapped keys */
364
365	for (i = 0; i < N_KEY; i++) {
366	kp = &km[i];
367	if (kp->k_str && (kp->k_str[1] == 0) && (kp->k_str[0] != kp->k_val))
368	for (j = 0; dont_use[j] != 0; j++)
369	if (kp->k_str[0] == dont_use[j]) {
370	kp->k_str = (char *)0;
371	break;
372	}
373	}
374
375
376	#ifdef TIOCSLTC
377	(void)ioctl(fileno(stdin), TIOCGLTC, (char *)&old_chars);
378	new_chars = old_chars;
379	if (old_chars.t_lnextc == ctl('v'))
380	new_chars.t_lnextc = -1;
381	if (old_chars.t_rprntc == ctl('r'))
382	new_chars.t_rprntc = -1;
383	(void)ioctl(fileno(stdin), TIOCSLTC, (char *)&new_chars);
384	#endif
385	}
386
387	void
388	kbd_again()
389	{
390	if (ks)
391	tputs(ks, 1, charout);
392
393	#ifdef TIOCSLTC
394	(void)ioctl(fileno(stdin), TIOCSLTC, (char *)&new_chars);
395	#endif
396	}
397
398	void
399	resetkbd()
400	{
401	if (ke)
402	tputs(ke, 1, charout);
403
404	#ifdef TIOCSLTC
405	(void)ioctl(fileno(stdin), TIOCSLTC, (char *)&old_chars);
406	#endif
407	}
408
409	nmgetch()
410	{
411	register int c;
412	register struct key_map *kp;
413	register struct key_map *biggest;
414	register int i;
415	int almost;
416	int maybe;
417
418	static char dumpbuf[10];
419	static char *dumpindex;
420
421	#ifdef SIGVOID
422	void time_out();
423	#else
424	int time_out();
425	#endif
426
427	if (dumpindex && *dumpindex)
428	return (*dumpindex++);
429
430	c = toascii(getchar());
431	biggest = 0;
432	almost = 0;
433
434	for (kp = &km[0]; kp < &km[N_KEY]; kp++) {
435	if (!kp->k_str)
436	continue;
437	if (c == kp->k_str[kp->k_index]) {
438	almost = 1;
439	kp->k_index++;
440	if (kp->k_str[kp->k_index] == 0) {
441	c = kp->k_val;
442	for (kp = &km[0]; kp < &km[N_KEY]; kp++)
443	kp->k_index = 0;
444	return(c);
445	}
446	}
447	if (!biggest && kp->k_index)
448	biggest = kp;
449	else if (kp->k_index && biggest->k_index < kp->k_index)
450	biggest = kp;
451	}
452
453	if (almost) {
454	(void) signal(SIGALRM, time_out);
455	(void) alarm(1);
456
457	if (setjmp(wakeup) == 0) {
458	maybe = nmgetch();
459	(void) alarm(0);
460	return(maybe);
461	}
462	}
463
464	if (biggest) {
465	for (i = 0; i<biggest->k_index; i++)
466	dumpbuf[i] = biggest->k_str[i];
467	if (!almost)
468	dumpbuf[i++] = c;
469	dumpbuf[i] = '\0';
470	dumpindex = &dumpbuf[1];
471	for (kp = &km[0]; kp < &km[N_KEY]; kp++)
472	kp->k_index = 0;
473	return (dumpbuf[0]);
474	}
475
476	return(c);
477	}
478
479	#endif
480
481	#if defined(SYSV2) \|\| defined(SYSV3)
482
483	initkbd()
484	{
485	keypad(stdscr, TRUE);
486	}
487
488	void
489	kbd_again()
490	{
491	keypad(stdscr, TRUE);
492	}
493
494	void
495	resetkbd()
496	{
497	keypad(stdscr, FALSE);
498	}
499
500	nmgetch()
501	{
502	register int c;
503
504	c = getch();
505	switch (c) {
506	case KEY_LEFT: c = ctl('b'); break;
507	case KEY_RIGHT: c = ctl('f'); break;
508	case KEY_UP: c = ctl('p'); break;
509	case KEY_DOWN: c = ctl('n'); break;
510	#ifdef KEY_C1
511	/* This stuff works for a wyse wy75 in ANSI mode under 5.3. Good luck. */
512	/* It is supposed to map the curses keypad back to the numeric equiv. */
513	case KEY_C1: c = '0'; break;
514	case KEY_A1: c = '1'; break;
515	case KEY_B2: c = '2'; break;
516	case KEY_A3: c = '3'; break;
517	case KEY_F(5): c = '4'; break;
518	case KEY_F(6): c = '5'; break;
519	case KEY_F(7): c = '6'; break;
520	case KEY_F(9): c = '7'; break;
521	case KEY_F(10): c = '8'; break;
522	case KEY_F0: c = '9'; break;
523	case KEY_C3: c = '.'; break;
524	case KEY_ENTER: c = ctl('m'); break;
525	#endif
526	default: c = toascii(c);
527	break;
528	}
529	return (c);
530	}
531
532	#endif /* SYSV2 \|\| SYSV3 */
533
534	#endif /* SIMPLE */
535
536	#ifdef SIGVOID
537	void
538	#endif
539	time_out(signo)
540	int signo;
541	{
542	#ifdef IEEE_MATH
543	(void)fpsetsticky((fp_except)0); /* Clear exception */
544	#endif /* IEEE_MATH */
545	longjmp(wakeup, -1);
546	}
547
548	#ifdef SIGVOID
549	void
550	#endif
551	fpe_trap(signo)
552	int signo;
553	{
554	longjmp(fpe_buf, 1);
555	}
556
557	/*
558	* This converts a floating point number of the form
559	* [s]ddd[.d][esd] where s can be a + or - and e is E or e.
560	* to floating point.
561	* p is advanced.
562	*/
563
564	char *
565	strtof(p, res)
566	register char *p;
567	double *res;
568	{
569	double acc;
570	int sign;
571	double fpos;
572	int exp;
573	int exps;
574	#ifdef SIGVOID
575	void (*sig_save)();
576	#else
577	int (*sig_save)();
578	#endif
579
580	sig_save = signal(SIGFPE, fpe_trap);
581	if (setjmp(fpe_buf)) {
582	error("Floating point exception\n");
583	*res = 0.0;
584	(void) signal(SIGFPE, sig_save);
585	return(p);
586	}
587	acc = 0.0;
588	sign = 1;
589	exp = 0;
590	exps = 1;
591	if (*p == '+')
592	p++;
593	else if (*p == '-') {
594	p++;
595	sign = -1;
596	}
597	while (isdigit(*p)) {
598	acc = acc * 10.0 + (double)(*p - '0');
599	p++;
600	}
601	if (p == 'e' \|\| p == 'E') {
602	p++;
603	if (*p == '+')
604	p++;
605	else if (*p == '-') {
606	p++;
607	exps = -1;
608	}
609	while(isdigit(*p)) {
610	exp = exp * 10 + (*p - '0');
611	p++;
612	}
613	}
614	if (*p == '.') {
615	fpos = 1.0/10.0;
616	p++;
617	while(isdigit(*p)) {
618	acc += (p - '0') fpos;
619	fpos *= 1.0/10.0;
620	p++;
621	}
622	}
623	if (p == 'e' \|\| p == 'E') {
624	exp = 0;
625	exps = 1;
626	p++;
627	if (*p == '+')
628	p++;
629	else if (*p == '-') {
630	p++;
631	exps = -1;
632	}
633	while(isdigit(*p)) {
634	exp = exp * 10 + (*p - '0');
635	p++;
636	}
637	}
638	if (exp) {
639	if (exps > 0)
640	while (exp--)
641	acc *= 10.0;
642	else
643	while (exp--)
644	acc *= 1.0/10.0;
645	}
646	if (sign > 0)
647	*res = acc;
648	else
649	*res = -acc;
650
651	(void) signal(SIGFPE, sig_save);
652	return(p);
653	}