summaryrefslogtreecommitdiffstats
path: root/contrib/tcsh/ed.xmap.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/tcsh/ed.xmap.c')
-rw-r--r--contrib/tcsh/ed.xmap.c762
1 files changed, 762 insertions, 0 deletions
diff --git a/contrib/tcsh/ed.xmap.c b/contrib/tcsh/ed.xmap.c
new file mode 100644
index 0000000..acd29d3
--- /dev/null
+++ b/contrib/tcsh/ed.xmap.c
@@ -0,0 +1,762 @@
+/* $Header: /p/tcsh/cvsroot/tcsh/ed.xmap.c,v 3.37 2009/06/25 21:15:37 christos Exp $ */
+/*
+ * ed.xmap.c: This module contains the procedures for maintaining
+ * the extended-key map.
+ *
+ * An extended-key (Xkey) is a sequence of keystrokes
+ * introduced with an sequence introducer and consisting
+ * of an arbitrary number of characters. This module maintains
+ * a map (the Xmap) to convert these extended-key sequences
+ * into input strings (XK_STR), editor functions (XK_CMD), or
+ * unix commands (XK_EXE). It contains the
+ * following externally visible functions.
+ *
+ * int GetXkey(ch,val);
+ * CStr *ch;
+ * XmapVal *val;
+ *
+ * Looks up *ch in map and then reads characters until a
+ * complete match is found or a mismatch occurs. Returns the
+ * type of the match found (XK_STR, XK_CMD, or XK_EXE).
+ * Returns NULL in val.str and XK_STR for no match.
+ * The last character read is returned in *ch.
+ *
+ * void AddXkey(Xkey, val, ntype);
+ * CStr *Xkey;
+ * XmapVal *val;
+ * int ntype;
+ *
+ * Adds Xkey to the Xmap and associates the value in val with it.
+ * If Xkey is already is in Xmap, the new code is applied to the
+ * existing Xkey. Ntype specifies if code is a command, an
+ * out string or a unix command.
+ *
+ * int DeleteXkey(Xkey);
+ * CStr *Xkey;
+ *
+ * Delete the Xkey and all longer Xkeys staring with Xkey, if
+ * they exists.
+ *
+ * Warning:
+ * If Xkey is a substring of some other Xkeys, then the longer
+ * Xkeys are lost!! That is, if the Xkeys "abcd" and "abcef"
+ * are in Xmap, adding the key "abc" will cause the first two
+ * definitions to be lost.
+ *
+ * void ResetXmap();
+ *
+ * Removes all entries from Xmap and resets the defaults.
+ *
+ * void PrintXkey(Xkey);
+ * CStr *Xkey;
+ *
+ * Prints all extended keys prefixed by Xkey and their associated
+ * commands.
+ *
+ * Restrictions:
+ * -------------
+ * 1) It is not possible to have one Xkey that is a
+ * substring of another.
+ */
+/*-
+ * Copyright (c) 1980, 1991 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include "sh.h"
+
+RCSID("$tcsh: ed.xmap.c,v 3.37 2009/06/25 21:15:37 christos Exp $")
+
+#include "ed.h"
+#include "ed.defns.h"
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+/* Internal Data types and declarations */
+
+/* The Nodes of the Xmap. The Xmap is a linked list of these node
+ * elements
+ */
+typedef struct Xmapnode {
+ Char ch; /* single character of Xkey */
+ int type;
+ XmapVal val; /* command code or pointer to string, if this
+ * is a leaf */
+ struct Xmapnode *next; /* ptr to next char of this Xkey */
+ struct Xmapnode *sibling; /* ptr to another Xkey with same prefix */
+} XmapNode;
+
+static XmapNode *Xmap = NULL; /* the current Xmap */
+
+
+/* Some declarations of procedures */
+static int TraverseMap (XmapNode *, CStr *, XmapVal *);
+static int TryNode (XmapNode *, CStr *, XmapVal *, int);
+static XmapNode *GetFreeNode (CStr *);
+static void PutFreeNode (XmapNode *);
+static int TryDeleteNode (XmapNode **, CStr *);
+static int Lookup (struct Strbuf *, const CStr *,
+ const XmapNode *);
+static void Enumerate (struct Strbuf *, const XmapNode *);
+static void unparsech (struct Strbuf *, Char);
+
+
+XmapVal *
+XmapCmd(int cmd)
+{
+ static XmapVal xm;
+ xm.cmd = (KEYCMD) cmd;
+ return &xm;
+}
+
+XmapVal *
+XmapStr(CStr *str)
+{
+ static XmapVal xm;
+ xm.str.len = str->len;
+ xm.str.buf = str->buf;
+ return &xm;
+}
+
+/* ResetXmap():
+ * Takes all nodes on Xmap and puts them on free list. Then
+ * initializes Xmap with arrow keys
+ */
+void
+ResetXmap(void)
+{
+ PutFreeNode(Xmap);
+ Xmap = NULL;
+
+ DefaultArrowKeys();
+ return;
+}
+
+
+/* GetXkey():
+ * Calls the recursive function with entry point Xmap
+ */
+int
+GetXkey(CStr *ch, XmapVal *val)
+{
+ return (TraverseMap(Xmap, ch, val));
+}
+
+/* TraverseMap():
+ * recursively traverses node in tree until match or mismatch is
+ * found. May read in more characters.
+ */
+static int
+TraverseMap(XmapNode *ptr, CStr *ch, XmapVal *val)
+{
+ Char tch;
+
+ if (ptr->ch == *(ch->buf)) {
+ /* match found */
+ if (ptr->next) {
+ /* Xkey not complete so get next char */
+ if (GetNextChar(&tch) != 1) { /* if EOF or error */
+ val->cmd = F_SEND_EOF;
+ return XK_CMD;/* PWP: Pretend we just read an end-of-file */
+ }
+ *(ch->buf) = tch;
+ return (TraverseMap(ptr->next, ch, val));
+ }
+ else {
+ *val = ptr->val;
+ if (ptr->type != XK_CMD)
+ *(ch->buf) = '\0';
+ return ptr->type;
+ }
+ }
+ else {
+ /* no match found here */
+ if (ptr->sibling) {
+ /* try next sibling */
+ return (TraverseMap(ptr->sibling, ch, val));
+ }
+ else {
+ /* no next sibling -- mismatch */
+ val->str.buf = NULL;
+ val->str.len = 0;
+ return XK_STR;
+ }
+ }
+}
+
+void
+AddXkey(const CStr *Xkey, XmapVal *val, int ntype)
+{
+ CStr cs;
+ cs.buf = Xkey->buf;
+ cs.len = Xkey->len;
+ if (Xkey->len == 0) {
+ xprintf("%s", CGETS(9, 1, "AddXkey: Null extended-key not allowed.\n"));
+ return;
+ }
+
+ if (ntype == XK_CMD && val->cmd == F_XKEY) {
+ xprintf("%s",
+ CGETS(9, 2, "AddXkey: sequence-lead-in command not allowed\n"));
+ return;
+ }
+
+ if (Xmap == NULL)
+ /* tree is initially empty. Set up new node to match Xkey[0] */
+ Xmap = GetFreeNode(&cs); /* it is properly initialized */
+
+ /* Now recurse through Xmap */
+ (void) TryNode(Xmap, &cs, val, ntype);
+ return;
+}
+
+static int
+TryNode(XmapNode *ptr, CStr *str, XmapVal *val, int ntype)
+{
+ /*
+ * Find a node that matches *string or allocate a new one
+ */
+ if (ptr->ch != *(str->buf)) {
+ XmapNode *xm;
+
+ for (xm = ptr; xm->sibling != NULL; xm = xm->sibling)
+ if (xm->sibling->ch == *(str->buf))
+ break;
+ if (xm->sibling == NULL)
+ xm->sibling = GetFreeNode(str); /* setup new node */
+ ptr = xm->sibling;
+ }
+
+ str->buf++;
+ str->len--;
+ if (str->len == 0) {
+ size_t len;
+
+ /* we're there */
+ if (ptr->next != NULL) {
+ PutFreeNode(ptr->next); /* lose longer Xkeys with this prefix */
+ ptr->next = NULL;
+ }
+
+ switch (ptr->type) {
+ case XK_STR:
+ case XK_EXE:
+ xfree(ptr->val.str.buf);
+ ptr->val.str.len = 0;
+ break;
+ case XK_NOD:
+ case XK_CMD:
+ break;
+ default:
+ abort();
+ break;
+ }
+
+ switch (ptr->type = ntype) {
+ case XK_CMD:
+ ptr->val = *val;
+ break;
+ case XK_STR:
+ case XK_EXE:
+ ptr->val.str.len = val->str.len;
+ len = (val->str.len + 1) * sizeof(*ptr->val.str.buf);
+ ptr->val.str.buf = xmalloc(len);
+ (void) memcpy(ptr->val.str.buf, val->str.buf, len);
+ break;
+ default:
+ abort();
+ break;
+ }
+ }
+ else {
+ /* still more chars to go */
+ if (ptr->next == NULL)
+ ptr->next = GetFreeNode(str); /* setup new node */
+ (void) TryNode(ptr->next, str, val, ntype);
+ }
+ return (0);
+}
+
+void
+ClearXkey(KEYCMD *map, const CStr *in)
+{
+ unsigned char c = (unsigned char) *(in->buf);
+ if ((map[c] == F_XKEY) &&
+ ((map == CcKeyMap && CcAltMap[c] != F_XKEY) ||
+ (map == CcAltMap && CcKeyMap[c] != F_XKEY)))
+ (void) DeleteXkey(in);
+}
+
+int
+DeleteXkey(const CStr *Xkey)
+{
+ CStr s;
+
+ s = *Xkey;
+ if (s.len == 0) {
+ xprintf("%s",
+ CGETS(9, 3, "DeleteXkey: Null extended-key not allowed.\n"));
+ return (-1);
+ }
+
+ if (Xmap == NULL)
+ return (0);
+
+ (void) TryDeleteNode(&Xmap, &s);
+ return (0);
+}
+
+/* Destroys str */
+static int
+TryDeleteNode(XmapNode **inptr, CStr *str)
+{
+ XmapNode *ptr;
+
+ ptr = *inptr;
+ /*
+ * Find a node that matches *string or allocate a new one
+ */
+ if (ptr->ch != *(str->buf)) {
+ XmapNode *xm;
+
+ for (xm = ptr; xm->sibling != NULL; xm = xm->sibling)
+ if (xm->sibling->ch == *(str->buf))
+ break;
+ if (xm->sibling == NULL)
+ return (0);
+ inptr = &xm->sibling;
+ ptr = xm->sibling;
+ }
+
+ str->buf++;
+ str->len--;
+
+ if (str->len == 0) {
+ /* we're there */
+ *inptr = ptr->sibling;
+ ptr->sibling = NULL;
+ PutFreeNode(ptr);
+ return (1);
+ }
+ else if (ptr->next != NULL && TryDeleteNode(&ptr->next, str) == 1) {
+ if (ptr->next != NULL)
+ return (0);
+ *inptr = ptr->sibling;
+ ptr->sibling = NULL;
+ PutFreeNode(ptr);
+ return (1);
+ }
+ else {
+ return (0);
+ }
+}
+
+/* PutFreeNode():
+ * Puts a tree of nodes onto free list using free(3).
+ */
+static void
+PutFreeNode(XmapNode *ptr)
+{
+ if (ptr == NULL)
+ return;
+
+ if (ptr->next != NULL) {
+ PutFreeNode(ptr->next);
+ ptr->next = NULL;
+ }
+
+ PutFreeNode(ptr->sibling);
+
+ switch (ptr->type) {
+ case XK_CMD:
+ case XK_NOD:
+ break;
+ case XK_EXE:
+ case XK_STR:
+ xfree(ptr->val.str.buf);
+ break;
+ default:
+ abort();
+ break;
+ }
+ xfree(ptr);
+}
+
+
+/* GetFreeNode():
+ * Returns pointer to an XmapNode for ch.
+ */
+static XmapNode *
+GetFreeNode(CStr *ch)
+{
+ XmapNode *ptr;
+
+ ptr = xmalloc(sizeof(XmapNode));
+ ptr->ch = ch->buf[0];
+ ptr->type = XK_NOD;
+ ptr->val.str.buf = NULL;
+ ptr->val.str.len = 0;
+ ptr->next = NULL;
+ ptr->sibling = NULL;
+ return (ptr);
+}
+
+
+/* PrintXKey():
+ * Print the binding associated with Xkey key.
+ * Print entire Xmap if null
+ */
+void
+PrintXkey(const CStr *key)
+{
+ struct Strbuf buf = Strbuf_INIT;
+ CStr cs;
+
+ if (key) {
+ cs.buf = key->buf;
+ cs.len = key->len;
+ }
+ else {
+ cs.buf = STRNULL;
+ cs.len = 0;
+ }
+ /* do nothing if Xmap is empty and null key specified */
+ if (Xmap == NULL && cs.len == 0)
+ return;
+
+ Strbuf_append1(&buf, '"');
+ cleanup_push(&buf, Strbuf_cleanup);
+ if (Lookup(&buf, &cs, Xmap) <= -1)
+ /* key is not bound */
+ xprintf(CGETS(9, 4, "Unbound extended key \"%S\"\n"), cs.buf);
+ cleanup_until(&buf);
+}
+
+/* Lookup():
+ * look for the string starting at node ptr.
+ * Print if last node
+ */
+static int
+Lookup(struct Strbuf *buf, const CStr *str, const XmapNode *ptr)
+{
+ if (ptr == NULL)
+ return (-1); /* cannot have null ptr */
+
+ if (str->len == 0) {
+ /* no more chars in string. Enumerate from here. */
+ Enumerate(buf, ptr);
+ return (0);
+ }
+ else {
+ /* If match put this char into buf. Recurse */
+ if (ptr->ch == *(str->buf)) {
+ /* match found */
+ unparsech(buf, ptr->ch);
+ if (ptr->next != NULL) {
+ /* not yet at leaf */
+ CStr tstr;
+ tstr.buf = str->buf + 1;
+ tstr.len = str->len - 1;
+ return (Lookup(buf, &tstr, ptr->next));
+ }
+ else {
+ /* next node is null so key should be complete */
+ if (str->len == 1) {
+ Strbuf_append1(buf, '"');
+ Strbuf_terminate(buf);
+ printOne(buf->s, &ptr->val, ptr->type);
+ return (0);
+ }
+ else
+ return (-1);/* mismatch -- string still has chars */
+ }
+ }
+ else {
+ /* no match found try sibling */
+ if (ptr->sibling)
+ return (Lookup(buf, str, ptr->sibling));
+ else
+ return (-1);
+ }
+ }
+}
+
+static void
+Enumerate(struct Strbuf *buf, const XmapNode *ptr)
+{
+ size_t old_len;
+
+ if (ptr == NULL) {
+#ifdef DEBUG_EDIT
+ xprintf(CGETS(9, 6, "Enumerate: BUG!! Null ptr passed\n!"));
+#endif
+ return;
+ }
+
+ old_len = buf->len;
+ unparsech(buf, ptr->ch); /* put this char at end of string */
+ if (ptr->next == NULL) {
+ /* print this Xkey and function */
+ Strbuf_append1(buf, '"');
+ Strbuf_terminate(buf);
+ printOne(buf->s, &ptr->val, ptr->type);
+ }
+ else
+ Enumerate(buf, ptr->next);
+
+ /* go to sibling if there is one */
+ if (ptr->sibling) {
+ buf->len = old_len;
+ Enumerate(buf, ptr->sibling);
+ }
+}
+
+
+/* PrintOne():
+ * Print the specified key and its associated
+ * function specified by val
+ */
+void
+printOne(const Char *key, const XmapVal *val, int ntype)
+{
+ struct KeyFuncs *fp;
+ static const char *fmt = "%s\n";
+
+ xprintf("%-15S-> ", key);
+ if (val != NULL)
+ switch (ntype) {
+ case XK_STR:
+ case XK_EXE: {
+ unsigned char *p;
+
+ p = unparsestring(&val->str, ntype == XK_STR ? STRQQ : STRBB);
+ cleanup_push(p, xfree);
+ xprintf(fmt, p);
+ cleanup_until(p);
+ break;
+ }
+ case XK_CMD:
+ for (fp = FuncNames; fp->name; fp++)
+ if (val->cmd == fp->func)
+ xprintf(fmt, fp->name);
+ break;
+ default:
+ abort();
+ break;
+ }
+ else
+ xprintf(fmt, CGETS(9, 7, "no input"));
+}
+
+static void
+unparsech(struct Strbuf *buf, Char ch)
+{
+ if (ch == 0) {
+ Strbuf_append1(buf, '^');
+ Strbuf_append1(buf, '@');
+ }
+ else if (Iscntrl(ch)) {
+ Strbuf_append1(buf, '^');
+ if (ch == CTL_ESC('\177'))
+ Strbuf_append1(buf, '?');
+ else
+#ifdef IS_ASCII
+ Strbuf_append1(buf, ch | 0100);
+#else
+ Strbuf_append1(buf, _toebcdic[_toascii[ch]|0100]);
+#endif
+ }
+ else if (ch == '^') {
+ Strbuf_append1(buf, '\\');
+ Strbuf_append1(buf, '^');
+ } else if (ch == '\\') {
+ Strbuf_append1(buf, '\\');
+ Strbuf_append1(buf, '\\');
+ } else if (ch == ' ' || (Isprint(ch) && !Isspace(ch))) {
+ Strbuf_append1(buf, ch);
+ }
+ else {
+ Strbuf_append1(buf, '\\');
+ Strbuf_append1(buf, ((ch >> 6) & 7) + '0');
+ Strbuf_append1(buf, ((ch >> 3) & 7) + '0');
+ Strbuf_append1(buf, (ch & 7) + '0');
+ }
+}
+
+eChar
+parseescape(const Char **ptr)
+{
+ const Char *p;
+ Char c;
+
+ p = *ptr;
+
+ if ((p[1] & CHAR) == 0) {
+ xprintf(CGETS(9, 8, "Something must follow: %c\n"), (char)*p);
+ return CHAR_ERR;
+ }
+ if ((*p & CHAR) == '\\') {
+ p++;
+ switch (*p & CHAR) {
+ case 'a':
+ c = CTL_ESC('\007'); /* Bell */
+ break;
+ case 'b':
+ c = CTL_ESC('\010'); /* Backspace */
+ break;
+ case 'e':
+ c = CTL_ESC('\033'); /* Escape */
+ break;
+ case 'f':
+ c = CTL_ESC('\014'); /* Form Feed */
+ break;
+ case 'n':
+ c = CTL_ESC('\012'); /* New Line */
+ break;
+ case 'r':
+ c = CTL_ESC('\015'); /* Carriage Return */
+ break;
+ case 't':
+ c = CTL_ESC('\011'); /* Horizontal Tab */
+ break;
+ case 'v':
+ c = CTL_ESC('\013'); /* Vertical Tab */
+ break;
+ case '\\':
+ c = '\\';
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ {
+ int cnt, val;
+ Char ch;
+
+ for (cnt = 0, val = 0; cnt < 3; cnt++) {
+ ch = *p++ & CHAR;
+ if (ch < '0' || ch > '7') {
+ p--;
+ break;
+ }
+ val = (val << 3) | (ch - '0');
+ }
+ if ((val & ~0xff) != 0) {
+ xprintf("%s", CGETS(9, 9,
+ "Octal constant does not fit in a char.\n"));
+ return 0;
+ }
+#ifndef IS_ASCII
+ if (CTL_ESC(val) != val && adrof(STRwarnebcdic))
+ xprintf(/*CGETS(9, 9, no NLS-String yet!*/
+ "Warning: Octal constant \\%3.3o is interpreted as EBCDIC value.\n", val/*)*/);
+#endif
+ c = (Char) val;
+ --p;
+ }
+ break;
+ default:
+ c = *p;
+ break;
+ }
+ }
+ else if ((*p & CHAR) == '^' && (Isalpha(p[1] & CHAR) ||
+ strchr("@^_?\\|[{]}", p[1] & CHAR))) {
+ p++;
+#ifdef IS_ASCII
+ c = ((*p & CHAR) == '?') ? CTL_ESC('\177') : ((*p & CHAR) & 0237);
+#else
+ c = ((*p & CHAR) == '?') ? CTL_ESC('\177') : _toebcdic[_toascii[*p & CHAR] & 0237];
+ if (adrof(STRwarnebcdic))
+ xprintf(/*CGETS(9, 9, no NLS-String yet!*/
+ "Warning: Control character ^%c may be interpreted differently in EBCDIC.\n", *p & CHAR /*)*/);
+#endif
+ }
+ else
+ c = *p;
+ *ptr = p;
+ return (c);
+}
+
+
+unsigned char *
+unparsestring(const CStr *str, const Char *sep)
+{
+ unsigned char *buf, *b;
+ Char p;
+ int l;
+
+ /* Worst-case is "\uuu" or result of wctomb() for each char from str */
+ buf = xmalloc((str->len + 1) * max(4, MB_LEN_MAX));
+ b = buf;
+ if (sep[0])
+#ifndef WINNT_NATIVE
+ *b++ = sep[0];
+#else /* WINNT_NATIVE */
+ *b++ = CHAR & sep[0];
+#endif /* !WINNT_NATIVE */
+
+ for (l = 0; l < str->len; l++) {
+ p = str->buf[l];
+ if (Iscntrl(p)) {
+ *b++ = '^';
+ if (p == CTL_ESC('\177'))
+ *b++ = '?';
+ else
+#ifdef IS_ASCII
+ *b++ = (unsigned char) (p | 0100);
+#else
+ *b++ = _toebcdic[_toascii[p]|0100];
+#endif
+ }
+ else if (p == '^' || p == '\\') {
+ *b++ = '\\';
+ *b++ = (unsigned char) p;
+ }
+ else if (p == ' ' || (Isprint(p) && !Isspace(p)))
+ b += one_wctomb((char *)b, p & CHAR);
+ else {
+ *b++ = '\\';
+ *b++ = ((p >> 6) & 7) + '0';
+ *b++ = ((p >> 3) & 7) + '0';
+ *b++ = (p & 7) + '0';
+ }
+ }
+ if (sep[0] && sep[1])
+#ifndef WINNT_NATIVE
+ *b++ = sep[1];
+#else /* WINNT_NATIVE */
+ *b++ = CHAR & sep[1];
+#endif /* !WINNT_NATIVE */
+ *b++ = 0;
+ return buf; /* should check for overflow */
+}
OpenPOWER on IntegriCloud