lib/libedit/parse.c

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