VirtualBox

Changeset 41553 in vbox for trunk


Ignore:
Timestamp:
Jun 2, 2012 8:11:07 PM (13 years ago)
Author:
vboxsync
Message:

Debugger hacking: Moving status codes to VBox/err.h. Changing the mod operator from '%s' to 'mod' to avoid confusing it an the flat-address operator. Working on more parsers testcases.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/err.h

    r41299 r41553  
    20952095
    20962096
     2097/** @name DBGC Status Codes
     2098 *  @{ */
     2099/** Status that causes DBGC to quit. */
     2100#define VERR_DBGC_QUIT                              (-5400)
     2101/** Async command pending. */
     2102#define VWRN_DBGC_CMD_PENDING                       5401
     2103/** The command has already been registered. */
     2104#define VWRN_DBGC_ALREADY_REGISTERED                5402
     2105/** The command cannot be deregistered because has not been registered.  */
     2106#define VERR_DBGC_COMMANDS_NOT_REGISTERED           (-5403)
     2107/** Unknown breakpoint.  */
     2108#define VERR_DBGC_BP_NOT_FOUND                      (-5404)
     2109/** The breakpoint already exists. */
     2110#define VERR_DBGC_BP_EXISTS                         (-5405)
     2111/** The breakpoint has no command. */
     2112#define VINF_DBGC_BP_NO_COMMAND                     5406
     2113/** Generic debugger command failure. */
     2114#define VERR_DBGC_COMMAND_FAILED                    (-5407)
     2115
     2116/** The lowest parse status code.   */
     2117#define VERR_DBGC_PARSE_LOWEST                      (-5499)
     2118/** Syntax error - too few arguments. */
     2119#define VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS           (VERR_DBGC_PARSE_LOWEST + 0)
     2120/** Syntax error - too many arguments. */
     2121#define VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS          (VERR_DBGC_PARSE_LOWEST + 1)
     2122/** Syntax error - too many arguments for static storage. */
     2123#define VERR_DBGC_PARSE_ARGUMENT_OVERFLOW           (VERR_DBGC_PARSE_LOWEST + 2)
     2124/** Syntax error - argument didn't match description. */
     2125#define VERR_DBGC_PARSE_NO_ARGUMENT_MATCH           (VERR_DBGC_PARSE_LOWEST + 3)
     2126/** Syntax error - the argument does not allow a range to be specified. */
     2127#define VERR_DBGC_PARSE_NO_RANGE_ALLOWED            (VERR_DBGC_PARSE_LOWEST + 5)
     2128/** Syntax error - unbalanced quotes. */
     2129#define VERR_DBGC_PARSE_UNBALANCED_QUOTE            (VERR_DBGC_PARSE_LOWEST + 6)
     2130/** Syntax error - unbalanced parenthesis. */
     2131#define VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS      (VERR_DBGC_PARSE_LOWEST + 7)
     2132/** Syntax error - an argument or subargument contains nothing useful. */
     2133#define VERR_DBGC_PARSE_EMPTY_ARGUMENT              (VERR_DBGC_PARSE_LOWEST + 8)
     2134/** Syntax error - invalid operator usage. */
     2135#define VERR_DBGC_PARSE_UNEXPECTED_OPERATOR         (VERR_DBGC_PARSE_LOWEST + 9)
     2136/** Syntax error - invalid numeric value. */
     2137#define VERR_DBGC_PARSE_INVALID_NUMBER              (VERR_DBGC_PARSE_LOWEST + 10)
     2138/** Syntax error - numeric overflow. */
     2139#define VERR_DBGC_PARSE_NUMBER_TOO_BIG              (VERR_DBGC_PARSE_LOWEST + 11)
     2140/** Syntax error - invalid operation attempted. */
     2141#define VERR_DBGC_PARSE_INVALID_OPERATION           (VERR_DBGC_PARSE_LOWEST + 12)
     2142/** Syntax error - function not found. */
     2143#define VERR_DBGC_PARSE_FUNCTION_NOT_FOUND          (VERR_DBGC_PARSE_LOWEST + 13)
     2144/** Syntax error - the specified function is not a function. */
     2145#define VERR_DBGC_PARSE_NOT_A_FUNCTION              (VERR_DBGC_PARSE_LOWEST + 14)
     2146/** Syntax error - out of regular heap memory. */
     2147#define VERR_DBGC_PARSE_NO_MEMORY                   (VERR_DBGC_PARSE_LOWEST + 15)
     2148/** Syntax error - incorrect argument type. */
     2149#define VERR_DBGC_PARSE_INCORRECT_ARG_TYPE          (VERR_DBGC_PARSE_LOWEST + 16)
     2150/** Syntax error - an undefined variable was referenced. */
     2151#define VERR_DBGC_PARSE_VARIABLE_NOT_FOUND          (VERR_DBGC_PARSE_LOWEST + 17)
     2152/** Syntax error - a type conversion failed. */
     2153#define VERR_DBGC_PARSE_CONVERSION_FAILED           (VERR_DBGC_PARSE_LOWEST + 18)
     2154/** Syntax error - you hit a debugger feature which isn't implemented yet.
     2155 * (Feel free to help implement it.) */
     2156#define VERR_DBGC_PARSE_NOT_IMPLEMENTED             (VERR_DBGC_PARSE_LOWEST + 19)
     2157/** Syntax error - Couldn't staisfy a request for a sepcific result type. */
     2158#define VERR_DBGC_PARSE_BAD_RESULT_TYPE             (VERR_DBGC_PARSE_LOWEST + 20)
     2159/** Syntax error - Cannot read symbol value, it is a set-only symbol. */
     2160#define VERR_DBGC_PARSE_WRITEONLY_SYMBOL            (VERR_DBGC_PARSE_LOWEST + 21)
     2161/** Syntax error - Invalid command name. */
     2162#define VERR_DBGC_PARSE_INVALD_COMMAND_NAME         (VERR_DBGC_PARSE_LOWEST + 22)
     2163/** Syntax error - Command not found. */
     2164#define VERR_DBGC_PARSE_COMMAND_NOT_FOUND           (VERR_DBGC_PARSE_LOWEST + 23)
     2165
     2166/** Syntax error - Obsolete. */
     2167#define VERR_DBGC_PARSE_ARGUMENT_TYPE_MISMATCH      (VERR_DBGC_PARSE_LOWEST + 4)
     2168
     2169
     2170/** @} */
     2171
    20972172/** @name VBox Extension Pack Status Codes
    20982173 * @{

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

    r41546 r41553  
    383383
    384384            default:
    385                 rc = VERR_PARSE_INCORRECT_ARG_TYPE;
     385                rc = VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    386386        }
    387387
    … …  
    697697        case DBGCVAR_TYPE_HC_PHYS:
    698698        default:
    699             return VERR_PARSE_CONVERSION_FAILED;
     699            return VERR_DBGC_PARSE_CONVERSION_FAILED;
    700700    }
    701701}
    … …  
    768768        case DBGCVAR_TYPE_SYMBOL:
    769769        case DBGCVAR_TYPE_STRING:
    770             return VERR_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
     770            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
    771771        default:
    772             return VERR_PARSE_INCORRECT_ARG_TYPE;
     772            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    773773    }
    774774    *pu64Number = u64Number;
    … …  
    816816                return VINF_SUCCESS;
    817817            }
    818             return VERR_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
     818            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
    819819
    820820        case DBGCVAR_TYPE_GC_FLAT:
    … …  
    829829        case DBGCVAR_TYPE_SYMBOL:
    830830        default:
    831             return VERR_PARSE_INCORRECT_ARG_TYPE;
     831            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    832832    }
    833833}
    … …  
    882882
    883883                case DBGCVAR_TYPE_GC_FAR:
    884                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     884                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    885885
    886886                case DBGCVAR_TYPE_GC_PHYS:
    … …  
    891891                    if (RT_SUCCESS(rc))
    892892                        return VINF_SUCCESS;
    893                     return VERR_PARSE_CONVERSION_FAILED;
     893                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    894894
    895895                case DBGCVAR_TYPE_HC_FLAT:
    … …  
    901901                    if (RT_SUCCESS(rc))
    902902                        return VINF_SUCCESS;
    903                     return VERR_PARSE_CONVERSION_FAILED;
     903                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    904904
    905905                case DBGCVAR_TYPE_HC_PHYS:
    … …  
    910910                    if (RT_SUCCESS(rc))
    911911                        return VINF_SUCCESS;
    912                     return VERR_PARSE_CONVERSION_FAILED;
     912                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    913913
    914914                case DBGCVAR_TYPE_NUMBER:
    … …  
    919919                case DBGCVAR_TYPE_STRING:
    920920                case DBGCVAR_TYPE_SYMBOL:
    921                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     921                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    922922
    923923                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    938938                        return VINF_SUCCESS;
    939939                    }
    940                     return VERR_PARSE_CONVERSION_FAILED;
     940                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    941941
    942942                case DBGCVAR_TYPE_GC_FAR:
    … …  
    952952                            return VINF_SUCCESS;
    953953                    }
    954                     return VERR_PARSE_CONVERSION_FAILED;
     954                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    955955
    956956                case DBGCVAR_TYPE_HC_FLAT:
    … …  
    964964                            return VINF_SUCCESS;
    965965                    }
    966                     return VERR_PARSE_CONVERSION_FAILED;
     966                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    967967
    968968                case DBGCVAR_TYPE_HC_PHYS:
    … …  
    975975                            return VINF_SUCCESS;
    976976                    }
    977                     return VERR_PARSE_CONVERSION_FAILED;
     977                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    978978
    979979                case DBGCVAR_TYPE_NUMBER:
    … …  
    984984                case DBGCVAR_TYPE_STRING:
    985985                case DBGCVAR_TYPE_SYMBOL:
    986                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     986                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    987987
    988988                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    997997                case DBGCVAR_TYPE_GC_FLAT:
    998998                    //rc = MMR3PhysGCPhys2GCVirtEx(pDbgc->pVM, pResult->u.GCPhys, ..., &pResult->u.GCFlat); - yea, sure.
    999                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     999                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10001000
    10011001                case DBGCVAR_TYPE_GC_FAR:
    1002                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1002                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10031003
    10041004                case DBGCVAR_TYPE_GC_PHYS:
    … …  
    10131013                    if (RT_SUCCESS(rc))
    10141014                        return VINF_SUCCESS;
    1015                     return VERR_PARSE_CONVERSION_FAILED;
     1015                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    10161016
    10171017                case DBGCVAR_TYPE_HC_PHYS:
    … …  
    10221022                    if (RT_SUCCESS(rc))
    10231023                        return VINF_SUCCESS;
    1024                     return VERR_PARSE_CONVERSION_FAILED;
     1024                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    10251025
    10261026                case DBGCVAR_TYPE_NUMBER:
    … …  
    10311031                case DBGCVAR_TYPE_STRING:
    10321032                case DBGCVAR_TYPE_SYMBOL:
    1033                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1033                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10341034
    10351035                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    10431043            {
    10441044                case DBGCVAR_TYPE_GC_FLAT:
    1045                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1045                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10461046
    10471047                case DBGCVAR_TYPE_GC_FAR:
    1048                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1048                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10491049
    10501050                case DBGCVAR_TYPE_GC_PHYS:
    … …  
    10541054                        return VINF_SUCCESS;
    10551055                    /** @todo more memory types! */
    1056                     return VERR_PARSE_CONVERSION_FAILED;
     1056                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    10571057
    10581058                case DBGCVAR_TYPE_HC_FLAT:
    … …  
    10651065                        return VINF_SUCCESS;
    10661066                    /** @todo more memory types! */
    1067                     return VERR_PARSE_CONVERSION_FAILED;
     1067                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    10681068
    10691069                case DBGCVAR_TYPE_NUMBER:
    … …  
    10741074                case DBGCVAR_TYPE_STRING:
    10751075                case DBGCVAR_TYPE_SYMBOL:
    1076                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1076                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10771077
    10781078                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    10861086            {
    10871087                case DBGCVAR_TYPE_GC_FLAT:
    1088                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1088                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10891089
    10901090                case DBGCVAR_TYPE_GC_FAR:
    1091                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1091                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    10921092
    10931093                case DBGCVAR_TYPE_GC_PHYS:
    … …  
    10961096                    if (RT_SUCCESS(rc))
    10971097                        return VINF_SUCCESS;
    1098                     return VERR_PARSE_CONVERSION_FAILED;
     1098                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    10991099
    11001100                case DBGCVAR_TYPE_HC_FLAT:
    1101                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1101                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    11021102
    11031103                case DBGCVAR_TYPE_HC_PHYS:
    … …  
    11111111                case DBGCVAR_TYPE_STRING:
    11121112                case DBGCVAR_TYPE_SYMBOL:
    1113                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1113                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    11141114
    11151115                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    11281128
    11291129                case DBGCVAR_TYPE_GC_FAR:
    1130                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1130                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    11311131
    11321132                case DBGCVAR_TYPE_GC_PHYS:
    … …  
    11501150                case DBGCVAR_TYPE_STRING:
    11511151                case DBGCVAR_TYPE_SYMBOL:
    1152                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1152                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    11531153
    11541154                case DBGCVAR_TYPE_UNKNOWN:
    … …  
    11811181                        }
    11821182                    }
    1183                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1183                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    11841184
    11851185                case DBGCVAR_TYPE_STRING:

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

    r40282 r41553  
    906906     * Dump it.
    907907     */
    908     int rc = DBGFR3InfoEx(pVM, pDbgc->idCpu, 
    909                           paArgs[0].u.pszString, 
    910                           cArgs == 2 ? paArgs[1].u.pszString : NULL, 
     908    int rc = DBGFR3InfoEx(pVM, pDbgc->idCpu,
     909                          paArgs[0].u.pszString,
     910                          cArgs == 2 ? paArgs[1].u.pszString : NULL,
    911911                          DBGCCmdHlpGetDbgfOutputHlp(pCmdHlp));
    912912    if (RT_FAILURE(rc))
    … …  
    11251125                 &&  paArgs[0].enmType == DBGCVAR_TYPE_STRING
    11261126                 &&  DBGCVAR_ISPOINTER(paArgs[1].enmType),
    1127                  VERR_PARSE_INCORRECT_ARG_TYPE);
     1127                 VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    11281128
    11291129    const char     *pszFilename = paArgs[0].u.pszString;
    … …  
    11371137    if (cArgs >= 3)
    11381138    {
    1139         AssertReturn(paArgs[2].enmType == DBGCVAR_TYPE_STRING, VERR_PARSE_INCORRECT_ARG_TYPE);
     1139        AssertReturn(paArgs[2].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    11401140        pszModName = paArgs[2].u.pszString;
    11411141    }
    … …  
    11751175                 &&  paArgs[0].enmType == DBGCVAR_TYPE_STRING
    11761176                 &&  DBGCVAR_ISPOINTER(paArgs[1].enmType),
    1177                  VERR_PARSE_INCORRECT_ARG_TYPE);
     1177                 VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    11781178
    11791179    const char     *pszFilename = paArgs[0].u.pszString;
    … …  
    11871187    if (cArgs >= 3)
    11881188    {
    1189         AssertReturn(paArgs[2].enmType == DBGCVAR_TYPE_STRING, VERR_PARSE_INCORRECT_ARG_TYPE);
     1189        AssertReturn(paArgs[2].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    11901190        pszModName = paArgs[2].u.pszString;
    11911191    }
    … …  
    11941194    if (cArgs >= 4)
    11951195    {
    1196         AssertReturn(paArgs[3].enmType == DBGCVAR_TYPE_NUMBER, VERR_PARSE_INCORRECT_ARG_TYPE);
     1196        AssertReturn(paArgs[3].enmType == DBGCVAR_TYPE_NUMBER, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    11971197        uSubtrahend = paArgs[3].u.u64Number;
    11981198    }
    … …  
    12011201    if (cArgs >= 5)
    12021202    {
    1203         AssertReturn(paArgs[4].enmType == DBGCVAR_TYPE_NUMBER, VERR_PARSE_INCORRECT_ARG_TYPE);
     1203        AssertReturn(paArgs[4].enmType == DBGCVAR_TYPE_NUMBER, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    12041204        iModSeg = (RTDBGSEGIDX)paArgs[4].u.u64Number;
    12051205        if (    iModSeg != paArgs[4].u.u64Number
    … …  
    12431243                 &&  DBGCVAR_ISPOINTER(paArgs[1].enmType)
    12441244                 &&  paArgs[2].enmType == DBGCVAR_TYPE_NUMBER,
    1245                  VERR_PARSE_INCORRECT_ARG_TYPE);
     1245                 VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    12461246
    12471247    const char     *pszFilename = paArgs[0].u.pszString;
    … …  
    12601260    if (cArgs >= 4)
    12611261    {
    1262         AssertReturn(paArgs[3].enmType == DBGCVAR_TYPE_STRING, VERR_PARSE_INCORRECT_ARG_TYPE);
     1262        AssertReturn(paArgs[3].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
    12631263        pszModName = paArgs[3].u.pszString;
    12641264    }
    … …  
    12981298    {
    12991299        AssertMsgFailed(("Parse error, first argument required to be string!\n"));
    1300         return VERR_PARSE_INCORRECT_ARG_TYPE;
     1300        return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    13011301    }
    13021302    DBGCVAR     AddrVar;
    … …  
    13181318            {
    13191319                AssertMsgFailed(("Parse error, module argument required to be string!\n"));
    1320                 return VERR_PARSE_INCORRECT_ARG_TYPE;
     1320                return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    13211321            }
    13221322            pszModule = paArgs[iArg].u.pszString;
    … …  
    13271327                {
    13281328                    AssertMsgFailed(("Parse error, module argument required to be GC pointer!\n"));
    1329                     return VERR_PARSE_INCORRECT_ARG_TYPE;
     1329                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    13301330                }
    13311331                int rc = DBGCCmdHlpEval(pCmdHlp, &AddrVar, "%%(%Dv)", &paArgs[iArg]);
    … …  
    13391339                    {
    13401340                        AssertMsgFailed(("Parse error, module argument required to be an integer!\n"));
    1341                         return VERR_PARSE_INCORRECT_ARG_TYPE;
     1341                        return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    13421342                    }
    13431343                    cbModule = (unsigned)paArgs[iArg].u.u64Number;
    … …  
    13461346                    {
    13471347                        AssertMsgFailed(("Parse error, too many arguments!\n"));
    1348                         return VERR_PARSE_TOO_MANY_ARGUMENTS;
     1348                        return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    13491349                    }
    13501350                }
    … …  
    13831383    AssertMsg(paArgs[0].enmType == DBGCVAR_TYPE_STRING, ("expected string not %d as first arg!\n", paArgs[0].enmType));
    13841384    if (paArgs[0].enmType != DBGCVAR_TYPE_STRING)
    1385         return VERR_PARSE_INCORRECT_ARG_TYPE;
     1385        return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    13861386
    13871387
    … …  
    14211421            void *pv = RTMemRealloc(pDbgc->papVars[iVar], cbVar);
    14221422            if (!pv)
    1423                 return VERR_PARSE_NO_MEMORY;
     1423                return VERR_DBGC_PARSE_NO_MEMORY;
    14241424            PDBGCNAMEDVAR pVar = pDbgc->papVars[iVar] = (PDBGCNAMEDVAR)pv;
    14251425
    … …  
    14491449        {
    14501450            RTMemFree(pVar);
    1451             return VERR_PARSE_NO_MEMORY;
     1451            return VERR_DBGC_PARSE_NO_MEMORY;
    14521452        }
    14531453        pDbgc->papVars = (PDBGCNAMEDVAR *)pv;
    … …  
    14811481        {
    14821482            AssertMsgFailed(("expected strings only. (arg=%d)!\n", i));
    1483             return VERR_PARSE_INCORRECT_ARG_TYPE;
     1483            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    14841484        }
    14851485
    … …  
    15371537    {
    15381538        AssertMsgFailed(("Expected one string exactly!\n"));
    1539         return VERR_PARSE_INCORRECT_ARG_TYPE;
     1539        return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    15401540    }
    15411541
    … …  
    20892089    {
    20902090        AssertMsgFailed(("Expected one string exactly!\n"));
    2091         return VERR_PARSE_INCORRECT_ARG_TYPE;
     2091        return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    20922092    }
    20932093

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

    r41546 r41553  
    7575    {
    7676        if (pszExpr[--cchExpr] != ch)
    77             return VERR_PARSE_UNBALANCED_QUOTE;
     77            return VERR_DBGC_PARSE_UNBALANCED_QUOTE;
    7878        cchExpr--;
    7979        pszExpr++;
    … …  
    117117            u64 = u64 * uBase + u;
    118118        else
    119             return VERR_PARSE_INVALID_NUMBER;
     119            return VERR_DBGC_PARSE_INVALID_NUMBER;
    120120
    121121        /* check for overflow - ARG!!! How to detect overflow correctly!?!?!? */
    122122        if (u64Prev != u64 / uBase)
    123             return VERR_PARSE_NUMBER_TOO_BIG;
     123            return VERR_DBGC_PARSE_NUMBER_TOO_BIG;
    124124
    125125        /* next */
    … …  
    170170        case DBGCVAR_CAT_POINTER_NUMBER_NO_RANGE:
    171171            if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
    172                 return VERR_PARSE_NO_RANGE_ALLOWED;
     172                return VERR_DBGC_PARSE_NO_RANGE_ALLOWED;
    173173            /* fallthru */
    174174        case DBGCVAR_CAT_POINTER:
    … …  
    226226        case DBGCVAR_CAT_GC_POINTER_NO_RANGE:
    227227            if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
    228                 return VERR_PARSE_NO_RANGE_ALLOWED;
     228                return VERR_DBGC_PARSE_NO_RANGE_ALLOWED;
    229229            /* fallthru */
    230230        case DBGCVAR_CAT_GC_POINTER:
    … …  
    238238                case DBGCVAR_TYPE_HC_FLAT:
    239239                case DBGCVAR_TYPE_HC_PHYS:
    240                     return VERR_PARSE_CONVERSION_FAILED;
     240                    return VERR_DBGC_PARSE_CONVERSION_FAILED;
    241241
    242242                case DBGCVAR_TYPE_SYMBOL:
    … …  
    281281        case DBGCVAR_CAT_NUMBER_NO_RANGE:
    282282            if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
    283                 return VERR_PARSE_NO_RANGE_ALLOWED;
     283                return VERR_DBGC_PARSE_NO_RANGE_ALLOWED;
    284284            /* fallthru */
    285285        case DBGCVAR_CAT_NUMBER:
    … …  
    347347    }
    348348
    349     return VERR_PARSE_NO_ARGUMENT_MATCH;
     349    return VERR_DBGC_PARSE_NO_ARGUMENT_MATCH;
    350350}
    351351
    … …  
    372372     */
    373373    if (cVars < cVarsMin)
    374         return VERR_PARSE_TOO_FEW_ARGUMENTS;
     374        return VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS;
    375375    if (cVars > cVarsMax)
    376         return VERR_PARSE_TOO_MANY_ARGUMENTS;
     376        return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    377377
    378378    /*
    … …  
    387387        /* walk the descriptors */
    388388        if (iVarDesc >= cVarDescs)
    389             return VERR_PARSE_TOO_MANY_ARGUMENTS;
     389            return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    390390        if (    (    paVarDescs[iVarDesc].fFlags & DBGCVD_FLAGS_DEP_PREV
    391391                &&  &paVarDescs[iVarDesc - 1] != pPrevDesc)
    … …  
    394394            iVarDesc++;
    395395            if (iVarDesc >= cVarDescs)
    396                 return VERR_PARSE_TOO_MANY_ARGUMENTS;
     396                return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    397397            cCurDesc = 0;
    398398        }
    … …  
    414414            /* can we advance? */
    415415            if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
    416                 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
     416                return VERR_DBGC_PARSE_ARGUMENT_TYPE_MISMATCH;
    417417            if (++iVarDesc >= cVarDescs)
    418                 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
     418                return VERR_DBGC_PARSE_ARGUMENT_TYPE_MISMATCH;
    419419            cCurDesc = 0;
    420420        }
    … …  
    430430    {
    431431        if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
    432             return VERR_PARSE_TOO_FEW_ARGUMENTS;
     432            return VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS;
    433433        cCurDesc = 0;
    434434
    … …  
    470470        /* binary operators means syntax error. */
    471471        if (pOp->fBinary)
    472             return VERR_PARSE_UNEXPECTED_OPERATOR;
     472            return VERR_DBGC_PARSE_UNEXPECTED_OPERATOR;
    473473
    474474        /*
    … …  
    482482
    483483        if (!*pszExpr2)
    484             rc = VERR_PARSE_EMPTY_ARGUMENT;
     484            rc = VERR_DBGC_PARSE_EMPTY_ARGUMENT;
    485485        else
    486486        {
    … …  
    527527            PCDBGCCMD pFun = dbgcRoutineLookup(pDbgc, pszExpr, pszFunEnd - pszExpr, fExternal);
    528528            if (!pFun)
    529                 return VERR_PARSE_FUNCTION_NOT_FOUND;
     529                return VERR_DBGC_PARSE_FUNCTION_NOT_FOUND;
    530530#if 0
    531531            if (!pFun->pResultDesc)
    532                 return VERR_PARSE_NOT_A_FUNCTION;
     532                return VERR_DBGC_PARSE_NOT_A_FUNCTION;
    533533
    534534            /*
    … …  
    546546                    rc = pFun->pfnHandler(pFun, &pDbgc->CmdHlp, pDbgc->pVM, &Arg, 1, pResult);
    547547            }
    548             else if (rc == VERR_PARSE_EMPTY_ARGUMENT && pFun->cArgsMin == 0)
     548            else if (rc == VERR_DBGC_PARSE_EMPTY_ARGUMENT && pFun->cArgsMin == 0)
    549549                rc = pFun->pfnHandler(pFun, &pDbgc->CmdHlp, pDbgc->pVM, NULL, 0, pResult);
    550550#else
    … …  
    622622        pszExpr++, cchExpr--;
    623623    if (!*pszExpr)
    624         return VERR_PARSE_EMPTY_ARGUMENT;
     624        return VERR_DBGC_PARSE_EMPTY_ARGUMENT;
    625625
    626626    /* it there is any kind of quoting in the expression, it's string meat. */
    … …  
    645645                {
    646646                    if (cPar <= 0)
    647                         return VERR_PARSE_UNBALANCED_PARENTHESIS;
     647                        return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
    648648                    cPar--;
    649649                    if (cPar == 0 && psz[1]) /* If not at end, there's nothing to do. */
    … …  
    667667                pszExpr++, cchExpr--;
    668668            if (!*pszExpr)
    669                 return VERR_PARSE_EMPTY_ARGUMENT;
     669                return VERR_DBGC_PARSE_EMPTY_ARGUMENT;
    670670        } while (pszExpr[0] == '(' && pszExpr[cchExpr - 1] == ')');
    671671    }
    … …  
    705705        {
    706706            if (cPar <= 0)
    707                 return VERR_PARSE_UNBALANCED_PARENTHESIS;
     707                return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
    708708            cPar--;
    709709            fBinary = true;
    … …  
    721721                /* If not the right kind of operator we've got a syntax error. */
    722722                if (pOp->fBinary != fBinary)
    723                     return VERR_PARSE_UNEXPECTED_OPERATOR;
     723                    return VERR_DBGC_PARSE_UNEXPECTED_OPERATOR;
    724724
    725725                /*
    … …  
    828828        if (!pCmd->cArgsMin)
    829829            return VINF_SUCCESS;
    830         return VERR_PARSE_TOO_FEW_ARGUMENTS;
     830        return VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS;
    831831    }
    832832    /** @todo fixme - foo() doesn't work. */
    833833    if (!pCmd->cArgsMax)
    834         return VERR_PARSE_TOO_MANY_ARGUMENTS;
     834        return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    835835
    836836    /*
    … …  
    868868         */
    869869        if (*pcArgs >= pCmd->cArgsMax)
    870             return VERR_PARSE_TOO_MANY_ARGUMENTS;
     870            return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    871871        if (pArg >= &paArgs[cArgs])
    872             return VERR_PARSE_ARGUMENT_OVERFLOW;
     872            return VERR_DBGC_PARSE_ARGUMENT_OVERFLOW;
    873873#ifdef DEBUG_bird /* work in progress. */
    874874        if (iVarDesc >= cVarDescs)
    875             return VERR_PARSE_TOO_MANY_ARGUMENTS;
     875            return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    876876
    877877        /* Walk argument descriptors. */
    … …  
    882882            iVarDesc++;
    883883            if (iVarDesc >= cVarDescs)
    884                 return VERR_PARSE_TOO_MANY_ARGUMENTS;
     884                return VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS;
    885885            cCurDesc = 0;
    886886        }
    … …  
    904904            {
    905905                if (chQuote)
    906                     return VERR_PARSE_UNBALANCED_QUOTE;
     906                    return VERR_DBGC_PARSE_UNBALANCED_QUOTE;
    907907                if (cPar)
    908                     return VERR_PARSE_UNBALANCED_PARENTHESIS;
     908                    return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
    909909                pszEnd = psz;
    910910                break;
    … …  
    941941            {
    942942                if (!cPar)
    943                     return VERR_PARSE_UNBALANCED_PARENTHESIS;
     943                    return VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS;
    944944                cPar--;
    945945                fBinary = true;
    … …  
    10231023            /* can we advance? */
    10241024            if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
    1025                 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
     1025                return rc;
    10261026            if (++iVarDesc >= cVarDescs)
    1027                 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
     1027                return rc;
    10281028            cCurDesc = 0;
    10291029        }
    … …  
    10921092    {
    10931093        DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Syntax error: Invalid command '%s'!\n", pszCmdInput);
    1094         return pDbgc->rcCmd = VINF_PARSE_INVALD_COMMAND_NAME;
     1094        return pDbgc->rcCmd = VERR_DBGC_PARSE_INVALD_COMMAND_NAME;
    10951095    }
    10961096
    … …  
    11021102    {
    11031103        DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Syntax error: Unknown command '%s'!\n", pszCmdInput);
    1104         return pDbgc->rcCmd = VINF_PARSE_COMMAND_NOT_FOUND;
     1104        return pDbgc->rcCmd = VERR_DBGC_PARSE_COMMAND_NOT_FOUND;
    11051105    }
    11061106
    … …  
    11311131        switch (rc)
    11321132        {
    1133             case VERR_PARSE_TOO_FEW_ARGUMENTS:
     1133            case VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS:
    11341134                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11351135                    "Syntax error: Too few arguments. Minimum is %d for command '%s'.\n", pCmd->cArgsMin, pCmd->pszCmd);
    11361136                break;
    1137             case VERR_PARSE_TOO_MANY_ARGUMENTS:
     1137            case VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS:
    11381138                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11391139                    "Syntax error: Too many arguments. Maximum is %d for command '%s'.\n", pCmd->cArgsMax, pCmd->pszCmd);
    11401140                break;
    1141             case VERR_PARSE_ARGUMENT_OVERFLOW:
     1141            case VERR_DBGC_PARSE_ARGUMENT_OVERFLOW:
    11421142                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11431143                    "Syntax error: Too many arguments.\n");
    11441144                break;
    1145             case VERR_PARSE_UNBALANCED_QUOTE:
     1145            case VERR_DBGC_PARSE_UNBALANCED_QUOTE:
    11461146                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11471147                    "Syntax error: Unbalanced quote (argument %d).\n", cArgs);
    11481148                break;
    1149             case VERR_PARSE_UNBALANCED_PARENTHESIS:
     1149            case VERR_DBGC_PARSE_UNBALANCED_PARENTHESIS:
    11501150                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11511151                    "Syntax error: Unbalanced parenthesis (argument %d).\n", cArgs);
    11521152                break;
    1153             case VERR_PARSE_EMPTY_ARGUMENT:
     1153            case VERR_DBGC_PARSE_EMPTY_ARGUMENT:
    11541154                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11551155                    "Syntax error: An argument or subargument contains nothing useful (argument %d).\n", cArgs);
    11561156                break;
    1157             case VERR_PARSE_UNEXPECTED_OPERATOR:
     1157            case VERR_DBGC_PARSE_UNEXPECTED_OPERATOR:
    11581158                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11591159                    "Syntax error: Invalid operator usage (argument %d).\n", cArgs);
    11601160                break;
    1161             case VERR_PARSE_INVALID_NUMBER:
    1162                 rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    1163                     "Syntax error: Ivalid numeric value (argument %d). If a string was the intention, then quote it.\n", cArgs);
    1164                 break;
    1165             case VERR_PARSE_NUMBER_TOO_BIG:
     1161            case VERR_DBGC_PARSE_INVALID_NUMBER:
     1162                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
     1163                    "Syntax error: Invalid numeric value (argument %d). If a string was the intention, then quote it.\n", cArgs);
     1164                break;
     1165            case VERR_DBGC_PARSE_NUMBER_TOO_BIG:
    11661166                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11671167                    "Error: Numeric overflow (argument %d).\n", cArgs);
    11681168                break;
    1169             case VERR_PARSE_INVALID_OPERATION:
     1169            case VERR_DBGC_PARSE_INVALID_OPERATION:
    11701170                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11711171                    "Error: Invalid operation attempted (argument %d).\n", cArgs);
    11721172                break;
    1173             case VERR_PARSE_FUNCTION_NOT_FOUND:
     1173            case VERR_DBGC_PARSE_FUNCTION_NOT_FOUND:
    11741174                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11751175                    "Error: Function not found (argument %d).\n", cArgs);
    11761176                break;
    1177             case VERR_PARSE_NOT_A_FUNCTION:
     1177            case VERR_DBGC_PARSE_NOT_A_FUNCTION:
    11781178                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11791179                    "Error: The function specified is not a function (argument %d).\n", cArgs);
    11801180                break;
    1181             case VERR_PARSE_NO_MEMORY:
     1181            case VERR_DBGC_PARSE_NO_MEMORY:
    11821182                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11831183                    "Error: Out memory in the regular heap! Expect odd stuff to happen...\n", cArgs);
    11841184                break;
    1185             case VERR_PARSE_INCORRECT_ARG_TYPE:
     1185            case VERR_DBGC_PARSE_INCORRECT_ARG_TYPE:
    11861186                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11871187                    "Error: Incorrect argument type (argument %d?).\n", cArgs);
    11881188                break;
    1189             case VERR_PARSE_VARIABLE_NOT_FOUND:
     1189            case VERR_DBGC_PARSE_VARIABLE_NOT_FOUND:
    11901190                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11911191                    "Error: An undefined variable was referenced (argument %d).\n", cArgs);
    11921192                break;
    1193             case VERR_PARSE_CONVERSION_FAILED:
     1193            case VERR_DBGC_PARSE_CONVERSION_FAILED:
    11941194                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11951195                    "Error: A conversion between two types failed (argument %d).\n", cArgs);
    11961196                break;
    1197             case VERR_PARSE_NOT_IMPLEMENTED:
     1197            case VERR_DBGC_PARSE_NOT_IMPLEMENTED:
    11981198                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    11991199                    "Error: You hit a debugger feature which isn't implemented yet (argument %d).\n", cArgs);
    12001200                break;
    1201             case VERR_PARSE_BAD_RESULT_TYPE:
     1201            case VERR_DBGC_PARSE_BAD_RESULT_TYPE:
    12021202                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    12031203                    "Error: Couldn't satisfy a request for a specific result type (argument %d). (Usually applies to symbols)\n", cArgs);
    12041204                break;
    1205             case VERR_PARSE_WRITEONLY_SYMBOL:
     1205            case VERR_DBGC_PARSE_WRITEONLY_SYMBOL:
    12061206                rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp,
    12071207                    "Error: Cannot get symbol, it's set only (argument %d).\n", cArgs);
    … …  
    12121212
    12131213            default:
    1214                 rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Error: Unknown error %Rrc (%d)!\n", rc, rc);
    1215                 break;
     1214            {
     1215                PCRTSTATUSMSG pErr = RTErrGet(rc);
     1216                if (strncmp(pErr->pszDefine, RT_STR_TUPLE("Unknown Status")))
     1217                    rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Error: %s (%d) - %s\n", pErr->pszDefine, rc, pErr->pszMsgFull);
     1218                else
     1219                    rc = DBGCCmdHlpPrintf(&pDbgc->CmdHlp, "Error: Unknown error %d (%#x)!\n", rc, rc);
     1220                break;
     1221            }
    12161222        }
    12171223    }

  • trunk/src/VBox/Debugger/DBGCInternal.h

    r41546 r41553  
    2525*******************************************************************************/
    2626#include <VBox/dbg.h>
    27 
    28 
    29 /*******************************************************************************
    30 *   Defined Constants And Macros                                               *
    31 *******************************************************************************/
    32 /* to err.h! */
    33 #define VERR_DBGC_QUIT                          (-11999)
    34 #define VERR_PARSE_FIRST                        (-11000)
    35 #define VERR_PARSE_TOO_FEW_ARGUMENTS            (VERR_PARSE_FIRST - 0)
    36 #define VERR_PARSE_TOO_MANY_ARGUMENTS           (VERR_PARSE_FIRST - 1)
    37 #define VERR_PARSE_ARGUMENT_OVERFLOW            (VERR_PARSE_FIRST - 2)
    38 #define VERR_PARSE_ARGUMENT_TYPE_MISMATCH       (VERR_PARSE_FIRST - 3)
    39 #define VERR_PARSE_NO_RANGE_ALLOWED             (VERR_PARSE_FIRST - 4)
    40 #define VERR_PARSE_UNBALANCED_QUOTE             (VERR_PARSE_FIRST - 5)
    41 #define VERR_PARSE_UNBALANCED_PARENTHESIS       (VERR_PARSE_FIRST - 6)
    42 #define VERR_PARSE_EMPTY_ARGUMENT               (VERR_PARSE_FIRST - 7)
    43 #define VERR_PARSE_UNEXPECTED_OPERATOR          (VERR_PARSE_FIRST - 8)
    44 #define VERR_PARSE_INVALID_NUMBER               (VERR_PARSE_FIRST - 9)
    45 #define VERR_PARSE_NUMBER_TOO_BIG               (VERR_PARSE_FIRST - 10)
    46 #define VERR_PARSE_INVALID_OPERATION            (VERR_PARSE_FIRST - 11)
    47 #define VERR_PARSE_FUNCTION_NOT_FOUND           (VERR_PARSE_FIRST - 12)
    48 #define VERR_PARSE_NOT_A_FUNCTION               (VERR_PARSE_FIRST - 13)
    49 #define VERR_PARSE_NO_MEMORY                    (VERR_PARSE_FIRST - 14)
    50 #define VERR_PARSE_INCORRECT_ARG_TYPE           (VERR_PARSE_FIRST - 15)
    51 #define VERR_PARSE_VARIABLE_NOT_FOUND           (VERR_PARSE_FIRST - 16)
    52 #define VERR_PARSE_CONVERSION_FAILED            (VERR_PARSE_FIRST - 17)
    53 #define VERR_PARSE_NOT_IMPLEMENTED              (VERR_PARSE_FIRST - 18)
    54 #define VERR_PARSE_BAD_RESULT_TYPE              (VERR_PARSE_FIRST - 19)
    55 #define VERR_PARSE_WRITEONLY_SYMBOL             (VERR_PARSE_FIRST - 20)
    56 #define VERR_PARSE_NO_ARGUMENT_MATCH            (VERR_PARSE_FIRST - 21)
    57 #define VINF_PARSE_COMMAND_NOT_FOUND            (VERR_PARSE_FIRST - 22)
    58 #define VINF_PARSE_INVALD_COMMAND_NAME          (VERR_PARSE_FIRST - 23)
    59 #define VERR_PARSE_LAST                         (VERR_PARSE_FIRST - 30)
    60 
    61 #define VWRN_DBGC_CMD_PENDING                   12000
    62 #define VWRN_DBGC_ALREADY_REGISTERED            12001
    63 #define VERR_DBGC_COMMANDS_NOT_REGISTERED       (-12002)
    64 #define VERR_DBGC_BP_NOT_FOUND                  (-12003)
    65 #define VERR_DBGC_BP_EXISTS                     (-12004)
    66 #define VINF_DBGC_BP_NO_COMMAND                 12005
    67 #define VERR_DBGC_COMMAND_FAILED                (-12006)
     27#include <VBox/err.h>
    6828
    6929

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

    r41546 r41553  
    119119                    break; \
    120120                default: \
    121                     return VERR_PARSE_INCORRECT_ARG_TYPE; \
     121                    return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE; \
    122122            } \
    123123        } \
    … …  
    169169    { {'*'},            1,       true,       10,             NULL,               dbgcOpMult,                 DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Multiplication." },
    170170    { {'/'},            1,       true,       11,             NULL,               dbgcOpDiv,                  DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Division." },
    171     { {'%'},            1,       true,       12,             NULL,               dbgcOpMod,                  DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Modulus." },
     171    { {'m','o','d'},    3,       true,       12,             NULL,               dbgcOpMod,                  DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Modulus." },
    172172    { {'+'},            1,       true,       13,             NULL,               dbgcOpAdd,                  DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Addition." },
    173173    { {'-'},            1,       true,       14,             NULL,               dbgcOpSub,                  DBGCVAR_CAT_ANY,    DBGCVAR_CAT_ANY, "Subtraction." },
    … …  
    228228            break;
    229229        default:
    230             return VERR_PARSE_INCORRECT_ARG_TYPE;
     230            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    231231    }
    232232    return VINF_SUCCESS;
    … …  
    272272        case DBGCVAR_TYPE_STRING:
    273273        default:
    274             return VERR_PARSE_INCORRECT_ARG_TYPE;
     274            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    275275    }
    276276    NOREF(pDbgc);
    … …  
    306306        case DBGCVAR_TYPE_STRING:
    307307        default:
    308             return VERR_PARSE_INCORRECT_ARG_TYPE;
     308            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    309309    }
    310310    NOREF(pDbgc);
    … …  
    353353        case DBGCVAR_TYPE_UNKNOWN:
    354354        default:
    355             return VERR_PARSE_INCORRECT_ARG_TYPE;
     355            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    356356    }
    357357    pResult->enmType = DBGCVAR_TYPE_NUMBER;
    … …  
    399399        case DBGCVAR_TYPE_STRING:
    400400        default:
    401             return VERR_PARSE_INCORRECT_ARG_TYPE;
     401            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    402402    }
    403403    NOREF(pDbgc);
    … …  
    424424     */
    425425    if (pArg->enmType != DBGCVAR_TYPE_STRING)
    426         return VERR_PARSE_INCORRECT_ARG_TYPE;
     426        return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    427427
    428428    /*
    … …  
    439439    }
    440440
    441     return VERR_PARSE_VARIABLE_NOT_FOUND;
     441    return VERR_DBGC_PARSE_VARIABLE_NOT_FOUND;
    442442}
    443443
    … …  
    462462    if (   pArg->enmType != DBGCVAR_TYPE_STRING
    463463        && pArg->enmType != DBGCVAR_TYPE_SYMBOL)
    464         return VERR_PARSE_INCORRECT_ARG_TYPE;
     464        return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    465465
    466466    /*
    … …  
    632632        case DBGCVAR_TYPE_UNKNOWN:
    633633        default:
    634             return VERR_PARSE_INCORRECT_ARG_TYPE;
     634            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    635635    }
    636636    pResult->u.GCFar.sel = (RTSEL)pResult->u.u64Number;
    … …  
    670670        case DBGCVAR_TYPE_UNKNOWN:
    671671        default:
    672             return VERR_PARSE_INCORRECT_ARG_TYPE;
     672            return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
    673673    }
    674674    return VINF_SUCCESS;
    … …  
    787787                case DBGCVAR_TYPE_HC_FLAT:
    788788                case DBGCVAR_TYPE_HC_PHYS:
    789                     return VERR_PARSE_INVALID_OPERATION;
     789                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    790790                default:
    791791                    *pResult = *pArg1;
    … …  
    806806                case DBGCVAR_TYPE_HC_FLAT:
    807807                case DBGCVAR_TYPE_HC_PHYS:
    808                     return VERR_PARSE_INVALID_OPERATION;
     808                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    809809                case DBGCVAR_TYPE_NUMBER:
    810810                    *pResult = *pArg1;
    … …  
    831831                case DBGCVAR_TYPE_HC_FLAT:
    832832                case DBGCVAR_TYPE_HC_PHYS:
    833                     return VERR_PARSE_INVALID_OPERATION;
     833                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    834834                default:
    835835                    *pResult = *pArg1;
    … …  
    838838                        return rc;
    839839                    if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
    840                         return VERR_PARSE_INVALID_OPERATION;
     840                        return VERR_DBGC_PARSE_INVALID_OPERATION;
    841841                    pResult->u.GCPhys += Var.u.GCPhys;
    842842                    break;
    … …  
    885885                    break;
    886886                default:
    887                     return VERR_PARSE_INVALID_OPERATION;
     887                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    888888            }
    889889            break;
    890890
    891891        default:
    892             return VERR_PARSE_INVALID_OPERATION;
     892            return VERR_DBGC_PARSE_INVALID_OPERATION;
    893893
    894894    }
    … …  
    10121012                case DBGCVAR_TYPE_HC_FLAT:
    10131013                case DBGCVAR_TYPE_HC_PHYS:
    1014                     return VERR_PARSE_INVALID_OPERATION;
     1014                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    10151015                default:
    10161016                    *pResult = *pArg1;
    … …  
    10311031                case DBGCVAR_TYPE_HC_FLAT:
    10321032                case DBGCVAR_TYPE_HC_PHYS:
    1033                     return VERR_PARSE_INVALID_OPERATION;
     1033                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    10341034                case DBGCVAR_TYPE_NUMBER:
    10351035                    *pResult = *pArg1;
    … …  
    10561056                case DBGCVAR_TYPE_HC_FLAT:
    10571057                case DBGCVAR_TYPE_HC_PHYS:
    1058                     return VERR_PARSE_INVALID_OPERATION;
     1058                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    10591059                default:
    10601060                    *pResult = *pArg1;
    … …  
    10631063                        return rc;
    10641064                    if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
    1065                         return VERR_PARSE_INVALID_OPERATION;
     1065                        return VERR_DBGC_PARSE_INVALID_OPERATION;
    10661066                    pResult->u.GCPhys -= Var.u.GCPhys;
    10671067                    break;
    … …  
    11101110                    break;
    11111111                default:
    1112                     return VERR_PARSE_INVALID_OPERATION;
     1112                    return VERR_DBGC_PARSE_INVALID_OPERATION;
    11131113            }
    11141114            break;
    11151115
    11161116        default:
    1117             return VERR_PARSE_INVALID_OPERATION;
     1117            return VERR_DBGC_PARSE_INVALID_OPERATION;
    11181118
    11191119    }
    … …  
    13001300
    13011301        default:
    1302             return VERR_PARSE_INVALID_OPERATION;
     1302            return VERR_DBGC_PARSE_INVALID_OPERATION;
    13031303    }
    13041304
    … …  
    13781378        default:
    13791379            AssertMsgFailed(("Impossible!\n"));
    1380             return VERR_PARSE_INVALID_OPERATION;
     1380            return VERR_DBGC_PARSE_INVALID_OPERATION;
    13811381    }
    13821382

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

    r41546 r41553  
    174174    {
    175175        if (!pSymDesc->pfnGet)
    176             return VERR_PARSE_WRITEONLY_SYMBOL;
     176            return VERR_DBGC_PARSE_WRITEONLY_SYMBOL;
    177177        return pSymDesc->pfnGet(pSymDesc, &pDbgc->CmdHlp, enmType, pResult);
    178178    }
    … …  
    250250            /* impossible at the moment. */
    251251            case DBGCVAR_TYPE_GC_FAR:
    252                 return VERR_PARSE_CONVERSION_FAILED;
     252                return VERR_DBGC_PARSE_CONVERSION_FAILED;
    253253
    254254            /* simply make it numeric. */
    … …  
    270270    }
    271271
    272     return VERR_PARSE_NOT_IMPLEMENTED;
     272    return VERR_DBGC_PARSE_NOT_IMPLEMENTED;
    273273}
    274274

  • trunk/src/VBox/Debugger/testcase/tstDBGCParser.cpp

    r39091 r41553  
    2424#include <iprt/string.h>
    2525#include <iprt/test.h>
     26#include <VBox/err.h>
    2627
    2728
    … …  
    175176
    176177/**
     178 * Checks if two DBGC variables are identical
     179 *
     180 * @returns
     181 * @param   pVar1               .
     182 * @param   pVar2               .
     183 */
     184bool DBGCVarAreIdentical(PCDBGCVAR pVar1, PCDBGCVAR pVar2)
     185{
     186    if (!pVar1)
     187        return false;
     188    if (pVar1 == pVar2)
     189        return true;
     190
     191    if (pVar1->enmType != pVar2->enmType)
     192        return false;
     193    switch (pVar1->enmType)
     194    {
     195        case DBGCVAR_TYPE_GC_FLAT:
     196            if (pVar1->u.GCFlat != pVar2->u.GCFlat)
     197                return false;
     198            break;
     199        case DBGCVAR_TYPE_GC_FAR:
     200            if (pVar1->u.GCFar.off != pVar2->u.GCFar.off)
     201                return false;
     202            if (pVar1->u.GCFar.sel != pVar2->u.GCFar.sel)
     203                return false;
     204            break;
     205        case DBGCVAR_TYPE_GC_PHYS:
     206            if (pVar1->u.GCPhys != pVar2->u.GCPhys)
     207                return false;
     208            break;
     209        case DBGCVAR_TYPE_HC_FLAT:
     210            if (pVar1->u.pvHCFlat != pVar2->u.pvHCFlat)
     211                return false;
     212            break;
     213        case DBGCVAR_TYPE_HC_PHYS:
     214            if (pVar1->u.HCPhys != pVar2->u.HCPhys)
     215                return false;
     216            break;
     217        case DBGCVAR_TYPE_NUMBER:
     218            if (pVar1->u.u64Number != pVar2->u.u64Number)
     219                return false;
     220            break;
     221        case DBGCVAR_TYPE_STRING:
     222        case DBGCVAR_TYPE_SYMBOL:
     223            if (RTStrCmp(pVar1->u.pszString, pVar2->u.pszString) != 0)
     224                return false;
     225            break;
     226        default:
     227            AssertFailedReturn(false);
     228    }
     229
     230    if (pVar1->enmRangeType != pVar2->enmRangeType)
     231        return false;
     232    switch (pVar1->enmRangeType)
     233    {
     234        case DBGCVAR_RANGE_NONE:
     235            break;
     236
     237        case DBGCVAR_RANGE_ELEMENTS:
     238        case DBGCVAR_RANGE_BYTES:
     239            if (pVar1->u64Range != pVar2->u64Range)
     240                return false;
     241            break;
     242        default:
     243            AssertFailedReturn(false);
     244    }
     245
     246    return true;
     247}
     248
     249/**
    177250 * Tries one command string.
    178251 * @param   pDbgc           Pointer to the debugger instance.
    … …  
    183256 *                          of the output, just the start of it.  Thus the
    184257 *                          prompt can be omitted.
    185  */
    186 static void tstTryEx(PDBGC pDbgc, const char *pszCmds, int rcCmd, bool fNoExecute, const char *pszExpected)
     258 * @param   cArgs           The number of expected arguments. -1 if we don't
     259 *                          want to check the parsed arguments.
     260 * @param   va              Info about expected parsed arguments. For each
     261 *                          argument a DBGCVARTYPE, value (depends on type),
     262 *                          DBGCVARRANGETYPE and optionally range value.
     263 */
     264static void tstTryExV(PDBGC pDbgc, const char *pszCmds, int rcCmd, bool fNoExecute, const char *pszExpected,
     265                      int32_t cArgs, va_list va)
    187266{
    188267    RT_ZERO(g_szOutput);
    … …  
    204283             && strncmp(pszExpected, g_szOutput, strlen(pszExpected)))
    205284        RTTestFailed(g_hTest, "Wrong output - expected \"%s\"", pszExpected);
    206 }
    207 
    208 
    209 /**
    210  * Tries one command string without executing it.
     285
     286    if (cArgs >= 0)
     287    {
     288        PCDBGCVAR paArgs = pDbgc->aArgs;
     289        for (int32_t iArg = 0; iArg < cArgs; iArg++)
     290        {
     291            DBGCVAR ExpectedArg;
     292            ExpectedArg.enmType = (DBGCVARTYPE)va_arg(va, int/*DBGCVARTYPE*/);
     293            switch (ExpectedArg.enmType)
     294            {
     295                case DBGCVAR_TYPE_GC_FLAT:  ExpectedArg.u.GCFlat    = va_arg(va, RTGCPTR); break;
     296                case DBGCVAR_TYPE_GC_FAR:   ExpectedArg.u.GCFar.sel = va_arg(va, int /*RTSEL*/);
     297                                            ExpectedArg.u.GCFar.off = va_arg(va, uint32_t); break;
     298                case DBGCVAR_TYPE_GC_PHYS:  ExpectedArg.u.GCPhys    = va_arg(va, RTGCPHYS); break;
     299                case DBGCVAR_TYPE_HC_FLAT:  ExpectedArg.u.pvHCFlat  = va_arg(va, void *); break;
     300                case DBGCVAR_TYPE_HC_PHYS:  ExpectedArg.u.HCPhys    = va_arg(va, RTHCPHYS); break;
     301                case DBGCVAR_TYPE_NUMBER:   ExpectedArg.u.u64Number = va_arg(va, uint64_t); break;
     302                case DBGCVAR_TYPE_STRING:   ExpectedArg.u.pszString = va_arg(va, const char *); break;
     303                case DBGCVAR_TYPE_SYMBOL:   ExpectedArg.u.pszString = va_arg(va, const char *); break;
     304                default:
     305                    RTTestFailed(g_hTest, "enmType=%u iArg=%u\n", ExpectedArg.enmType, iArg);
     306                    ExpectedArg.u.u64Number = 0;
     307                    break;
     308            }
     309            ExpectedArg.enmRangeType = (DBGCVARRANGETYPE)va_arg(va, int /*DBGCVARRANGETYPE*/);
     310            switch (ExpectedArg.enmRangeType)
     311            {
     312                case DBGCVAR_RANGE_NONE:        ExpectedArg.u64Range = 0; break;
     313                case DBGCVAR_RANGE_ELEMENTS:    ExpectedArg.u64Range = va_arg(va, uint64_t); break;
     314                case DBGCVAR_RANGE_BYTES:       ExpectedArg.u64Range = va_arg(va, uint64_t); break;
     315                    default:
     316                        RTTestFailed(g_hTest, "enmRangeType=%u iArg=%u\n", ExpectedArg.enmRangeType, iArg);
     317                        ExpectedArg.u64Range = 0;
     318                        break;
     319            }
     320
     321            if (!DBGCVarAreIdentical(&ExpectedArg, &paArgs[iArg]))
     322                RTTestFailed(g_hTest,
     323                             "Arg #%u\n"
     324                             "actual:   enmType=%u u64=%#RX64 enmRangeType=%u u64Range=%#RX64\n"
     325                             "expected: enmType=%u u64=%#RX64 enmRangeType=%u u64Range=%#RX64\n",
     326                             iArg,
     327                             paArgs[iArg].enmType, paArgs[iArg].u.u64Number, paArgs[iArg].enmRangeType, paArgs[iArg].u64Range,
     328                             ExpectedArg.enmType, ExpectedArg.u.u64Number, ExpectedArg.enmRangeType, ExpectedArg.u64Range);
     329        }
     330    }
     331}
     332
     333/**
     334 * Tries one command string.
    211335 *
    212336 * @param   pDbgc           Pointer to the debugger instance.
    213337 * @param   pszCmds         The command to test.
    214338 * @param   rcCmd           The expected result.
     339 * @param   fNoExecute      When set, the command is not executed.
     340 * @param   pszExpected     Expected output.  This does not need to include all
     341 *                          of the output, just the start of it.  Thus the
     342 *                          prompt can be omitted.
     343 * @param   cArgs           The number of expected arguments. -1 if we don't
     344 *                          want to check the parsed arguments.
     345 * @param   ...             Info about expected parsed arguments. For each
     346 *                          argument a DBGCVARTYPE, value (depends on type),
     347 *                          DBGCVARRANGETYPE and optionally range value.
     348 */
     349static void tstTryEx(PDBGC pDbgc, const char *pszCmds, int rcCmd, bool fNoExecute, const char *pszExpected, int32_t cArgs, ...)
     350{
     351    va_list va;
     352    va_start(va, cArgs);
     353    tstTryExV(pDbgc, pszCmds, rcCmd, fNoExecute, pszExpected, cArgs, va);
     354    va_end(va);
     355}
     356
     357
     358/**
     359 * Tries one command string without executing it.
     360 *
     361 * @param   pDbgc           Pointer to the debugger instance.
     362 * @param   pszCmds         The command to test.
     363 * @param   rcCmd           The expected result.
    215364 */
    216365static void tstTry(PDBGC pDbgc, const char *pszCmds, int rcCmd)
    217366{
    218     return tstTryEx(pDbgc, pszCmds, rcCmd, true /*fNoExecute*/, NULL);
     367    return tstTryEx(pDbgc, pszCmds, rcCmd, true /*fNoExecute*/, NULL, -1);
    219368}
    220369
    … …  
    232381static void tstTryExec(PDBGC pDbgc, const char *pszCmds, int rcCmd, const char *pszExpected)
    233382{
    234     return tstTryEx(pDbgc, pszCmds, rcCmd, false /*fNoExecute*/, pszExpected);
     383    return tstTryEx(pDbgc, pszCmds, rcCmd, false /*fNoExecute*/, pszExpected, -1);
    235384}
    236385#endif
    … …  
    253402                "Number: hex %llx  dec 0i%lld  oct 0t%llo", u64Expect, u64Expect, u64Expect);
    254403
    255     return tstTryEx(pDbgc, szCmd, VINF_SUCCESS, false /*fNoExecute*/, szExpected);
    256 }
    257 
     404    return tstTryEx(pDbgc, szCmd, VINF_SUCCESS, false /*fNoExecute*/, szExpected, -1);
     405}
     406
     407
     408
     409static void testCodeView_ba(PDBGC pDbgc)
     410{
     411    RTTestISub("codeview - ba");
     412    tstTry(pDbgc, "ba x 1 0f000:0000\n", VINF_SUCCESS);
     413    tstTry(pDbgc, "ba x 1 0f000:0000 0\n", VINF_SUCCESS);
     414    tstTry(pDbgc, "ba x 1 0f000:0000 0 ~0\n", VINF_SUCCESS);
     415    tstTry(pDbgc, "ba x 1 0f000:0000 0 ~0 \"command\"\n", VINF_SUCCESS);
     416    tstTry(pDbgc, "ba x 1 0f000:0000 0 ~0 \"command\" too_many\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
     417    tstTry(pDbgc, "ba x 1\n", VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS);
     418
     419    tstTryEx(pDbgc, "ba x 1 0f000:1234 5 1000 \"command\"\n", VINF_SUCCESS,
     420             true /*fNoExecute*/,  NULL /*pszExpected*/, 6 /*cArgs*/,
     421             DBGCVAR_TYPE_STRING, "x",                          DBGCVAR_RANGE_BYTES, UINT64_C(1),
     422             DBGCVAR_TYPE_NUMBER, UINT64_C(1),                  DBGCVAR_RANGE_NONE,
     423             DBGCVAR_TYPE_GC_FAR, 0xf000, UINT32_C(0x1234),     DBGCVAR_RANGE_NONE,
     424             DBGCVAR_TYPE_NUMBER, UINT64_C(0x5),                DBGCVAR_RANGE_NONE,
     425             DBGCVAR_TYPE_NUMBER, UINT64_C(0x1000),             DBGCVAR_RANGE_NONE,
     426             DBGCVAR_TYPE_STRING, "command",                    DBGCVAR_RANGE_BYTES, UINT64_C(7));
     427
     428    tstTryEx(pDbgc, "ba x 1 %0f000:1234 5 1000 \"command\"\n", VINF_SUCCESS,
     429             true /*fNoExecute*/,  NULL /*pszExpected*/, 6 /*cArgs*/,
     430             DBGCVAR_TYPE_STRING, "x",                          DBGCVAR_RANGE_BYTES, UINT64_C(1),
     431             DBGCVAR_TYPE_NUMBER, UINT64_C(1),                  DBGCVAR_RANGE_NONE,
     432             DBGCVAR_TYPE_GC_FLAT, UINT64_C(0xf1234),           DBGCVAR_RANGE_NONE,
     433             DBGCVAR_TYPE_NUMBER, UINT64_C(0x5),                DBGCVAR_RANGE_NONE,
     434             DBGCVAR_TYPE_NUMBER, UINT64_C(0x1000),             DBGCVAR_RANGE_NONE,
     435             DBGCVAR_TYPE_STRING, "command",                    DBGCVAR_RANGE_BYTES, UINT64_C(7));
     436
     437    tstTry(pDbgc, "ba x 1 bad:bad 5 1000 \"command\"\n", VINF_SUCCESS);
     438    tstTry(pDbgc, "ba x 1 %bad:bad 5 1000 \"command\"\n", VERR_DBGC_PARSE_CONVERSION_FAILED);
     439
     440    tstTryEx(pDbgc, "ba f 1 0f000:1234 5 1000 \"command\"\n", VINF_SUCCESS,
     441             true /*fNoExecute*/,  NULL /*pszExpected*/, 6 /*cArgs*/,
     442             DBGCVAR_TYPE_STRING, "f",                          DBGCVAR_RANGE_BYTES, UINT64_C(1),
     443             DBGCVAR_TYPE_NUMBER, UINT64_C(1),                  DBGCVAR_RANGE_NONE,
     444             DBGCVAR_TYPE_GC_FAR, 0xf000, UINT32_C(0x1234),     DBGCVAR_RANGE_NONE,
     445             DBGCVAR_TYPE_NUMBER, UINT64_C(0x5),                DBGCVAR_RANGE_NONE,
     446             DBGCVAR_TYPE_NUMBER, UINT64_C(0x1000),             DBGCVAR_RANGE_NONE,
     447             DBGCVAR_TYPE_STRING, "command",                    DBGCVAR_RANGE_BYTES, UINT64_C(7));
     448
     449    tstTry(pDbgc, "ba x 1 0f000:1234 qnx 1000 \"command\"\n",   VERR_DBGC_PARSE_ARGUMENT_TYPE_MISMATCH);
     450    tstTry(pDbgc, "ba x 1 0f000:1234 5 qnx \"command\"\n",      VERR_DBGC_PARSE_ARGUMENT_TYPE_MISMATCH);
     451    tstTry(pDbgc, "ba x qnx 0f000:1234 5 1000 \"command\"\n",   VERR_DBGC_PARSE_ARGUMENT_TYPE_MISMATCH);
     452    tstTry(pDbgc, "ba x 1 qnx 5 1000 \"command\"\n",            VERR_DBGC_PARSE_ARGUMENT_TYPE_MISMATCH);
     453}
    258454
    259455
    … …  
    276472    if (RT_SUCCESS(rc))
    277473    {
     474        pDbgc->pVM = (PVM)pDbgc;
    278475        rc = dbgcProcessInput(pDbgc, true /* fNoExecute */);
    279476        tstCompleteOutput();
    … …  
    283480            tstTry(pDbgc, "stop\n", VINF_SUCCESS);
    284481            tstTry(pDbgc, "format 1\n", VINF_SUCCESS);
    285             tstTry(pDbgc, "format \n", VERR_PARSE_TOO_FEW_ARGUMENTS);
    286             tstTry(pDbgc, "format 0 1 23 4\n", VERR_PARSE_TOO_MANY_ARGUMENTS);
     482            tstTry(pDbgc, "format \n", VERR_DBGC_PARSE_TOO_FEW_ARGUMENTS);
     483            tstTry(pDbgc, "format 0 1 23 4\n", VERR_DBGC_PARSE_TOO_MANY_ARGUMENTS);
    287484            tstTry(pDbgc, "sa 3 23 4 'q' \"21123123\" 'b' \n", VINF_SUCCESS);
    288485
    … …  
    328525                tstNumOp(pDbgc, "0i1024 / 0i4",                             256);
    329526
     527                tstNumOp(pDbgc, "8 mod 7",                                  1);
     528
    330529                tstNumOp(pDbgc, "1<<1",                                     2);
    331530                tstNumOp(pDbgc, "1<<0i32",                                  UINT64_C(0x0000000100000000));
    … …  
    371570                tstTry(pDbgc, "r @eax\n", VINF_SUCCESS);
    372571                tstTry(pDbgc, "r @ah\n", VINF_SUCCESS);
     572                tstTry(pDbgc, "r @notavalidregister\n", VERR_DBGF_REGISTER_NOT_FOUND);
    373573            }
     574
     575            /*
     576             * Test codeview commands.
     577             */
     578#ifdef DEBUG_bird /* This will fail for a while */
     579            if (RTTestErrorCount(g_hTest) == 0)
     580            {
     581                testCodeView_ba(pDbgc);
     582
     583            }
     584#endif
    374585        }
    375586

  • trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp

    r41546 r41553  
    3030VMMR3DECL(int) DBGFR3AddrFromSelOff(PVM pVM, VMCPUID idCpu, PDBGFADDRESS pAddress, RTSEL Sel, RTUINTPTR off)
    3131{
    32     return VERR_INTERNAL_ERROR;
     32    /* bad:bad -> provke error during parsing. */
     33    if (Sel == 0xbad && off == 0xbad)
     34        return VERR_OUT_OF_SELECTOR_BOUNDS;
     35
     36    /* real mode conversion. */
     37    pAddress->FlatPtr = (uint32_t)(Sel << 4) | off;
     38    pAddress->fFlags |= DBGFADDRESS_FLAGS_FLAT;
     39    pAddress->Sel     = DBGF_SEL_FLAT;
     40    pAddress->off     = pAddress->FlatPtr;
     41    return VINF_SUCCESS;
    3342}
    3443
    … …  
    197206VMMR3DECL(int) DBGFR3RegNmValidate(PVM pVM, VMCPUID idDefCpu, const char *pszReg)
    198207{
    199     return VINF_SUCCESS;
     208    if (   !strcmp(pszReg, "ah")
     209        || !strcmp(pszReg, "ax")
     210        || !strcmp(pszReg, "eax")
     211        || !strcmp(pszReg, "rax"))
     212        return VINF_SUCCESS;
     213    return VERR_DBGF_REGISTER_NOT_FOUND;
    200214}
    201215VMMR3DECL(int) DBGFR3RegCpuQueryU8(  PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint8_t     *pu8)
    … …  
    244258        }
    245259    }
    246     return VERR_INTERNAL_ERROR;
     260    return VERR_DBGF_REGISTER_NOT_FOUND;
    247261}
    248262VMMR3DECL(int) DBGFR3RegPrintf(PVM pVM, VMCPUID idCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, ...)
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