/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */

/* $Header: getc.c,v 2.5 85/08/22 16:02:44 timo Exp $ */

/* B editor -- read key definitions from file */

#include "b.h"
#include "feat.h"
#ifdef LINDA
#include "b1mem.h"
#define syserr EDsyserr
#else !LINDA
#define freemem(p) free(p)
#endif !LINDA
#include "file.h"
#include "keys.h"

#include <ctype.h>

extern bool dflag;

#define ESC '\033'

/*
This file contains a little parser for key definition files.
To allow sufficient freedom in preparing such a file, a simple
grammar has been defined according to which the file is parsed.
The parsing process is extremely simple, as it can be done
top-down using recursive descent.


Lexical conventions:

- Blanks between lexical symbols are gnored.
- From '#' to end of line is comment (except inside strings).
- Strings are delimited by single or double quotes and
  use the same escape sequences as C strings, plus:
  \e or \E means an ESCape ('\033').
- Command names are like C identifiers ([a-zA-Z_][a-zA-Z0-9_]*).
  Upper/lower case distinction is significant.
- numbers are octal or decimal integers in C-style (leading zero means octal)
- After '^' a character is expected, this must be a letter or one of @^_[]\ .

Syntax in modified BNF ([] mean 0 or 1, * means 0 or more, + means 1 or more):

   file: line*
   line: [def] [comment]
   def: commandname '=' rhs
   rhs: item+
   item: string | '^' character | number


Notes:

- A definition for command "term_init" defines a string to be sent
  TO the terminal at initialization time, e.g. to set programmable
  function key definitions.  Similar for "term_done" on exiting.
- Command names are  conventional editor commands.

*/


#ifndef LINDA
/* Defines subroutine that used to be in the support levels: */

Hidden string getmem(nbytes)
	unsigned nbytes;
{
	string malloc();
	string pointer= malloc(nbytes);

	if (pointer == NULL)
		syserr("memory full in initkeys");
	return pointer;
}

Hidden string regetmem(pp, nbytes)
	string *pp;
	unsigned nbytes;
{
	*pp= realloc(*pp, nbytes);
	if (*pp == NULL)
		syserr("memory full in initkeys (regetmem)");
}
#endif !LINDA


#define COMMENT '#' /* Not B-like but very UNIX-like */
#define MAXDEFS 100

Hidden FILE *fp; /* File from which to read */
Hidden string filename; /* File name for error messages */
Hidden char nextc; /* Next character to be analyzed */
Hidden bool eof; /* EOF seen? */
Hidden int lcount; /* Current line number */
Hidden bool errcount; /* Number of errors detected */


struct tabent {
	int code;
	string name;
	string def;
};

/* Table of key definitions, mostly filled by reading definitions from a file.
   The "I" macro has two arguments: the default for termcap and that for
   the IBM PC.  It expands to either depending on whether IBMPC is defined.
   'def' fields initialized with a string starting with '=' are termcap names,
   and are replaced by the corresponding termcap entry (NULL if none).
   On the IBM PC, 'extended codes' are by convention a null character
   followed by another character (usually the scan code).  Since the null
   character is rather unsuitable for use in C strings, we use \377 (hex FF)
   instead, a code which has no assigned graphic is the extended IBM PC
   character set.  E.g., F1 is 0-59, which we encode as \377\073 (since
   \073 is octal for 59 decimal).  For the exact codes, see for instance the
   BASIC 2.0 manual, appendix G, or the XT Technical Reference, page 2-14.
*/

#ifdef IBMPC
#define I(tc, ibm) ibm
#else !IBMPC
#define I(tc, ibm) tc
#endif !IBMPC

Visible struct tabent deftab[MAXDEFS] = {
	/* General rule:
	   unix => ctrl-x
	   IBM  => alt-x
	   where x is first letter of command name
	*/
	{0377, "ignore", NULL}, /* Entry to ignore a key */
	{COPY, "copy", I(NULL, "\377\056")},
	{DELETE, "delete", I(NULL, "\377\040")},
	{DELETE, "delete", I(NULL, "\377\123")}, /* IBM DEL key */
	{ACCEPT, "accept", I(NULL, "\377\022")}, /* ^E, alt-E */
	{ACCEPT, "end", I(NULL, "\377\117")}, /* IBM END key */
	{'\t', "tab", NULL}, /* = ACCEPT in Bed, insert tab in Linda */
	{UNDO, "undo"}, /* Always backspace = ^H */
	{REDRAW, "redraw", I(NULL, "\377\046")}, /* ^L, alt-L */
	{REDRAW, "look"},
	{RETURN, "newline"}, /* Always ^M */
	{REDO, "redo", I(NULL, "\177")}, /* IBM ctrl-BS = ASCII 177 (DEL) */
	{EXIT, "exit", I(NULL, "\377\055")}, /* ^X, alt-X */

#ifdef RECORDING
	/*
	 * The IBM-PC has a problem here in ANSI.SYS mode: ctrl-P is
	 * unusable because it means Print Screen, and alt-R is unusable
	 * because it transmits 0, 19 but 19 is ctrl-S which means stop
	 * output :-(.
	 * The only reasonable place to put the things would then be on
	 * function keys.  You should do this in the key definitions file. (?)
	 */
	{PLAYBACK, "play", I(NULL, "\377\031")},
	{PLAYBACK, "playback", I(NULL, "\377\031")},
	{RECORD, "record", I(NULL, "\377\023")},
#endif RECORDING

#ifdef LINDA
	{BFIND, "bfind", I(NULL, "\377\060")},
	{FIND, "find", I(NULL, "\377\041")},
	{GLOBAL, "global", I(NULL, "\377\042")},
	{JOIN, "join", I(NULL, "\377\044")},
	{TOGGLE, "toggle", I(NULL, "\377\024")},
	{YANK, "yank", I(NULL, "\377\025")},
	{LITERAL, "literal", I(NULL, "\377\057")}, /* ^V, alt-V */
#endif LINDA

	{WIDEN, "widen", I("=k1", "\377\073")}, /* IBM F1 */
	{NARROW, "narrow", I("=k2", "\377\075")}, /* IBM F3 (!!!) */
	{NARROW, "first"},
	{RNARROW, "rnarrow", I("=k3", "\377\076")}, /* IBM F4 (!!!) */
	{RNARROW, "last"},
	{EXTEND, "extend", I("=k4", "\377\074")}, /* IBM F2 (!!!) */
	{UPARROW, "up", I("=ku", "\377\110")},
	{UPLINE, "upline", I("=k5", "\377\110")},
	{LEFTARROW, "left", I("=kl", "\377\113")},
	{PREVIOUS, "previous", I("=k6", NULL)},
	{RITEARROW, "right", I("=kr", "\377\115")},
	{NEXT, "next", I("=k7", NULL)},
	{DOWNARROW, "down", I("=kd", "\377\120")},
	{DOWNLINE, "downline", I("=k8", "\377\120")},

	{GOTO, "goto", I("\033g", NULL)}, /* Doesn't exist on IBM */
#ifdef HELPFUL
	{HELP, "help", I("\033?", "\377\104")}, /* ESC ?, IBM F10 */
#endif HELPFUL

	{0, "term_init", I("=ks", NULL)},
	{0, "term_done", I("=ke", NULL)},
};

#undef I

Hidden int ndefs;


Hidden Procedure err(fmt, arg)
	string fmt, arg;
{
	if (errcount == 0)
		fprintf(stderr, "Errors in key definitions file:\n");
	++errcount;
	fprintf(stderr, "%s, line %d: ", filename, lcount);
	fprintf(stderr, fmt, arg);
	fprintf(stderr, "\n");
}

Hidden Procedure adv()
{
	int c;

	if (eof)
		return;
	c= getc(fp);
	if (c == EOF) {
		nextc= '\n';
		eof= Yes;
	}
	else {
		nextc= c;
		if (c == '\n')
			++lcount;
	}
}

Hidden Procedure skipsp()
{
	while (nextc == ' ' || nextc == '\t')
		adv();
}

Hidden int lookup(name)
	string name;
{
	int i;

	for (i= 0; i < ndefs; ++i) {
		if (deftab[i].name != NULL && strcmp(name, deftab[i].name) == 0)
			return i;
	}
	return -1;
}

