main/editline/parse.c

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