DBGCEval.cpp@ 62840

Last change on this file since 62840 was 62838, checked in by vboxsync, 8 years ago
Debugger: warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 53.7 KB

Line
1	/* $Id: DBGCEval.cpp 62838 2016-08-01 17:01:57Z vboxsync $ */
2	/** @file
3	* DBGC - Debugger Console, command evaluator.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGC
23	#include <VBox/dbg.h>
24	#include <VBox/err.h>
25	#include <VBox/log.h>
26
27	#include <iprt/asm.h>
28	#include <iprt/assert.h>
29	#include <iprt/mem.h>
30	#include <iprt/string.h>
31	#include <iprt/ctype.h>
32
33	#include <stdio.h>
34
35	#include "DBGCInternal.h"
36
37	/** Rewrite in progress. */
38	#define BETTER_ARGUMENT_MATCHING
39
40
41	/*********************************************************************************************************************************
42	* Global Variables *
43	*********************************************************************************************************************************/
44	/** Bitmap where set bits indicates the characters the may start an operator name. */
45	static uint32_t g_bmOperatorChars[256 / (4*8)];
46
47
48	/*********************************************************************************************************************************
49	* Internal Functions *
50	*********************************************************************************************************************************/
51	static int dbgcCheckAndTypePromoteArgument(PDBGC pDbgc, DBGCVARCAT enmCategory, PDBGCVAR pArg);
52	static int dbgcProcessArguments(PDBGC pDbgc, const char *pszCmdOrFunc,
53	uint32_t const cArgsMin, uint32_t const cArgsMax,
54	PCDBGCVARDESC const paVarDescs, uint32_t const cVarDescs,
55	char pszArgs, unsigned piArg, unsigned *pcArgs);
56
57
58
59	/**
60	* Initializes g_bmOperatorChars.
61	*/
62	void dbgcEvalInit(void)
63	{
64	memset(g_bmOperatorChars, 0, sizeof(g_bmOperatorChars));
65	for (unsigned iOp = 0; iOp < g_cDbgcOps; iOp++)
66	ASMBitSet(&g_bmOperatorChars[0], (uint8_t)g_aDbgcOps[iOp].szName[0]);
67	}
68
69
70	/**
71	* Checks whether the character may be the start of an operator.
72	*
73	* @returns true/false.
74	* @param ch The character.
75	*/
76	DECLINLINE(bool) dbgcIsOpChar(char ch)
77	{
78	return ASMBitTest(&g_bmOperatorChars[0], (uint8_t)ch);
79	}
80
81
82	/**
83	* Returns the amount of free scratch space.
84	*
85	* @returns Number of unallocated bytes.
86	* @param pDbgc The DBGC instance.
87	*/
88	size_t dbgcGetFreeScratchSpace(PDBGC pDbgc)
89	{
90	return sizeof(pDbgc->achScratch) - (pDbgc->pszScratch - &pDbgc->achScratch[0]);
91	}
92
93
94	/**
95	* Allocates a string from the scratch space.
96	*
97	* @returns Pointer to the allocated string buffer, NULL if out of space.
98	* @param pDbgc The DBGC instance.
99	* @param cbRequested The number of bytes to allocate.
100	*/
101	char *dbgcAllocStringScatch(PDBGC pDbgc, size_t cbRequested)
102	{
103	if (cbRequested > dbgcGetFreeScratchSpace(pDbgc))
104	return NULL;
105	char *psz = pDbgc->pszScratch;
106	pDbgc->pszScratch += cbRequested;
107	return psz;
108	}
109
110
111	/**
112	* Evals an expression into a string or symbol (single quotes).
113	*
114	* The string memory is allocated from the scratch buffer.
115	*
116	* @returns VBox status code.
117	* @param pDbgc The DBGC instance.
118	* @param pachExpr The string/symbol expression.
119	* @param cchExpr The length of the expression.
120	* @param pArg Where to return the string.
121	*/
122	static int dbgcEvalSubString(PDBGC pDbgc, const char *pachExpr, size_t cchExpr, PDBGCVAR pArg)
123	{
124	Log2(("dbgcEvalSubString: cchExpr=%d pachExpr=%.*s\n", cchExpr, cchExpr, pachExpr));
125
126	/*
127	* Allocate scratch space for the string.
128	*/
129	char *pszCopy = dbgcAllocStringScatch(pDbgc, cchExpr + 1);
130	if (!pszCopy)
131	return VERR_DBGC_PARSE_NO_SCRATCH;
132
133	/*
134	* Removing any quoting and escapings.
135	*/
136	char const chQuote = *pachExpr;
137	if (chQuote == '"' \|\| chQuote == '\'')
138	{
139	if (pachExpr[--cchExpr] != chQuote)
140	return VERR_DBGC_PARSE_UNBALANCED_QUOTE;
141
142	cchExpr--;
143	pachExpr++;
144	if (!memchr(pachExpr, chQuote, cchExpr))
145	memcpy(pszCopy, pachExpr, cchExpr);
146	else
147	{
148	size_t offSrc = 0;
149	size_t offDst = 0;
150	while (offSrc < cchExpr)
151	{
152	char const ch = pachExpr[offSrc++];
153	if (ch == chQuote)
154	{
155	if (pachExpr[offSrc] != ch)
156	return VERR_DBGC_PARSE_EXPECTED_BINARY_OP;
157	offSrc++;
158	}
159	pszCopy[offDst++] = ch;
160	}
161	}
162	}
163	else
164	memcpy(pszCopy, pachExpr, cchExpr);
165	pszCopy[cchExpr] = '\0';
166
167	/*
168	* Make the argument.
169	*/
170	pArg->pDesc = NULL;
171	pArg->pNext = NULL;
172	pArg->enmType = chQuote == '"' ? DBGCVAR_TYPE_STRING : DBGCVAR_TYPE_SYMBOL;
173	pArg->u.pszString = pszCopy;
174	pArg->enmRangeType = DBGCVAR_RANGE_BYTES;
175	pArg->u64Range = cchExpr;
176
177	NOREF(pDbgc);
178	return VINF_SUCCESS;
179	}
180
181
182	static int dbgcEvalSubNum(const char *pachExpr, size_t cchExpr, unsigned uBase, PDBGCVAR pArg)
183	{
184	Log2(("dbgcEvalSubNum: uBase=%d pachExpr=%.*s\n", uBase, cchExpr, pachExpr));
185
186	/*
187	* Empty expressions cannot be valid numbers.
188	*/
189	if (!cchExpr)
190	return VERR_DBGC_PARSE_INVALID_NUMBER;
191
192	/*
193	* Convert to number.
194	*/
195	uint64_t u64 = 0;
196	while (cchExpr-- > 0)
197	{
198	char const ch = *pachExpr;
199	uint64_t u64Prev = u64;
200	unsigned u = ch - '0';
201	if (u < 10 && u < uBase)
202	u64 = u64 * uBase + u;
203	else if (ch >= 'a' && (u = ch - ('a' - 10)) < uBase)
204	u64 = u64 * uBase + u;
205	else if (ch >= 'A' && (u = ch - ('A' - 10)) < uBase)
206	u64 = u64 * uBase + u;
207	else
208	return VERR_DBGC_PARSE_INVALID_NUMBER;
209
210	/* check for overflow - ARG!!! How to detect overflow correctly!?!?!? */
211	if (u64Prev != u64 / uBase)
212	return VERR_DBGC_PARSE_NUMBER_TOO_BIG;
213
214	/* next */
215	pachExpr++;
216	}
217
218	/*
219	* Initialize the argument.
220	*/
221	pArg->pDesc = NULL;
222	pArg->pNext = NULL;
223	pArg->enmType = DBGCVAR_TYPE_NUMBER;
224	pArg->u.u64Number = u64;
225	pArg->enmRangeType = DBGCVAR_RANGE_NONE;
226	pArg->u64Range = 0;
227
228	return VINF_SUCCESS;
229	}
230
231
232	/**
233	* dbgcEvalSubUnary worker that handles simple numeric or pointer expressions.
234	*
235	* @returns VBox status code. pResult contains the result on success.
236	* @param pDbgc Debugger console instance data.
237	* @param pszExpr The expression string.
238	* @param cchExpr The length of the expression.
239	* @param enmCategory The desired type category (for range / no range).
240	* @param pResult Where to store the result of the expression evaluation.
241	*/
242	static int dbgcEvalSubNumericOrPointer(PDBGC pDbgc, char *pszExpr, size_t cchExpr, DBGCVARCAT enmCategory,
243	PDBGCVAR pResult)
244	{
245	char const ch = pszExpr[0];
246	char const ch2 = pszExpr[1];
247
248	/* 0x<hex digits> */
249	if (ch == '0' && (ch2 == 'x' \|\| ch2 == 'X'))
250	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 16, pResult);
251
252	/* <hex digits>h */
253	if (RT_C_IS_XDIGIT(*pszExpr) && (pszExpr[cchExpr - 1] == 'h' \|\| pszExpr[cchExpr - 1] == 'H'))
254	{
255	pszExpr[cchExpr] = '\0';
256	return dbgcEvalSubNum(pszExpr, cchExpr - 1, 16, pResult);
257	}
258
259	/* 0i<decimal digits> */
260	if (ch == '0' && ch2 == 'i')
261	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 10, pResult);
262
263	/* 0t<octal digits> */
264	if (ch == '0' && ch2 == 't')
265	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 8, pResult);
266
267	/* 0y<binary digits> */
268	if (ch == '0' && ch2 == 'y')
269	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 10, pResult);
270
271	/* Hex number? */
272	unsigned off = 0;
273	while (off < cchExpr && (RT_C_IS_XDIGIT(pszExpr[off]) \|\| pszExpr[off] == '`'))
274	off++;
275	if (off == cchExpr)
276	return dbgcEvalSubNum(pszExpr, cchExpr, 16, pResult);
277
278	/*
279	* Some kind of symbol? Rejected double quoted strings, only unquoted
280	* and single quoted strings will be considered as symbols.
281	*/
282	DBGCVARTYPE enmType;
283	bool fStripRange = false;
284	switch (enmCategory)
285	{
286	case DBGCVAR_CAT_POINTER_NUMBER: enmType = DBGCVAR_TYPE_NUMBER; break;
287	case DBGCVAR_CAT_POINTER_NUMBER_NO_RANGE: enmType = DBGCVAR_TYPE_NUMBER; fStripRange = true; break;
288	case DBGCVAR_CAT_POINTER: enmType = DBGCVAR_TYPE_NUMBER; break;
289	case DBGCVAR_CAT_POINTER_NO_RANGE: enmType = DBGCVAR_TYPE_NUMBER; fStripRange = true; break;
290	case DBGCVAR_CAT_GC_POINTER: enmType = DBGCVAR_TYPE_GC_FLAT; break;
291	case DBGCVAR_CAT_GC_POINTER_NO_RANGE: enmType = DBGCVAR_TYPE_GC_FLAT; fStripRange = true; break;
292	case DBGCVAR_CAT_NUMBER: enmType = DBGCVAR_TYPE_NUMBER; break;
293	case DBGCVAR_CAT_NUMBER_NO_RANGE: enmType = DBGCVAR_TYPE_NUMBER; fStripRange = true; break;
294	default:
295	AssertFailedReturn(VERR_DBGC_PARSE_NOT_IMPLEMENTED);
296	}
297
298	char const chQuote = *pszExpr;
299	if (chQuote == '"')
300	return VERR_DBGC_PARSE_INVALID_NUMBER;
301
302	if (chQuote == '\'')
303	{
304	if (pszExpr[cchExpr - 1] != chQuote)
305	return VERR_DBGC_PARSE_UNBALANCED_QUOTE;
306	pszExpr[cchExpr - 1] = '\0';
307	pszExpr++;
308	}
309
310	int rc = dbgcSymbolGet(pDbgc, pszExpr, enmType, pResult);
311	if (RT_SUCCESS(rc))
312	{
313	if (fStripRange)
314	{
315	pResult->enmRangeType = DBGCVAR_RANGE_NONE;
316	pResult->u64Range = 0;
317	}
318	}
319	else if (rc == VERR_DBGC_PARSE_NOT_IMPLEMENTED)
320	rc = VERR_DBGC_PARSE_INVALID_NUMBER;
321	return rc;
322	}
323
324
325	/**
326	* dbgcEvalSubUnary worker that handles simple DBGCVAR_CAT_ANY expressions.
327	*
328	* @returns VBox status code. pResult contains the result on success.
329	* @param pDbgc Debugger console instance data.
330	* @param pszExpr The expression string.
331	* @param cchExpr The length of the expression.
332	* @param pResult Where to store the result of the expression evaluation.
333	*/
334	static int dbgcEvalSubUnaryAny(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pResult)
335	{
336	char const ch = pszExpr[0];
337	char const ch2 = pszExpr[1];
338	unsigned off = 2;
339
340	/* 0x<hex digits> */
341	if (ch == '0' && (ch2 == 'x' \|\| ch2 == 'X'))
342	{
343	while (RT_C_IS_XDIGIT(pszExpr[off]) \|\| pszExpr[off] == '`')
344	off++;
345	if (off == cchExpr)
346	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 16, pResult);
347	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
348	}
349
350	/* <hex digits>h */
351	if (RT_C_IS_XDIGIT(*pszExpr) && (pszExpr[cchExpr - 1] == 'h' \|\| pszExpr[cchExpr - 1] == 'H'))
352	{
353	cchExpr--;
354	while (off < cchExpr && (RT_C_IS_XDIGIT(pszExpr[off]) \|\| pszExpr[off] == '`'))
355	off++;
356	if (off == cchExpr)
357	{
358	pszExpr[cchExpr] = '\0';
359	return dbgcEvalSubNum(pszExpr, cchExpr, 16, pResult);
360	}
361	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr + 1, pResult);
362	}
363
364	/* 0n<decimal digits> or 0i<decimal digits> */
365	if (ch == '0' && (ch2 == 'n' \|\| ch2 == 'i'))
366	{
367	while (RT_C_IS_DIGIT(pszExpr[off]) \|\| pszExpr[off] == '`')
368	off++;
369	if (off == cchExpr)
370	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 10, pResult);
371	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
372	}
373
374	/* 0t<octal digits> */
375	if (ch == '0' && ch2 == 't')
376	{
377	while (RT_C_IS_ODIGIT(pszExpr[off]) \|\| pszExpr[off] == '`')
378	off++;
379	if (off == cchExpr)
380	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 8, pResult);
381	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
382	}
383
384	/* 0y<binary digits> */
385	if (ch == '0' && ch2 == 'y')
386	{
387	while (pszExpr[off] == '0' \|\| pszExpr[off] == '1' \|\| pszExpr[off] == '`')
388	off++;
389	if (off == cchExpr)
390	return dbgcEvalSubNum(pszExpr + 2, cchExpr - 2, 10, pResult);
391	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
392	}
393
394	/* Ok, no prefix of suffix. Is it a hex number after all? If not it must
395	be a string. */
396	off = 0;
397	while (RT_C_IS_XDIGIT(pszExpr[off]) \|\| pszExpr[off] == '`')
398	off++;
399	if (off == cchExpr)
400	return dbgcEvalSubNum(pszExpr, cchExpr, 16, pResult);
401	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
402	}
403
404
405	/**
406	* Handles a call.
407	*
408	* @returns VBox status code. pResult contains the result on success.
409	* @param pDbgc The DBGC instance.
410	* @param pszFuncNm The function name.
411	* @param cchFuncNm The length of the function name.
412	* @param fExternal Whether it's an external name.
413	* @param pszArgs The start of the arguments (after parenthesis).
414	* @param cchArgs The length for the argument (exclusing
415	* parentesis).
416	* @param enmCategory The desired category of the result (ignored).
417	* @param pResult The result.
418	*/
419	static int dbgcEvalSubCall(PDBGC pDbgc, char pszFuncNm, size_t cchFuncNm, bool fExternal, char pszArgs, size_t cchArgs,
420	DBGCVARCAT enmCategory, PDBGCVAR pResult)
421	{
422	RT_NOREF1(enmCategory);
423
424	/*
425	* Lookup the function.
426	*/
427	PCDBGCFUNC pFunc = dbgcFunctionLookup(pDbgc, pszFuncNm, cchFuncNm, fExternal);
428	if (!pFunc)
429	return VERR_DBGC_PARSE_FUNCTION_NOT_FOUND;
430
431	/*
432	* Parse the arguments.
433	*/
434	unsigned cArgs;
435	unsigned iArg;
436	pszArgs[cchArgs] = '\0';
437	int rc = dbgcProcessArguments(pDbgc, pFunc->pszFuncNm,
438	pFunc->cArgsMin, pFunc->cArgsMax, pFunc->paArgDescs, pFunc->cArgDescs,
439	pszArgs, &iArg, &cArgs);
440	if (RT_SUCCESS(rc))
441	rc = pFunc->pfnHandler(pFunc, &pDbgc->CmdHlp, pDbgc->pUVM, &pDbgc->aArgs[iArg], cArgs, pResult);
442	pDbgc->iArg = iArg;
443	return rc;
444	}
445
446
447	/**
448	* Evaluates one argument with respect to unary operators.
449	*
450	* @returns VBox status code. pResult contains the result on success.
451	*
452	* @param pDbgc Debugger console instance data.
453	* @param pszExpr The expression string.
454	* @param cchExpr The length of the expression.
455	* @param enmCategory The target category for the result.
456	* @param pResult Where to store the result of the expression evaluation.
457	*/
458	static int dbgcEvalSubUnary(PDBGC pDbgc, char *pszExpr, size_t cchExpr, DBGCVARCAT enmCategory, PDBGCVAR pResult)
459	{
460	Log2(("dbgcEvalSubUnary: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
461
462	/*
463	* The state of the expression is now such that it will start by zero or more
464	* unary operators and being followed by an expression of some kind.
465	* The expression is either plain or in parenthesis.
466	*
467	* Being in a lazy, recursive mode today, the parsing is done as simple as possible. :-)
468	* ASSUME: unary operators are all of equal precedence.
469	*/
470	int rc = VINF_SUCCESS;
471	PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, pszExpr, false, ' ');
472	if (pOp)
473	{
474	/* binary operators means syntax error. */
475	if (pOp->fBinary)
476	return VERR_DBGC_PARSE_UNEXPECTED_OPERATOR;
477
478	/*
479	* If the next expression (the one following the unary operator) is in a
480	* parenthesis a full eval is needed. If not the unary eval will suffice.
481	*/
482	/* calc and strip next expr. */
483	char *pszExpr2 = pszExpr + pOp->cchName;
484	while (RT_C_IS_BLANK(*pszExpr2))
485	pszExpr2++;
486
487	if (*pszExpr2)
488	{
489	DBGCVAR Arg;
490	if (*pszExpr2 == '(')
491	rc = dbgcEvalSub(pDbgc, pszExpr2, cchExpr - (pszExpr2 - pszExpr), pOp->enmCatArg1, &Arg);
492	else
493	rc = dbgcEvalSubUnary(pDbgc, pszExpr2, cchExpr - (pszExpr2 - pszExpr), pOp->enmCatArg1, &Arg);
494	if (RT_SUCCESS(rc))
495	rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOp->enmCatArg1, &Arg);
496	if (RT_SUCCESS(rc))
497	rc = pOp->pfnHandlerUnary(pDbgc, &Arg, enmCategory, pResult);
498	}
499	else
500	rc = VERR_DBGC_PARSE_EMPTY_ARGUMENT;
501	return rc;
502	}
503
504	/*
505	* Could this be a function call?
506	*
507	* ASSUMPTIONS:
508	* - A function name only contains alphanumerical chars and it can not
509	* start with a numerical character.
510	* - Immediately following the name is a parenthesis which must cover
511	* the remaining part of the expression.
512	*/
513	bool fExternal = *pszExpr == '.';
514	char *pszFun = fExternal ? pszExpr + 1 : pszExpr;
515	char *pszFunEnd = NULL;
516	if (pszExpr[cchExpr - 1] == ')' && RT_C_IS_ALPHA(*pszFun))
517	{
518	pszFunEnd = pszExpr + 1;
519	while (pszFunEnd != '(' && RT_C_IS_ALNUM(pszFunEnd))
520	pszFunEnd++;
521	if (*pszFunEnd != '(')
522	pszFunEnd = NULL;
523	}
524	if (pszFunEnd)
525	{
526	size_t cchFunNm = pszFunEnd - pszFun;
527	return dbgcEvalSubCall(pDbgc, pszFun, cchFunNm, fExternal, pszFunEnd + 1, cchExpr - cchFunNm - fExternal - 2,
528	enmCategory, pResult);
529	}
530
531	/*
532	* Assuming plain expression.
533	* Didn't find any operators, so it must be a plain expression.
534	* Go by desired category first, then if anythings go, try guess.
535	*/
536	switch (enmCategory)
537	{
538	case DBGCVAR_CAT_ANY:
539	return dbgcEvalSubUnaryAny(pDbgc, pszExpr, cchExpr, pResult);
540
541	case DBGCVAR_CAT_POINTER_NUMBER:
542	case DBGCVAR_CAT_POINTER_NUMBER_NO_RANGE:
543	case DBGCVAR_CAT_POINTER:
544	case DBGCVAR_CAT_POINTER_NO_RANGE:
545	case DBGCVAR_CAT_GC_POINTER:
546	case DBGCVAR_CAT_GC_POINTER_NO_RANGE:
547	case DBGCVAR_CAT_NUMBER:
548	case DBGCVAR_CAT_NUMBER_NO_RANGE:
549	/* Pointers will be promoted later. */
550	return dbgcEvalSubNumericOrPointer(pDbgc, pszExpr, cchExpr, enmCategory, pResult);
551
552	case DBGCVAR_CAT_STRING:
553	case DBGCVAR_CAT_SYMBOL:
554	/* Symbols will be promoted later. */
555	return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
556
557	case DBGCVAR_CAT_OPTION:
558	case DBGCVAR_CAT_OPTION_STRING:
559	case DBGCVAR_CAT_OPTION_NUMBER:
560	return VERR_DBGC_PARSE_NOT_IMPLEMENTED;
561	}
562
563	AssertMsgFailed(("enmCategory=%d\n", enmCategory));
564	return VERR_NOT_IMPLEMENTED;
565	}
566
567
568	/**
569	* Evaluates one argument.
570	*
571	* @returns VBox status code.
572	*
573	* @param pDbgc Debugger console instance data.
574	* @param pszExpr The expression string.
575	* @param enmCategory The target category for the result.
576	* @param pResult Where to store the result of the expression evaluation.
577	*/
578	int dbgcEvalSub(PDBGC pDbgc, char *pszExpr, size_t cchExpr, DBGCVARCAT enmCategory, PDBGCVAR pResult)
579	{
580	Log2(("dbgcEvalSub: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
581
582	/*
583	* First we need to remove blanks in both ends.
584	* ASSUMES: There is no quoting unless the entire expression is a string.
585	*/
586
587	/* stripping. */
588	while (cchExpr > 0 && RT_C_IS_BLANK(pszExpr[cchExpr - 1]))
589	pszExpr[--cchExpr] = '\0';
590	while (RT_C_IS_BLANK(*pszExpr))
591	pszExpr++, cchExpr--;
592	if (!*pszExpr)
593	return VERR_DBGC_PARSE_EMPTY_ARGUMENT;
594
595	/*
596	* Check if there are any parenthesis which needs removing.
597	*/
598	if (pszExpr[0] == '(' && pszExpr[cchExpr - 1] == ')')
599	{
600	do
601	{
602	unsigned cPar = 1;
603	char *psz = pszExpr + 1;
604	char ch;
605	while ((ch = *psz) != '\0')
606	{
607	if (ch == '(')
608	cPar++;
609	else if (ch == ')')
610	{
611	if (cPar <= 0)
612	return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
613	cPar--;
614	if (cPar == 0 && psz[1]) /* If not at end, there's nothing to do. */
615	break;
616	}
617	/* next */
618	psz++;
619	}
620	if (ch)
621	break;
622
623	/* remove the parenthesis. */
624	pszExpr++;
625	cchExpr -= 2;
626	pszExpr[cchExpr] = '\0';
627
628	/* strip blanks. */
629	while (cchExpr > 0 && RT_C_IS_BLANK(pszExpr[cchExpr - 1]))
630	pszExpr[--cchExpr] = '\0';
631	while (RT_C_IS_BLANK(*pszExpr))
632	pszExpr++, cchExpr--;
633	if (!*pszExpr)
634	return VERR_DBGC_PARSE_EMPTY_ARGUMENT;
635	} while (pszExpr[0] == '(' && pszExpr[cchExpr - 1] == ')');
636	}
637
638	/*
639	* Now, we need to look for the binary operator with the lowest precedence.
640	*
641	* If there are no operators we're left with a simple expression which we
642	* evaluate with respect to unary operators
643	*/
644	char *pszOpSplit = NULL;
645	PCDBGCOP pOpSplit = NULL;
646	unsigned cBinaryOps = 0;
647	unsigned cPar = 0;
648	unsigned cchWord = 0;
649	char chQuote = '\0';
650	char chPrev = ' ';
651	bool fBinary = false;
652	char *psz = pszExpr;
653	char ch;
654
655	while ((ch = *psz) != '\0')
656	{
657	/*
658	* String quoting.
659	*/
660	if (chQuote)
661	{
662	if (ch == chQuote)
663	{
664	if (psz[1] == chQuote)
665	{
666	psz++; /* escaped quote */
667	cchWord++;
668	}
669	else
670	{
671	chQuote = '\0';
672	fBinary = true;
673	cchWord = 0;
674	}
675	}
676	else
677	cchWord++;
678	}
679	else if (ch == '"' \|\| ch == '\'')
680	{
681	if (fBinary \|\| cchWord)
682	return VERR_DBGC_PARSE_EXPECTED_BINARY_OP;
683	chQuote = ch;
684	}
685	/*
686	* Parentheses.
687	*/
688	else if (ch == '(')
689	{
690	if (!cPar && fBinary && !cchWord)
691	return VERR_DBGC_PARSE_EXPECTED_BINARY_OP;
692	cPar++;
693	fBinary = false;
694	cchWord = 0;
695	}
696	else if (ch == ')')
697	{
698	if (cPar <= 0)
699	return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
700	cPar--;
701	fBinary = true;
702	cchWord = 0;
703	}
704	/*
705	* Potential operator.
706	*/
707	else if (cPar == 0 && !RT_C_IS_BLANK(ch))
708	{
709	PCDBGCOP pOp = dbgcIsOpChar(ch)
710	? dbgcOperatorLookup(pDbgc, psz, fBinary, chPrev)
711	: NULL;
712	if (pOp)
713	{
714	/* If not the right kind of operator we've got a syntax error. */
715	if (pOp->fBinary != fBinary)
716	return VERR_DBGC_PARSE_UNEXPECTED_OPERATOR;
717
718	/*
719	* Update the parse state and skip the operator.
720	*/
721	if (!pOpSplit)
722	{
723	pOpSplit = pOp;
724	pszOpSplit = psz;
725	cBinaryOps = fBinary;
726	}
727	else if (fBinary)
728	{
729	cBinaryOps++;
730	if (pOp->iPrecedence >= pOpSplit->iPrecedence)
731	{
732	pOpSplit = pOp;
733	pszOpSplit = psz;
734	}
735	}
736
737	psz += pOp->cchName - 1;
738	fBinary = false;
739	cchWord = 0;
740	}
741	else if (fBinary && !cchWord)
742	return VERR_DBGC_PARSE_EXPECTED_BINARY_OP;
743	else
744	{
745	fBinary = true;
746	cchWord++;
747	}
748	}
749	else if (cPar == 0 && RT_C_IS_BLANK(ch))
750	cchWord++;
751
752	/* next */
753	psz++;
754	chPrev = ch;
755	} /* parse loop. */
756
757	if (chQuote)
758	return VERR_DBGC_PARSE_UNBALANCED_QUOTE;
759
760	/*
761	* Either we found an operator to divide the expression by or we didn't
762	* find any. In the first case it's divide and conquer. In the latter
763	* it's a single expression which needs dealing with its unary operators
764	* if any.
765	*/
766	int rc;
767	if ( cBinaryOps
768	&& pOpSplit->fBinary)
769	{
770	/* process 1st sub expression. */
771	*pszOpSplit = '\0';
772	DBGCVAR Arg1;
773	rc = dbgcEvalSub(pDbgc, pszExpr, pszOpSplit - pszExpr, pOpSplit->enmCatArg1, &Arg1);
774	if (RT_SUCCESS(rc))
775	{
776	/* process 2nd sub expression. */
777	char *psz2 = pszOpSplit + pOpSplit->cchName;
778	DBGCVAR Arg2;
779	rc = dbgcEvalSub(pDbgc, psz2, cchExpr - (psz2 - pszExpr), pOpSplit->enmCatArg2, &Arg2);
780	if (RT_SUCCESS(rc))
781	rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOpSplit->enmCatArg1, &Arg1);
782	if (RT_SUCCESS(rc))
783	rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOpSplit->enmCatArg2, &Arg2);
784	if (RT_SUCCESS(rc))
785	rc = pOpSplit->pfnHandlerBinary(pDbgc, &Arg1, &Arg2, pResult);
786	}
787	}
788	else if (cBinaryOps)
789	{
790	/* process sub expression. */
791	pszOpSplit += pOpSplit->cchName;
792	DBGCVAR Arg;
793	rc = dbgcEvalSub(pDbgc, pszOpSplit, cchExpr - (pszOpSplit - pszExpr), pOpSplit->enmCatArg1, &Arg);
794	if (RT_SUCCESS(rc))
795	rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOpSplit->enmCatArg1, &Arg);
796	if (RT_SUCCESS(rc))
797	rc = pOpSplit->pfnHandlerUnary(pDbgc, &Arg, enmCategory, pResult);
798	}
799	else
800	/* plain expression, qutoed string, or using unary operators perhaps with parentheses. */
801	rc = dbgcEvalSubUnary(pDbgc, pszExpr, cchExpr, enmCategory, pResult);
802
803	return rc;
804	}
805
806
807	/**
808	* Worker for dbgcProcessArguments that performs type checking and promoptions.
809	*
810	* @returns VBox status code.
811	*
812	* @param pDbgc Debugger console instance data.
813	* @param enmCategory The target category for the result.
814	* @param pArg The argument to check and promote.
815	*/
816	static int dbgcCheckAndTypePromoteArgument(PDBGC pDbgc, DBGCVARCAT enmCategory, PDBGCVAR pArg)
817	{
818	switch (enmCategory)
819	{
820	/*
821	* Anything goes
822	*/
823	case DBGCVAR_CAT_ANY:
824	return VINF_SUCCESS;
825
826	/*
827	* Pointer with and without range.
828	* We can try resolve strings and symbols as symbols and promote
829	* numbers to flat GC pointers.
830	*/
831	case DBGCVAR_CAT_POINTER_NO_RANGE:
832	case DBGCVAR_CAT_POINTER_NUMBER_NO_RANGE:
833	if (pArg->enmRangeType != DBGCVAR_RANGE_NONE)
834	return VERR_DBGC_PARSE_NO_RANGE_ALLOWED;
835	/* fallthru */
836	case DBGCVAR_CAT_POINTER:
837	case DBGCVAR_CAT_POINTER_NUMBER:
838	switch (pArg->enmType)
839	{
840	case DBGCVAR_TYPE_GC_FLAT:
841	case DBGCVAR_TYPE_GC_FAR:
842	case DBGCVAR_TYPE_GC_PHYS:
843	case DBGCVAR_TYPE_HC_FLAT:
844	case DBGCVAR_TYPE_HC_PHYS:
845	return VINF_SUCCESS;
846
847	case DBGCVAR_TYPE_SYMBOL:
848	case DBGCVAR_TYPE_STRING:
849	{
850	DBGCVAR Var;
851	int rc = dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_FLAT, &Var);
852	if (RT_SUCCESS(rc))
853	{
854	/* deal with range */
855	if (pArg->enmRangeType != DBGCVAR_RANGE_NONE)
856	{
857	Var.enmRangeType = pArg->enmRangeType;
858	Var.u64Range = pArg->u64Range;
859	}
860	else if (enmCategory == DBGCVAR_CAT_POINTER_NO_RANGE)
861	Var.enmRangeType = DBGCVAR_RANGE_NONE;
862	*pArg = Var;
863	}
864	return rc;
865	}
866
867	case DBGCVAR_TYPE_NUMBER:
868	if ( enmCategory != DBGCVAR_CAT_POINTER_NUMBER
869	&& enmCategory != DBGCVAR_CAT_POINTER_NUMBER_NO_RANGE)
870	{
871	RTGCPTR GCPtr = (RTGCPTR)pArg->u.u64Number;
872	pArg->enmType = DBGCVAR_TYPE_GC_FLAT;
873	pArg->u.GCFlat = GCPtr;
874	}
875	return VINF_SUCCESS;
876
877	default:
878	AssertMsgFailedReturn(("Invalid type %d\n", pArg->enmType), VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
879	}
880	break; /* (not reached) */
881
882	/*
883	* GC pointer with and without range.
884	* We can try resolve strings and symbols as symbols and
885	* promote numbers to flat GC pointers.
886	*/
887	case DBGCVAR_CAT_GC_POINTER_NO_RANGE:
888	if (pArg->enmRangeType != DBGCVAR_RANGE_NONE)
889	return VERR_DBGC_PARSE_NO_RANGE_ALLOWED;
890	/* fallthru */
891	case DBGCVAR_CAT_GC_POINTER:
892	switch (pArg->enmType)
893	{
894	case DBGCVAR_TYPE_GC_FLAT:
895	case DBGCVAR_TYPE_GC_FAR:
896	case DBGCVAR_TYPE_GC_PHYS:
897	return VINF_SUCCESS;
898
899	case DBGCVAR_TYPE_HC_FLAT:
900	case DBGCVAR_TYPE_HC_PHYS:
901	return VERR_DBGC_PARSE_CONVERSION_FAILED;
902
903	case DBGCVAR_TYPE_SYMBOL:
904	case DBGCVAR_TYPE_STRING:
905	{
906	DBGCVAR Var;
907	int rc = dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_FLAT, &Var);
908	if (RT_SUCCESS(rc))
909	{
910	/* deal with range */
911	if (pArg->enmRangeType != DBGCVAR_RANGE_NONE)
912	{
913	Var.enmRangeType = pArg->enmRangeType;
914	Var.u64Range = pArg->u64Range;
915	}
916	else if (enmCategory == DBGCVAR_CAT_POINTER_NO_RANGE)
917	Var.enmRangeType = DBGCVAR_RANGE_NONE;
918	*pArg = Var;
919	}
920	return rc;
921	}
922
923	case DBGCVAR_TYPE_NUMBER:
924	{
925	RTGCPTR GCPtr = (RTGCPTR)pArg->u.u64Number;
926	pArg->enmType = DBGCVAR_TYPE_GC_FLAT;
927	pArg->u.GCFlat = GCPtr;
928	return VINF_SUCCESS;
929	}
930
931	default:
932	AssertMsgFailedReturn(("Invalid type %d\n", pArg->enmType), VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
933	}
934	break; /* (not reached) */
935
936	/*
937	* Number with or without a range.
938	* Numbers can be resolved from symbols, but we cannot demote a pointer
939	* to a number.
940	*/
941	case DBGCVAR_CAT_NUMBER_NO_RANGE:
942	if (pArg->enmRangeType != DBGCVAR_RANGE_NONE)
943	return VERR_DBGC_PARSE_NO_RANGE_ALLOWED;
944	/* fallthru */
945	case DBGCVAR_CAT_NUMBER:
946	switch (pArg->enmType)
947	{
948	case DBGCVAR_TYPE_GC_FLAT:
949	case DBGCVAR_TYPE_GC_FAR:
950	case DBGCVAR_TYPE_GC_PHYS:
951	case DBGCVAR_TYPE_HC_FLAT:
952	case DBGCVAR_TYPE_HC_PHYS:
953	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
954
955	case DBGCVAR_TYPE_NUMBER:
956	return VINF_SUCCESS;
957
958	case DBGCVAR_TYPE_SYMBOL:
959	case DBGCVAR_TYPE_STRING:
960	{
961	DBGCVAR Var;
962	int rc = dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
963	if (RT_SUCCESS(rc))
964	{
965	/* deal with range */
966	if (pArg->enmRangeType != DBGCVAR_RANGE_NONE)
967	{
968	Var.enmRangeType = pArg->enmRangeType;
969	Var.u64Range = pArg->u64Range;
970	}
971	else if (enmCategory == DBGCVAR_CAT_POINTER_NO_RANGE)
972	Var.enmRangeType = DBGCVAR_RANGE_NONE;
973	*pArg = Var;
974	}
975	return rc;
976	}
977
978	default:
979	AssertMsgFailedReturn(("Invalid type %d\n", pArg->enmType), VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
980	}
981	break; /* (not reached) */
982
983	/*
984	* Symbols and strings are basically the same thing for the time being.
985	*/
986	case DBGCVAR_CAT_STRING:
987	case DBGCVAR_CAT_SYMBOL:
988	{
989	switch (pArg->enmType)
990	{
991	case DBGCVAR_TYPE_STRING:
992	if (enmCategory == DBGCVAR_CAT_SYMBOL)
993	pArg->enmType = DBGCVAR_TYPE_SYMBOL;
994	return VINF_SUCCESS;
995
996	case DBGCVAR_TYPE_SYMBOL:
997	if (enmCategory == DBGCVAR_CAT_STRING)
998	pArg->enmType = DBGCVAR_TYPE_STRING;
999	return VINF_SUCCESS;
1000	default:
1001	break;
1002	}
1003
1004	/* Stringify numeric and pointer values. */
1005	size_t cbScratch = sizeof(pDbgc->achScratch) - (pDbgc->pszScratch - &pDbgc->achScratch[0]);
1006	size_t cch = pDbgc->CmdHlp.pfnStrPrintf(&pDbgc->CmdHlp, pDbgc->pszScratch, cbScratch, "%Dv", pArg);
1007	if (cch + 1 >= cbScratch)
1008	return VERR_DBGC_PARSE_NO_SCRATCH;
1009
1010	pArg->enmType = enmCategory == DBGCVAR_CAT_STRING ? DBGCVAR_TYPE_STRING : DBGCVAR_TYPE_SYMBOL;
1011	pArg->u.pszString = pDbgc->pszScratch;
1012	pArg->enmRangeType = DBGCVAR_RANGE_BYTES;
1013	pArg->u64Range = cch;
1014
1015	pDbgc->pszScratch += cch + 1;
1016	return VINF_SUCCESS;
1017	}
1018
1019	/*
1020	* These are not yet implemented.
1021	*/
1022	case DBGCVAR_CAT_OPTION:
1023	case DBGCVAR_CAT_OPTION_STRING:
1024	case DBGCVAR_CAT_OPTION_NUMBER:
1025	AssertMsgFailedReturn(("Not implemented enmCategory=%d\n", enmCategory), VERR_DBGC_PARSE_NOT_IMPLEMENTED);
1026
1027	default:
1028	AssertMsgFailedReturn(("Bad enmCategory=%d\n", enmCategory), VERR_DBGC_PARSE_NOT_IMPLEMENTED);
1029	}
1030	}
1031
1032
1033	/**
1034	* Parses the arguments of one command.
1035	*
1036	* @returns VBox statuc code. On parser errors the index of the troublesome
1037	* argument is indicated by *pcArg.
1038	*
1039	* @param pDbgc Debugger console instance data.
1040	* @param pszCmdOrFunc The name of the function or command. (For logging.)
1041	* @param cArgsMin See DBGCCMD::cArgsMin and DBGCFUNC::cArgsMin.
1042	* @param cArgsMax See DBGCCMD::cArgsMax and DBGCFUNC::cArgsMax.
1043	* @param paVarDescs See DBGCCMD::paVarDescs and DBGCFUNC::paVarDescs.
1044	* @param cVarDescs See DBGCCMD::cVarDescs and DBGCFUNC::cVarDescs.
1045	* @param pszArg Pointer to the arguments to parse.
1046	* @param piArg Where to return the index of the first argument in
1047	* DBGC::aArgs. Always set. Caller must restore DBGC::iArg
1048	* to this value when done, even on failure.
1049	* @param pcArgs Where to store the number of arguments. In the event
1050	* of an error this is (ab)used to store the index of the
1051	* offending argument.
1052	*/
1053	static int dbgcProcessArguments(PDBGC pDbgc, const char *pszCmdOrFunc,
1054	uint32_t const cArgsMin, uint32_t const cArgsMax,
1055	PCDBGCVARDESC const paVarDescs, uint32_t const cVarDescs,
1056	char pszArgs, unsigned piArg, unsigned *pcArgs)
1057	{
1058	RT_NOREF1(pszCmdOrFunc);
1059	Log2(("dbgcProcessArguments: pszCmdOrFunc=%s pszArgs='%s'\n", pszCmdOrFunc, pszArgs));
1060
1061	/*
1062	* Check if we have any argument and if the command takes any.
1063	*/
1064	*piArg = pDbgc->iArg;
1065	*pcArgs = 0;
1066	/* strip leading blanks. */
1067	while (pszArgs && RT_C_IS_BLANK(pszArgs))
1068	pszArgs++;
1069	if (!*pszArgs)
1070	{
1071	if (!cArgsMin)
1072	return VINF_SUCCESS;
1073	return VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS;
1074	}
1075	if (!cArgsMax)
1076	return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
1077
1078	/*
1079	* The parse loop.
1080	*/
1081	PDBGCVAR pArg = &pDbgc->aArgs[pDbgc->iArg];
1082	PCDBGCVARDESC pPrevDesc = NULL;
1083	unsigned cCurDesc = 0;
1084	unsigned iVar = 0;
1085	unsigned iVarDesc = 0;
1086	*pcArgs = 0;
1087	do
1088	{
1089	/*
1090	* Can we have another argument?
1091	*/
1092	if (*pcArgs >= cArgsMax)
1093	return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
1094	if (pDbgc->iArg >= RT_ELEMENTS(pDbgc->aArgs))
1095	return VERR_DBGC_PARSE_ARGUMENT_OVERFLOW;
1096	if (iVarDesc >= cVarDescs)
1097	return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
1098
1099	/* Walk argument descriptors. */
1100	if (cCurDesc >= paVarDescs[iVarDesc].cTimesMax)
1101	{
1102	iVarDesc++;
1103	if (iVarDesc >= cVarDescs)
1104	return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
1105	cCurDesc = 0;
1106	}
1107
1108	/*
1109	* Find the end of the argument. This is just rough splitting,
1110	* dbgcEvalSub will do stricter syntax checking later on.
1111	*/
1112	int cPar = 0;
1113	char chQuote = '\0';
1114	char *pszEnd = NULL;
1115	char *psz = pszArgs;
1116	char ch;
1117	bool fBinary = false;
1118	for (;;)
1119	{
1120	/*
1121	* Check for the end.
1122	*/
1123	if ((ch = *psz) == '\0')
1124	{
1125	if (chQuote)
1126	return VERR_DBGC_PARSE_UNBALANCED_QUOTE;
1127	if (cPar)
1128	return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
1129	pszEnd = psz;
1130	break;
1131	}
1132	/*
1133	* When quoted we ignore everything but the quotation char.
1134	* We use the REXX way of escaping the quotation char, i.e. double occurrence.
1135	*/
1136	else if (chQuote)
1137	{
1138	if (ch == chQuote)
1139	{
1140	if (psz[1] == chQuote)
1141	psz++; /* skip the escaped quote char */
1142	else
1143	{
1144	chQuote = '\0'; /* end of quoted string. */
1145	fBinary = true;
1146	}
1147	}
1148	}
1149	else if (ch == '\'' \|\| ch == '"')
1150	{
1151	if (fBinary)
1152	return VERR_DBGC_PARSE_EXPECTED_BINARY_OP;
1153	chQuote = ch;
1154	}
1155	/*
1156	* Parenthesis can of course be nested.
1157	*/
1158	else if (ch == '(')
1159	{
1160	cPar++;
1161	fBinary = false;
1162	}
1163	else if (ch == ')')
1164	{
1165	if (!cPar)
1166	return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
1167	cPar--;
1168	fBinary = true;
1169	}
1170	else if (!cPar)
1171	{
1172	/*
1173	* Encountering a comma is a definite end of parameter.
1174	*/
1175	if (ch == ',')
1176	{
1177	pszEnd = psz++;
1178	break;
1179	}
1180
1181	/*
1182	* Encountering blanks may mean the end of it all. A binary
1183	* operator will force continued parsing.
1184	*/
1185	if (RT_C_IS_BLANK(ch))
1186	{
1187	pszEnd = psz++; /* in case it's the end. */
1188	while (RT_C_IS_BLANK(*psz))
1189	psz++;
1190
1191	if (*psz == ',')
1192	{
1193	psz++;
1194	break;
1195	}
1196
1197	PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, psz, fBinary, ' ');
1198	if (!pOp \|\| pOp->fBinary != fBinary)
1199	break; /* the end. */
1200
1201	psz += pOp->cchName;
1202	while (RT_C_IS_BLANK(psz)) / skip blanks so we don't get here again */
1203	psz++;
1204	fBinary = false;
1205	continue;
1206	}
1207
1208	/*
1209	* Look for operators without a space up front.
1210	*/
1211	if (dbgcIsOpChar(ch))
1212	{
1213	PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, psz, fBinary, ' ');
1214	if (pOp)
1215	{
1216	if (pOp->fBinary != fBinary)
1217	{
1218	pszEnd = psz;
1219	/** @todo this is a parsing error really. */
1220	break; /* the end. */
1221	}
1222	psz += pOp->cchName;
1223	while (RT_C_IS_BLANK(psz)) / skip blanks so we don't get here again */
1224	psz++;
1225	fBinary = false;
1226	continue;
1227	}
1228	}
1229	fBinary = true;
1230	}
1231
1232	/* next char */
1233	psz++;
1234	}
1235	*pszEnd = '\0';
1236	/* (psz = next char to process) */
1237	size_t cchArgs = strlen(pszArgs);
1238
1239	/*
1240	* Try optional arguments until we find something which matches
1241	* or can easily be promoted to what the descriptor want.
1242	*/
1243	for (;;)
1244	{
1245	char pszArgsCopy = (char )RTMemDup(pszArgs, cchArgs + 1);
1246	if (!pszArgsCopy)
1247	return VERR_DBGC_PARSE_NO_MEMORY;
1248
1249	int rc = dbgcEvalSub(pDbgc, pszArgs, cchArgs, paVarDescs[iVarDesc].enmCategory, pArg);
1250	if (RT_SUCCESS(rc))
1251	rc = dbgcCheckAndTypePromoteArgument(pDbgc, paVarDescs[iVarDesc].enmCategory, pArg);
1252	if (RT_SUCCESS(rc))
1253	{
1254	pArg->pDesc = pPrevDesc = &paVarDescs[iVarDesc];
1255	cCurDesc++;
1256	RTMemFree(pszArgsCopy);
1257	break;
1258	}
1259
1260	memcpy(pszArgs, pszArgsCopy, cchArgs + 1);
1261	RTMemFree(pszArgsCopy);
1262
1263	/* Continue searching optional descriptors? */
1264	if ( rc != VERR_DBGC_PARSE_INCORRECT_ARG_TYPE
1265	&& rc != VERR_DBGC_PARSE_INVALID_NUMBER
1266	&& rc != VERR_DBGC_PARSE_NO_RANGE_ALLOWED
1267	)
1268	return rc;
1269
1270	/* Try advance to the next descriptor. */
1271	if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
1272	return rc;
1273	iVarDesc++;
1274	if (!cCurDesc)
1275	while ( iVarDesc < cVarDescs
1276	&& (paVarDescs[iVarDesc].fFlags & DBGCVD_FLAGS_DEP_PREV))
1277	iVarDesc++;
1278	if (iVarDesc >= cVarDescs)
1279	return rc;
1280	cCurDesc = 0;
1281	}
1282
1283	/*
1284	* Next argument.
1285	*/
1286	iVar++;
1287	pArg++;
1288	pDbgc->iArg++;
1289	*pcArgs += 1;
1290	pszArgs = psz;
1291	while (pszArgs && RT_C_IS_BLANK(pszArgs))
1292	pszArgs++;
1293	} while (*pszArgs);
1294
1295	/*
1296	* Check that the rest of the argument descriptors indicate optional args.
1297	*/
1298	if (iVarDesc < cVarDescs)
1299	{
1300	if (cCurDesc < paVarDescs[iVarDesc].cTimesMin)
1301	return VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS;
1302	iVarDesc++;
1303	while (iVarDesc < cVarDescs)
1304	{
1305	if (paVarDescs[iVarDesc].cTimesMin)
1306	return VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS;
1307	iVarDesc++;
1308	}
1309	}
1310
1311	return VINF_SUCCESS;
1312	}
1313
1314
1315	/**
1316	* Evaluate one command.
1317	*
1318	* @returns VBox status code. This is also stored in DBGC::rcCmd.
1319	*
1320	* @param pDbgc Debugger console instance data.
1321	* @param pszCmd Pointer to the command.
1322	* @param cchCmd Length of the command.
1323	* @param fNoExecute Indicates that no commands should actually be executed.
1324	*/
1325	int dbgcEvalCommand(PDBGC pDbgc, char *pszCmd, size_t cchCmd, bool fNoExecute)
1326	{
1327	char *pszCmdInput = pszCmd;
1328
1329	/*
1330	* Skip blanks.
1331	*/
1332	while (RT_C_IS_BLANK(*pszCmd))
1333	pszCmd++, cchCmd--;
1334
1335	/* external command? */
1336	bool const fExternal = *pszCmd == '.';
1337	if (fExternal)
1338	pszCmd++, cchCmd--;
1339
1340	/*
1341	* Find arguments.
1342	*/
1343	char *pszArgs = pszCmd;
1344	while (RT_C_IS_ALNUM(pszArgs) \|\| pszArgs == '_')
1345	pszArgs++;
1346	if ( (pszArgs && !RT_C_IS_BLANK(pszArgs))
1347	\|\| !RT_C_IS_ALPHA(*pszCmd))
1348	{
1349	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Syntax error: Invalid command '%s'!\n", pszCmdInput);
1350	return pDbgc->rcCmd = VERR_DBGC_PARSE_INVALD_COMMAND_NAME;
1351	}
1352
1353	/*
1354	* Find the command.
1355	*/
1356	PCDBGCCMD pCmd = dbgcCommandLookup(pDbgc, pszCmd, pszArgs - pszCmd, fExternal);
1357	if (!pCmd)
1358	{
1359	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Syntax error: Unknown command '%s'!\n", pszCmdInput);
1360	return pDbgc->rcCmd = VERR_DBGC_PARSE_COMMAND_NOT_FOUND;
1361	}
1362
1363	/*
1364	* Parse arguments (if any).
1365	*/
1366	unsigned iArg;
1367	unsigned cArgs;
1368	int rc = dbgcProcessArguments(pDbgc, pCmd->pszCmd,
1369	pCmd->cArgsMin, pCmd->cArgsMax, pCmd->paArgDescs, pCmd->cArgDescs,
1370	pszArgs, &iArg, &cArgs);
1371	if (RT_SUCCESS(rc))
1372	{
1373	AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
1374
1375	/*
1376	* Execute the command.
1377	*/
1378	if (!fNoExecute)
1379	rc = pCmd->pfnHandler(pCmd, &pDbgc->CmdHlp, pDbgc->pUVM, &pDbgc->aArgs[iArg], cArgs);
1380	pDbgc->rcCmd = rc;
1381	pDbgc->iArg = iArg;
1382	if (rc == VERR_DBGC_COMMAND_FAILED)
1383	rc = VINF_SUCCESS;
1384	}
1385	else
1386	{
1387	pDbgc->rcCmd = rc;
1388	pDbgc->iArg = iArg;
1389
1390	/* report parse / eval error. */
1391	switch (rc)
1392	{
1393	case VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS:
1394	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1395	"Syntax error: Too few arguments. Minimum is %d for command '%s'.\n", pCmd->cArgsMin, pCmd->pszCmd);
1396	break;
1397	case VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS:
1398	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1399	"Syntax error: Too many arguments. Maximum is %d for command '%s'.\n", pCmd->cArgsMax, pCmd->pszCmd);
1400	break;
1401	case VERR_DBGC_PARSE_ARGUMENT_OVERFLOW:
1402	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1403	"Syntax error: Too many arguments.\n");
1404	break;
1405	case VERR_DBGC_PARSE_UNBALANCED_QUOTE:
1406	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1407	"Syntax error: Unbalanced quote (argument %d).\n", cArgs);
1408	break;
1409	case VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS:
1410	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1411	"Syntax error: Unbalanced parenthesis (argument %d).\n", cArgs);
1412	break;
1413	case VERR_DBGC_PARSE_EMPTY_ARGUMENT:
1414	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1415	"Syntax error: An argument or subargument contains nothing useful (argument %d).\n", cArgs);
1416	break;
1417	case VERR_DBGC_PARSE_UNEXPECTED_OPERATOR:
1418	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1419	"Syntax error: Invalid operator usage (argument %d).\n", cArgs);
1420	break;
1421	case VERR_DBGC_PARSE_INVALID_NUMBER:
1422	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1423	"Syntax error: Invalid numeric value (argument %d). If a string was the intention, then quote it.\n", cArgs);
1424	break;
1425	case VERR_DBGC_PARSE_NUMBER_TOO_BIG:
1426	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1427	"Error: Numeric overflow (argument %d).\n", cArgs);
1428	break;
1429	case VERR_DBGC_PARSE_INVALID_OPERATION:
1430	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1431	"Error: Invalid operation attempted (argument %d).\n", cArgs);
1432	break;
1433	case VERR_DBGC_PARSE_FUNCTION_NOT_FOUND:
1434	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1435	"Error: Function not found (argument %d).\n", cArgs);
1436	break;
1437	case VERR_DBGC_PARSE_NOT_A_FUNCTION:
1438	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1439	"Error: The function specified is not a function (argument %d).\n", cArgs);
1440	break;
1441	case VERR_DBGC_PARSE_NO_MEMORY:
1442	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1443	"Error: Out memory in the regular heap! Expect odd stuff to happen...\n");
1444	break;
1445	case VERR_DBGC_PARSE_INCORRECT_ARG_TYPE:
1446	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1447	"Error: Incorrect argument type (argument %d?).\n", cArgs);
1448	break;
1449	case VERR_DBGC_PARSE_VARIABLE_NOT_FOUND:
1450	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1451	"Error: An undefined variable was referenced (argument %d).\n", cArgs);
1452	break;
1453	case VERR_DBGC_PARSE_CONVERSION_FAILED:
1454	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1455	"Error: A conversion between two types failed (argument %d).\n", cArgs);
1456	break;
1457	case VERR_DBGC_PARSE_NOT_IMPLEMENTED:
1458	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1459	"Error: You hit a debugger feature which isn't implemented yet (argument %d).\n", cArgs);
1460	break;
1461	case VERR_DBGC_PARSE_BAD_RESULT_TYPE:
1462	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1463	"Error: Couldn't satisfy a request for a specific result type (argument %d). (Usually applies to symbols)\n", cArgs);
1464	break;
1465	case VERR_DBGC_PARSE_WRITEONLY_SYMBOL:
1466	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
1467	"Error: Cannot get symbol, it's set only (argument %d).\n", cArgs);
1468	break;
1469
1470	case VERR_DBGC_COMMAND_FAILED:
1471	break;
1472
1473	default:
1474	{
1475	PCRTSTATUSMSG pErr = RTErrGet(rc);
1476	if (strncmp(pErr->pszDefine, RT_STR_TUPLE("Unknown Status")))
1477	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Error: %s (%d) - %s\n", pErr->pszDefine, rc, pErr->pszMsgFull);
1478	else
1479	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Error: Unknown error %d (%#x)!\n", rc, rc);
1480	break;
1481	}
1482	}
1483	}
1484
1485	return rc;
1486	}
1487
1488
1489	/**
1490	* Loads the script in @a pszFilename and executes the commands within.
1491	*
1492	* @returns VBox status code. Will complain about error to console.
1493	* @param pDbgc Debugger console instance data.
1494	* @param pszFilename The path to the script file.
1495	* @param fAnnounce Whether to announce the script.
1496	*/
1497	int dbgcEvalScript(PDBGC pDbgc, const char *pszFilename, bool fAnnounce)
1498	{
1499	FILE *pFile = fopen(pszFilename, "r");
1500	if (!pFile)
1501	return DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Failed to open '%s'.\n", pszFilename);
1502	if (fAnnounce)
1503	DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Running script '%s'...\n", pszFilename);
1504
1505	/*
1506	* Execute it line by line.
1507	*/
1508	int rc = VINF_SUCCESS;
1509	unsigned iLine = 0;
1510	char szLine[8192];
1511	while (fgets(szLine, sizeof(szLine), pFile))
1512	{
1513	/* check that the line isn't too long. */
1514	char *pszEnd = strchr(szLine, '\0');
1515	if (pszEnd == &szLine[sizeof(szLine) - 1])
1516	{
1517	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "runscript error: Line #%u is too long\n", iLine);
1518	break;
1519	}
1520	iLine++;
1521
1522	/* strip leading blanks and check for comment / blank line. */
1523	char *psz = RTStrStripL(szLine);
1524	if ( *psz == '\0'
1525	\|\| *psz == '\n'
1526	\|\| *psz == '#')
1527	continue;
1528
1529	/* strip trailing blanks and check for empty line (\r case). */
1530	while ( pszEnd > psz
1531	&& RT_C_IS_SPACE(pszEnd[-1])) /* RT_C_IS_SPACE includes \n and \r normally. */
1532	*--pszEnd = '\0';
1533
1534	/** @todo check for Control-C / Cancel at this point... */
1535
1536	/*
1537	* Execute the command.
1538	*
1539	* This is a bit wasteful with scratch space btw., can fix it later.
1540	* The whole return code crap should be fixed too, so that it's possible
1541	* to know whether a command succeeded (RT_SUCCESS()) or failed, and
1542	* more importantly why it failed.
1543	*/
1544	/** @todo optimize this. */
1545	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "%s", psz);
1546	if (RT_FAILURE(rc))
1547	{
1548	if (rc == VERR_BUFFER_OVERFLOW)
1549	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "runscript error: Line #%u is too long (exec overflowed)\n", iLine);
1550	break;
1551	}
1552	if (rc == VWRN_DBGC_CMD_PENDING)
1553	{
1554	rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "runscript error: VWRN_DBGC_CMD_PENDING on line #%u, script terminated\n", iLine);
1555	break;
1556	}
1557	}
1558
1559	fclose(pFile);
1560	return rc;
1561	}
1562

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Debugger/DBGCEval.cpp@ 62840

Download in other formats: