bnx: Remove unused code
[dragonfly.git] / contrib / tcsh-6 / ed.xmap.c
1 /* $Header: /p/tcsh/cvsroot/tcsh/ed.xmap.c,v 3.37 2009/06/25 21:15:37 christos Exp $ */
2 /*
3  * ed.xmap.c: This module contains the procedures for maintaining
4  *            the extended-key map.
5  *
6  *            An extended-key (Xkey) is a sequence of keystrokes
7  *            introduced with an sequence introducer and consisting
8  *            of an arbitrary number of characters.  This module maintains
9  *            a map (the Xmap) to convert these extended-key sequences
10  *            into input strings (XK_STR), editor functions (XK_CMD), or
11  *            unix commands (XK_EXE). It contains the
12  *            following externally visible functions.
13  *
14  *              int GetXkey(ch,val);
15  *              CStr *ch;
16  *              XmapVal *val;
17  *
18  *            Looks up *ch in map and then reads characters until a
19  *            complete match is found or a mismatch occurs. Returns the
20  *            type of the match found (XK_STR, XK_CMD, or XK_EXE).
21  *            Returns NULL in val.str and XK_STR for no match.  
22  *            The last character read is returned in *ch.
23  *
24  *              void AddXkey(Xkey, val, ntype);
25  *              CStr *Xkey;
26  *              XmapVal *val;
27  *              int ntype;
28  *
29  *            Adds Xkey to the Xmap and associates the value in val with it.
30  *            If Xkey is already is in Xmap, the new code is applied to the
31  *            existing Xkey. Ntype specifies if code is a command, an
32  *            out string or a unix command.
33  *
34  *              int DeleteXkey(Xkey);
35  *              CStr *Xkey;
36  *
37  *            Delete the Xkey and all longer Xkeys staring with Xkey, if
38  *            they exists.
39  *
40  *            Warning:
41  *              If Xkey is a substring of some other Xkeys, then the longer
42  *              Xkeys are lost!!  That is, if the Xkeys "abcd" and "abcef"
43  *              are in Xmap, adding the key "abc" will cause the first two
44  *              definitions to be lost.
45  *
46  *              void ResetXmap();
47  *
48  *            Removes all entries from Xmap and resets the defaults.
49  *
50  *              void PrintXkey(Xkey);
51  *              CStr *Xkey;
52  *
53  *            Prints all extended keys prefixed by Xkey and their associated
54  *            commands.
55  *
56  *            Restrictions:
57  *            -------------
58  *              1) It is not possible to have one Xkey that is a
59  *                 substring of another.
60  */
61 /*-
62  * Copyright (c) 1980, 1991 The Regents of the University of California.
63  * All rights reserved.
64  *
65  * Redistribution and use in source and binary forms, with or without
66  * modification, are permitted provided that the following conditions
67  * are met:
68  * 1. Redistributions of source code must retain the above copyright
69  *    notice, this list of conditions and the following disclaimer.
70  * 2. Redistributions in binary form must reproduce the above copyright
71  *    notice, this list of conditions and the following disclaimer in the
72  *    documentation and/or other materials provided with the distribution.
73  * 3. Neither the name of the University nor the names of its contributors
74  *    may be used to endorse or promote products derived from this software
75  *    without specific prior written permission.
76  *
77  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
78  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
79  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
80  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
81  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
82  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
83  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
84  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
85  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
86  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
87  * SUCH DAMAGE.
88  */
89 #include "sh.h"
90
91 RCSID("$tcsh: ed.xmap.c,v 3.37 2009/06/25 21:15:37 christos Exp $")
92
93 #include "ed.h"
94 #include "ed.defns.h"
95
96 #ifndef NULL
97 #define NULL 0
98 #endif
99
100 /* Internal Data types and declarations */
101
102 /* The Nodes of the Xmap.  The Xmap is a linked list of these node
103  * elements
104  */
105 typedef struct Xmapnode {
106     Char    ch;                 /* single character of Xkey */
107     int     type;
108     XmapVal val;                /* command code or pointer to string, if this
109                                  * is a leaf */
110     struct Xmapnode *next;      /* ptr to next char of this Xkey */
111     struct Xmapnode *sibling;   /* ptr to another Xkey with same prefix */
112 } XmapNode;
113
114 static XmapNode *Xmap = NULL;   /* the current Xmap */
115
116
117 /* Some declarations of procedures */
118 static  int       TraverseMap   (XmapNode *, CStr *, XmapVal *);
119 static  int       TryNode       (XmapNode *, CStr *, XmapVal *, int);
120 static  XmapNode *GetFreeNode   (CStr *);
121 static  void      PutFreeNode   (XmapNode *);
122 static  int       TryDeleteNode (XmapNode **, CStr *);
123 static  int       Lookup        (struct Strbuf *, const CStr *,
124                                  const XmapNode *);
125 static  void      Enumerate     (struct Strbuf *, const XmapNode *);
126 static  void      unparsech     (struct Strbuf *, Char);
127
128
129 XmapVal *
130 XmapCmd(int cmd)
131 {
132     static XmapVal xm;
133     xm.cmd = (KEYCMD) cmd;
134     return &xm;
135 }
136
137 XmapVal *
138 XmapStr(CStr *str)
139 {
140     static XmapVal xm;
141     xm.str.len = str->len;
142     xm.str.buf = str->buf;
143     return &xm;
144 }
145
146 /* ResetXmap():
147  *      Takes all nodes on Xmap and puts them on free list.  Then
148  *      initializes Xmap with arrow keys
149  */
150 void
151 ResetXmap(void)
152 {
153     PutFreeNode(Xmap);
154     Xmap = NULL;
155
156     DefaultArrowKeys();
157     return;
158 }
159
160
161 /* GetXkey():
162  *      Calls the recursive function with entry point Xmap
163  */
164 int
165 GetXkey(CStr *ch, XmapVal *val)
166 {
167     return (TraverseMap(Xmap, ch, val));
168 }
169
170 /* TraverseMap():
171  *      recursively traverses node in tree until match or mismatch is
172  *      found.  May read in more characters.
173  */
174 static int
175 TraverseMap(XmapNode *ptr, CStr *ch, XmapVal *val)
176 {
177     Char    tch;
178
179     if (ptr->ch == *(ch->buf)) {
180         /* match found */
181         if (ptr->next) {
182             /* Xkey not complete so get next char */
183             if (GetNextChar(&tch) != 1) {       /* if EOF or error */
184                 val->cmd = F_SEND_EOF;
185                 return XK_CMD;/* PWP: Pretend we just read an end-of-file */
186             }
187             *(ch->buf) = tch;
188             return (TraverseMap(ptr->next, ch, val));
189         }
190         else {
191             *val = ptr->val;
192             if (ptr->type != XK_CMD)
193                 *(ch->buf) = '\0';
194             return ptr->type;
195         }
196     }
197     else {
198         /* no match found here */
199         if (ptr->sibling) {
200             /* try next sibling */
201             return (TraverseMap(ptr->sibling, ch, val));
202         }
203         else {
204             /* no next sibling -- mismatch */
205             val->str.buf = NULL;
206             val->str.len = 0;
207             return XK_STR;
208         }
209     }
210 }
211
212 void
213 AddXkey(const CStr *Xkey, XmapVal *val, int ntype)
214 {
215     CStr cs;
216     cs.buf = Xkey->buf;
217     cs.len = Xkey->len;
218     if (Xkey->len == 0) {
219         xprintf("%s", CGETS(9, 1, "AddXkey: Null extended-key not allowed.\n"));
220         return;
221     }
222
223     if (ntype == XK_CMD && val->cmd == F_XKEY) {
224         xprintf("%s",
225             CGETS(9, 2, "AddXkey: sequence-lead-in command not allowed\n"));
226         return;
227     }
228
229     if (Xmap == NULL)
230         /* tree is initially empty.  Set up new node to match Xkey[0] */
231         Xmap = GetFreeNode(&cs);        /* it is properly initialized */
232
233     /* Now recurse through Xmap */
234     (void) TryNode(Xmap, &cs, val, ntype);      
235     return;
236 }
237
238 static int
239 TryNode(XmapNode *ptr, CStr *str, XmapVal *val, int ntype)
240 {
241     /*
242      * Find a node that matches *string or allocate a new one
243      */
244     if (ptr->ch != *(str->buf)) {
245         XmapNode *xm;
246
247         for (xm = ptr; xm->sibling != NULL; xm = xm->sibling)
248             if (xm->sibling->ch == *(str->buf))
249                 break;
250         if (xm->sibling == NULL)
251             xm->sibling = GetFreeNode(str);     /* setup new node */
252         ptr = xm->sibling;
253     }
254
255     str->buf++;
256     str->len--;
257     if (str->len == 0) {
258         size_t len;
259
260         /* we're there */
261         if (ptr->next != NULL) {
262             PutFreeNode(ptr->next);     /* lose longer Xkeys with this prefix */
263             ptr->next = NULL;
264         }
265
266         switch (ptr->type) {
267         case XK_STR:
268         case XK_EXE:
269             xfree(ptr->val.str.buf);
270             ptr->val.str.len = 0;
271             break;
272         case XK_NOD:
273         case XK_CMD:
274             break;
275         default:
276             abort();
277             break;
278         }
279
280         switch (ptr->type = ntype) {
281         case XK_CMD:
282             ptr->val = *val;
283             break;
284         case XK_STR:
285         case XK_EXE:
286             ptr->val.str.len = val->str.len;
287             len = (val->str.len + 1) * sizeof(*ptr->val.str.buf);
288             ptr->val.str.buf = xmalloc(len);
289             (void) memcpy(ptr->val.str.buf, val->str.buf, len);
290             break;
291         default:
292             abort();
293             break;
294         }
295     }
296     else {
297         /* still more chars to go */
298         if (ptr->next == NULL)
299             ptr->next = GetFreeNode(str);       /* setup new node */
300         (void) TryNode(ptr->next, str, val, ntype);
301     }
302     return (0);
303 }
304
305 void
306 ClearXkey(KEYCMD *map, const CStr *in)
307 {
308     unsigned char c = (unsigned char) *(in->buf);
309     if ((map[c] == F_XKEY) &&
310         ((map == CcKeyMap && CcAltMap[c] != F_XKEY) ||
311          (map == CcAltMap && CcKeyMap[c] != F_XKEY)))
312         (void) DeleteXkey(in);
313 }
314
315 int
316 DeleteXkey(const CStr *Xkey)
317 {
318     CStr s;
319
320     s = *Xkey;
321     if (s.len == 0) {
322         xprintf("%s",
323                 CGETS(9, 3, "DeleteXkey: Null extended-key not allowed.\n"));
324         return (-1);
325     }
326
327     if (Xmap == NULL)
328         return (0);
329
330     (void) TryDeleteNode(&Xmap, &s);
331     return (0);
332 }
333
334 /* Destroys str */
335 static int
336 TryDeleteNode(XmapNode **inptr, CStr *str)
337 {
338     XmapNode *ptr;
339
340     ptr = *inptr;
341     /*
342      * Find a node that matches *string or allocate a new one
343      */
344     if (ptr->ch != *(str->buf)) {
345         XmapNode *xm;
346
347         for (xm = ptr; xm->sibling != NULL; xm = xm->sibling)
348             if (xm->sibling->ch == *(str->buf))
349                 break;
350         if (xm->sibling == NULL)
351             return (0);
352         inptr = &xm->sibling;
353         ptr = xm->sibling;
354     }
355
356     str->buf++;
357     str->len--;
358
359     if (str->len == 0) {
360         /* we're there */
361         *inptr = ptr->sibling;
362         ptr->sibling = NULL;
363         PutFreeNode(ptr);
364         return (1);
365     }
366     else if (ptr->next != NULL && TryDeleteNode(&ptr->next, str) == 1) {
367         if (ptr->next != NULL)
368             return (0);
369         *inptr = ptr->sibling;
370         ptr->sibling = NULL;
371         PutFreeNode(ptr);
372         return (1);
373     }
374     else {
375         return (0);
376     }
377 }
378
379 /* PutFreeNode():
380  *      Puts a tree of nodes onto free list using free(3).
381  */
382 static void
383 PutFreeNode(XmapNode *ptr)
384 {
385     if (ptr == NULL)
386         return;
387
388     if (ptr->next != NULL) {
389         PutFreeNode(ptr->next);
390         ptr->next = NULL;
391     }
392
393     PutFreeNode(ptr->sibling);
394
395     switch (ptr->type) {
396     case XK_CMD:
397     case XK_NOD:
398         break;
399     case XK_EXE:
400     case XK_STR:
401         xfree(ptr->val.str.buf);
402         break;
403     default:
404         abort();
405         break;
406     }
407     xfree(ptr);
408 }
409
410
411 /* GetFreeNode():
412  *      Returns pointer to an XmapNode for ch.
413  */
414 static XmapNode *
415 GetFreeNode(CStr *ch)
416 {
417     XmapNode *ptr;
418
419     ptr = xmalloc(sizeof(XmapNode));
420     ptr->ch = ch->buf[0];
421     ptr->type = XK_NOD;
422     ptr->val.str.buf = NULL;
423     ptr->val.str.len = 0;
424     ptr->next = NULL;
425     ptr->sibling = NULL;
426     return (ptr);
427 }
428  
429
430 /* PrintXKey():
431  *      Print the binding associated with Xkey key.
432  *      Print entire Xmap if null
433  */
434 void
435 PrintXkey(const CStr *key)
436 {
437     struct Strbuf buf = Strbuf_INIT;
438     CStr cs;
439
440     if (key) {
441         cs.buf = key->buf;
442         cs.len = key->len;
443     }
444     else {
445         cs.buf = STRNULL;
446         cs.len = 0;
447     }
448     /* do nothing if Xmap is empty and null key specified */
449     if (Xmap == NULL && cs.len == 0)
450         return;
451
452     Strbuf_append1(&buf, '"');
453     cleanup_push(&buf, Strbuf_cleanup);
454     if (Lookup(&buf, &cs, Xmap) <= -1)
455         /* key is not bound */
456         xprintf(CGETS(9, 4, "Unbound extended key \"%S\"\n"), cs.buf);
457     cleanup_until(&buf);
458 }
459
460 /* Lookup():
461  *      look for the string starting at node ptr.
462  *      Print if last node
463  */
464 static int
465 Lookup(struct Strbuf *buf, const CStr *str, const XmapNode *ptr)
466 {
467     if (ptr == NULL)
468         return (-1);            /* cannot have null ptr */
469
470     if (str->len == 0) {
471         /* no more chars in string.  Enumerate from here. */
472         Enumerate(buf, ptr);
473         return (0);
474     }
475     else {
476         /* If match put this char into buf.  Recurse */
477         if (ptr->ch == *(str->buf)) {
478             /* match found */
479             unparsech(buf, ptr->ch);
480             if (ptr->next != NULL) {
481                 /* not yet at leaf */
482                 CStr tstr;
483                 tstr.buf = str->buf + 1;
484                 tstr.len = str->len - 1;
485                 return (Lookup(buf, &tstr, ptr->next));
486             }
487             else {
488                 /* next node is null so key should be complete */
489                 if (str->len == 1) {
490                     Strbuf_append1(buf, '"');
491                     Strbuf_terminate(buf);
492                     printOne(buf->s, &ptr->val, ptr->type);
493                     return (0);
494                 }
495                 else
496                     return (-1);/* mismatch -- string still has chars */
497             }
498         }
499         else {
500             /* no match found try sibling */
501             if (ptr->sibling)
502                 return (Lookup(buf, str, ptr->sibling));
503             else
504                 return (-1);
505         }
506     }
507 }
508
509 static void
510 Enumerate(struct Strbuf *buf, const XmapNode *ptr)
511 {
512     size_t old_len;
513
514     if (ptr == NULL) {
515 #ifdef DEBUG_EDIT
516         xprintf(CGETS(9, 6, "Enumerate: BUG!! Null ptr passed\n!"));
517 #endif
518         return;
519     }
520
521     old_len = buf->len;
522     unparsech(buf, ptr->ch); /* put this char at end of string */
523     if (ptr->next == NULL) {
524         /* print this Xkey and function */
525         Strbuf_append1(buf, '"');
526         Strbuf_terminate(buf);
527         printOne(buf->s, &ptr->val, ptr->type);
528     }
529     else
530         Enumerate(buf, ptr->next);
531
532     /* go to sibling if there is one */
533     if (ptr->sibling) {
534         buf->len = old_len;
535         Enumerate(buf, ptr->sibling);
536     }
537 }
538
539
540 /* PrintOne():
541  *      Print the specified key and its associated
542  *      function specified by val
543  */
544 void
545 printOne(const Char *key, const XmapVal *val, int ntype)
546 {
547     struct KeyFuncs *fp;
548     static const char *fmt = "%s\n";
549
550     xprintf("%-15S-> ", key);
551     if (val != NULL)
552         switch (ntype) {
553         case XK_STR:
554         case XK_EXE: {
555             unsigned char *p;
556
557             p = unparsestring(&val->str, ntype == XK_STR ? STRQQ : STRBB);
558             cleanup_push(p, xfree);
559             xprintf(fmt, p);
560             cleanup_until(p);
561             break;
562         }
563         case XK_CMD:
564             for (fp = FuncNames; fp->name; fp++)
565                 if (val->cmd == fp->func)
566                     xprintf(fmt, fp->name);
567                 break;
568         default:
569             abort();
570             break;
571         }
572     else
573         xprintf(fmt, CGETS(9, 7, "no input"));
574 }
575
576 static void
577 unparsech(struct Strbuf *buf, Char ch)
578 {
579     if (ch == 0) {
580         Strbuf_append1(buf, '^');
581         Strbuf_append1(buf, '@');
582     }
583     else if (Iscntrl(ch)) {
584         Strbuf_append1(buf, '^');
585         if (ch == CTL_ESC('\177'))
586             Strbuf_append1(buf, '?');
587         else
588 #ifdef IS_ASCII
589             Strbuf_append1(buf, ch | 0100);
590 #else
591             Strbuf_append1(buf, _toebcdic[_toascii[ch]|0100]);
592 #endif
593     }
594     else if (ch == '^') {
595         Strbuf_append1(buf, '\\');
596         Strbuf_append1(buf, '^');
597     } else if (ch == '\\') {
598         Strbuf_append1(buf, '\\');
599         Strbuf_append1(buf, '\\');
600     } else if (ch == ' ' || (Isprint(ch) && !Isspace(ch))) {
601         Strbuf_append1(buf, ch);
602     }
603     else {
604         Strbuf_append1(buf, '\\');
605         Strbuf_append1(buf, ((ch >> 6) & 7) + '0');
606         Strbuf_append1(buf, ((ch >> 3) & 7) + '0');
607         Strbuf_append1(buf, (ch & 7) + '0');
608     }
609 }
610
611 eChar
612 parseescape(const Char **ptr)
613 {
614     const Char *p;
615     Char c;
616
617     p = *ptr;
618
619     if ((p[1] & CHAR) == 0) {
620         xprintf(CGETS(9, 8, "Something must follow: %c\n"), (char)*p);
621         return CHAR_ERR;
622     }
623     if ((*p & CHAR) == '\\') {
624         p++;
625         switch (*p & CHAR) {
626         case 'a':
627             c = CTL_ESC('\007');         /* Bell */
628             break;
629         case 'b':
630             c = CTL_ESC('\010');         /* Backspace */
631             break;
632         case 'e':
633             c = CTL_ESC('\033');         /* Escape */
634             break;
635         case 'f':
636             c = CTL_ESC('\014');         /* Form Feed */
637             break;
638         case 'n':
639             c = CTL_ESC('\012');         /* New Line */
640             break;
641         case 'r':
642             c = CTL_ESC('\015');         /* Carriage Return */
643             break;
644         case 't':
645             c = CTL_ESC('\011');         /* Horizontal Tab */
646             break;
647         case 'v':
648             c = CTL_ESC('\013');         /* Vertical Tab */
649             break;
650         case '\\':
651             c = '\\';
652             break;
653         case '0':
654         case '1':
655         case '2':
656         case '3':
657         case '4':
658         case '5':
659         case '6':
660         case '7':
661             {
662                 int cnt, val;
663                 Char ch;
664
665                 for (cnt = 0, val = 0; cnt < 3; cnt++) {
666                     ch = *p++ & CHAR;
667                     if (ch < '0' || ch > '7') {
668                         p--;
669                         break;
670                     }
671                     val = (val << 3) | (ch - '0');
672                 }
673                 if ((val & ~0xff) != 0) {
674                     xprintf("%s", CGETS(9, 9,
675                             "Octal constant does not fit in a char.\n"));
676                     return 0;
677                 }
678 #ifndef IS_ASCII
679                 if (CTL_ESC(val) != val && adrof(STRwarnebcdic))
680                     xprintf(/*CGETS(9, 9, no NLS-String yet!*/
681                             "Warning: Octal constant \\%3.3o is interpreted as EBCDIC value.\n", val/*)*/);
682 #endif
683                 c = (Char) val;
684                 --p;
685             }
686             break;
687         default:
688             c = *p;
689             break;
690         }
691     }
692     else if ((*p & CHAR) == '^' && (Isalpha(p[1] & CHAR) || 
693                                     strchr("@^_?\\|[{]}", p[1] & CHAR))) {
694         p++;
695 #ifdef IS_ASCII
696         c = ((*p & CHAR) == '?') ? CTL_ESC('\177') : ((*p & CHAR) & 0237);
697 #else
698         c = ((*p & CHAR) == '?') ? CTL_ESC('\177') : _toebcdic[_toascii[*p & CHAR] & 0237];
699         if (adrof(STRwarnebcdic))
700             xprintf(/*CGETS(9, 9, no NLS-String yet!*/
701                 "Warning: Control character ^%c may be interpreted differently in EBCDIC.\n", *p & CHAR /*)*/);
702 #endif
703     }
704     else
705         c = *p;
706     *ptr = p;
707     return (c);
708 }
709
710
711 unsigned char *
712 unparsestring(const CStr *str, const Char *sep)
713 {
714     unsigned char *buf, *b;
715     Char   p;
716     int l;
717
718     /* Worst-case is "\uuu" or result of wctomb() for each char from str */
719     buf = xmalloc((str->len + 1) * max(4, MB_LEN_MAX));
720     b = buf;
721     if (sep[0])
722 #ifndef WINNT_NATIVE
723         *b++ = sep[0];
724 #else /* WINNT_NATIVE */
725         *b++ = CHAR & sep[0];
726 #endif /* !WINNT_NATIVE */
727
728     for (l = 0; l < str->len; l++) {
729         p = str->buf[l];
730         if (Iscntrl(p)) {
731             *b++ = '^';
732             if (p == CTL_ESC('\177'))
733                 *b++ = '?';
734             else
735 #ifdef IS_ASCII
736                 *b++ = (unsigned char) (p | 0100);
737 #else
738                 *b++ = _toebcdic[_toascii[p]|0100];
739 #endif
740         }
741         else if (p == '^' || p == '\\') {
742             *b++ = '\\';
743             *b++ = (unsigned char) p;
744         }
745         else if (p == ' ' || (Isprint(p) && !Isspace(p)))
746             b += one_wctomb((char *)b, p & CHAR);
747         else {
748             *b++ = '\\';
749             *b++ = ((p >> 6) & 7) + '0';
750             *b++ = ((p >> 3) & 7) + '0';
751             *b++ = (p & 7) + '0';
752         }
753     }
754     if (sep[0] && sep[1])
755 #ifndef WINNT_NATIVE
756         *b++ = sep[1];
757 #else /* WINNT_NATIVE */
758         *b++ = CHAR & sep[1];
759 #endif /* !WINNT_NATIVE */
760     *b++ = 0;
761     return buf;                 /* should check for overflow */
762 }