Hidden Procedure store(code, name, def)
	int code;
	string name;
	string def;
{
	struct tabent *d, *last= deftab+ndefs; 
	string p, q;

	/* Undefine conflicting definitions.  Conflicts arise
	   when a command definition is an initial subsequence
	   of another, or vice versa.  Key definitions (code < 0)
	   are not undefined. */
	if (code > 0) {
		for (d= deftab; d < last; ++d) {
			if (d->code >= 0 && d->def != NULL) {
				for (p= def, q= d->def; *p == *q; ++p, ++q) {
					if (*p == '\0' || *q == '\0') {
						d->def= NULL;
						break;
					}
				}
			}
		}
	}

	/* Find a free slot with the same code and NULL definition */
	/* (For code == 0, the name must match instead of the code,
	   and the definition need not be NULL) */
	for (d= deftab; d < last; ++d) {
		if (code == 0 ? strcmp(name, d->name) == 0
			: (d->code == code && d->def == NULL))
			break;
	}
	if (d == last) { /* Extend definition table */
		if (ndefs >= MAXDEFS) {
			err("Too many key definitions", "");
			return;
		}
		++ndefs;
		d->code= code;
		d->name= name;
	}
	d->def= def;
}

Hidden string savestr(s)
	string s;
{
	string new;

	new= getmem((unsigned) (strlen(s) + 1));
	strcpy(new, s);
	return new;
}

Hidden Procedure append(to, item)
	string *to, item;
{
	int len= strlen(*to) + strlen(item) + 1;
	regetmem(to, len);
	strcat(*to, item);
}

Hidden string getname()
{
	char buffer[20];
	string bp;

	if (!isalpha(nextc) && nextc != '_') {
		err("No name where expected", "");
		return NULL;
	}
	for (bp= buffer; isalnum(nextc) || nextc == '_'; ) {
		if (bp < buffer + sizeof buffer - 1)
			*bp++ = nextc;
		adv();
	}
	*bp= '\0';
	return savestr(buffer);
}

Hidden int getnumber()
{
	int base= (nextc == '0') ? 8 : 10;
	int i= 0;
	int d;

	for (;; adv()) {
		d= nextc-'0';
		if (d < 0 || d > 9)
			break;
		if (d > base) {
			err("8 or 9 in octal number", "");
			return 0;
		}
		i= i*base + d;
	}
	return i;
}

Hidden string getstring()
{
	char buf[256]; /* Arbitrary limit */
	char quote= nextc;
	char c;
	int len= 0;

	adv();
	while (nextc != quote) {
		if (nextc == '\n') {
			err("closing string quote not found", "");
			return NULL;
		}
		if (nextc != '\\') {
			c= nextc;
			adv();
		}
		else {
			adv();
			switch (nextc) {

			case 'r': c= '\r'; adv(); break;
			case 'n': c= '\n'; adv(); break;
			case 'b': c= '\b'; adv(); break;
			case 't': c= '\t'; adv(); break;
			case 'f': c= '\f'; adv(); break;

			case 'E':
			case 'e': c= ESC; adv(); break;

			case '0': case '1': case '2': case '3':
			case '4': case '5': case '6': case '7':
				c= nextc-'0';
				adv();
				if (nextc >= '0' && nextc < '8') {
					c= 8*c + nextc-'0';
					adv();
					if (nextc >= '0' && nextc < '8') {
						c= 8*c + nextc-'0';
						adv();
					}
				}
				break;

			default: c=nextc; adv(); break;

			}
		}
		if (len >= sizeof buf) {
			err("string too long", "");
			return NULL;
		}
		buf[len++]= c;
	}
	adv();
	buf[len]= '\0';
	return savestr(buf);
}

