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