src/VBox/Debugger/DBGCEval.cpp

   1 /* $Id$ */
   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