Update libedit from version 2014-06-20 to 2015-03-25 on vendor branch
[dragonfly.git] / contrib / libedit / src / parse.c
1 /*      $NetBSD: parse.c,v 1.27 2014/07/06 18:15:34 christos Exp $      */
2
3 /*-
4  * Copyright (c) 1992, 1993
5  *      The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Christos Zoulas of Cornell University.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34
35 #include "config.h"
36 #if !defined(lint) && !defined(SCCSID)
37 #if 0
38 static char sccsid[] = "@(#)parse.c     8.1 (Berkeley) 6/4/93";
39 #else
40 __RCSID("$NetBSD: parse.c,v 1.27 2014/07/06 18:15:34 christos Exp $");
41 #endif
42 #endif /* not lint && not SCCSID */
43
44 /*
45  * parse.c: parse an editline extended command
46  *
47  * commands are:
48  *
49  *      bind
50  *      echotc
51  *      edit
52  *      gettc
53  *      history
54  *      settc
55  *      setty
56  */
57 #include "el.h"
58 #include <stdlib.h>
59
60 private const struct {
61         const Char *name;
62         int (*func)(EditLine *, int, const Char **);
63 } cmds[] = {
64         { STR("bind"),          map_bind        },
65         { STR("echotc"),        terminal_echotc },
66         { STR("edit"),          el_editmode     },
67         { STR("history"),       hist_command    },
68         { STR("telltc"),        terminal_telltc },
69         { STR("settc"),         terminal_settc  },
70         { STR("setty"),         tty_stty        },
71         { NULL,                 NULL            }
72 };
73
74
75 /* parse_line():
76  *      Parse a line and dispatch it
77  */
78 protected int
79 parse_line(EditLine *el, const Char *line)
80 {
81         const Char **argv;
82         int argc;
83         TYPE(Tokenizer) *tok;
84
85         tok = FUN(tok,init)(NULL);
86         FUN(tok,str)(tok, line, &argc, &argv);
87         argc = FUN(el,parse)(el, argc, argv);
88         FUN(tok,end)(tok);
89         return argc;
90 }
91
92
93 /* el_parse():
94  *      Command dispatcher
95  */
96 public int
97 FUN(el,parse)(EditLine *el, int argc, const Char *argv[])
98 {
99         const Char *ptr;
100         int i;
101
102         if (argc < 1)
103                 return -1;
104         ptr = Strchr(argv[0], ':');
105         if (ptr != NULL) {
106                 Char *tprog;
107                 size_t l;
108
109                 if (ptr == argv[0])
110                         return 0;
111                 l = (size_t)(ptr - argv[0] - 1);
112                 tprog = el_malloc((l + 1) * sizeof(*tprog));
113                 if (tprog == NULL)
114                         return 0;
115                 (void) Strncpy(tprog, argv[0], l);
116                 tprog[l] = '\0';
117                 ptr++;
118                 l = (size_t)el_match(el->el_prog, tprog);
119                 el_free(tprog);
120                 if (!l)
121                         return 0;
122         } else
123                 ptr = argv[0];
124
125         for (i = 0; cmds[i].name != NULL; i++)
126                 if (Strcmp(cmds[i].name, ptr) == 0) {
127                         i = (*cmds[i].func) (el, argc, argv);
128                         return -i;
129                 }
130         return -1;
131 }
132
133
134 /* parse__escape():
135  *      Parse a string of the form ^<char> \<odigit> \<char> \U+xxxx and return
136  *      the appropriate character or -1 if the escape is not valid
137  */
138 protected int
139 parse__escape(const Char **ptr)
140 {
141         const Char *p;
142         Int c;
143
144         p = *ptr;
145
146         if (p[1] == 0)
147                 return -1;
148
149         if (*p == '\\') {
150                 p++;
151                 switch (*p) {
152                 case 'a':
153                         c = '\007';     /* Bell */
154                         break;
155                 case 'b':
156                         c = '\010';     /* Backspace */
157                         break;
158                 case 't':
159                         c = '\011';     /* Horizontal Tab */
160                         break;
161                 case 'n':
162                         c = '\012';     /* New Line */
163                         break;
164                 case 'v':
165                         c = '\013';     /* Vertical Tab */
166                         break;
167                 case 'f':
168                         c = '\014';     /* Form Feed */
169                         break;
170                 case 'r':
171                         c = '\015';     /* Carriage Return */
172                         break;
173                 case 'e':
174                         c = '\033';     /* Escape */
175                         break;
176                 case 'U':               /* Unicode \U+xxxx or \U+xxxxx format */
177                 {
178                         int i;
179                         const Char hex[] = STR("0123456789ABCDEF");
180                         const Char *h;
181                         ++p;
182                         if (*p++ != '+')
183                                 return -1;
184                         c = 0;
185                         for (i = 0; i < 5; ++i) {
186                                 h = Strchr(hex, *p++);
187                                 if (!h && i < 4)
188                                         return -1;
189                                 else if (h)
190                                         c = (c << 4) | ((int)(h - hex));
191                                 else
192                                         --p;
193                         }
194                         if (c > 0x10FFFF) /* outside valid character range */
195                                 return -1;
196                         break;
197                 }
198                 case '0':
199                 case '1':
200                 case '2':
201                 case '3':
202                 case '4':
203                 case '5':
204                 case '6':
205                 case '7':
206                 {
207                         int cnt, ch;
208
209                         for (cnt = 0, c = 0; cnt < 3; cnt++) {
210                                 ch = *p++;
211                                 if (ch < '0' || ch > '7') {
212                                         p--;
213                                         break;
214                                 }
215                                 c = (c << 3) | (ch - '0');
216                         }
217                         if ((c & (wint_t)0xffffff00) != (wint_t)0)
218                                 return -1;
219                         --p;
220                         break;
221                 }
222                 default:
223                         c = *p;
224                         break;
225                 }
226         } else if (*p == '^') {
227                 p++;
228                 c = (*p == '?') ? '\177' : (*p & 0237);
229         } else
230                 c = *p;
231         *ptr = ++p;
232         return c;
233 }
234
235 /* parse__string():
236  *      Parse the escapes from in and put the raw string out
237  */
238 protected Char *
239 parse__string(Char *out, const Char *in)
240 {
241         Char *rv = out;
242         int n;
243
244         for (;;)
245                 switch (*in) {
246                 case '\0':
247                         *out = '\0';
248                         return rv;
249
250                 case '\\':
251                 case '^':
252                         if ((n = parse__escape(&in)) == -1)
253                                 return NULL;
254                         *out++ = n;
255                         break;
256
257                 case 'M':
258                         if (in[1] == '-' && in[2] != '\0') {
259                                 *out++ = '\033';
260                                 in += 2;
261                                 break;
262                         }
263                         /*FALLTHROUGH*/
264
265                 default:
266                         *out++ = *in++;
267                         break;
268                 }
269 }
270
271
272 /* parse_cmd():
273  *      Return the command number for the command string given
274  *      or -1 if one is not found
275  */
276 protected int
277 parse_cmd(EditLine *el, const Char *cmd)
278 {
279         el_bindings_t *b = el->el_map.help;
280         size_t i;
281
282         for (i = 0; i < el->el_map.nfunc; i++)
283                 if (Strcmp(b[i].name, cmd) == 0)
284                         return b[i].func;
285         return -1;
286 }