Hidden string getitem()
{
	char buf[2];
	string keyname;
	int i;

	switch (nextc) {
	case '"':
	case '\'':
		return getstring();
	case '^':
		adv();
		if (isalpha(nextc) || index("@^_[]\\?", nextc)) {
			if (nextc == '?')
				buf[0]= '\177';
			else
				buf[0]= nextc & 037;
			buf[1]= '\0';
			adv();
			return savestr(buf);
		}
		err("Invalid character after '^'", "");
		return NULL;
	default:
		if (isdigit(nextc)) {
			buf[0]= getnumber();
			buf[1]= '\0';
			return savestr(buf);
		}
		if (isalpha(nextc) || nextc == '_') {
			keyname= getname(); /* Cannot fail */
			if (strlen(keyname) == 1)
				return savestr(keyname);
				/* Single letters stand for themselves */
			i= lookup(keyname);
			if (i < 0 || deftab[i].code <= 0) {
				err("%s: not a key name", keyname);
				freemem(keyname);
				return NULL;
			}
			else if (deftab[i].def == NULL) {
				err("%s: undefined key", keyname);
				freemem(keyname);
				return NULL;
			}
			else
				return savestr(deftab[i].def);
		}
		err("Invalid item", "");
		return NULL;
	}
}

Hidden string getrhs()
{
	string first, item;

	skipsp();
	first= getitem();
	if (first != NULL) {
		for (;;) {
			skipsp();
			if (nextc == '\n' || nextc == COMMENT)
				break;
			item= getitem();
			if (item == NULL) {
				freemem(first);
				return NULL;
			}
			append(&first, item);
			freemem(item);
		}
	}
	return first;
}

Hidden Procedure getdef()
{
	string name;
	int key;
	string rhs;

	name= getname();
	if (name == NULL)
		return;
	skipsp();
	if (nextc != '=') {
		err("Command name %s not followed by '='", name);
		return;
	}
	key= lookup(name);
	if (key < 0) {
		err("Unknown command: %s", name);
		return;
	}
	if (deftab[key].code < 0) {
		err("No redefinition of %s allowed", name);
		return;
	}
	adv();
	rhs= getrhs();
	if (rhs != NULL)
		store(deftab[key].code, name, rhs);
}

Hidden Procedure getline()
{
	adv();
	skipsp();
	if (nextc != COMMENT && nextc != '\n')
		getdef();
	while (nextc != '\n')
		adv();
}

#ifndef NDEBUG
Hidden Procedure dump(where)
	string where;
{
	int i;
	string s;

	printf("\nDump of key definitions %s.\n\n", where);
	printf("Code    Name            Definition\n");
	for (i= 0; i < ndefs; ++i) {
		printf("%04o    ", deftab[i].code);
		if (deftab[i].name != NULL)
			printf("%-15s ", deftab[i].name);
		else
			printf("%16s", "");
		s= deftab[i].def;
		if (s != NULL) {
			for (; *s != '\0'; ++s) {
				if (isascii(*s) && (isprint(*s) || *s == ' '))
					fputc(*s, stdout);
				else
					printf("\\%03o", *s&0377);
			}
		}
		printf("\n");
	}
	fflush(stdout);
}
#endif !NDEBUG

Hidden Procedure countdefs()
{
	struct tabent *d;

	d= deftab;
	while (d->name != NULL || d->code != 0 || d->def != NULL) {
		++d;
		if (d >= deftab+MAXDEFS)
			syserr("too many predefined keys");
	}
	ndefs= d-deftab;
}

Hidden Procedure process()
{
	errcount= 0;
	lcount= 1;
	eof= No;
	do {
		getline();
	} while (!eof);
}

Hidden bool try(dir, file, type)
	string dir, file, type;
{
	char buffer[200];

#ifdef IBMPC
	sprintf(buffer, "%.150s\\%.9s%.3s", dir, file, type);
#else !IBMPC
	sprintf(buffer, "%.150s/%.20s%.20s", dir, file, type);
#endif !IBMPC
	fp= fopen(buffer, "r");
	if (fp == NULL)
		return No;
	filename= buffer;
	process();
	fclose(fp);
#ifndef NDEBUG
	if (dflag)
		dump("after try");
#endif NDEBUG
	return Yes;
}

