The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/cmd-line-utils/libedit/parse.c File Reference

mysql/src/5.1-dbg/cmd-line-utils/libedit/parse.c File Reference

#include <config.h>
#include "el.h"
#include <stdlib.h>

Include dependency graph for parse.c:


Functions
protected int	parse_line (EditLine el, const char line)
public int	el_parse (EditLine el, int argc, const char argv[])
protected int	parse__escape (const char **const ptr)
protected char *	parse__string (char out, const char in)
protected int	parse_cmd (EditLine el, const char cmd)
Variables
struct {
const char * name
int(* func )(EditLine , int, const char *)
}	cmds []

Function Documentation

public int el_parse	(	EditLine *	el,
		int	argc,
		const char *	argv[]
	)

Definition at line 90 of file parse.c.

References cmds, el, el_free, el_malloc, el_match(), editline::el_prog, func, name, NULL, strchr(), and strcmp().

00091 {
00092         const char *ptr;
00093         int i;
00094 
00095         if (argc < 1)
00096                 return (-1);
00097         ptr = strchr(argv[0], ':');
00098         if (ptr != NULL) {
00099                 char *tprog;
00100                 size_t l;
00101 
00102                 if (ptr == argv[0])
00103                         return (0);
00104                 l = ptr - argv[0] - 1;
00105                 tprog = (char *) el_malloc(l + 1);
00106                 if (tprog == NULL)
00107                         return (0);
00108                 (void) strncpy(tprog, argv[0], l);
00109                 tprog[l] = '\0';
00110                 ptr++;
00111                 l = el_match(el->el_prog, tprog);
00112                 el_free(tprog);
00113                 if (!l)
00114                         return (0);
00115         } else
00116                 ptr = argv[0];
00117 
00118         for (i = 0; cmds[i].name != NULL; i++)
00119                 if (strcmp(cmds[i].name, ptr) == 0) {
00120                         i = (*cmds[i].func) (el, argc, argv);
00121                         return (-i);
00122                 }
00123         return (-1);
00124 }

Here is the call graph for this function:

protected int parse__escape ( const char **const ptr )

Definition at line 132 of file parse.c.

References p.

Referenced by parse__string().

00133 {
00134         const char *p;
00135         int c;
00136 
00137         p = *ptr;
00138 
00139         if (p[1] == 0)
00140                 return (-1);
00141 
00142         if (*p == '\\') {
00143                 p++;
00144                 switch (*p) {
00145                 case 'a':
00146                         c = '\007';     /* Bell */
00147                         break;
00148                 case 'b':
00149                         c = '\010';     /* Backspace */
00150                         break;
00151                 case 't':
00152                         c = '\011';     /* Horizontal Tab */
00153                         break;
00154                 case 'n':
00155                         c = '\012';     /* New Line */
00156                         break;
00157                 case 'v':
00158                         c = '\013';     /* Vertical Tab */
00159                         break;
00160                 case 'f':
00161                         c = '\014';     /* Form Feed */
00162                         break;
00163                 case 'r':
00164                         c = '\015';     /* Carriage Return */
00165                         break;
00166                 case 'e':
00167                         c = '\033';     /* Escape */
00168                         break;
00169                 case '0':
00170                 case '1':
00171                 case '2':
00172                 case '3':
00173                 case '4':
00174                 case '5':
00175                 case '6':
00176                 case '7':
00177                 {
00178                         int cnt, ch;
00179 
00180                         for (cnt = 0, c = 0; cnt < 3; cnt++) {
00181                                 ch = *p++;
00182                                 if (ch < '0' || ch > '7') {
00183                                         p--;
00184                                         break;
00185                                 }
00186                                 c = (c << 3) | (ch - '0');
00187                         }
00188                         if ((c & 0xffffff00) != 0)
00189                                 return (-1);
00190                         --p;
00191                         break;
00192                 }
00193                 default:
00194                         c = *p;
00195                         break;
00196                 }
00197         } else if (*p == '^') {
00198                 p++;
00199                 c = (*p == '?') ? '\177' : (*p & 0237);
00200         } else
00201                 c = *p;
00202         *ptr = ++p;
00203         return (c);
00204 }

Here is the caller graph for this function:

protected char* parse__string	(	char *	out,
		const char *	in
	)

Definition at line 210 of file parse.c.

References n, NULL, and parse__escape().

Referenced by map_bind().

00211 {
00212         char *rv = out;
00213         int n;
00214 
00215         for (;;)
00216                 switch (*in) {
00217                 case '\0':
00218                         *out = '\0';
00219                         return (rv);
00220 
00221                 case '\\':
00222                 case '^':
00223                         if ((n = parse__escape(&in)) == -1)
00224                                 return (NULL);
00225                         *out++ = n;
00226                         break;
00227 
00228                 case 'M':
00229                         if (in[1] == '-' && in[2] != '\0') {
00230                                 *out++ = '\033';
00231                                 in += 2;
00232                                 break;
00233                         }
00234                         /*FALLTHROUGH*/
00235 
00236                 default:
00237                         *out++ = *in++;
00238                         break;
00239                 }
00240 }

Here is the call graph for this function:

Here is the caller graph for this function:

protected int parse_cmd	(	EditLine *	el,
		const char *	cmd
	)

Definition at line 248 of file parse.c.

References el, editline::el_map, el_bindings_t::func, el_map_t::help, el_bindings_t::name, NULL, and strcmp().

Referenced by map_bind().

00249 {
00250         el_bindings_t *b;
00251 
00252         for (b = el->el_map.help; b->name != NULL; b++)
00253                 if (strcmp(b->name, cmd) == 0)
00254                         return (b->func);
00255         return (-1);
00256 }

Here is the call graph for this function:

Here is the caller graph for this function:

protected int parse_line	(	EditLine *	el,
		const char *	line
	)

Definition at line 72 of file parse.c.

References el, el_parse(), NULL, tok_end(), tok_init(), and tok_str().

Referenced by ed_command(), and el_source().

00073 {
00074         const char **argv;
00075         int argc;
00076         Tokenizer *tok;
00077 
00078         tok = tok_init(NULL);
00079         tok_str(tok, line, &argc, &argv);
00080         argc = el_parse(el, argc, argv);
00081         tok_end(tok);
00082         return (argc);
00083 }