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.12 2007/06/28 14:58:38 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;


/*
 *  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.%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.machine[%i].%s",
                            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.machine[%i]."
                            "cpu[%i].%s", 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	/*
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.12 2007/06/28 14:58:38 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
57
58	/*
59	* debugger_parse_name():
60	*
61	* This function takes a string as input, and tries to match it to a register
62	* name or a more general "setting", a hexadecimal or decimal numeric value,
63	* or a registered symbol.
64	*
65	* Some examples:
66	*
67	* Settings (including register names):
68	* verbose
69	* pc
70	* r5
71	*
72	* Numeric values:
73	* 12345
74	* 0x7fff1234
75	*
76	* Symbols:
77	* memcpy
78	*
79	* To force detection of different types, a character can be added in front of
80	* the name: "$" for numeric values, "#" for registers or other settings,
81	* and "@" for symbols.
82	*
83	* Return value is:
84	*
85	* PARSE_NOMATCH no match
86	* PARSE_MULTIPLE multiple matches
87	*
88	* or one of these (and then *valuep is read or written, depending on
89	* the writeflag):
90	*
91	* PARSE_SETTINGS a setting (e.g. a register)
92	* PARSE_NUMBER a hex number
93	* PARSE_SYMBOL a symbol
94	*/
95	int debugger_parse_name(struct machine m, char name, int writeflag,
96	uint64_t *valuep)
97	{
98	int match_settings = 0, match_symbol = 0, match_numeric = 0;
99	int skip_settings, skip_numeric, skip_symbol;
100
101	if (m == NULL \|\| name == NULL) {
102	fprintf(stderr, "debugger_parse_name(): NULL ptr\n");
103	exit(1);
104	}
105
106	while (name[0] == '\t' \|\| name[0] == ' ')
107	name ++;
108
109	/* Warn about non-signextended values: */
110	if (writeflag) {
111	if (m->cpus[0]->is_32bit) {
112	/* Automagically sign-extend. TODO: Is this good? */
113	if (((valuep) >> 32) == 0 && (valuep) & 0x80000000ULL)
114	(*valuep) \|= 0xffffffff00000000ULL;
115	} else {
116	if (((valuep) >> 32) == 0 && (valuep) & 0x80000000ULL)
117	printf("WARNING: The value is not sign-extende"
118	"d. Is this what you intended?\n");
119	}
120	}
121
122	skip_settings = name[0] == '$' \|\| name[0] == '@';
123	skip_numeric = name[0] == '#' \|\| name[0] == '@';
124	skip_symbol = name[0] == '$' \|\| name[0] == '#';
125
126	if (!skip_settings) {
127	char setting_name[400];
128	int res;
129
130	res = settings_access(global_settings, name, writeflag, valuep);
131	if (res == SETTINGS_OK)
132	match_settings = 1;
133
134	if (!match_settings) {
135	snprintf(setting_name, sizeof(setting_name),
136	GLOBAL_SETTINGS_NAME".%s", name);
137	res = settings_access(global_settings, setting_name,
138	writeflag, valuep);
139	if (res == SETTINGS_OK)
140	match_settings = 1;
141	}
142
143	if (!match_settings) {
144	snprintf(setting_name, sizeof(setting_name),
145	GLOBAL_SETTINGS_NAME".emul.%s", name);
146	res = settings_access(global_settings, setting_name,
147	writeflag, valuep);
148	if (res == SETTINGS_OK)
149	match_settings = 1;
150	}
151
152	if (!match_settings) {
153	snprintf(setting_name, sizeof(setting_name),
154	GLOBAL_SETTINGS_NAME".emul.machine[%i].%s",
155	debugger_cur_machine, name);
156	res = settings_access(global_settings, setting_name,
157	writeflag, valuep);
158	if (res == SETTINGS_OK)
159	match_settings = 1;
160	}
161
162	if (!match_settings) {
163	snprintf(setting_name, sizeof(setting_name),
164	GLOBAL_SETTINGS_NAME".emul.machine[%i]."
165	"cpu[%i].%s", debugger_cur_machine,
166	debugger_cur_cpu, name);
167	res = settings_access(global_settings, setting_name,
168	writeflag, valuep);
169	if (res == SETTINGS_OK)
170	match_settings = 1;
171	}
172	}
173
174	/* Check for a number match: */
175	if (!skip_numeric && isdigit((int)name[0])) {
176	uint64_t x;
177	x = strtoull(name, NULL, 0);
178	if (writeflag)
179	printf("You cannot assign like that.\n");
180	else
181	*valuep = x;
182	match_numeric = 1;
183	}
184
185	/* Check for a symbol match: */
186	if (!skip_symbol) {
187	uint64_t newaddr;
188	if (get_symbol_addr(&m->symbol_context, name, &newaddr)) {
189	if (writeflag)
190	printf("You cannot assign like that.\n");
191	else
192	*valuep = newaddr;
193	match_symbol = 1;
194	}
195	}
196
197	if (match_settings + match_symbol + match_numeric > 1)
198	return PARSE_MULTIPLE;
199
200	if (match_settings)
201	return PARSE_SETTINGS;
202	if (match_numeric)
203	return PARSE_NUMBER;
204	if (match_symbol)
205	return PARSE_SYMBOL;
206
207	return PARSE_NOMATCH;
208	}
209
210
211	/*
212	* debugger_parse_expression()
213	*
214	* Input:
215	* writeflag = 0: expr = an expression to evaluate. The result is
216	* returned in *valuep.
217	*
218	* writeflag = 1: expr = an lvalue name. *valuep is written to that
219	* lvalue, using debugger_parse_name().
220	*
221	* Parentheses always have precedence.
222	* * / and % have second highest precedence.
223	* + - & \| ^ have lowest precedence.
224	*
225	* Return value on failure is:
226	*
227	* PARSE_NOMATCH one or more words in the expression didn't
228	* match any known symbol/register/number
229	* PARSE_MULTIPLE multiple matches within the expression
230	*
231	* Return value on success is PARSE_NUMBER (for now).
232	*
233	*
234	* TODO: BETTER RETURN VALUE!
235	*
236	* NOTE: This is a quick hack, but hopefully it should work. The internal
237	* mechanism is to split the expression into a left half and a right
238	* half around an operator. This operator should be the operator
239	* in the string which has the lowest precedence (except those that
240	* are inside parentheses sub-expressions). E.g. if the expression
241	* is a * (b + c * d) / e then the operator with the lowest
242	* precedence is the first multiplication sign, and the split will
243	* be: left = a
244	* right = (b+c*d)/e
245	*/
246	int debugger_parse_expression(struct machine m, char expr, int writeflag,
247	uint64_t *valuep)
248	{
249	int prec, res, i, nest;
250	char *copy;
251
252	if (writeflag)
253	return debugger_parse_name(m, expr, writeflag, valuep);
254
255	while (expr[0] == '\t' \|\| expr[0] == ' ')
256	expr ++;
257
258	CHECK_ALLOCATION(copy = strdup(expr));
259
260	while (copy[0] && copy[strlen(copy)-1] == ' ')
261	copy[strlen(copy)-1] = '\0';
262
263	/* Find the lowest operator precedence: */
264	i = 0; prec = 2; nest = 0;
265	while (copy[i] != '\0') {
266	switch (copy[i]) {
267	case '(':
268	nest ++;
269	break;
270	case ')':
271	nest --;
272	break;
273	case '+':
274	case '-':
275	case '^':
276	case '&':
277	case '\|':
278	if (nest == 0)
279	prec = 0;
280	break;
281	case '*':
282	case '/':
283	case '%':
284	if (nest == 0 && prec > 1)
285	prec = 1;
286	break;
287	}
288
289	i++;
290	}
291
292	if (nest != 0) {
293	printf("Unmatching parentheses.\n");
294	return PARSE_NOMATCH;
295	}
296
297	if (prec == 2 && copy[0] == '(' && copy[strlen(copy)-1] == ')') {
298	int res;
299	copy[strlen(copy)-1] = '\0';
300	res = debugger_parse_expression(m, copy+1, 0, valuep);
301	free(copy);
302	return res;
303	}
304
305	/* Split according to the first lowest priority operator: */
306	i = 0; nest = 0;
307	while (copy[i] != '\0') {
308	switch (copy[i]) {
309	case '(':
310	nest ++;
311	break;
312	case ')':
313	nest --;
314	break;
315	case '*':
316	case '/':
317	case '%':
318	if (prec == 0)
319	break;
320	/* Fallthrough. */
321	case '+':
322	case '-':
323	case '^':
324	case '&':
325	case '\|':
326	if (nest == 0) {
327	uint64_t left, right;
328	int res1, res2, j;
329	char op = copy[i];
330
331	copy[i] = '\0';
332	j = i;
333	while (j>0 && copy[j-1] == ' ') {
334	copy[j-1] = '\0';
335	j --;
336	}
337
338	res1 = debugger_parse_expression(
339	m, copy, 0, &left);
340	res2 = debugger_parse_expression(
341	m, copy + i + 1, 0, &right);
342
343	if (res1 == PARSE_NOMATCH \|\|
344	res2 == PARSE_NOMATCH) {
345	res = PARSE_NOMATCH;
346	goto return_failure;
347	}
348
349	if (res1 == PARSE_MULTIPLE \|\|
350	res2 == PARSE_MULTIPLE) {
351	res = PARSE_MULTIPLE;
352	goto return_failure;
353	}
354
355	switch (op) {
356	case '+':
357	(*valuep) = left + right;
358	break;
359	case '-':
360	(*valuep) = left - right;
361	break;
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	}
381
382	goto return_ok;
383	}
384	break;
385	}
386
387	i ++;
388	}
389
390	res = debugger_parse_name(m, expr, writeflag, valuep);
391	if (res == PARSE_NOMATCH \|\| res == PARSE_MULTIPLE)
392	goto return_failure;
393
394	return_ok:
395	free(copy);
396	return PARSE_NUMBER;
397
398	return_failure:
399	free(copy);
400	return res;
401	}
402