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.10 2006/12/30 13:30:56 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 ++;

        copy = strdup(expr);
        if (copy == NULL) {
                fprintf(stderr, "debugger_parse_expression(): out of memory\n");
                exit(1);
        }

        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	/*
2	* Copyright (C) 2004-2007 Anders Gavare. All rights reserved.
3	*
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	* $Id: debugger_expr.c,v 1.10 2006/12/30 13:30:56 debug Exp $
29	*
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	copy = strdup(expr);
261	if (copy == NULL) {
262	fprintf(stderr, "debugger_parse_expression(): out of memory\n");
263	exit(1);
264	}
265
266	while (copy[0] && copy[strlen(copy)-1] == ' ')
267	copy[strlen(copy)-1] = '\0';
268
269	/* Find the lowest operator precedence: */
270	i = 0; prec = 2; nest = 0;
271	while (copy[i] != '\0') {
272	switch (copy[i]) {
273	case '(':
274	nest ++;
275	break;
276	case ')':
277	nest --;
278	break;
279	case '+':
280	case '-':
281	case '^':
282	case '&':
283	case '\|':
284	if (nest == 0)
285	prec = 0;
286	break;
287	case '*':
288	case '/':
289	case '%':
290	if (nest == 0 && prec > 1)
291	prec = 1;
292	break;
293	}
294
295	i++;
296	}
297
298	if (nest != 0) {
299	printf("Unmatching parentheses.\n");
300	return PARSE_NOMATCH;
301	}
302
303	if (prec == 2 && copy[0] == '(' && copy[strlen(copy)-1] == ')') {
304	int res;
305	copy[strlen(copy)-1] = '\0';
306	res = debugger_parse_expression(m, copy+1, 0, valuep);
307	free(copy);
308	return res;
309	}
310
311	/* Split according to the first lowest priority operator: */
312	i = 0; nest = 0;
313	while (copy[i] != '\0') {
314	switch (copy[i]) {
315	case '(':
316	nest ++;
317	break;
318	case ')':
319	nest --;
320	break;
321	case '*':
322	case '/':
323	case '%':
324	if (prec == 0)
325	break;
326	/* Fallthrough. */
327	case '+':
328	case '-':
329	case '^':
330	case '&':
331	case '\|':
332	if (nest == 0) {
333	uint64_t left, right;
334	int res1, res2, j;
335	char op = copy[i];
336
337	copy[i] = '\0';
338	j = i;
339	while (j>0 && copy[j-1] == ' ') {
340	copy[j-1] = '\0';
341	j --;
342	}
343
344	res1 = debugger_parse_expression(
345	m, copy, 0, &left);
346	res2 = debugger_parse_expression(
347	m, copy + i + 1, 0, &right);
348
349	if (res1 == PARSE_NOMATCH \|\|
350	res2 == PARSE_NOMATCH) {
351	res = PARSE_NOMATCH;
352	goto return_failure;
353	}
354
355	if (res1 == PARSE_MULTIPLE \|\|
356	res2 == PARSE_MULTIPLE) {
357	res = PARSE_MULTIPLE;
358	goto return_failure;
359	}
360
361	switch (op) {
362	case '+':
363	(*valuep) = left + right;
364	break;
365	case '-':
366	(*valuep) = left - right;
367	break;
368	case '^':
369	(*valuep) = left ^ right;
370	break;
371	case '&':
372	(*valuep) = left & right;
373	break;
374	case '\|':
375	(*valuep) = left \| right;
376	break;
377	case '*':
378	(valuep) = left right;
379	break;
380	case '/':
381	(*valuep) = left / right;
382	break;
383	case '%':
384	(*valuep) = left % right;
385	break;
386	}
387
388	goto return_ok;
389	}
390	break;
391	}
392
393	i ++;
394	}
395
396	res = debugger_parse_name(m, expr, writeflag, valuep);
397	if (res == PARSE_NOMATCH \|\| res == PARSE_MULTIPLE)
398	goto return_failure;
399
400	return_ok:
401	free(copy);
402	return PARSE_NUMBER;
403
404	return_failure:
405	free(copy);
406	return res;
407	}
408