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