VirtualBox

Changeset 41573 in vbox for trunk


Ignore:
Timestamp:
Jun 4, 2012 9:13:23 PM (13 years ago)
Author:
vboxsync
Message:

DBGC: Working on making STRING the inflexible type and SYMBOL the flexible one.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/dbg.h

    r41565 r41573  
    109109    /** Physical HC pointer. */
    110110    DBGCVAR_TYPE_HC_PHYS,
     111    /** Number. */
     112    DBGCVAR_TYPE_NUMBER,
    111113    /** String. */
    112114    DBGCVAR_TYPE_STRING,
    113     /** Number. */
    114     DBGCVAR_TYPE_NUMBER,
    115     /** Symbol.
    116      * @todo drop this   */
     115    /** Symbol. */
    117116    DBGCVAR_TYPE_SYMBOL,
    118117    /** Special type used when querying symbols. */
    … …  
    322321
    323322/**
     323 * Macro for initializing a DBGC variable with a symbol.
     324 */
     325#define DBGCVAR_INIT_SYMBOL(pVar, a_pszSymbol) \
     326        do { \
     327            DBGCVAR_INIT(pVar); \
     328            (pVar)->enmType      = DBGCVAR_TYPE_SYMBOL; \
     329            (pVar)->enmRangeType = DBGCVAR_RANGE_BYTES; \
     330            (pVar)->u.pszString  = (a_pszSymbol); \
     331            (pVar)->u64Range     = strlen(a_pszSymbol); \
     332        } while (0)
     333
     334
     335/**
    324336 * Macro for setting the range of a DBGC variable.
    325337 * @param   pVar            The variable.

  • trunk/include/VBox/err.h

    r41561 r41573  
    21132113/** Generic debugger command failure. */
    21142114#define VERR_DBGC_COMMAND_FAILED                    (-5407)
     2115/** Logic bug in the DBGC code.. */
     2116#define VERR_DBGC_IPE                               (-5408)
    21152117
    21162118/** The lowest parse status code.   */

  • trunk/src/VBox/Debugger/DBGCCmdHlp.cpp

    r41571 r41573  
    5050
    5151    return rc;
     52}
     53
     54
     55/**
     56 * Outputs a string in quotes.
     57 *
     58 * @returns The number of bytes formatted.
     59 * @param   pfnOutput       Pointer to output function.
     60 * @param   pvArgOutput     Argument for the output function.
     61 * @param   chQuote         The quote character.
     62 * @param   psz             The string to quote.
     63 * @param   cch             The string length.
     64 */
     65static size_t dbgcStringOutputInQuotes(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput, char chQuote, const char *psz, size_t cch)
     66{
     67    size_t cchOutput = pfnOutput(pvArgOutput, &chQuote, 1);
     68
     69    while (cch > 0)
     70    {
     71        char *pchQuote = (char *)memchr(psz, chQuote, cch);
     72        if (!pchQuote)
     73        {
     74            cchOutput += pfnOutput(pvArgOutput, psz, cch);
     75            break;
     76        }
     77        size_t cchSub = pchQuote - psz + 1;
     78        cchOutput += pfnOutput(pvArgOutput, psz, cchSub);
     79        cchOutput += pfnOutput(pvArgOutput, &chQuote, 1);
     80        cchSub -= cchSub;
     81        psz    += cchSub;
     82    }
     83
     84    cchOutput += pfnOutput(pvArgOutput, &chQuote, 1);
     85    return cchOutput;
    5286}
    5387
    … …  
    103137                case DBGCVAR_TYPE_HC_PHYS:
    104138                    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%%%%%RHp", pVar->u.HCPhys);
    105                 case DBGCVAR_TYPE_STRING:
    106                     return pfnOutput(pvArgOutput, pVar->u.pszString, (size_t)pVar->u64Range);
    107139                case DBGCVAR_TYPE_NUMBER:
    108140                    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%llx", pVar->u.u64Number);
     141                case DBGCVAR_TYPE_STRING:
     142                    return dbgcStringOutputInQuotes(pfnOutput, pvArgOutput, '"', pVar->u.pszString, (size_t)pVar->u64Range);
     143                case DBGCVAR_TYPE_SYMBOL:
     144                    return dbgcStringOutputInQuotes(pfnOutput, pvArgOutput, '\'', pVar->u.pszString, (size_t)pVar->u64Range);
    109145
    110146                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    149185                case DBGCVAR_TYPE_HC_PHYS:
    150186                    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%%%%%RHp%s", pVar->u.HCPhys, szRange);
    151                 case DBGCVAR_TYPE_STRING:
    152                     return pfnOutput(pvArgOutput, pVar->u.pszString, (size_t)pVar->u64Range);
    153187                case DBGCVAR_TYPE_NUMBER:
    154188                    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%llx%s", pVar->u.u64Number, szRange);
     189                case DBGCVAR_TYPE_STRING:
     190                    return dbgcStringOutputInQuotes(pfnOutput, pvArgOutput, '"', pVar->u.pszString, (size_t)pVar->u64Range);
     191                case DBGCVAR_TYPE_SYMBOL:
     192                    return dbgcStringOutputInQuotes(pfnOutput, pvArgOutput, '\'', pVar->u.pszString, (size_t)pVar->u64Range);
    155193
    156194                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    710748            return VINF_SUCCESS;
    711749
    712         case DBGCVAR_TYPE_STRING:
    713750        case DBGCVAR_TYPE_SYMBOL:
    714751        {
    … …  
    720757        }
    721758
     759        case DBGCVAR_TYPE_STRING:
    722760        case DBGCVAR_TYPE_HC_FLAT:
    723761        case DBGCVAR_TYPE_HC_PHYS:
    … …  
    793831            break;
    794832        case DBGCVAR_TYPE_SYMBOL:
     833            /** @todo try convert as symbol? */
    795834        case DBGCVAR_TYPE_STRING:
    796835            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
    … …  
    813852    switch (pVar->enmType)
    814853    {
     854        case DBGCVAR_TYPE_SYMBOL:
    815855        case DBGCVAR_TYPE_STRING:
    816             /** @todo add strcasecmp / stricmp wrappers to iprt/string.h. */
    817             if (    !strcmp(pVar->u.pszString, "true")
    818                 ||  !strcmp(pVar->u.pszString, "True")
    819                 ||  !strcmp(pVar->u.pszString, "TRUE")
    820                 ||  !strcmp(pVar->u.pszString, "on")
    821                 ||  !strcmp(pVar->u.pszString, "On")
    822                 ||  !strcmp(pVar->u.pszString, "oN")
    823                 ||  !strcmp(pVar->u.pszString, "ON")
    824                 ||  !strcmp(pVar->u.pszString, "enabled")
    825                 ||  !strcmp(pVar->u.pszString, "Enabled")
    826                 ||  !strcmp(pVar->u.pszString, "DISABLED"))
     856            if (    !RTStrICmp(pVar->u.pszString, "true")
     857                ||  !RTStrICmp(pVar->u.pszString, "on")
     858                ||  !RTStrICmp(pVar->u.pszString, "no")
     859                ||  !RTStrICmp(pVar->u.pszString, "enabled"))
    827860            {
    828861                *pf = true;
    829862                return VINF_SUCCESS;
    830863            }
    831             if (    !strcmp(pVar->u.pszString, "false")
    832                 ||  !strcmp(pVar->u.pszString, "False")
    833                 ||  !strcmp(pVar->u.pszString, "FALSE")
    834                 ||  !strcmp(pVar->u.pszString, "off")
    835                 ||  !strcmp(pVar->u.pszString, "Off")
    836                 ||  !strcmp(pVar->u.pszString, "OFF")
    837                 ||  !strcmp(pVar->u.pszString, "disabled")
    838                 ||  !strcmp(pVar->u.pszString, "Disabled")
    839                 ||  !strcmp(pVar->u.pszString, "DISABLED"))
     864            if (    !RTStrICmp(pVar->u.pszString, "false")
     865                ||  !RTStrICmp(pVar->u.pszString, "off")
     866                ||  !RTStrICmp(pVar->u.pszString, "yes")
     867                ||  !RTStrICmp(pVar->u.pszString, "disabled"))
    840868            {
    841869                *pf = false;
    … …  
    853881
    854882        case DBGCVAR_TYPE_GC_FAR:
    855         case DBGCVAR_TYPE_SYMBOL:
    856883        default:
    857884            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;

  • trunk/src/VBox/Debugger/DBGCCommands.cpp

    r41571 r41573  
    206206{
    207207    /* cTimesMin,   cTimesMax,  enmCategory,            fFlags,                         pszName,        pszDescription */
    208     {  1,           1,          DBGCVAR_CAT_STRING,     0,                              "var",          "Variable name." },
     208    {  1,           1,          DBGCVAR_CAT_SYMBOL,     0,                              "var",          "Variable name." },
    209209    {  1,           1,          DBGCVAR_CAT_ANY,        0,                              "value",        "Value to assign to the variable." },
    210210};
    211211
     212/** 'unset' arguments */
     213static const DBGCVARDESC    g_aArgUnset[] =
     214{
     215    /* cTimesMin,   cTimesMax,  enmCategory,            fFlags,                         pszName,        pszDescription */
     216    {  1,           ~0U,        DBGCVAR_CAT_SYMBOL,     0,                              "vars",         "One or more variable names." },
     217};
    212218
    213219/** writecore arguments. */
    … …  
    257263    { "stop",       0,        0,        NULL,                0,                            0, dbgcCmdStop,      "",                     "Stop execution." },
    258264    { "unloadplugin", 1,     ~0U,       &g_aArgPlugIn[0],    RT_ELEMENTS(g_aArgPlugIn),    0, dbgcCmdUnloadPlugIn, "<plugin1> [plugin2..N]", "Unloads one or more plugins." },
    259     { "unset",      1,       ~0U,       &g_aArgMultiStr[0],  RT_ELEMENTS(g_aArgMultiStr),  0, dbgcCmdUnset,     "<var1> [var1..[varN]]",  "Unsets (delete) one or more global variables." },
     265    { "unset",      1,       ~0U,       &g_aArgUnset[0],     RT_ELEMENTS(g_aArgUnset),     0, dbgcCmdUnset,     "<var1> [var1..[varN]]",  "Unsets (delete) one or more global variables." },
    260266    { "writecore",  1,        1,        &g_aArgWriteCore[0], RT_ELEMENTS(g_aArgWriteCore), 0, dbgcCmdWriteCore,   "<filename>",           "Write core to file." },
    261267};
    … …  
    476482    unsigned    i;
    477483
     484/** @todo rewrite this.  */
    478485    if (!cArgs)
    479486    {
    … …  
    548555        for (unsigned iArg = 0; iArg < cArgs; iArg++)
    549556        {
    550             Assert(paArgs[iArg].enmType == DBGCVAR_TYPE_STRING);
     557            AssertReturn(paArgs[iArg].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_BUG);
    551558            const char *pszPattern = paArgs[iArg].u.pszString;
    552559            bool        fFound     = false;
    … …  
    687694    for (unsigned i = 0; i < cArgs; i++)
    688695    {
    689         if (paArgs[i].enmType == DBGCVAR_TYPE_STRING)
    690             rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, i ? " %s" : "%s", paArgs[i].u.pszString);
    691         else
    692             rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, i ? " <parser error>" : "<parser error>");
     696        AssertReturn(paArgs[i].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_BUG);
     697        rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, i ? " %s" : "%s", paArgs[i].u.pszString);
    693698        if (RT_FAILURE(rc))
    694699            return rc;
    … …  
    14691474{
    14701475    PDBGC   pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
    1471 
    1472     /*
    1473      * Don't trust the parser.
    1474      */
    14751476    for (unsigned  i = 0; i < cArgs; i++)
    1476         if (paArgs[i].enmType != DBGCVAR_TYPE_STRING)
    1477         {
    1478             AssertMsgFailed(("expected strings only. (arg=%d)!\n", i));
    1479             return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    1480         }
     1477        AssertReturn(paArgs[i].enmType == DBGCVAR_TYPE_SYMBOL, VERR_DBGC_PARSE_BUG);
    14811478
    14821479    /*

  • trunk/src/VBox/Debugger/DBGCEval.cpp

    r41572 r41573  
    4646*   Internal Functions                                                         *
    4747*******************************************************************************/
     48static int dbgcCheckAndTypePromoteArgument(PDBGC pDbgc, DBGCVARCAT enmCategory, PDBGCVAR pArg);
    4849static int dbgcProcessArguments(PDBGC pDbgc, const char *pszCmdOrFunc,
    4950                                uint32_t const cArgsMin, uint32_t const cArgsMax,
    … …  
    166167    pArg->pDesc         = NULL;
    167168    pArg->pNext         = NULL;
    168     pArg->enmType       = chQuote == '\'' ? DBGCVAR_TYPE_SYMBOL : DBGCVAR_TYPE_STRING;
     169    pArg->enmType       = chQuote == '"' ? DBGCVAR_TYPE_STRING : DBGCVAR_TYPE_SYMBOL;
    169170    pArg->u.pszString   = pszCopy;
    170171    pArg->enmRangeType  = DBGCVAR_RANGE_BYTES;
    … …  
    486487            else
    487488                rc = dbgcEvalSubUnary(pDbgc, pszExpr2, cchExpr - (pszExpr2 - pszExpr), pOp->enmCatArg1, &Arg);
     489            if (RT_SUCCESS(rc))
     490                rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOp->enmCatArg1, &Arg);
    488491            if (RT_SUCCESS(rc))
    489492                rc = pOp->pfnHandlerUnary(pDbgc, &Arg, enmCategory, pResult);
    … …  
    751754
    752755    /*
    753      * Either we found an operator to divide the expression by
    754      * or we didn't find any. In the first case it's divide and
    755      * conquer. In the latter it's a single expression which
    756      * needs dealing with its unary operators if any.
     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.
    757760     */
    758761    int rc;
    … …  
    771774            rc = dbgcEvalSub(pDbgc, psz2, cchExpr - (psz2 - pszExpr), pOpSplit->enmCatArg2, &Arg2);
    772775            if (RT_SUCCESS(rc))
    773                 /* apply the operator. */
     776                rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOpSplit->enmCatArg1, &Arg1);
     777            if (RT_SUCCESS(rc))
     778                rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOpSplit->enmCatArg2, &Arg2);
     779            if (RT_SUCCESS(rc))
    774780                rc = pOpSplit->pfnHandlerBinary(pDbgc, &Arg1, &Arg2, pResult);
    775781        }
    … …  
    782788        rc = dbgcEvalSub(pDbgc, pszOpSplit, cchExpr - (pszOpSplit - pszExpr), pOpSplit->enmCatArg1, &Arg);
    783789        if (RT_SUCCESS(rc))
    784             /* apply the operator. */
     790            rc = dbgcCheckAndTypePromoteArgument(pDbgc, pOpSplit->enmCatArg1, &Arg);
     791        if (RT_SUCCESS(rc))
    785792            rc = pOpSplit->pfnHandlerUnary(pDbgc, &Arg, enmCategory, pResult);
    786793    }
    … …  
    13091316 * @param   cchCmd      Length of the command.
    13101317 * @param   fNoExecute  Indicates that no commands should actually be executed.
    1311  *
    1312  * @todo    Change pszCmd into argc/argv?
    13131318 */
    13141319int dbgcEvalCommand(PDBGC pDbgc, char *pszCmd, size_t cchCmd, bool fNoExecute)
    … …  
    13311336     */
    13321337    char *pszArgs = pszCmd;
    1333     while (RT_C_IS_ALNUM(*pszArgs))
     1338    while (RT_C_IS_ALNUM(*pszArgs) || *pszArgs == '_')
    13341339        pszArgs++;
    1335     if (*pszArgs && (!RT_C_IS_BLANK(*pszArgs) || pszArgs == pszCmd))
     1340    if (   (*pszArgs && !RT_C_IS_BLANK(*pszArgs))
     1341        || !RT_C_IS_ALPHA(*pszCmd))
    13361342    {
    13371343        DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Syntax error: Invalid command '%s'!\n", pszCmdInput);

  • trunk/src/VBox/Debugger/DBGCOps.cpp

    r41561 r41573  
    8181    do \
    8282    { \
     83        if ((pArg1)->enmType == DBGCVAR_TYPE_STRING) \
     84            return VERR_DBGC_PARSE_INVALID_OPERATION; \
     85        \
    8386        /* Get the 64-bit right side value. */ \
    8487        uint64_t u64Right; \
    … …  
    8992        { \
    9093            /* Apply it to the left hand side. */ \
    91             if (   (pArg1)->enmType == DBGCVAR_TYPE_SYMBOL \
    92                 || (pArg1)->enmType == DBGCVAR_TYPE_STRING) \
     94            if ((pArg1)->enmType == DBGCVAR_TYPE_SYMBOL) \
    9395            { \
    9496                rc = dbgcSymbolGet((pDbgc), (pArg1)->u.pszString, DBGCVAR_TYPE_ANY, (pResult)); \
    … …  
    165167    { {'#'},            1,       false,      3,              dbgcOpAddrHost,     NULL,                       DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Flat host address." },
    166168    { {'#','%','%'},    3,       false,      3,              dbgcOpAddrHostPhys, NULL,                       DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Physical host address." },
    167     { {'$'},            1,       false,      3,              dbgcOpVar,          NULL,                       DBGCVAR_CAT_STRING, DBGCVAR_CAT_ANY, "Reference a variable." },
    168     { {'@'},            1,       false,      3,              dbgcOpRegister,     NULL,                       DBGCVAR_CAT_STRING, DBGCVAR_CAT_ANY, "Reference a register." },
     169    { {'$'},            1,       false,      3,              dbgcOpVar,          NULL,                       DBGCVAR_CAT_SYMBOL, DBGCVAR_CAT_ANY, "Reference a variable." },
     170    { {'@'},            1,       false,      3,              dbgcOpRegister,     NULL,                       DBGCVAR_CAT_SYMBOL, DBGCVAR_CAT_ANY, "Reference a register." },
    169171    { {'*'},            1,       true,       10,             NULL,               dbgcOpMult,                 DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Multiplication." },
    170172    { {'/'},            1,       true,       11,             NULL,               dbgcOpDiv,                  DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Division." },
    … …  
    216218            *pu64Ret = Var.u.HCPhys;
    217219            break;
    218         case DBGCVAR_TYPE_STRING:
     220        case DBGCVAR_TYPE_NUMBER:
     221            *pu64Ret = Var.u.u64Number;
     222            break;
    219223        case DBGCVAR_TYPE_SYMBOL:
    220224        {
    … …  
    224228            /* fall thru */
    225229        }
    226         case DBGCVAR_TYPE_NUMBER:
    227             *pu64Ret = Var.u.u64Number;
    228             break;
     230        case DBGCVAR_TYPE_STRING:
    229231        default:
    230232            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    … …  
    269271            break;
    270272
    271         case DBGCVAR_TYPE_UNKNOWN:
    272273        case DBGCVAR_TYPE_STRING:
     274        case DBGCVAR_TYPE_SYMBOL:
    273275        default:
    274276            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    … …  
    303305            break;
    304306
    305         case DBGCVAR_TYPE_UNKNOWN:
    306307        case DBGCVAR_TYPE_STRING:
     308        case DBGCVAR_TYPE_SYMBOL:
    307309        default:
    308310            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    … …  
    348350            break;
    349351        case DBGCVAR_TYPE_STRING:
     352        case DBGCVAR_TYPE_SYMBOL:
    350353            pResult->u.u64Number    = !pResult->u64Range;
    351354            break;
    … …  
    396399            break;
    397400
    398         case DBGCVAR_TYPE_UNKNOWN:
    399401        case DBGCVAR_TYPE_STRING:
     402        case DBGCVAR_TYPE_SYMBOL:
    400403        default:
    401404            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    … …  
    419422{
    420423    LogFlow(("dbgcOpVar: %s\n", pArg->u.pszString));
    421 
    422     /*
    423      * Parse sanity.
    424      */
    425     if (pArg->enmType != DBGCVAR_TYPE_STRING)
    426         return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
     424    AssertReturn(pArg->enmType == DBGCVAR_TYPE_SYMBOL, VERR_DBGC_PARSE_BUG);
    427425
    428426    /*
    … …  
    456454{
    457455    LogFlow(("dbgcOpRegister: %s\n", pArg->u.pszString));
    458 
    459     /*
    460      * Parse sanity.
    461      */
    462     if (   pArg->enmType != DBGCVAR_TYPE_STRING
    463         && pArg->enmType != DBGCVAR_TYPE_SYMBOL)
    464         return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
     456    AssertReturn(pArg->enmType == DBGCVAR_TYPE_SYMBOL, VERR_DBGC_PARSE_BUG);
    465457
    466458    /*
    … …  
    616608    switch (pArg1->enmType)
    617609    {
    618         case DBGCVAR_TYPE_STRING:
     610        case DBGCVAR_TYPE_SYMBOL:
    619611            rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
    620612            if (RT_FAILURE(rc))
    … …  
    624616            *pResult = *pArg1;
    625617            break;
    626 
    627         case DBGCVAR_TYPE_GC_FLAT:
    628         case DBGCVAR_TYPE_GC_FAR:
    629         case DBGCVAR_TYPE_GC_PHYS:
    630         case DBGCVAR_TYPE_HC_FLAT:
    631         case DBGCVAR_TYPE_HC_PHYS:
    632         case DBGCVAR_TYPE_UNKNOWN:
    633618        default:
    634619            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    … …  
    654639            break;
    655640
    656         case DBGCVAR_TYPE_STRING:
     641        case DBGCVAR_TYPE_SYMBOL:
    657642        {
    658643            DBGCVAR Var;
    … …  
    665650        }
    666651
    667         case DBGCVAR_TYPE_GC_FAR:
    668         case DBGCVAR_TYPE_GC_PHYS:
    669         case DBGCVAR_TYPE_HC_PHYS:
    670         case DBGCVAR_TYPE_UNKNOWN:
    671652        default:
    672653            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    … …  
    750731     * An addition operation will return (when possible) the left side type in the
    751732     * expression. We make an omission for numbers, where we'll take the right side
    752      * type instead. An expression where only the left hand side is a string we'll
    753      * use the right hand type assuming that the string is a symbol.
     733     * type instead. An expression where only the left hand side is a symbol we'll
     734     * use the right hand type to try resolve it.
    754735     */
    755     if (    (pArg1->enmType == DBGCVAR_TYPE_NUMBER && pArg2->enmType != DBGCVAR_TYPE_STRING)
    756         ||  (pArg1->enmType == DBGCVAR_TYPE_STRING && pArg2->enmType != DBGCVAR_TYPE_STRING))
     736    if (   pArg1->enmType == DBGCVAR_TYPE_STRING
     737        || pArg2->enmType == DBGCVAR_TYPE_STRING)
     738        return VERR_DBGC_PARSE_INVALID_OPERATION; /** @todo string contactenation later. */
     739
     740    if (    (pArg1->enmType == DBGCVAR_TYPE_NUMBER && pArg2->enmType != DBGCVAR_TYPE_SYMBOL)
     741        ||  (pArg1->enmType == DBGCVAR_TYPE_SYMBOL && pArg2->enmType != DBGCVAR_TYPE_SYMBOL))
    757742    {
    758743        PCDBGCVAR pTmp = pArg2;
    … …  
    760745        pArg1 = pTmp;
    761746    }
     747
    762748    DBGCVAR     Sym1, Sym2;
    763     if (pArg1->enmType == DBGCVAR_TYPE_STRING)
     749    if (pArg1->enmType == DBGCVAR_TYPE_SYMBOL)
    764750    {
    765751        int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, &Sym1);
    … …  
    877863            {
    878864                case DBGCVAR_TYPE_SYMBOL:
    879                 case DBGCVAR_TYPE_STRING:
    880865                    rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
    881866                    if (RT_FAILURE(rc))
    … …  
    916901     * However, if the left hand side is a number and the right hand a pointer of
    917902     * some kind we'll convert the left hand side to the same type as the right hand.
    918      * Any strings will be attempted resolved as symbols.
     903     * Any symbols will be resolved, strings will be rejected.
    919904     */
    920905    DBGCVAR     Sym1, Sym2;
    921     if (    pArg2->enmType == DBGCVAR_TYPE_STRING
     906    if (    pArg2->enmType == DBGCVAR_TYPE_SYMBOL
    922907        &&  (   pArg1->enmType == DBGCVAR_TYPE_NUMBER
    923              || pArg1->enmType == DBGCVAR_TYPE_STRING))
     908             || pArg1->enmType == DBGCVAR_TYPE_SYMBOL))
    924909    {
    925910        int rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_ANY, &Sym2);
    … …  
    929914    }
    930915
    931     if (pArg1->enmType == DBGCVAR_TYPE_STRING)
     916    if (   pArg1->enmType == DBGCVAR_TYPE_STRING
     917        || pArg2->enmType == DBGCVAR_TYPE_STRING)
     918        return VERR_DBGC_PARSE_INVALID_OPERATION;
     919
     920    if (pArg1->enmType == DBGCVAR_TYPE_SYMBOL)
    932921    {
    933922        DBGCVARTYPE enmType;
    … …  
    946935                enmType = DBGCVAR_TYPE_GC_FLAT;
    947936                break;
    948 
    949             default:
    950             case DBGCVAR_TYPE_STRING:
    951                 AssertMsgFailed(("Can't happen\n"));
    952                 enmType = DBGCVAR_TYPE_STRING;
    953                 break;
     937            default: AssertFailedReturn(VERR_DBGC_IPE);
    954938        }
    955939        if (enmType != DBGCVAR_TYPE_STRING)
    … …  
    981965            case DBGCVAR_TYPE_NUMBER:
    982966                break;
    983             default:
    984             case DBGCVAR_TYPE_STRING:
    985                 AssertMsgFailed(("Can't happen\n"));
    986                 break;
     967            default: AssertFailedReturn(VERR_DBGC_IPE);
    987968        }
    988969        if (pOp)
    … …  
    994975        }
    995976    }
    996 
    997977
    998978    /*
    … …  
    11021082            {
    11031083                case DBGCVAR_TYPE_SYMBOL:
    1104                 case DBGCVAR_TYPE_STRING:
    11051084                    rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
    11061085                    if (RT_FAILURE(rc))
    … …  
    12681247    LogFlow(("dbgcOpRangeLength\n"));
    12691248
     1249    if (pArg1->enmType == DBGCVAR_TYPE_STRING)
     1250        return VERR_DBGC_PARSE_INVALID_OPERATION;
     1251
    12701252    /*
    1271      * Make result. Strings needs to be resolved into symbols.
     1253     * Make result. Symbols needs to be resolved.
    12721254     */
    1273     if (pArg1->enmType == DBGCVAR_TYPE_STRING)
     1255    if (pArg1->enmType == DBGCVAR_TYPE_SYMBOL)
    12741256    {
    12751257        int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, pResult);
    … …  
    12901272            break;
    12911273
    1292         case DBGCVAR_TYPE_STRING:
     1274        case DBGCVAR_TYPE_SYMBOL:
    12931275        {
    12941276            int rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
    … …  
    12991281        }
    13001282
     1283        case DBGCVAR_TYPE_STRING:
    13011284        default:
    13021285            return VERR_DBGC_PARSE_INVALID_OPERATION;
    … …  
    13761359        case DBGCVAR_TYPE_GC_FAR:
    13771360        case DBGCVAR_TYPE_STRING:
     1361        case DBGCVAR_TYPE_SYMBOL:
    13781362        default:
    13791363            AssertMsgFailed(("Impossible!\n"));

  • trunk/src/VBox/Debugger/DBGConsole.cpp

    r41572 r41573  
    243243        {
    244244            DBGCVAR Var;
    245             DBGCVAR_INIT_STRING(&Var, pszSymbol);
     245            DBGCVAR_INIT_SYMBOL(&Var, pszSymbol);
    246246            rc = dbgcOpRegister(pDbgc, &Var, DBGCVAR_CAT_ANY, pResult);
    247247            if (RT_SUCCESS(rc))
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette