src/debugger/debugger_expr.c

/*
 *  Copyright (C) 2004-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: debugger_expr.c,v 1.11 2007/06/15 17:02:39 debug Exp $
 *
 *  Expression evaluator.
 *
 *
 *  TODO:
 *      Sign-extension only on MIPS?
 *      SPECIAL IMPORTANT CASE: Clear the delay_slot flag when writing
 *              to the pc register.
 *      TAB completion? :-)
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "cpu.h"
#include "debugger.h"
#include "machine.h"
#include "misc.h"
#include "settings.h"


extern struct settings *global_settings;

extern int debugger_cur_cpu;
extern int debugger_cur_machine;
extern int debugger_cur_emul;


/*
 *  debugger_parse_name():
 *
 *  This function takes a string as input, and tries to match it to a register
 *  name or a more general "setting", a hexadecimal or decimal numeric value,
 *  or a registered symbol.
 *
 *  Some examples:
 *
 *      Settings (including register names):
 *              verbose
 *              pc
 *              r5
 *
 *      Numeric values:
 *              12345
 *              0x7fff1234
 *
 *      Symbols:
 *              memcpy
 *
 *  To force detection of different types, a character can be added in front of
 *  the name: "$" for numeric values, "#" for registers or other settings,
 *  and "@" for symbols.
 *
 *  Return value is:
 *
 *      PARSE_NOMATCH           no match
 *      PARSE_MULTIPLE          multiple matches
 *
 *  or one of these (and then *valuep is read or written, depending on
 *  the writeflag):
 *
 *      PARSE_SETTINGS          a setting (e.g. a register)
 *      PARSE_NUMBER            a hex number
 *      PARSE_SYMBOL            a symbol
 */
int debugger_parse_name(struct machine *m, char *name, int writeflag,
        uint64_t *valuep)
{
        int match_settings = 0, match_symbol = 0, match_numeric = 0;
        int skip_settings, skip_numeric, skip_symbol;

        if (m == NULL || name == NULL) {
                fprintf(stderr, "debugger_parse_name(): NULL ptr\n");
                exit(1);
        }

        while (name[0] == '\t' || name[0] == ' ')
                name ++;

        /*  Warn about non-signextended values:  */
        if (writeflag) {
                if (m->cpus[0]->is_32bit) {
                        /*  Automagically sign-extend.  TODO: Is this good?  */
                        if (((*valuep) >> 32) == 0 && (*valuep) & 0x80000000ULL)
                                (*valuep) |= 0xffffffff00000000ULL;
                } else {
                        if (((*valuep) >> 32) == 0 && (*valuep) & 0x80000000ULL)
                                printf("WARNING: The value is not sign-extende"
                                    "d. Is this what you intended?\n");
                }
        }

        skip_settings = name[0] == '$' || name[0] == '@';
        skip_numeric  = name[0] == '#' || name[0] == '@';
        skip_symbol   = name[0] == '$' || name[0] == '#';

        if (!skip_settings) {
                char setting_name[400];
                int res;

                res = settings_access(global_settings, name, writeflag, valuep);
                if (res == SETTINGS_OK)
                        match_settings = 1;

                if (!match_settings) {
                        snprintf(setting_name, sizeof(setting_name),
                            GLOBAL_SETTINGS_NAME".%s", name);
                        res = settings_access(global_settings, setting_name,
                            writeflag, valuep);
                        if (res == SETTINGS_OK)
                                match_settings = 1;
                }

                if (!match_settings) {
                        snprintf(setting_name, sizeof(setting_name),
                            GLOBAL_SETTINGS_NAME".emul[%i].%s",
                            debugger_cur_emul, name);
                        res = settings_access(global_settings, setting_name,
                            writeflag, valuep);
                        if (res == SETTINGS_OK)
                                match_settings = 1;
                }

                if (!match_settings) {
                        snprintf(setting_name, sizeof(setting_name),
                            GLOBAL_SETTINGS_NAME".emul[%i].machine[%i].%s",
                            debugger_cur_emul, debugger_cur_machine, name);
                        res = settings_access(global_settings, setting_name,
                            writeflag, valuep);
                        if (res == SETTINGS_OK)
                                match_settings = 1;
                }

                if (!match_settings) {
                        snprintf(setting_name, sizeof(setting_name),
                            GLOBAL_SETTINGS_NAME".emul[%i].machine[%i]."
                            "cpu[%i].%s", debugger_cur_emul,
                            debugger_cur_machine, debugger_cur_cpu, name);
                        res = settings_access(global_settings, setting_name,
                            writeflag, valuep);
                        if (res == SETTINGS_OK)
                                match_settings = 1;
                }
        }

        /*  Check for a number match:  */
        if (!skip_numeric && isdigit((int)name[0])) {
                uint64_t x;
                x = strtoull(name, NULL, 0);
                if (writeflag)
                        printf("You cannot assign like that.\n");
                else
                        *valuep = x;
                match_numeric = 1;
        }

        /*  Check for a symbol match:  */
        if (!skip_symbol) {
                uint64_t newaddr;
                if (get_symbol_addr(&m->symbol_context, name, &newaddr)) {
                        if (writeflag)
                                printf("You cannot assign like that.\n");
                        else
                                *valuep = newaddr;
                        match_symbol = 1;
                }
        }

        if (match_settings + match_symbol + match_numeric > 1)
                return PARSE_MULTIPLE;

        if (match_settings)
                return PARSE_SETTINGS;
        if (match_numeric)
                return PARSE_NUMBER;
        if (match_symbol)
                return PARSE_SYMBOL;

        return PARSE_NOMATCH;
}


/*
 *  debugger_parse_expression()
 *
 *  Input:
 *      writeflag = 0:  expr = an expression to evaluate. The result is
 *                      returned in *valuep.
 *
 *      writeflag = 1:  expr = an lvalue name. *valuep is written to that
 *                      lvalue, using debugger_parse_name().
 *
 *  Parentheses always have precedence.
 *  * / and % have second highest precedence.
 *  + - & | ^ have lowest precedence.
 *
 *  Return value on failure is:
 *
 *      PARSE_NOMATCH           one or more words in the expression didn't
 *                              match any known symbol/register/number
 *      PARSE_MULTIPLE          multiple matches within the expression
 *
 *  Return value on success is PARSE_NUMBER (for now).
 *
 *
 *  TODO: BETTER RETURN VALUE!
 *
 *  NOTE: This is a quick hack, but hopefully it should work. The internal
 *        mechanism is to split the expression into a left half and a right
 *        half around an operator. This operator should be the operator
 *        in the string which has the lowest precedence (except those that
 *        are inside parentheses sub-expressions). E.g. if the expression
 *        is   a * (b + c * d) / e   then the operator with the lowest
 *        precedence is the first multiplication sign, and the split will
 *        be:   left  = a
 *              right = (b+c*d)/e
 */
int debugger_parse_expression(struct machine *m, char *expr, int writeflag,
        uint64_t *valuep)
{
        int prec, res, i, nest;
        char *copy;

        if (writeflag)
                return debugger_parse_name(m, expr, writeflag, valuep);

        while (expr[0] == '\t' || expr[0] == ' ')
                expr ++;

        CHECK_ALLOCATION(copy = strdup(expr));

        while (copy[0] && copy[strlen(copy)-1] == ' ')
                copy[strlen(copy)-1] = '\0';

        /*  Find the lowest operator precedence:  */
        i = 0; prec = 2; nest = 0;
        while (copy[i] != '\0') {
                switch (copy[i]) {
                case '(':
                        nest ++;
                        break;
                case ')':
                        nest --;
                        break;
                case '+':
                case '-':
                case '^':
                case '&':
                case '|':
                        if (nest == 0)
                                prec = 0;
                        break;
                case '*':
                case '/':
                case '%':
                        if (nest == 0 && prec > 1)
                                prec = 1;
                        break;
                }

                i++;
        }

        if (nest != 0) {
                printf("Unmatching parentheses.\n");
                return PARSE_NOMATCH;
        }

        if (prec == 2 && copy[0] == '(' && copy[strlen(copy)-1] == ')') {
                int res;
                copy[strlen(copy)-1] = '\0';
                res = debugger_parse_expression(m, copy+1, 0, valuep);
                free(copy);
                return res;
        }

        /*  Split according to the first lowest priority operator:  */
        i = 0; nest = 0;
        while (copy[i] != '\0') {
                switch (copy[i]) {
                case '(':
                        nest ++;
                        break;
                case ')':
                        nest --;
                        break;
                case '*':
                case '/':
                case '%':
                        if (prec == 0)
                                break;
                        /*  Fallthrough.  */
                case '+':
                case '-':
                case '^':
                case '&':
                case '|':
                        if (nest == 0) {
                                uint64_t left, right;
                                int res1, res2, j;
                                char op = copy[i];

                                copy[i] = '\0';
                                j = i;
                                while (j>0 && copy[j-1] == ' ') {
                                        copy[j-1] = '\0';
                                        j --;
                                }

                                res1 = debugger_parse_expression(
                                    m, copy, 0, &left);
                                res2 = debugger_parse_expression(
                                    m, copy + i + 1, 0, &right);

                                if (res1 == PARSE_NOMATCH ||
                                    res2 == PARSE_NOMATCH) {
                                        res = PARSE_NOMATCH;
                                        goto return_failure;
                                }

                                if (res1 == PARSE_MULTIPLE ||
                                    res2 == PARSE_MULTIPLE) {
                                        res = PARSE_MULTIPLE;
                                        goto return_failure;
                                }

                                switch (op) {
                                case '+':
                                        (*valuep) = left + right;
                                        break;
                                case '-':
                                        (*valuep) = left - right;
                                        break;
                                case '^':
                                        (*valuep) = left ^ right;
                                        break;
                                case '&':
                                        (*valuep) = left & right;
                                        break;
                                case '|':
                                        (*valuep) = left | right;
                                        break;
                                case '*':
                                        (*valuep) = left * right;
                                        break;
                                case '/':
                                        (*valuep) = left / right;
                                        break;
                                case '%':
                                        (*valuep) = left % right;
                                        break;
                                }

                                goto return_ok;
                        }
                        break;
                }

                i ++;
        }

        res = debugger_parse_name(m, expr, writeflag, valuep);
        if (res == PARSE_NOMATCH || res == PARSE_MULTIPLE)
                goto return_failure;

return_ok:
        free(copy);
        return PARSE_NUMBER;

return_failure:
        free(copy);
        return res;
}

1	dpavlin	32	/*
2	dpavlin	34	* Copyright (C) 2004-2007 Anders Gavare. All rights reserved.
3	dpavlin	32	*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	42	* $Id: debugger_expr.c,v 1.11 2007/06/15 17:02:39 debug Exp $
29	dpavlin	32	*
30			* Expression evaluator.
31			*
32			*
33			* TODO:
34			* Sign-extension only on MIPS?
35			* SPECIAL IMPORTANT CASE: Clear the delay_slot flag when writing
36			* to the pc register.
37			* TAB completion? :-)
38			*/
39
40			#include <stdio.h>
41			#include <stdlib.h>
42			#include <string.h>
43			#include <ctype.h>
44
45			#include "cpu.h"
46			#include "debugger.h"
47			#include "machine.h"
48			#include "misc.h"
49			#include "settings.h"
50
51
52			extern struct settings *global_settings;
53
54			extern int debugger_cur_cpu;
55			extern int debugger_cur_machine;
56			extern int debugger_cur_emul;
57
58
59			/*
60			* debugger_parse_name():
61			*
62			* This function takes a string as input, and tries to match it to a register
63			* name or a more general "setting", a hexadecimal or decimal numeric value,
64			* or a registered symbol.
65			*
66			* Some examples:
67			*
68			* Settings (including register names):
69			* verbose
70			* pc
71			* r5
72			*
73			* Numeric values:
74			* 12345
75			* 0x7fff1234
76			*
77			* Symbols:
78			* memcpy
79			*
80			* To force detection of different types, a character can be added in front of
81			* the name: "$" for numeric values, "#" for registers or other settings,
82			* and "@" for symbols.
83			*
84			* Return value is:
85			*
86			* PARSE_NOMATCH no match
87			* PARSE_MULTIPLE multiple matches
88			*
89			* or one of these (and then *valuep is read or written, depending on
90			* the writeflag):
91			*
92			* PARSE_SETTINGS a setting (e.g. a register)
93			* PARSE_NUMBER a hex number
94			* PARSE_SYMBOL a symbol
95			*/
96			int debugger_parse_name(struct machine m, char name, int writeflag,
97			uint64_t *valuep)
98			{
99			int match_settings = 0, match_symbol = 0, match_numeric = 0;
100			int skip_settings, skip_numeric, skip_symbol;
101
102			if (m == NULL \|\| name == NULL) {
103			fprintf(stderr, "debugger_parse_name(): NULL ptr\n");
104			exit(1);
105			}
106
107			while (name[0] == '\t' \|\| name[0] == ' ')
108			name ++;
109
110			/* Warn about non-signextended values: */
111			if (writeflag) {
112			if (m->cpus[0]->is_32bit) {
113			/* Automagically sign-extend. TODO: Is this good? */
114			if (((valuep) >> 32) == 0 && (valuep) & 0x80000000ULL)
115			(*valuep) \|= 0xffffffff00000000ULL;
116			} else {
117			if (((valuep) >> 32) == 0 && (valuep) & 0x80000000ULL)
118			printf("WARNING: The value is not sign-extende"
119			"d. Is this what you intended?\n");
120			}
121			}
122
123			skip_settings = name[0] == '$' \|\| name[0] == '@';
124			skip_numeric = name[0] == '#' \|\| name[0] == '@';
125			skip_symbol = name[0] == '$' \|\| name[0] == '#';
126
127			if (!skip_settings) {
128			char setting_name[400];
129			int res;
130
131			res = settings_access(global_settings, name, writeflag, valuep);
132			if (res == SETTINGS_OK)
133			match_settings = 1;
134
135			if (!match_settings) {
136			snprintf(setting_name, sizeof(setting_name),
137			GLOBAL_SETTINGS_NAME".%s", name);
138			res = settings_access(global_settings, setting_name,
139			writeflag, valuep);
140			if (res == SETTINGS_OK)
141			match_settings = 1;
142			}
143
144			if (!match_settings) {
145			snprintf(setting_name, sizeof(setting_name),
146			GLOBAL_SETTINGS_NAME".emul[%i].%s",
147			debugger_cur_emul, name);
148			res = settings_access(global_settings, setting_name,
149			writeflag, valuep);
150			if (res == SETTINGS_OK)
151			match_settings = 1;
152			}
153
154			if (!match_settings) {
155			snprintf(setting_name, sizeof(setting_name),
156			GLOBAL_SETTINGS_NAME".emul[%i].machine[%i].%s",
157			debugger_cur_emul, debugger_cur_machine, name);
158			res = settings_access(global_settings, setting_name,
159			writeflag, valuep);
160			if (res == SETTINGS_OK)
161			match_settings = 1;
162			}
163
164			if (!match_settings) {
165			snprintf(setting_name, sizeof(setting_name),
166			GLOBAL_SETTINGS_NAME".emul[%i].machine[%i]."
167			"cpu[%i].%s", debugger_cur_emul,
168			debugger_cur_machine, debugger_cur_cpu, name);
169			res = settings_access(global_settings, setting_name,
170			writeflag, valuep);
171			if (res == SETTINGS_OK)
172			match_settings = 1;
173			}
174			}
175
176			/* Check for a number match: */
177			if (!skip_numeric && isdigit((int)name[0])) {
178			uint64_t x;
179			x = strtoull(name, NULL, 0);
180			if (writeflag)
181			printf("You cannot assign like that.\n");
182			else
183			*valuep = x;
184			match_numeric = 1;
185			}
186
187			/* Check for a symbol match: */
188			if (!skip_symbol) {
189			uint64_t newaddr;
190			if (get_symbol_addr(&m->symbol_context, name, &newaddr)) {
191			if (writeflag)
192			printf("You cannot assign like that.\n");
193			else
194			*valuep = newaddr;
195			match_symbol = 1;
196			}
197			}
198
199			if (match_settings + match_symbol + match_numeric > 1)
200			return PARSE_MULTIPLE;
201
202			if (match_settings)
203			return PARSE_SETTINGS;
204			if (match_numeric)
205			return PARSE_NUMBER;
206			if (match_symbol)
207			return PARSE_SYMBOL;
208
209			return PARSE_NOMATCH;
210			}
211
212
213			/*
214			* debugger_parse_expression()
215			*
216			* Input:
217			* writeflag = 0: expr = an expression to evaluate. The result is
218			* returned in *valuep.
219			*
220			* writeflag = 1: expr = an lvalue name. *valuep is written to that
221			* lvalue, using debugger_parse_name().
222			*
223			* Parentheses always have precedence.
224			* * / and % have second highest precedence.
225			* + - & \| ^ have lowest precedence.
226			*
227			* Return value on failure is:
228			*
229			* PARSE_NOMATCH one or more words in the expression didn't
230			* match any known symbol/register/number
231			* PARSE_MULTIPLE multiple matches within the expression
232			*
233			* Return value on success is PARSE_NUMBER (for now).
234			*
235			*
236			* TODO: BETTER RETURN VALUE!
237			*
238			* NOTE: This is a quick hack, but hopefully it should work. The internal
239			* mechanism is to split the expression into a left half and a right
240			* half around an operator. This operator should be the operator
241			* in the string which has the lowest precedence (except those that
242			* are inside parentheses sub-expressions). E.g. if the expression
243			* is a * (b + c * d) / e then the operator with the lowest
244			* precedence is the first multiplication sign, and the split will
245			* be: left = a
246			* right = (b+c*d)/e
247			*/
248			int debugger_parse_expression(struct machine m, char expr, int writeflag,
249			uint64_t *valuep)
250			{
251			int prec, res, i, nest;
252			char *copy;
253
254			if (writeflag)
255			return debugger_parse_name(m, expr, writeflag, valuep);
256
257			while (expr[0] == '\t' \|\| expr[0] == ' ')
258			expr ++;
259
260	dpavlin	42	CHECK_ALLOCATION(copy = strdup(expr));
261	dpavlin	32
262			while (copy[0] && copy[strlen(copy)-1] == ' ')
263			copy[strlen(copy)-1] = '\0';
264
265			/* Find the lowest operator precedence: */
266			i = 0; prec = 2; nest = 0;
267			while (copy[i] != '\0') {
268			switch (copy[i]) {
269			case '(':
270			nest ++;
271			break;
272			case ')':
273			nest --;
274			break;
275			case '+':
276			case '-':
277			case '^':
278			case '&':
279			case '\|':
280			if (nest == 0)
281			prec = 0;
282			break;
283			case '*':
284			case '/':
285			case '%':
286			if (nest == 0 && prec > 1)
287			prec = 1;
288			break;
289			}
290
291			i++;
292			}
293
294			if (nest != 0) {
295			printf("Unmatching parentheses.\n");
296			return PARSE_NOMATCH;
297			}
298
299			if (prec == 2 && copy[0] == '(' && copy[strlen(copy)-1] == ')') {
300			int res;
301			copy[strlen(copy)-1] = '\0';
302			res = debugger_parse_expression(m, copy+1, 0, valuep);
303			free(copy);
304			return res;
305			}
306
307			/* Split according to the first lowest priority operator: */
308			i = 0; nest = 0;
309			while (copy[i] != '\0') {
310			switch (copy[i]) {
311			case '(':
312			nest ++;
313			break;
314			case ')':
315			nest --;
316			break;
317			case '*':
318			case '/':
319			case '%':
320			if (prec == 0)
321			break;
322			/* Fallthrough. */
323			case '+':
324			case '-':
325			case '^':
326			case '&':
327			case '\|':
328			if (nest == 0) {
329			uint64_t left, right;
330			int res1, res2, j;
331			char op = copy[i];
332
333			copy[i] = '\0';
334			j = i;
335			while (j>0 && copy[j-1] == ' ') {
336			copy[j-1] = '\0';
337			j --;
338			}
339
340			res1 = debugger_parse_expression(
341			m, copy, 0, &left);
342			res2 = debugger_parse_expression(
343			m, copy + i + 1, 0, &right);
344
345			if (res1 == PARSE_NOMATCH \|\|
346			res2 == PARSE_NOMATCH) {
347			res = PARSE_NOMATCH;
348			goto return_failure;
349			}
350
351			if (res1 == PARSE_MULTIPLE \|\|
352			res2 == PARSE_MULTIPLE) {
353			res = PARSE_MULTIPLE;
354			goto return_failure;
355			}
356
357			switch (op) {
358			case '+':
359			(*valuep) = left + right;
360			break;
361			case '-':
362			(*valuep) = left - right;
363			break;
364			case '^':
365			(*valuep) = left ^ right;
366			break;
367			case '&':
368			(*valuep) = left & right;
369			break;
370			case '\|':
371			(*valuep) = left \| right;
372			break;
373			case '*':
374			(valuep) = left right;
375			break;
376			case '/':
377			(*valuep) = left / right;
378			break;
379			case '%':
380			(*valuep) = left % right;
381			break;
382			}
383
384			goto return_ok;
385			}
386			break;
387			}
388
389			i ++;
390			}
391
392			res = debugger_parse_name(m, expr, writeflag, valuep);
393			if (res == PARSE_NOMATCH \|\| res == PARSE_MULTIPLE)
394			goto return_failure;
395
396			return_ok:
397			free(copy);
398			return PARSE_NUMBER;
399
400			return_failure:
401			free(copy);
402			return res;
403			}
404