#ifndef IBMPC
Hidden Procedure readtermcap()
{
	string tgetstr();
	char buffer[1024]; /* Constant dictated by termcap manual entry */
	static char area[1024];
	string endarea= area;
	string anentry;
	struct tabent *d, *last;

	switch (tgetent(buffer, getenv("TERM"))) {

	default:
		fprintf(stderr, "*** Bad tgetent() return value.\n");
		/* Fall through */
	case -1:
		fprintf(stderr, "*** Can't read termcap.\n");
		/* Fall through again */
	case 0:
		fprintf(stderr, "*** No description for your terminal.\n");
		exit(1);

	case 1:
		break;
	}
	last= deftab+ndefs;
	for (d= deftab; d < last; ++d) {
		if (d->def != NULL && d->def[0] == '=') {
			anentry= tgetstr(d->def+1, &endarea);
			if (anentry != NULL && anentry[0] != '\0')
				d->def= anentry;
			else
				d->def= NULL;
		}
	}
}
#endif !IBMPC

Visible Procedure initkeys()
{
	string term= NULL;

	countdefs();
#ifndef NDEBUG
	if (dflag)
		dump("before termcap");
#endif NDEBUG
#ifndef IBMPC
	readtermcap();
#ifndef NDEBUG
	if (dflag)
		dump("after termcap");
#endif NDEBUG
	term= getenv("TERM");
	if (term != NULL && term[0] == '\0')
		term= NULL;
#endif !IBMPC
#ifdef DEBUG
	/* Try in the current directory. Only for debugging porpoises. */
	if (term != NULL)
		if (try(".", keyfile, term)) return;
#endif DEBUG
	if (term != NULL) {
		if (try(homedir, keyfile, term)) return;
		if (try(libdir, keyfile, term)) return;
	}
#ifdef DEBUG
	if (try(".", keyfile, deftype)) return;
#endif DEBUG
	if (try(homedir, keyfile, deftype)) return;
	if (try(libdir, keyfile, deftype)) return;
#ifndef NDEBUG
	printf("[No key definitions file found, using defaults.]\n");
#endif !NDEBUG
}


/* Output a named string to the terminal */

Hidden Procedure outstring(name)
	string name;
{
	int i= lookup(name);
	string def;

	if (i >= 0 && (def= deftab[i].def) != NULL)
		fputs(def, stdout);
}


/* Output the terminal's initialization sequence, if any. */

Visible Procedure
initgetc()
{
	outstring("term_init");
}


/* Output a sequence, if any, to return the terminal to a 'normal' state. */

Visible Procedure endgetc()
{
	outstring("term_done");
}


/* Read a command from the keyboard, decoding composite key definitions. */

#ifndef IBMPC
/* Strip high bit from input characters (matters only on PWB systems?) */
#define getch() (getchar() & 0177)
#endif !IBMPC

Visible int inchar()
{
	int c;
	struct tabent *d, *last;
	char buffer[100];
	int len;

	c= getch();
	if (c == EOF)
		return c;
#ifdef IBMPC
	if (c == 0)
		c= 0377;
#endif IBMPC
	last= deftab+ndefs;
	for (d= deftab; d < last; ++d) {
		if (d->code > 0 && d->def != NULL && c == (d->def[0] & 0377))
			break;
	}
	if (d == last) {
		if (c == ESC) {
			/* Kludge to make ESC-char by default equal to
			   char|MASK -- the command definitions do the rest:
			   e.g. WIDEN is 'w'|MASK, so ESC-w means WIDEN. */
			c= getch();
			if (c == EOF)
				return EOF;
			return (c&0177) | MASK;
		}
		return c;
	}
	if (d->def[1] == '\0')
		return d->code;
	buffer[0]= c;
	len= 1;
	for (;;) {
		c= getch();
		if (c == EOF)
			return EOF;
		buffer[len]= c;
		if (len < sizeof buffer - 1)
			++len;
		for (d= deftab; d < last; ++d) {
			if (d->code > 0 && d->def != NULL
				&& strncmp(buffer, d->def, len) == 0)
				break;
		}
		if (d == last) {
			if (buffer[0] == ESC && len == 2) {
				/* Same kludge as above */
				return c&0177 | MASK;
			}
			return 0377; /* Hope this rings a bell */
		}
		if (d->def[len] == '\0')
			return d->code;
	}
}