OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [mi/] [mi-parse.c] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* MI Command Set - MI parser.
2
 
3
   Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   Contributed by Cygnus Solutions (a Red Hat company).
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "mi-cmds.h"
24
#include "mi-parse.h"
25
 
26
#include <ctype.h>
27
#include "gdb_string.h"
28
 
29
static void
30
mi_parse_argv (char *args, struct mi_parse *parse)
31
{
32
  char *chp = args;
33
  int argc = 0;
34
  char **argv = xmalloc ((argc + 1) * sizeof (char *));
35
  argv[argc] = NULL;
36
  while (1)
37
    {
38
      char *arg;
39
      /* skip leading white space */
40
      while (isspace (*chp))
41
        chp++;
42
      /* Three possibilities: EOF, quoted string, or other text. */
43
      switch (*chp)
44
        {
45
        case '\0':
46
          parse->argv = argv;
47
          parse->argc = argc;
48
          return;
49
        case '"':
50
          {
51
            /* A quoted string. */
52
            int len;
53
            char *start = chp + 1;
54
            /* Determine the buffer size. */
55
            chp = start;
56
            len = 0;
57
            while (*chp != '\0' && *chp != '"')
58
              {
59
                if (*chp == '\\')
60
                  {
61
                    chp++;
62
                    if (parse_escape (&chp) <= 0)
63
                      {
64
                        /* Do not allow split lines or "\000" */
65
                        freeargv (argv);
66
                        return;
67
                      }
68
                  }
69
                else
70
                  chp++;
71
                len++;
72
              }
73
            /* Insist on a closing quote. */
74
            if (*chp != '"')
75
              {
76
                freeargv (argv);
77
                return;
78
              }
79
            /* Insist on trailing white space. */
80
            if (chp[1] != '\0' && !isspace (chp[1]))
81
              {
82
                freeargv (argv);
83
                return;
84
              }
85
            /* create the buffer. */
86
            arg = xmalloc ((len + 1) * sizeof (char));
87
            /* And copy the characters in. */
88
            chp = start;
89
            len = 0;
90
            while (*chp != '\0' && *chp != '"')
91
              {
92
                if (*chp == '\\')
93
                  {
94
                    chp++;
95
                    arg[len] = parse_escape (&chp);
96
                  }
97
                else
98
                  arg[len] = *chp++;
99
                len++;
100
              }
101
            arg[len] = '\0';
102
            chp++;              /* that closing quote. */
103
            break;
104
          }
105
        default:
106
          {
107
            /* An unquoted string.  Accumulate all non blank
108
               characters into a buffer. */
109
            int len;
110
            char *start = chp;
111
            while (*chp != '\0' && !isspace (*chp))
112
              {
113
                chp++;
114
              }
115
            len = chp - start;
116
            arg = xmalloc ((len + 1) * sizeof (char));
117
            strncpy (arg, start, len);
118
            arg[len] = '\0';
119
            break;
120
          }
121
        }
122
      /* Append arg to argv. */
123
      argv = xrealloc (argv, (argc + 2) * sizeof (char *));
124
      argv[argc++] = arg;
125
      argv[argc] = NULL;
126
    }
127
}
128
 
129
 
130
void
131
mi_parse_free (struct mi_parse *parse)
132
{
133
  if (parse == NULL)
134
    return;
135
  if (parse->command != NULL)
136
    xfree (parse->command);
137
  if (parse->token != NULL)
138
    xfree (parse->token);
139
  if (parse->args != NULL)
140
    xfree (parse->args);
141
  if (parse->argv != NULL)
142
    freeargv (parse->argv);
143
  xfree (parse);
144
}
145
 
146
 
147
struct mi_parse *
148
mi_parse (char *cmd)
149
{
150
  char *chp;
151
  struct mi_parse *parse = XMALLOC (struct mi_parse);
152
  memset (parse, 0, sizeof (*parse));
153
 
154
  /* Before starting, skip leading white space. */
155
  while (isspace (*cmd))
156
    cmd++;
157
 
158
  /* Find/skip any token and then extract it. */
159
  for (chp = cmd; *chp >= '0' && *chp <= '9'; chp++)
160
    ;
161
  parse->token = xmalloc ((chp - cmd + 1) * sizeof (char *));
162
  memcpy (parse->token, cmd, (chp - cmd));
163
  parse->token[chp - cmd] = '\0';
164
 
165
  /* This wasn't a real MI command.  Return it as a CLI_COMMAND. */
166
  if (*chp != '-')
167
    {
168
      while (isspace (*chp))
169
        chp++;
170
      parse->command = xstrdup (chp);
171
      parse->op = CLI_COMMAND;
172
      return parse;
173
    }
174
 
175
  /* Extract the command. */
176
  {
177
    char *tmp = chp + 1;        /* discard ``-'' */
178
    for (; *chp && !isspace (*chp); chp++)
179
      ;
180
    parse->command = xmalloc ((chp - tmp + 1) * sizeof (char *));
181
    memcpy (parse->command, tmp, chp - tmp);
182
    parse->command[chp - tmp] = '\0';
183
  }
184
 
185
  /* Find the command in the MI table. */
186
  parse->cmd = mi_lookup (parse->command);
187
  if (parse->cmd == NULL)
188
    {
189
      /* FIXME: This should be a function call. */
190
      fprintf_unfiltered
191
        (raw_stdout,
192
         "%s^error,msg=\"Undefined MI command: %s\"\n",
193
         parse->token, parse->command);
194
      mi_parse_free (parse);
195
      return NULL;
196
    }
197
 
198
  /* Skip white space following the command. */
199
  while (isspace (*chp))
200
    chp++;
201
 
202
  /* For new argv commands, attempt to return the parsed argument
203
     list. */
204
  if (parse->cmd->argv_func != NULL)
205
    {
206
      mi_parse_argv (chp, parse);
207
      if (parse->argv == NULL)
208
        {
209
          /* FIXME: This should be a function call. */
210
          fprintf_unfiltered
211
            (raw_stdout,
212
             "%s^error,msg=\"Problem parsing arguments: %s %s\"\n",
213
             parse->token, parse->command, chp);
214
          mi_parse_free (parse);
215
          return NULL;
216
        }
217
    }
218
 
219
  /* FIXME: DELETE THIS */
220
  /* For CLI and old ARGS commands, also return the remainder of the
221
     command line as a single string. */
222
  if (parse->cmd->args_func != NULL
223
      || parse->cmd->cli.cmd != NULL)
224
    {
225
      parse->args = xstrdup (chp);
226
    }
227
 
228
  /* Fully parsed. */
229
  parse->op = MI_COMMAND;
230
  return parse;
231
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.