VirtualBox

Changeset 95140 in vbox


Ignore:
Timestamp:
May 31, 2022 9:11:39 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
151631
Message:

Frontends + Main: Adjust to the new rules wrt. to rc -> hrc,vrc usage. This also fixes quite a few bugs wrt shadow variables, wrong return values and output error translations / exit codes. Also see @todos added. ​​bugref:10223

Location:
trunk
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/com/errorprint.h

    r93115 r95140  
    114114#define CHECK_ERROR(iface, method) \
    115115    do { \
    116         rc = iface->method; \
    117         if (FAILED(rc) || SUCCEEDED_WARNING(rc)) \
    118             com::GlueHandleComError(iface, #method, rc, __FILE__, __LINE__); \
     116        hrc = iface->method; \
     117        if (FAILED(hrc) || SUCCEEDED_WARNING(hrc)) \
     118            com::GlueHandleComError(iface, #method, hrc, __FILE__, __LINE__); \
    119119    } while (0)
    120120/**
    … …  
    146146#define CHECK_ERROR_STMT(iface, method, stmt) \
    147147    do { \
    148         rc = iface->method; \
    149         if (FAILED(rc) || SUCCEEDED_WARNING(rc)) \
    150         { \
    151             com::GlueHandleComError(iface, #method, rc, __FILE__, __LINE__); \
    152             if (!SUCCEEDED_WARNING(rc) \
     148        hrc = iface->method; \
     149        if (FAILED(hrc) || SUCCEEDED_WARNING(hrc)) \
     150        { \
     151            com::GlueHandleComError(iface, #method, hrc, __FILE__, __LINE__); \
     152            if (!SUCCEEDED_WARNING(hrc) \
    153153            { \
    154154                stmt; \
    … …  
    188188    __extension__ \
    189189    ({ \
    190         rc = iface->method; \
    191         if (FAILED(rc) || SUCCEEDED_WARNING(rc)) \
    192         { \
    193             com::GlueHandleComError(iface, #method, rc, __FILE__, __LINE__); \
    194             if (!SUCCEEDED_WARNING(rc)) \
     190        hrc = iface->method; \
     191        if (FAILED(hrc) || SUCCEEDED_WARNING(hrc)) \
     192        { \
     193            com::GlueHandleComError(iface, #method, hrc, __FILE__, __LINE__); \
     194            if (!SUCCEEDED_WARNING(hrc)) \
    195195                break; \
    196196        } \
    … …  
    200200    if (1) \
    201201    { \
    202         rc = iface->method; \
    203         if (FAILED(rc)) \
    204         { \
    205             com::GlueHandleComError(iface, #method, rc, __FILE__, __LINE__); \
    206             if (!SUCCEEDED_WARNING(rc)) \
     202        hrc = iface->method; \
     203        if (FAILED(hrc)) \
     204        { \
     205            com::GlueHandleComError(iface, #method, hrc, __FILE__, __LINE__); \
     206            if (!SUCCEEDED_WARNING(hrc)) \
    207207                break; \
    208208        } \
    … …  
    250250#define CHECK_ERROR_RET(iface, method, ret) \
    251251    do { \
    252         rc = iface->method; \
    253         if (FAILED(rc) || SUCCEEDED_WARNING(rc)) \
    254         { \
    255             com::GlueHandleComError(iface, #method, rc, __FILE__, __LINE__); \
    256             if (!SUCCEEDED_WARNING(rc)) \
     252        hrc = iface->method; \
     253        if (FAILED(hrc) || SUCCEEDED_WARNING(hrc)) \
     254        { \
     255            com::GlueHandleComError(iface, #method, hrc, __FILE__, __LINE__); \
     256            if (!SUCCEEDED_WARNING(hrc)) \
    257257                return (ret); \
    258258        } \
    … …  
    289289    do { \
    290290        LONG iRc; \
    291         rc = progress->COMGETTER(ResultCode)(&iRc); \
    292         if (FAILED(rc) || FAILED(iRc)) \
    293         { \
    294             if (SUCCEEDED(rc)) rc = iRc; else iRc = rc; \
     291        hrc = progress->COMGETTER(ResultCode)(&iRc); \
     292        if (FAILED(hrc) || FAILED(iRc)) \
     293        { \
     294            if (SUCCEEDED(hrc)) hrc = iRc; else iRc = hrc; \
    295295            RTMsgError msg; \
    296296            com::GlueHandleComErrorProgress(progress, __PRETTY_FUNCTION__, iRc, __FILE__, __LINE__); \
    … …  
    308308    ({ \
    309309        LONG iRc; \
    310         rc = progress->COMGETTER(ResultCode)(&iRc); \
    311         if (FAILED(rc) || FAILED(iRc)) \
    312         { \
    313             if (SUCCEEDED(rc)) rc = iRc; else iRc = rc; \
     310        hrc = progress->COMGETTER(ResultCode)(&iRc); \
     311        if (FAILED(hrc) || FAILED(iRc)) \
     312        { \
     313            if (SUCCEEDED(hrc)) hrc = iRc; else iRc = hrc; \
    314314            RTMsgError msg; \
    315315            com::GlueHandleComErrorProgress(progress, __PRETTY_FUNCTION__, iRc, __FILE__, __LINE__); \
    … …  
    322322    { \
    323323        LONG iRc; \
    324         rc = progress->COMGETTER(ResultCode)(&iRc); \
    325         if (FAILED(rc) || FAILED(iRc)) \
    326         { \
    327             if (SUCCEEDED(rc)) rc = iRc; else iRc = rc; \
     324        hrc = progress->COMGETTER(ResultCode)(&iRc); \
     325        if (FAILED(hrc) || FAILED(iRc)) \
     326        { \
     327            if (SUCCEEDED(hrc)) hrc = iRc; else iRc = hrc; \
    328328            RTMsgError msg; \
    329329            com::GlueHandleComErrorProgress(progress, __PRETTY_FUNCTION__, iRc, __FILE__, __LINE__); \

  • trunk/src/VBox/Frontends/Common/PasswordInput.cpp

    r93648 r95140  
    9494    if (rcExit == RTEXITCODE_SUCCESS)
    9595    {
    96         int rc;
     96        HRESULT hrc;
    9797        CHECK_ERROR(virtualBox, SetSettingsSecret(com::Bstr(passwd).raw()));
    98         if (FAILED(rc))
     98        if (FAILED(hrc))
    9999            rcExit = RTEXITCODE_FAILURE;
    100100    }

  • trunk/src/VBox/Frontends/VBoxAutostart/VBoxAutostartStart.cpp

    r95139 r95140  
    8787     */
    8888    com::SafeIfaceArray<IMachine> machines;
    89     HRESULT rc = g_pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
    90     if (SUCCEEDED(rc))
     89    HRESULT hrc = g_pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
     90    if (SUCCEEDED(hrc))
    9191    {
    9292        /*
    … …  
    131131         * just to add this log, hence a bit of duplicate logic here.
    132132         */
    133         if (SUCCEEDED(rc))
     133        if (SUCCEEDED(hrc))
    134134        {
    135135            if (machines.size() == 0)
    … …  
    142142        }
    143143        else
    144             autostartSvcLogError("Enumerating virtual machines failed with %Rhrc\n", rc);
    145 
    146         if (   SUCCEEDED(rc)
     144            autostartSvcLogError("Enumerating virtual machines failed with %Rhrc\n", hrc);
     145
     146        if (   SUCCEEDED(hrc)
    147147            && !listVM.empty())
    148148        {
    … …  
    173173                CHECK_ERROR_BREAK(machine, LaunchVMProcess(g_pSession, Bstr("headless").raw(),
    174174                                                           ComSafeArrayNullInParam(), progress.asOutParam()));
    175                 if (SUCCEEDED(rc) && !progress.isNull())
     175                if (SUCCEEDED(hrc) && !progress.isNull())
    176176                {
    177177                    autostartSvcLogVerbose(1, "Waiting for machine '%ls' to power on ...\n", strName.raw());
    178178                    CHECK_ERROR(progress, WaitForCompletion(-1));
    179                     if (SUCCEEDED(rc))
     179                    if (SUCCEEDED(hrc))
    180180                    {
    181181                        BOOL completed = true;
    182182                        CHECK_ERROR(progress, COMGETTER(Completed)(&completed));
    183                         if (SUCCEEDED(rc))
     183                        if (SUCCEEDED(hrc))
    184184                        {
    185185                            ASSERT(completed);
    … …  
    187187                            LONG iRc;
    188188                            CHECK_ERROR(progress, COMGETTER(ResultCode)(&iRc));
    189                             if (SUCCEEDED(rc))
     189                            if (SUCCEEDED(hrc))
    190190                            {
    191191                                if (FAILED(iRc))
    … …  
    202202                SessionState_T enmSessionState;
    203203                CHECK_ERROR(g_pSession, COMGETTER(State)(&enmSessionState));
    204                 if (SUCCEEDED(rc) && enmSessionState == SessionState_Locked)
     204                if (SUCCEEDED(hrc) && enmSessionState == SessionState_Locked)
    205205                    g_pSession->UnlockMachine();
    206206            }

  • trunk/src/VBox/Frontends/VBoxAutostart/VBoxAutostartStop.cpp

    r95139 r95140  
    4949static HRESULT autostartSaveVMState(ComPtr<IConsole> &console)
    5050{
    51     HRESULT rc = S_OK;
     51    HRESULT hrc = S_OK;
    5252    ComPtr<IMachine> machine;
    5353    ComPtr<IProgress> progress;
    … …  
    5757        /* first pause so we don't trigger a live save which needs more time/resources */
    5858        bool fPaused = false;
    59         rc = console->Pause();
    60         if (FAILED(rc))
     59        hrc = console->Pause();
     60        if (FAILED(hrc))
    6161        {
    6262            bool fError = true;
    63             if (rc == VBOX_E_INVALID_VM_STATE)
     63            if (hrc == VBOX_E_INVALID_VM_STATE)
    6464            {
    6565                /* check if we are already paused */
    … …  
    6767                CHECK_ERROR_BREAK(console, COMGETTER(State)(&machineState));
    6868                /* the error code was lost by the previous instruction */
    69                 rc = VBOX_E_INVALID_VM_STATE;
     69                hrc = VBOX_E_INVALID_VM_STATE;
    7070                if (machineState != MachineState_Paused)
    7171                {
    … …  
    8585        CHECK_ERROR(console, COMGETTER(Machine)(machine.asOutParam()));
    8686        CHECK_ERROR(machine, SaveState(progress.asOutParam()));
    87         if (FAILED(rc))
     87        if (FAILED(hrc))
    8888        {
    8989            if (!fPaused)
    … …  
    9292        }
    9393
    94         rc = showProgress(progress);
     94        hrc = showProgress(progress);
    9595        CHECK_PROGRESS_ERROR(progress, ("Failed to save machine state"));
    96         if (FAILED(rc))
     96        if (FAILED(hrc))
    9797        {
    9898            if (!fPaused)
    … …  
    101101    } while (0);
    102102
    103     return rc;
     103    return hrc;
    104104}
    105105
    … …  
    116116     */
    117117    com::SafeIfaceArray<IMachine> machines;
    118     HRESULT rc = g_pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
    119     if (SUCCEEDED(rc))
     118    HRESULT hrc = g_pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
     119    if (SUCCEEDED(hrc))
    120120    {
    121121        /*
    … …  
    155155        }
    156156
    157         if (   SUCCEEDED(rc)
     157        if (   SUCCEEDED(hrc)
    158158            && !listVM.empty())
    159159        {
    … …  
    197197                        case AutostopType_SaveState:
    198198                        {
    199                             rc = autostartSaveVMState(console);
     199                            hrc = autostartSaveVMState(console);
    200200                            break;
    201201                        }
    … …  
    204204                            CHECK_ERROR_BREAK(console, PowerDown(progress.asOutParam()));
    205205
    206                             rc = showProgress(progress);
     206                            hrc = showProgress(progress);
    207207                            CHECK_PROGRESS_ERROR(progress, ("Failed to powering off machine '%ls'", strName.raw()));
    208                             if (FAILED(rc))
    209                                 autostartSvcLogError("Powering off machine '%ls' failed with %Rhrc\n", strName.raw(), rc);
     208                            if (FAILED(hrc))
     209                                autostartSvcLogError("Powering off machine '%ls' failed with %Rhrc\n", strName.raw(), hrc);
    210210                            break;
    211211                        }
    … …  
    240240                                autostartSvcLogWarning("The guest of machine '%ls' does not support ACPI shutdown or is currently paused, saving state...\n",
    241241                                                       strName.raw());
    242                                 rc = autostartSaveVMState(console);
     242                                hrc = autostartSaveVMState(console);
    243243                            }
    244244                            break;

  • trunk/src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp

    r94660 r95140  
    992992    }
    993993
    994     HRESULT rc;
    995     int irc;
    996 
    997     rc = com::Initialize();
     994    HRESULT hrc;
     995    int vrc;
     996
     997    hrc = com::Initialize();
    998998#ifdef VBOX_WITH_XPCOM
    999     if (rc == NS_ERROR_FILE_ACCESS_DENIED)
     999    if (hrc == NS_ERROR_FILE_ACCESS_DENIED)
    10001000    {
    10011001        char szHome[RTPATH_MAX] = "";
    … …  
    10051005    }
    10061006#endif
    1007     if (FAILED(rc))
     1007    if (FAILED(hrc))
    10081008    {
    10091009        RTPrintf("VBoxHeadless: ERROR: failed to initialize COM!\n");
    … …  
    10221022    do
    10231023    {
    1024         rc = pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
    1025         if (FAILED(rc))
     1024        hrc = pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
     1025        if (FAILED(hrc))
    10261026        {
    10271027            RTPrintf("VBoxHeadless: ERROR: failed to create the VirtualBoxClient object!\n");
    … …  
    10291029            if (!info.isFullAvailable() && !info.isBasicAvailable())
    10301030            {
    1031                 com::GluePrintRCMessage(rc);
     1031                com::GluePrintRCMessage(hrc);
    10321032                RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
    10331033            }
    … …  
    10371037        }
    10381038
    1039         rc = pVirtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
    1040         if (FAILED(rc))
    1041         {
    1042             RTPrintf("Failed to get VirtualBox object (rc=%Rhrc)!\n", rc);
     1039        hrc = pVirtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
     1040        if (FAILED(hrc))
     1041        {
     1042            RTPrintf("Failed to get VirtualBox object (rc=%Rhrc)!\n", hrc);
    10431043            break;
    10441044        }
    1045         rc = pVirtualBoxClient->COMGETTER(Session)(session.asOutParam());
    1046         if (FAILED(rc))
    1047         {
    1048             RTPrintf("Failed to get session object (rc=%Rhrc)!\n", rc);
     1045        hrc = pVirtualBoxClient->COMGETTER(Session)(session.asOutParam());
     1046        if (FAILED(hrc))
     1047        {
     1048            RTPrintf("Failed to get session object (rc=%Rhrc)!\n", hrc);
    10491049            break;
    10501050        }
    … …  
    10531053        {
    10541054            CHECK_ERROR(virtualBox, SetSettingsSecret(Bstr(pcszSettingsPw).raw()));
    1055             if (FAILED(rc))
     1055            if (FAILED(hrc))
    10561056                break;
    10571057        }
    … …  
    10651065        ComPtr<IMachine> m;
    10661066
    1067         rc = virtualBox->FindMachine(Bstr(pcszNameOrUUID).raw(), m.asOutParam());
    1068         if (FAILED(rc))
    1069         {
    1070             LogError("Invalid machine name or UUID!\n", rc);
     1067        hrc = virtualBox->FindMachine(Bstr(pcszNameOrUUID).raw(), m.asOutParam());
     1068        if (FAILED(hrc))
     1069        {
     1070            LogError("Invalid machine name or UUID!\n", hrc);
    10711071            break;
    10721072        }
    … …  
    10931093        }
    10941094        Bstr bstrVMId;
    1095         rc = m->COMGETTER(Id)(bstrVMId.asOutParam());
    1096         AssertComRC(rc);
    1097         if (FAILED(rc))
     1095        hrc = m->COMGETTER(Id)(bstrVMId.asOutParam());
     1096        AssertComRC(hrc);
     1097        if (FAILED(hrc))
    10981098            break;
    10991099        g_strVMUUID = bstrVMId;
    11001100
    11011101        Bstr bstrVMName;
    1102         rc = m->COMGETTER(Name)(bstrVMName.asOutParam());
    1103         AssertComRC(rc);
    1104         if (FAILED(rc))
     1102        hrc = m->COMGETTER(Name)(bstrVMName.asOutParam());
     1103        AssertComRC(hrc);
     1104        if (FAILED(hrc))
    11051105            break;
    11061106        g_strVMName = bstrVMName;
    … …  
    12551255                            RTPrintf("Error: Invalid VRDE property '%s'\n", aVRDEProperties[i]);
    12561256                            RTStrFree(pszProperty);
    1257                             rc = E_INVALIDARG;
     1257                            hrc = E_INVALIDARG;
    12581258                            break;
    12591259                        }
    … …  
    12631263                    {
    12641264                        RTPrintf("Error: Failed to allocate memory for VRDE property '%s'\n", aVRDEProperties[i]);
    1265                         rc = E_OUTOFMEMORY;
     1265                        hrc = E_OUTOFMEMORY;
    12661266                        break;
    12671267                    }
    12681268                }
    1269                 if (FAILED(rc))
     1269                if (FAILED(hrc))
    12701270                    break;
    12711271            }
    … …  
    13291329            CHECK_ERROR_BREAK(console, PowerUpPaused(progress.asOutParam()));
    13301330
    1331         rc = showProgress(progress);
    1332         if (FAILED(rc))
     1331        hrc = showProgress(progress);
     1332        if (FAILED(hrc))
    13331333        {
    13341334            com::ProgressErrorInfo info(progress);
    … …  
    13491349         */
    13501350        RTTHREAD hThrMsg;
    1351         irc = RTThreadCreate(&hThrMsg,
    1352                             windowsMessageMonitor, NULL,
    1353                             0, /* :cbStack */
    1354                             RTTHREADTYPE_MSG_PUMP, 0,
    1355                             "MSG");
    1356         if (RT_FAILURE(irc))    /* not fatal */
    1357             LogRel(("VBoxHeadless: failed to start windows message monitor: %Rrc\n", irc));
     1351        vrc = RTThreadCreate(&hThrMsg,
     1352                             windowsMessageMonitor, NULL,
     1353                             0, /* :cbStack */
     1354                             RTTHREADTYPE_MSG_PUMP, 0,
     1355                             "MSG");
     1356        if (RT_FAILURE(vrc))    /* not fatal */
     1357            LogRel(("VBoxHeadless: failed to start windows message monitor: %Rrc\n", vrc));
    13581358#endif /* RT_OS_WINDOWS */
    13591359
    … …  
    13651365        for (;;)
    13661366        {
    1367             irc = gEventQ->processEventQueue(RT_INDEFINITE_WAIT);
     1367            vrc = gEventQ->processEventQueue(RT_INDEFINITE_WAIT);
    13681368
    13691369            /*
    … …  
    13731373            if (g_fTerminateFE)
    13741374            {
    1375                 LogRel(("VBoxHeadless: processEventQueue: %Rrc, termination requested\n", irc));
    1376                 break;
    1377             }
    1378 
    1379             if (RT_FAILURE(irc))
    1380             {
    1381                 LogRel(("VBoxHeadless: processEventQueue: %Rrc\n", irc));
    1382                 RTMsgError("event loop: %Rrc", irc);
     1375                LogRel(("VBoxHeadless: processEventQueue: %Rrc, termination requested\n", vrc));
     1376                break;
     1377            }
     1378
     1379            if (RT_FAILURE(vrc))
     1380            {
     1381                LogRel(("VBoxHeadless: processEventQueue: %Rrc\n", vrc));
     1382                RTMsgError("event loop: %Rrc", vrc);
    13831383                break;
    13841384            }
    … …  
    14091409    if (!machine.isNull())
    14101410    {
    1411         rc = machine->COMGETTER(State)(&machineState);
    1412         if (SUCCEEDED(rc))
     1411        hrc = machine->COMGETTER(State)(&machineState);
     1412        if (SUCCEEDED(hrc))
    14131413            Log(("machine state = %RU32\n", machineState));
    14141414        else
    1415             Log(("IMachine::getState: %Rhrc\n", rc));
     1415            Log(("IMachine::getState: %Rhrc\n", hrc));
    14161416    }
    14171417    else
    … …  
    14401440            CHECK_ERROR_BREAK(gConsole, PowerDown(pProgress.asOutParam()));
    14411441
    1442         rc = showProgress(pProgress);
    1443         if (FAILED(rc))
     1442        hrc = showProgress(pProgress);
     1443        if (FAILED(hrc))
    14441444        {
    14451445            com::ErrorInfo info;
    14461446            if (!info.isFullAvailable() && !info.isBasicAvailable())
    1447                 com::GluePrintRCMessage(rc);
     1447                com::GluePrintRCMessage(hrc);
    14481448            else
    14491449                com::GluePrintErrorInfo(info);
    … …  
    15181518
    15191519    LogRel(("VBoxHeadless: exiting\n"));
    1520     return FAILED(rc) ? 1 : 0;
     1520    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    15211521}
    15221522

  • trunk/src/VBox/Frontends/VBoxHeadless/testcase/tstHeadless.cpp

    r93115 r95140  
    6969             name, operation);
    7070
    71     HRESULT rc;
    72 
    73     rc = com::Initialize();
    74     if (FAILED(rc))
     71    HRESULT hrc;
     72
     73    hrc = com::Initialize();
     74    if (FAILED(hrc))
    7575    {
    7676        RTPrintf("ERROR: failed to initialize COM!\n");
    77         return rc;
     77        return hrc;
    7878    }
    7979
    … …  
    8585
    8686        RTPrintf("Creating VirtualBox object...\n");
    87         rc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
    88         if (SUCCEEDED(rc))
    89             rc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
    90         if (FAILED(rc))
     87        hrc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
     88        if (SUCCEEDED(hrc))
     89            hrc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
     90        if (FAILED(hrc))
    9191            RTPrintf("ERROR: failed to create the VirtualBox object!\n");
    9292        else
    9393        {
    94             rc = session.createInprocObject(CLSID_Session);
    95             if (FAILED(rc))
     94            hrc = session.createInprocObject(CLSID_Session);
     95            if (FAILED(hrc))
    9696                RTPrintf("ERROR: failed to create a session object!\n");
    9797        }
    9898
    99         if (FAILED(rc))
     99        if (FAILED(hrc))
    100100        {
    101101            com::ErrorInfo info;
    102102            if (!info.isFullAvailable() && !info.isBasicAvailable())
    103103            {
    104                 com::GluePrintRCMessage(rc);
     104                com::GluePrintRCMessage(hrc);
    105105                RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
    106106            }
    … …  
    204204    RTPrintf("tstHeadless FINISHED.\n");
    205205
    206     return rc;
     206    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    207207}
    208208

  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r94290 r95140  
    584584{
    585585    RT_NOREF(aSession);
    586     HRESULT rc;
     586    HRESULT hrc;
    587587
    588588    /*
    … …  
    610610    if (argc >= 3)
    611611    {
    612         int irc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta);
    613         if (RT_FAILURE(irc))
    614             return errorArgument(argv[0], Internal::tr("Failed to read delta '%s', rc=%Rrc\n"), argv[2], rc);
     612        int vrc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta);
     613        if (RT_FAILURE(vrc))
     614            return errorArgument(argv[0], Internal::tr("Failed to read delta '%s', rc=%Rrc\n"), argv[2], vrc);
    615615    }
    616616
    … …  
    622622    if (argc >= 5)
    623623    {
    624         int irc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress);
    625         if (RT_FAILURE(irc))
    626             return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[4], rc);
     624        int vrc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress);
     625        if (RT_FAILURE(vrc))
     626            return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[4], vrc);
    627627    }
    628628
    … …  
    630630    if (argc >= 6)
    631631    {
    632         int irc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize);
    633         if (RT_FAILURE(irc))
    634             return errorArgument(argv[0], Internal::tr("Failed to read module size '%s', rc=%Rrc\n"), argv[5], rc);
     632        int vrc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize);
     633        if (RT_FAILURE(vrc))
     634            return errorArgument(argv[0], Internal::tr("Failed to read module size '%s', rc=%Rrc\n"), argv[5], vrc);
    635635    }
    636636
    … …  
    639639     */
    640640    Utf8Str KeyStr;
    641     HRESULT hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadsyms", KeyStr);
     641    hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadsyms", KeyStr);
    642642    if (SUCCEEDED(hrc))
    643643        hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Filename", pszFilename);
    … …  
    661661{
    662662    RT_NOREF(aSession);
    663     HRESULT rc;
     663    HRESULT hrc;
    664664
    665665    /*
    … …  
    687687    if (argc < 3)
    688688        return errorArgument(Internal::tr("Missing the module address argument!\n"));
    689     int irc = RTStrToUInt64Ex(argv[2], NULL, 0, &ModuleAddress);
    690     if (RT_FAILURE(irc))
    691         return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[2], rc);
     689    int vrc = RTStrToUInt64Ex(argv[2], NULL, 0, &ModuleAddress);
     690    if (RT_FAILURE(vrc))
     691        return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', rc=%Rrc\n"), argv[2], vrc);
    692692
    693693    /* name (optional) */
    … …  
    698698    if (argc > 4)
    699699    {
    700         irc = RTStrToUInt64Ex(argv[4], NULL, 0, &offSubtrahend);
    701         if (RT_FAILURE(irc))
    702             return errorArgument(argv[0], Internal::tr("Failed to read subtrahend '%s', rc=%Rrc\n"), argv[4], rc);
     700        vrc = RTStrToUInt64Ex(argv[4], NULL, 0, &offSubtrahend);
     701        if (RT_FAILURE(vrc))
     702            return errorArgument(argv[0], Internal::tr("Failed to read subtrahend '%s', rc=%Rrc\n"), argv[4], vrc);
    703703    }
    704704
    … …  
    706706    if (argc > 5)
    707707    {
    708         irc = RTStrToUInt32Ex(argv[5], NULL, 0, &iSeg);
    709         if (RT_FAILURE(irc))
    710             return errorArgument(argv[0], Internal::tr("Failed to read segment number '%s', rc=%Rrc\n"), argv[5], rc);
     708        vrc = RTStrToUInt32Ex(argv[5], NULL, 0, &iSeg);
     709        if (RT_FAILURE(vrc))
     710            return errorArgument(argv[0], Internal::tr("Failed to read segment number '%s', rc=%Rrc\n"), argv[5], vrc);
    711711    }
    712712
    … …  
    715715     */
    716716    Utf8Str KeyStr;
    717     HRESULT hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadmap", KeyStr);
     717    hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadmap", KeyStr);
    718718    if (SUCCEEDED(hrc))
    719719        hrc = SetString(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Filename", pszFilename);
    … …  
    12831283{
    12841284    RT_NOREF(aVirtualBox, aSession);
    1285     HRESULT rc = S_OK;
     1285    HRESULT hrc = S_OK;
    12861286    Utf8Str filename;
    12871287    const char *pszMBRFilename = NULL;
    … …  
    19491949    vdInterfaceError.pfnMessage   = handleVDMessage;
    19501950
    1951     rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
    1952                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
     1951    hrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
     1952                         NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
    19531953    AssertRC(vrc);
    19541954
    … …  
    19971997    }
    19981998
    1999     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1999    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    20002000
    20012001out:
    … …  
    24772477
    24782478    ComPtr<IMachine> ptrMachine;
    2479     HRESULT rc;
     2479    HRESULT hrc;
    24802480    CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
    24812481                                             ptrMachine.asOutParam()), RTEXITCODE_FAILURE);
    … …  
    26442644
    26452645    ComPtr<IMachine> ptrMachine;
    2646     HRESULT rc;
     2646    HRESULT hrc;
    26472647    CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
    26482648                                             ptrMachine.asOutParam()), RTEXITCODE_FAILURE);

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp

    r94236 r95140  
    218218RTEXITCODE handleImportAppliance(HandlerArg *arg)
    219219{
    220     HRESULT rc = S_OK;
     220    HRESULT hrc = S_OK;
    221221    APPLIANCETYPE enmApplType = NOT_SET;
    222222    Utf8Str strOvfFilename;
    … …  
    497497        RTStrFree(pszAbsFilePath);
    498498
    499         rc = showProgress(progressRead);
     499        hrc = showProgress(progressRead);
    500500        CHECK_PROGRESS_ERROR_RET(progressRead, (Appliance::tr("Appliance read failed")), RTEXITCODE_FAILURE);
    501501
    … …  
    511511            // to tinker with the error info a bit
    512512            RTStrmPrintf(g_pStdErr, Appliance::tr("Interpreting %ls...\n"), path.raw());
    513             rc = pAppliance->Interpret();
     513            hrc = pAppliance->Interpret();
    514514            com::ErrorInfoKeeper eik;
    515515
    … …  
    528528
    529529            eik.restore();
    530             if (FAILED(rc))     // during interpret, after printing warnings
     530            if (FAILED(hrc))     // during interpret, after printing warnings
    531531            {
    532                 com::GlueHandleComError(pAppliance, "Interpret()", rc, __FILE__, __LINE__);
     532                com::GlueHandleComError(pAppliance, "Interpret()", hrc, __FILE__, __LINE__);
    533533                break;
    534534            }
    … …  
    13941394                                  ImportMachines(ComSafeArrayAsInParam(options), progress.asOutParam()));
    13951395
    1396                 rc = showProgress(progress);
     1396                hrc = showProgress(progress);
    13971397                CHECK_PROGRESS_ERROR_RET(progress, (Appliance::tr("Appliance import failed")), RTEXITCODE_FAILURE);
    13981398
    1399                 if (SUCCEEDED(rc))
     1399                if (SUCCEEDED(hrc))
    14001400                    RTPrintf(Appliance::tr("Successfully imported the appliance.\n"));
    14011401            }
    … …  
    14031403    } while (0);
    14041404
    1405     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1405    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    14061406}
    14071407
    … …  
    14851485RTEXITCODE handleExportAppliance(HandlerArg *a)
    14861486{
    1487     HRESULT rc = S_OK;
     1487    HRESULT hrc = S_OK;
    14881488
    14891489    Utf8Str strOutputFile;
    … …  
    17611761            }
    17621762
    1763             if (FAILED(rc))
     1763            if (FAILED(hrc))
    17641764                break;
    17651765        }
    17661766
    1767         if (FAILED(rc))
     1767        if (FAILED(hrc))
    17681768            break;
    17691769
    … …  
    19281928        }
    19291929
    1930         if (FAILED(rc))
     1930        if (FAILED(hrc))
    19311931            break;
    19321932
    … …  
    19751975        RTStrFree(pszAbsFilePath);
    19761976
    1977         rc = showProgress(progress);
     1977        hrc = showProgress(progress);
    19781978        CHECK_PROGRESS_ERROR_RET(progress, (Appliance::tr("Appliance write failed")), RTEXITCODE_FAILURE);
    19791979
    1980         if (SUCCEEDED(rc))
     1980        if (SUCCEEDED(hrc))
    19811981            RTPrintf(Appliance::tr("Successfully exported %d machine(s).\n", "", llMachines.size()), llMachines.size());
    19821982
    … …  
    20392039                    ComPtr<IProgress> progress1;
    20402040                    CHECK_ERROR_BREAK(oCloudClient, LaunchVM(pVSD, progress1.asOutParam()));
    2041                     rc = showProgress(progress1);
     2041                    hrc = showProgress(progress1);
    20422042                    CHECK_PROGRESS_ERROR_RET(progress1, (Appliance::tr("Creating the cloud instance failed")),
    20432043                                             RTEXITCODE_FAILURE);
    20442044
    2045                     if (SUCCEEDED(rc))
     2045                    if (SUCCEEDED(hrc))
    20462046                    {
    20472047                        CHECK_ERROR_BREAK(pVSD, GetDescriptionByType(VirtualSystemDescriptionType_CloudInstanceId,
    … …  
    20622062    } while (0);
    20632063
    2064     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     2064    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    20652065}
    20662066

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp

    r94236 r95140  
    100100static RTEXITCODE handleBandwidthControlAdd(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl)
    101101{
    102     HRESULT rc = S_OK;
     102    HRESULT hrc = S_OK;
    103103    static const RTGETOPTDEF g_aBWCtlAddOptions[] =
    104104        {
    … …  
    125125                 RT_ELEMENTS(g_aBWCtlAddOptions), 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    126126
    127     while (   SUCCEEDED(rc)
     127    while (   SUCCEEDED(hrc)
    128128           && (c = RTGetOpt(&GetState, &ValueUnion)))
    129129    {
    … …  
    135135                    pszType = ValueUnion.psz;
    136136                else
    137                     rc = E_FAIL;
     137                    hrc = E_FAIL;
    138138                break;
    139139            }
    … …  
    151151                }
    152152                else
    153                     rc = E_FAIL;
     153                    hrc = E_FAIL;
    154154                break;
    155155            }
    … …  
    158158            {
    159159                errorGetOpt(c, &ValueUnion);
    160                 rc = E_FAIL;
     160                hrc = E_FAIL;
    161161                break;
    162162            }
    … …  
    189189static RTEXITCODE handleBandwidthControlSet(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl)
    190190{
    191     HRESULT rc = S_OK;
     191    HRESULT hrc = S_OK;
    192192    static const RTGETOPTDEF g_aBWCtlAddOptions[] =
    193193        {
    … …  
    206206                 RT_ELEMENTS(g_aBWCtlAddOptions), 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    207207
    208     while (   SUCCEEDED(rc)
     208    while (   SUCCEEDED(hrc)
    209209           && (c = RTGetOpt(&GetState, &ValueUnion)))
    210210    {
    … …  
    223223                }
    224224                else
    225                     rc = E_FAIL;
     225                    hrc = E_FAIL;
    226226                break;
    227227            }
    … …  
    230230            {
    231231                errorGetOpt(c, &ValueUnion);
    232                 rc = E_FAIL;
     232                hrc = E_FAIL;
    233233                break;
    234234            }
    … …  
    241241        ComPtr<IBandwidthGroup> bwGroup;
    242242        CHECK_ERROR2I_RET(bwCtrl, GetBandwidthGroup(name.raw(), bwGroup.asOutParam()), RTEXITCODE_FAILURE);
    243         if (SUCCEEDED(rc))
     243        if (SUCCEEDED(hrc))
    244244        {
    245245            CHECK_ERROR2I_RET(bwGroup, COMSETTER(MaxBytesPerSec)((LONG64)cMaxBytesPerSec), RTEXITCODE_FAILURE);
    … …  
    311311RTEXITCODE handleBandwidthControl(HandlerArg *a)
    312312{
    313     HRESULT rc = S_OK;
     313    HRESULT hrc = S_OK;
    314314    ComPtr<IMachine> machine;
    315315    ComPtr<IBandwidthControl> bwCtrl;
    … …  
    332332    /* get the mutable session machine */
    333333    a->session->COMGETTER(Machine)(machine.asOutParam());
    334     rc = machine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam());
    335     if (FAILED(rc)) goto leave;
     334    hrc = machine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam());
     335    if (FAILED(hrc)) goto leave; /** @todo r=andy Argh!! */
    336336
    337337    if (!strcmp(a->argv[1], "add"))
    … …  
    342342            goto leave;
    343343        }
    344         rc = handleBandwidthControlAdd(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     344        hrc = handleBandwidthControlAdd(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    345345    }
    346346    else if (!strcmp(a->argv[1], "remove"))
    … …  
    351351            goto leave;
    352352        }
    353         rc = handleBandwidthControlRemove(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     353        hrc = handleBandwidthControlRemove(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    354354    }
    355355    else if (!strcmp(a->argv[1], "set"))
    356         rc = handleBandwidthControlSet(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     356        hrc = handleBandwidthControlSet(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    357357    else if (!strcmp(a->argv[1], "list"))
    358         rc = handleBandwidthControlList(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     358        hrc = handleBandwidthControlList(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    359359    else
    360360    {
    361361        errorSyntax(BWControl::tr("Invalid parameter '%s'"), a->argv[1]);
    362         rc = E_FAIL;
     362        hrc = E_FAIL;
    363363    }
    364364
    365365    /* commit changes */
    366     if (SUCCEEDED(rc))
     366    if (SUCCEEDED(hrc))
    367367        CHECK_ERROR(machine, SaveSettings());
    368368
    … …  
    371371    a->session->UnlockMachine();
    372372
    373     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    374 }
     373    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     374}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

    r94660 r95140  
    213213    com::SafeArray<LONG> saScancodes(llScancodes);
    214214
    215     HRESULT rc = S_OK;
     215    HRESULT hrc = S_OK;
    216216    size_t i;
    217217    for (i = 0; i < saScancodes.size(); ++i)
    218218    {
    219         rc = pKeyboard->PutScancode(saScancodes[i]);
    220         if (FAILED(rc))
     219        hrc = pKeyboard->PutScancode(saScancodes[i]);
     220        if (FAILED(hrc))
    221221        {
    222222            RTMsgError(ControlVM::tr("Failed to send a scancode."));
    … …  
    227227    }
    228228
    229     return rc;
     229    return hrc;
    230230}
    231231
    … …  
    346346    using namespace com;
    347347    bool fNeedsSaving = false;
    348     HRESULT rc;
     348    HRESULT hrc;
    349349
    350350    if (a->argc < 2)
    … …  
    355355    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    356356                                           machine.asOutParam()));
    357     if (FAILED(rc))
     357    if (FAILED(hrc))
    358358        return RTEXITCODE_FAILURE;
    359359
    … …  
    396396            {
    397397                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    398                 rc = E_FAIL;
     398                hrc = E_FAIL;
    399399                break;
    400400            }
    … …  
    410410            {
    411411                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    412                 rc = E_FAIL;
     412                hrc = E_FAIL;
    413413                break;
    414414            }
    … …  
    424424            {
    425425                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    426                 rc = E_FAIL;
     426                hrc = E_FAIL;
    427427                break;
    428428            }
    … …  
    443443                {
    444444                    errorSyntax(ControlVM::tr("Invalid value '%s'."), a->argv[2]);
    445                     rc = E_FAIL;
     445                    hrc = E_FAIL;
    446446                    break;
    447447                }
    … …  
    452452            {
    453453                errorSyntax(ControlVM::tr("Audio adapter not enabled in VM configuration."));
    454                 rc = E_FAIL;
     454                hrc = E_FAIL;
    455455                break;
    456456            }
    … …  
    467467                {
    468468                    errorSyntax(ControlVM::tr("Invalid value '%s'."), a->argv[2]);
    469                     rc = E_FAIL;
     469                    hrc = E_FAIL;
    470470                    break;
    471471                }
    … …  
    476476            {
    477477                errorSyntax(ControlVM::tr("Audio adapter not enabled in VM configuration."));
    478                 rc = E_FAIL;
     478                hrc = E_FAIL;
    479479                break;
    480480            }
    … …  
    486486            {
    487487                errorArgument(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    488                 rc = E_FAIL;
     488                hrc = E_FAIL;
    489489                break;
    490490            }
    … …  
    497497                {
    498498                    errorSyntax(ControlVM::tr("Missing argument to '%s %s'."), a->argv[1], a->argv[2]);
    499                     rc = E_FAIL;
     499                    hrc = E_FAIL;
    500500                    break;
    501501                }
    … …  
    512512                {
    513513                    errorSyntax(ControlVM::tr("Invalid '%s %s' argument '%s'."), a->argv[1], a->argv[2], a->argv[3]);
    514                     rc = E_FAIL;
     514                    hrc = E_FAIL;
    515515                    break;
    516516                }
    517517
    518518                CHECK_ERROR_BREAK(sessionMachine, COMSETTER(ClipboardMode)(mode));
    519                 if (SUCCEEDED(rc))
     519                if (SUCCEEDED(hrc))
    520520                    fNeedsSaving = true;
    521521            }
    … …  
    527527                {
    528528                    errorSyntax(ControlVM::tr("Missing argument to '%s %s'."), a->argv[1], a->argv[2]);
    529                     rc = E_FAIL;
     529                    hrc = E_FAIL;
    530530                    break;
    531531                }
    … …  
    535535                {
    536536                    errorSyntax(ControlVM::tr("Invalid '%s %s' argument '%s'."), a->argv[1], a->argv[2], a->argv[3]);
    537                     rc = E_FAIL;
     537                    hrc = E_FAIL;
    538538                    break;
    539539                }
    … …  
    546546            {
    547547                errorArgument(ControlVM::tr("Invalid '%s' argument '%s'."), a->argv[1], a->argv[2]);
    548                 rc = E_FAIL;
     548                hrc = E_FAIL;
    549549                break;
    550550            }
    … …  
    557557            {
    558558                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    559                 rc = E_FAIL;
     559                hrc = E_FAIL;
    560560                break;
    561561            }
    … …  
    573573            {
    574574                errorSyntax(ControlVM::tr("Invalid '%s' argument '%s'."), a->argv[1], a->argv[2]);
    575                 rc = E_FAIL;
    576             }
    577             if (SUCCEEDED(rc))
     575                hrc = E_FAIL;
     576            }
     577            if (SUCCEEDED(hrc))
    578578            {
    579579                CHECK_ERROR_BREAK(sessionMachine, COMSETTER(DnDMode)(mode));
    580                 if (SUCCEEDED(rc))
     580                if (SUCCEEDED(hrc))
    581581                    fNeedsSaving = true;
    582582            }
    … …  
    588588            CHECK_ERROR_BREAK(console, PowerDown(progress.asOutParam()));
    589589
    590             rc = showProgress(progress);
     590            hrc = showProgress(progress);
    591591            CHECK_PROGRESS_ERROR(progress, (ControlVM::tr("Failed to power off machine.")));
    592592        }
    … …  
    596596            /* first pause so we don't trigger a live save which needs more time/resources */
    597597            bool fPaused = false;
    598             rc = console->Pause();
    599             if (FAILED(rc))
     598            hrc = console->Pause();
     599            if (FAILED(hrc))
    600600            {
    601601                bool fError = true;
    602                 if (rc == VBOX_E_INVALID_VM_STATE)
     602                if (hrc == VBOX_E_INVALID_VM_STATE)
    603603                {
    604604                    /* check if we are already paused */
    … …  
    606606                    CHECK_ERROR_BREAK(console, COMGETTER(State)(&machineState));
    607607                    /* the error code was lost by the previous instruction */
    608                     rc = VBOX_E_INVALID_VM_STATE;
     608                    hrc = VBOX_E_INVALID_VM_STATE;
    609609                    if (machineState != MachineState_Paused)
    610610                    {
    … …  
    624624            ComPtr<IProgress> progress;
    625625            CHECK_ERROR(sessionMachine, SaveState(progress.asOutParam()));
    626             if (FAILED(rc))
     626            if (FAILED(hrc))
    627627            {
    628628                if (!fPaused)
    … …  
    631631            }
    632632
    633             rc = showProgress(progress);
     633            hrc = showProgress(progress);
    634634            CHECK_PROGRESS_ERROR(progress, (ControlVM::tr("Failed to save machine state.")));
    635             if (FAILED(rc))
     635            if (FAILED(hrc))
    636636            {
    637637                if (!fPaused)
    … …  
    664664            {
    665665                RTMsgError(ControlVM::tr("Guest not running."));
    666                 rc = E_FAIL;
     666                hrc = E_FAIL;
    667667                break;
    668668            }
    … …  
    679679
    680680            CHECK_ERROR(pGuest, Shutdown(ComSafeArrayAsInParam(aShutdownFlags)));
    681             if (FAILED(rc))
    682             {
    683                 if (rc == VBOX_E_NOT_SUPPORTED)
     681            if (FAILED(hrc))
     682            {
     683                if (hrc == VBOX_E_NOT_SUPPORTED)
    684684                {
    685685                    if (fReboot)
    … …  
    699699            {
    700700                RTMsgError(ControlVM::tr("Guest not running."));
    701                 rc = E_FAIL;
     701                hrc = E_FAIL;
    702702                break;
    703703            }
    … …  
    707707                errorSyntax(ControlVM::tr("Missing argument to '%s'. Expected IBM PC AT set 2 keyboard scancode(s)."),
    708708                              a->argv[1]);
    709                 rc = E_FAIL;
     709                hrc = E_FAIL;
    710710                break;
    711711            }
    … …  
    722722                {
    723723                    uint8_t u8Scancode;
    724                     int irc = RTStrToUInt8Ex(a->argv[i], NULL, 16, &u8Scancode);
    725                     if (RT_FAILURE (irc))
     724                    int vrc = RTStrToUInt8Ex(a->argv[i], NULL, 16, &u8Scancode);
     725                    if (RT_FAILURE (vrc))
    726726                    {
    727                         RTMsgError(ControlVM::tr("Converting '%s' returned %Rrc!"), a->argv[i], rc);
    728                         rc = E_FAIL;
     727                        RTMsgError(ControlVM::tr("Converting '%s' returned %Rrc!"), a->argv[i], vrc);
     728                        hrc = E_FAIL;
    729729                        break;
    730730                    }
    … …  
    735735                {
    736736                    RTMsgError(ControlVM::tr("'%s' is not a hex byte!"), a->argv[i]);
    737                     rc = E_FAIL;
    738                     break;
    739                 }
    740             }
    741 
    742             if (FAILED(rc))
    743                 break;
    744 
    745             rc = keyboardPutScancodes(pKeyboard, llScancodes);
     737                    hrc = E_FAIL;
     738                    break;
     739                }
     740            }
     741
     742            if (FAILED(hrc))
     743                break;
     744
     745            hrc = keyboardPutScancodes(pKeyboard, llScancodes);
    746746        }
    747747        else if (!strcmp(a->argv[1], "keyboardputstring"))
    … …  
    753753            {
    754754                RTMsgError(ControlVM::tr("Guest not running."));
    755                 rc = E_FAIL;
     755                hrc = E_FAIL;
    756756                break;
    757757            }
    … …  
    760760            {
    761761                errorSyntax(ControlVM::tr("Missing argument to '%s'. Expected ASCII string(s)."), a->argv[1]);
    762                 rc = E_FAIL;
    763                 break;
    764             }
    765 
    766             rc = keyboardPutString(pKeyboard, a->argc, a->argv);
     762                hrc = E_FAIL;
     763                break;
     764            }
     765
     766            hrc = keyboardPutString(pKeyboard, a->argc, a->argv);
    767767        }
    768768        else if (!strcmp(a->argv[1], "keyboardputfile"))
    … …  
    774774            {
    775775                RTMsgError(ControlVM::tr("Guest not running."));
    776                 rc = E_FAIL;
     776                hrc = E_FAIL;
    777777                break;
    778778            }
    … …  
    781781            {
    782782                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    783                 rc = E_FAIL;
    784                 break;
    785             }
    786 
    787             rc = keyboardPutFile(pKeyboard, a->argv[2]);
     783                hrc = E_FAIL;
     784                break;
     785            }
     786
     787            hrc = keyboardPutFile(pKeyboard, a->argv[2]);
    788788        }
    789789        else if (!strncmp(a->argv[1], "setlinkstate", 12))
    … …  
    795795            if (!n)
    796796            {
    797                 rc = E_FAIL;
     797                hrc = E_FAIL;
    798798                break;
    799799            }
    … …  
    801801            {
    802802                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    803                 rc = E_FAIL;
     803                hrc = E_FAIL;
    804804                break;
    805805            }
    … …  
    813813                {
    814814                    errorSyntax(ControlVM::tr("Invalid link state '%s'."), a->argv[2]);
    815                     rc = E_FAIL;
     815                    hrc = E_FAIL;
    816816                    break;
    817817                }
    … …  
    833833            if (!n)
    834834            {
    835                 rc = E_FAIL;
     835                hrc = E_FAIL;
    836836                break;
    837837            }
    … …  
    839839            {
    840840                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    841                 rc = E_FAIL;
     841                hrc = E_FAIL;
    842842                break;
    843843            }
    … …  
    859859                    {
    860860                        errorSyntax(ControlVM::tr("Filename not specified for NIC %lu."), n);
    861                         rc = E_FAIL;
     861                        hrc = E_FAIL;
    862862                        break;
    863863                    }
    864                     if (SUCCEEDED(rc))
     864                    if (SUCCEEDED(hrc))
    865865                        fNeedsSaving = true;
    866866                }
    … …  
    877877            if (!n)
    878878            {
    879                 rc = E_FAIL;
     879                hrc = E_FAIL;
    880880                break;
    881881            }
    … …  
    883883            {
    884884                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    885                 rc = E_FAIL;
     885                hrc = E_FAIL;
    886886                break;
    887887            }
    … …  
    900900                    {
    901901                        errorSyntax(ControlVM::tr("Invalid nictrace%lu argument '%s'."), n, a->argv[2]);
    902                         rc = E_FAIL;
     902                        hrc = E_FAIL;
    903903                        break;
    904904                    }
    … …  
    918918            if (!n)
    919919            {
    920                 rc = E_FAIL;
     920                hrc = E_FAIL;
    921921                break;
    922922            }
    … …  
    924924            {
    925925                errorArgument(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    926                 rc = E_FAIL;
     926                hrc = E_FAIL;
    927927                break;
    928928            }
    … …  
    933933            if (!adapter)
    934934            {
    935                 rc = E_FAIL;
     935                hrc = E_FAIL;
    936936                break;
    937937            }
    … …  
    940940            if (!engine)
    941941            {
    942                 rc = E_FAIL;
     942                hrc = E_FAIL;
    943943                break;
    944944            }
    … …  
    10011001#undef ITERATE_TO_NEXT_TERM
    10021002            }
    1003             if (SUCCEEDED(rc))
     1003            if (SUCCEEDED(hrc))
    10041004                fNeedsSaving = true;
    10051005        }
    … …  
    10121012            if (!n)
    10131013            {
    1014                 rc = E_FAIL;
     1014                hrc = E_FAIL;
    10151015                break;
    10161016            }
    … …  
    10181018            {
    10191019                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1020                 rc = E_FAIL;
     1020                hrc = E_FAIL;
    10211021                break;
    10221022            }
    … …  
    10431043                            Bstr bstrValue = &pDelimiter[1];
    10441044                            CHECK_ERROR(adapter, SetProperty(bstrName.raw(), bstrValue.raw()));
    1045                             if (SUCCEEDED(rc))
     1045                            if (SUCCEEDED(hrc))
    10461046                                fNeedsSaving = true;
    10471047                        }
    … …  
    10491049                        {
    10501050                            errorSyntax(ControlVM::tr("Invalid nicproperty%d argument '%s'."), n, a->argv[2]);
    1051                             rc = E_FAIL;
     1051                            hrc = E_FAIL;
    10521052                        }
    10531053                        RTStrFree(pszProperty);
    … …  
    10571057                        RTMsgError(ControlVM::tr("Failed to allocate memory for nicproperty%d '%s'."),
    10581058                                     n, a->argv[2]);
    1059                         rc = E_FAIL;
     1059                        hrc = E_FAIL;
    10601060                    }
    1061                     if (FAILED(rc))
     1061                    if (FAILED(hrc))
    10621062                        break;
    10631063                }
    … …  
    10741074            if (!n)
    10751075            {
    1076                 rc = E_FAIL;
     1076                hrc = E_FAIL;
    10771077                break;
    10781078            }
    … …  
    10801080            {
    10811081                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1082                 rc = E_FAIL;
     1082                hrc = E_FAIL;
    10831083                break;
    10841084            }
    … …  
    11041104                    {
    11051105                        errorSyntax(ControlVM::tr("Unknown promiscuous mode policy '%s'."), a->argv[2]);
    1106                         rc = E_INVALIDARG;
     1106                        hrc = E_INVALIDARG;
    11071107                        break;
    11081108                    }
    11091109
    11101110                    CHECK_ERROR(adapter, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy));
    1111                     if (SUCCEEDED(rc))
     1111                    if (SUCCEEDED(hrc))
    11121112                        fNeedsSaving = true;
    11131113                }
    … …  
    11241124            if (!n)
    11251125            {
    1126                 rc = E_FAIL;
     1126                hrc = E_FAIL;
    11271127                break;
    11281128            }
    … …  
    11301130            {
    11311131                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1132                 rc = E_FAIL;
     1132                hrc = E_FAIL;
    11331133                break;
    11341134            }
    … …  
    11591159                        {
    11601160                            errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
    1161                             rc = E_FAIL;
     1161                            hrc = E_FAIL;
    11621162                            break;
    11631163                        }
    … …  
    11711171                        {
    11721172                            errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
    1173                             rc = E_FAIL;
     1173                            hrc = E_FAIL;
    11741174                            break;
    11751175                        }
    … …  
    11831183                        {
    11841184                            errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
    1185                             rc = E_FAIL;
     1185                            hrc = E_FAIL;
    11861186                            break;
    11871187                        }
    … …  
    11961196                        {
    11971197                            errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
    1198                             rc = E_FAIL;
     1198                            hrc = E_FAIL;
    11991199                            break;
    12001200                        }
    … …  
    12071207                        {
    12081208                            errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[2]);
    1209                             rc = E_FAIL;
     1209                            hrc = E_FAIL;
    12101210                            break;
    12111211                        }
    … …  
    12161216                    {
    12171217                        errorSyntax(ControlVM::tr("Invalid type '%s' specfied for NIC %lu."), a->argv[2], n);
    1218                         rc = E_FAIL;
     1218                        hrc = E_FAIL;
    12191219                        break;
    12201220                    }
    1221                     if (SUCCEEDED(rc))
     1221                    if (SUCCEEDED(hrc))
    12221222                        fNeedsSaving = true;
    12231223                }
    … …  
    12361236            {
    12371237                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1238                 rc = E_FAIL;
     1238                hrc = E_FAIL;
    12391239                break;
    12401240            }
    … …  
    12481248                {
    12491249                    errorSyntax(ControlVM::tr("Invalid remote desktop server state '%s'."), a->argv[2]);
    1250                     rc = E_FAIL;
     1250                    hrc = E_FAIL;
    12511251                    break;
    12521252                }
    … …  
    12651265            {
    12661266                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1267                 rc = E_FAIL;
     1267                hrc = E_FAIL;
    12681268                break;
    12691269            }
    … …  
    12821282
    12831283                CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), ports.raw()));
    1284                 if (SUCCEEDED(rc))
     1284                if (SUCCEEDED(hrc))
    12851285                    fNeedsSaving = true;
    12861286            }
    … …  
    12961296            {
    12971297                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1298                 rc = E_FAIL;
     1298                hrc = E_FAIL;
    12991299                break;
    13001300            }
    … …  
    13071307
    13081308                CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(), value.raw()));
    1309                 if (SUCCEEDED(rc))
     1309                if (SUCCEEDED(hrc))
    13101310                    fNeedsSaving = true;
    13111311            }
    … …  
    13171317            {
    13181318                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1319                 rc = E_FAIL;
     1319                hrc = E_FAIL;
    13201320                break;
    13211321            }
    … …  
    13371337                        Bstr bstrValue = &pDelimiter[1];
    13381338                        CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
    1339                         if (SUCCEEDED(rc))
     1339                        if (SUCCEEDED(hrc))
    13401340                            fNeedsSaving = true;
    13411341                    }
    … …  
    13431343                    {
    13441344                        errorSyntax(ControlVM::tr("Invalid vrdeproperty argument '%s'."), a->argv[2]);
    1345                         rc = E_FAIL;
     1345                        hrc = E_FAIL;
    13461346                    }
    13471347                    RTStrFree(pszProperty);
    … …  
    13511351                    RTMsgError(ControlVM::tr("Failed to allocate memory for VRDE property '%s'."),
    13521352                                 a->argv[2]);
    1353                     rc = E_FAIL;
    1354                 }
    1355             }
    1356             if (FAILED(rc))
     1353                    hrc = E_FAIL;
     1354                }
     1355            }
     1356            if (FAILED(hrc))
    13571357            {
    13581358                break;
    … …  
    13711371            {
    13721372                errorSyntax(ControlVM::tr("Not enough parameters."));
    1373                 rc = E_FAIL;
     1373                hrc = E_FAIL;
    13741374                break;
    13751375            }
    … …  
    13771377            {
    13781378                errorSyntax(ControlVM::tr("Wrong number of arguments."));
    1379                 rc = E_FAIL;
     1379                hrc = E_FAIL;
    13801380                break;
    13811381            }
    … …  
    13911391                {
    13921392                    errorSyntax(ControlVM::tr("Invalid parameter '%s'."), a->argv[3]);
    1393                     rc = E_FAIL;
     1393                    hrc = E_FAIL;
    13941394                    break;
    13951395                }
    … …  
    14241424            {
    14251425                errorSyntax(ControlVM::tr("Zero UUID argument '%s'."), a->argv[2]);
    1426                 rc = E_FAIL;
     1426                hrc = E_FAIL;
    14271427                break;
    14281428            }
    … …  
    14431443            {
    14441444                errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1445                 rc = E_FAIL;
     1445                hrc = E_FAIL;
    14461446                break;
    14471447            }
    … …  
    14611461                {
    14621462                    errorSyntax(ControlVM::tr("Either \"yes\" or \"no\" is expected."));
    1463                     rc = E_FAIL;
     1463                    hrc = E_FAIL;
    14641464                    break;
    14651465                }
    … …  
    14771477            {
    14781478                RTMsgError(ControlVM::tr("Guest not running."));
    1479                 rc = E_FAIL;
     1479                hrc = E_FAIL;
    14801480                break;
    14811481            }
    … …  
    14901490            {
    14911491                errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1492                 rc = E_FAIL;
     1492                hrc = E_FAIL;
    14931493                break;
    14941494            }
    … …  
    14991499            {
    15001500                RTMsgError(ControlVM::tr("Guest not running."));
    1501                 rc = E_FAIL;
     1501                hrc = E_FAIL;
    15021502                break;
    15031503            }
    … …  
    15261526                {
    15271527                    errorSyntax(ControlVM::tr("Display status must be <on> or <off>."));
    1528                     rc = E_FAIL;
     1528                    hrc = E_FAIL;
    15291529                    break;
    15301530                }
    … …  
    15411541                    {
    15421542                        errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1543                         rc = E_FAIL;
     1543                        hrc = E_FAIL;
    15441544                        break;
    15451545                    }
    … …  
    15681568            }
    15691569
    1570             if (FAILED(rc))
     1570            if (FAILED(hrc))
    15711571                break;
    15721572
    … …  
    15861586                {
    15871587                    errorSyntax(ControlVM::tr("Invalid parameter '%s'."), a->argv[5]);
    1588                     rc = E_FAIL;
     1588                    hrc = E_FAIL;
    15891589                    break;
    15901590                }
    … …  
    15981598            {
    15991599                errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1600                 rc = E_FAIL;
     1600                hrc = E_FAIL;
    16011601                break;
    16021602            }
    … …  
    16121612                if (rcExit != RTEXITCODE_SUCCESS)
    16131613                {
    1614                     rc = E_FAIL;
     1614                    hrc = E_FAIL;
    16151615                    break;
    16161616                }
    … …  
    16231623            {
    16241624                RTMsgError(ControlVM::tr("Guest not running."));
    1625                 rc = E_FAIL;
     1625                hrc = E_FAIL;
    16261626                break;
    16271627            }
    … …  
    16371637            {
    16381638                errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1639                 rc = E_FAIL;
     1639                hrc = E_FAIL;
    16401640                break;
    16411641            }
    … …  
    16461646            {
    16471647                errorSyntax(ControlVM::tr("Error parsing guest memory balloon size '%s'."), a->argv[2]);
    1648                 rc = E_FAIL;
     1648                hrc = E_FAIL;
    16491649                break;
    16501650            }
    16511651            /* guest is running; update IGuest */
    16521652            ComPtr<IGuest> pGuest;
    1653             rc = console->COMGETTER(Guest)(pGuest.asOutParam());
    1654             if (SUCCEEDED(rc))
     1653            hrc = console->COMGETTER(Guest)(pGuest.asOutParam());
     1654            if (SUCCEEDED(hrc))
    16551655            {
    16561656                if (!pGuest)
    16571657                {
    16581658                    RTMsgError(ControlVM::tr("Guest not running."));
    1659                     rc = E_FAIL;
     1659                    hrc = E_FAIL;
    16601660                    break;
    16611661                }
    … …  
    16851685            int ch;
    16861686            RTGETOPTUNION Value;
    1687             while (   SUCCEEDED(rc)
     1687            while (   SUCCEEDED(hrc)
    16881688                   && (ch = RTGetOpt(&GetOptState, &Value)))
    16891689            {
    … …  
    16981698                        RTEXITCODE rcExit = readPasswordFile(Value.psz, &strPassword);
    16991699                        if (rcExit != RTEXITCODE_SUCCESS)
    1700                             rc = E_FAIL;
     1700                            hrc = E_FAIL;
    17011701                        break;
    17021702                    }
    … …  
    17051705                    default:
    17061706                        errorGetOpt(ch, &Value);
    1707                         rc = E_FAIL;
     1707                        hrc = E_FAIL;
    17081708                        break;
    17091709                }
    17101710            }
    1711             if (FAILED(rc))
     1711            if (FAILED(hrc))
    17121712                break;
    17131713
    … …  
    17201720            if (cMsTimeout)
    17211721            {
    1722                 rc = progress->COMSETTER(Timeout)(cMsTimeout);
    1723                 if (FAILED(rc) && rc != VBOX_E_INVALID_OBJECT_STATE)
     1722                hrc = progress->COMSETTER(Timeout)(cMsTimeout);
     1723                if (FAILED(hrc) && hrc != VBOX_E_INVALID_OBJECT_STATE)
    17241724                    CHECK_ERROR_BREAK(progress, COMSETTER(Timeout)(cMsTimeout)); /* lazyness */
    17251725            }
    17261726
    1727             rc = showProgress(progress);
     1727            hrc = showProgress(progress);
    17281728            CHECK_PROGRESS_ERROR(progress, (ControlVM::tr("Teleportation failed")));
    17291729        }
    … …  
    17341734            {
    17351735                errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1736                 rc = E_FAIL;
     1736                hrc = E_FAIL;
    17371737                break;
    17381738            }
    … …  
    17451745                {
    17461746                    errorSyntax(ControlVM::tr("Error parsing display number '%s'."), a->argv[3]);
    1747                     rc = E_FAIL;
     1747                    hrc = E_FAIL;
    17481748                    break;
    17491749                }
    … …  
    17541754            {
    17551755                RTMsgError(ControlVM::tr("Guest not running."));
    1756                 rc = E_FAIL;
     1756                hrc = E_FAIL;
    17571757                break;
    17581758            }
    … …  
    17681768            {
    17691769                RTMsgError(ControlVM::tr("Failed to create file '%s' (%Rrc)."), a->argv[2], vrc);
    1770                 rc = E_FAIL;
     1770                hrc = E_FAIL;
    17711771                break;
    17721772            }
    … …  
    17751775            {
    17761776                RTMsgError(ControlVM::tr("Failed to write screenshot to file '%s' (%Rrc)."), a->argv[2], vrc);
    1777                 rc = E_FAIL;
     1777                hrc = E_FAIL;
    17781778            }
    17791779            RTFileClose(pngFile);
    … …  
    17861786            {
    17871787                errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1788                 rc = E_FAIL;
     1788                hrc = E_FAIL;
    17891789                break;
    17901790            }
    … …  
    18201820                {
    18211821                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1822                     rc = E_FAIL;
     1822                    hrc = E_FAIL;
    18231823                    break;
    18241824                }
    … …  
    18261826                {
    18271827                    errorSyntax(ControlVM::tr("Error parsing list of screen IDs '%s'."), a->argv[3]);
    1828                     rc = E_FAIL;
     1828                    hrc = E_FAIL;
    18291829                    break;
    18301830                }
    … …  
    18391839                {
    18401840                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1841                     rc = E_FAIL;
     1841                    hrc = E_FAIL;
    18421842                    break;
    18431843                }
    … …  
    18531853                {
    18541854                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1855                     rc = E_FAIL;
     1855                    hrc = E_FAIL;
    18561856                    break;
    18571857                }
    … …  
    18621862                {
    18631863                    errorSyntax(ControlVM::tr("Error parsing video width '%s'."), a->argv[3]);
    1864                     rc = E_FAIL;
     1864                    hrc = E_FAIL;
    18651865                    break;
    18661866                }
    … …  
    18711871                {
    18721872                    errorSyntax(ControlVM::tr("Error parsing video height '%s'."), a->argv[4]);
    1873                     rc = E_FAIL;
     1873                    hrc = E_FAIL;
    18741874                    break;
    18751875                }
    … …  
    18871887                {
    18881888                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1889                     rc = E_FAIL;
     1889                    hrc = E_FAIL;
    18901890                    break;
    18911891                }
    … …  
    18961896                {
    18971897                    errorSyntax(ControlVM::tr("Error parsing video rate '%s'."), a->argv[3]);
    1898                     rc = E_FAIL;
     1898                    hrc = E_FAIL;
    18991899                    break;
    19001900                }
    … …  
    19091909                {
    19101910                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1911                     rc = E_FAIL;
     1911                    hrc = E_FAIL;
    19121912                    break;
    19131913                }
    … …  
    19181918                {
    19191919                    errorSyntax(ControlVM::tr("Error parsing video FPS '%s'."), a->argv[3]);
    1920                     rc = E_FAIL;
     1920                    hrc = E_FAIL;
    19211921                    break;
    19221922                }
    … …  
    19311931                {
    19321932                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1933                     rc = E_FAIL;
     1933                    hrc = E_FAIL;
    19341934                    break;
    19351935                }
    … …  
    19401940                {
    19411941                    errorSyntax(ControlVM::tr("Error parsing maximum time '%s'."), a->argv[3]);
    1942                     rc = E_FAIL;
     1942                    hrc = E_FAIL;
    19431943                    break;
    19441944                }
    … …  
    19531953                {
    19541954                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1955                     rc = E_FAIL;
     1955                    hrc = E_FAIL;
    19561956                    break;
    19571957                }
    … …  
    19621962                {
    19631963                    errorSyntax(ControlVM::tr("Error parsing maximum file size '%s'."), a->argv[3]);
    1964                     rc = E_FAIL;
     1964                    hrc = E_FAIL;
    19651965                    break;
    19661966                }
    … …  
    19771977                {
    19781978                    errorSyntax(ControlVM::tr("Incorrect number of parameters."));
    1979                     rc = E_FAIL;
     1979                    hrc = E_FAIL;
    19801980                    break;
    19811981                }
    … …  
    19911991            {
    19921992                errorArgument(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    1993                 rc = E_FAIL;
     1993                hrc = E_FAIL;
    19941994                break;
    19951995            }
    … …  
    20002000            {
    20012001                RTMsgError(ControlVM::tr("Guest not running."));
    2002                 rc = E_FAIL;
     2002                hrc = E_FAIL;
    20032003                break;
    20042004            }
    … …  
    20362036            {
    20372037                errorArgument(ControlVM::tr("Invalid argument to '%s'."), a->argv[1]);
    2038                 rc = E_FAIL;
     2038                hrc = E_FAIL;
    20392039                break;
    20402040            }
    … …  
    21082108            if (!n)
    21092109            {
    2110                 rc = E_FAIL;
     2110                hrc = E_FAIL;
    21112111                break;
    21122112            }
    … …  
    21142114            {
    21152115                errorSyntax(ControlVM::tr("Missing argument to '%s'."), a->argv[1]);
    2116                 rc = E_FAIL;
     2116                hrc = E_FAIL;
    21172117                break;
    21182118            }
    … …  
    21282128                {
    21292129                    errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
    2130                     rc = E_FAIL;
     2130                    hrc = E_FAIL;
    21312131                    break;
    21322132                }
    … …  
    21432143                {
    21442144                    errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
    2145                     rc = E_FAIL;
     2145                    hrc = E_FAIL;
    21462146                    break;
    21472147                }
    … …  
    21842184                {
    21852185                    errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
    2186                     rc = E_FAIL;
     2186                    hrc = E_FAIL;
    21872187                    break;
    21882188                }
    … …  
    21972197            {
    21982198                errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
    2199                 rc = E_FAIL;
     2199                hrc = E_FAIL;
    22002200                break;
    22012201            }
    … …  
    22042204            {
    22052205                errorSyntax(ControlVM::tr("Invalid vm-process-priority '%s'."), a->argv[2]);
    2206                 rc = E_FAIL;
     2206                hrc = E_FAIL;
    22072207            }
    22082208            else
    … …  
    22182218            {
    22192219                errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
    2220                 rc = E_FAIL;
     2220                hrc = E_FAIL;
    22212221                break;
    22222222            }
    … …  
    22252225            {
    22262226                errorSyntax(ControlVM::tr("Invalid value '%s'."), a->argv[2]);
    2227                 rc = E_FAIL;
     2227                hrc = E_FAIL;
    22282228                break;
    22292229            }
    … …  
    22382238            {
    22392239                errorSyntax(ControlVM::tr("Incorrect arguments to '%s'."), a->argv[1]);
    2240                 rc = E_FAIL;
     2240                hrc = E_FAIL;
    22412241                break;
    22422242            }
    … …  
    22472247            {
    22482248                errorSyntax(ControlVM::tr("Invalid autostart delay number '%s'."), a->argv[2]);
    2249                 rc = E_FAIL;
     2249                hrc = E_FAIL;
    22502250                break;
    22512251            }
    22522252            CHECK_ERROR(sessionMachine, COMSETTER(AutostartDelay)(u32));
    2253             if (SUCCEEDED(rc))
     2253            if (SUCCEEDED(hrc))
    22542254                fNeedsSaving = true;
    22552255            break;
    … …  
    22582258        {
    22592259            errorSyntax(ControlVM::tr("Invalid parameter '%s'."), a->argv[1]);
    2260             rc = E_FAIL;
     2260            hrc = E_FAIL;
    22612261        }
    22622262    } while (0);
    … …  
    22682268    a->session->UnlockMachine();
    22692269
    2270     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     2270    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    22712271}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDHCPServer.cpp

    r93115 r95140  
    907907         * Find or create the server.
    908908         */
    909         HRESULT rc;
     909        HRESULT hrc;
    910910        Bstr NetName;
    911911        if (!pCtx->pszNetwork)
    … …  
    916916            ComPtr<IHostNetworkInterface> hif;
    917917            CHECK_ERROR(host, FindHostNetworkInterfaceByName(Bstr(pCtx->pszInterface).mutableRaw(), hif.asOutParam()));
    918             if (FAILED(rc))
     918            if (FAILED(hrc))
    919919                return errorArgument(DHCPServer::tr("Could not find interface '%s'"), pCtx->pszInterface);
    920920
    921921            CHECK_ERROR(hif, COMGETTER(NetworkName) (NetName.asOutParam()));
    922             if (FAILED(rc))
     922            if (FAILED(hrc))
    923923                return errorArgument(DHCPServer::tr("Could not get network name for the interface '%s'"), pCtx->pszInterface);
    924924        }
    … …  
    928928        }
    929929
    930         rc = pCtx->pArg->virtualBox->FindDHCPServerByNetworkName(NetName.mutableRaw(), ptrDHCPServer.asOutParam());
     930        hrc = pCtx->pArg->virtualBox->FindDHCPServerByNetworkName(NetName.mutableRaw(), ptrDHCPServer.asOutParam());
    931931        if (pCtx->pCmdDef->fSubcommandScope == HELP_SCOPE_DHCPSERVER_ADD)
    932932        {
    933             if (SUCCEEDED(rc))
     933            if (SUCCEEDED(hrc))
    934934                return errorArgument(DHCPServer::tr("DHCP server already exists"));
    935935
    936936            CHECK_ERROR(pCtx->pArg->virtualBox, CreateDHCPServer(NetName.mutableRaw(), ptrDHCPServer.asOutParam()));
    937             if (FAILED(rc))
     937            if (FAILED(hrc))
    938938                return errorArgument(DHCPServer::tr("Failed to create the DHCP server"));
    939939        }
    940         else if (FAILED(rc))
     940        else if (FAILED(hrc))
    941941            return errorArgument(DHCPServer::tr("DHCP server does not exist"));
    942942
    … …  
    944944         * Apply IDHCPServer settings:
    945945         */
    946         HRESULT hrc;
    947946        if (pszServerIp || pszNetmask || pszLowerIp || pszUpperIp)
    948947        {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r94236 r95140  
    171171                   bool fSilent)
    172172{
    173     HRESULT rc;
     173    HRESULT hrc;
    174174    Guid id(pszFilenameOrUuid);
    175175    char szFilenameAbs[RTPATH_MAX] = "";
    … …  
    195195                                              pMedium.asOutParam()));
    196196    else
    197         rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
    198                                        enmDevType,
    199                                        enmAccessMode,
    200                                        fForceNewUuidOnOpen,
    201                                        pMedium.asOutParam());
    202 
    203     return rc;
     197        hrc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
     198                                        enmDevType,
     199                                        enmAccessMode,
     200                                        fForceNewUuidOnOpen,
     201                                        pMedium.asOutParam());
     202
     203    return hrc;
    204204}
    205205
    … …  
    208208                            AccessMode_T enmAccessMode, ComPtr<IMedium> &pMedium)
    209209{
    210     HRESULT rc;
     210    HRESULT hrc;
    211211    char szFilenameAbs[RTPATH_MAX] = "";
    212212
    … …  
    228228                                            enmDevType,
    229229                                            pMedium.asOutParam()));
    230     return rc;
     230    return hrc;
    231231}
    232232
    … …  
    298298    std::list<MediumProperty> lstProperties;
    299299
    300     HRESULT rc;
     300    HRESULT hrc;
    301301    int vrc;
    302302    const char *filename = NULL;
    … …  
    497497                format = pszExt;
    498498        }
    499         rc = openMedium(a, diffparent, DeviceType_HardDisk,
    500                         AccessMode_ReadWrite, pParentMedium,
    501                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    502         if (FAILED(rc))
     499        hrc = openMedium(a, diffparent, DeviceType_HardDisk,
     500                         AccessMode_ReadWrite, pParentMedium,
     501                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     502        if (FAILED(hrc))
    503503            return RTEXITCODE_FAILURE;
    504504        if (pParentMedium.isNull())
    … …  
    506506        MediumState_T state;
    507507        CHECK_ERROR(pParentMedium, COMGETTER(State)(&state));
    508         if (FAILED(rc))
     508        if (FAILED(hrc))
    509509            return RTEXITCODE_FAILURE;
    510510        if (state == MediumState_Inaccessible)
    511511        {
    512512            CHECK_ERROR(pParentMedium, RefreshState(&state));
    513             if (FAILED(rc))
     513            if (FAILED(hrc))
    514514                return RTEXITCODE_FAILURE;
    515515        }
    … …  
    539539    ComPtr<IMedium> pMedium;
    540540    if (cmd == CMD_DISK)
    541         rc = createMedium(a, format, filename, DeviceType_HardDisk,
    542                           AccessMode_ReadWrite, pMedium);
     541        hrc = createMedium(a, format, filename, DeviceType_HardDisk,
     542                           AccessMode_ReadWrite, pMedium);
    543543    else if (cmd == CMD_DVD)
    544         rc = createMedium(a, format, filename, DeviceType_DVD,
    545                           AccessMode_ReadOnly, pMedium);
     544        hrc = createMedium(a, format, filename, DeviceType_DVD,
     545                           AccessMode_ReadOnly, pMedium);
    546546    else if (cmd == CMD_FLOPPY)
    547         rc = createMedium(a, format, filename, DeviceType_Floppy,
    548                           AccessMode_ReadWrite, pMedium);
     547        hrc = createMedium(a, format, filename, DeviceType_Floppy,
     548                           AccessMode_ReadWrite, pMedium);
    549549    else
    550         rc = E_INVALIDARG; /* cannot happen but make gcc happy */
    551 
    552 
    553     if (SUCCEEDED(rc) && pMedium)
     550        hrc = E_INVALIDARG; /* cannot happen but make gcc happy */
     551
     552
     553    if (SUCCEEDED(hrc) && pMedium)
    554554    {
    555555        if (lstProperties.size() > 0)
    … …  
    594594                {
    595595                    com::Bstr bstrBase64Value;
    596                     HRESULT hrc = bstrBase64Value.base64Encode(it->m_pszValue, it->m_cbValue);
     596                    hrc = bstrBase64Value.base64Encode(it->m_pszValue, it->m_cbValue);
    597597                    if (FAILED(hrc))
    598598                        return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Base64 encoding of the property %s failed. (%Rhrc)"),
    … …  
    617617        else
    618618            CHECK_ERROR(pParentMedium, CreateDiffStorage(pMedium, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam()));
    619         if (SUCCEEDED(rc) && pProgress)
    620         {
    621             rc = showProgress(pProgress);
     619        if (SUCCEEDED(hrc) && pProgress)
     620        {
     621            hrc = showProgress(pProgress);
    622622            CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to create medium")));
    623623        }
    624624    }
    625625
    626     if (SUCCEEDED(rc) && pMedium)
     626    if (SUCCEEDED(hrc) && pMedium)
    627627    {
    628628        Bstr uuid;
    … …  
    632632        //CHECK_ERROR(pMedium, Close());
    633633    }
    634     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     634    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    635635}
    636636
    … …  
    659659RTEXITCODE handleModifyMedium(HandlerArg *a)
    660660{
    661     HRESULT rc;
     661    HRESULT hrc;
    662662    int vrc;
    663663    enum {
    … …  
    747747                    {
    748748                        errorArgument(Disk::tr("Invalid --property argument '%s'"), ValueUnion.psz);
    749                         rc = E_FAIL;
     749                        hrc = E_FAIL;
    750750                    }
    751751                    RTStrFree(pszProperty);
    … …  
    755755                    RTStrmPrintf(g_pStdErr, Disk::tr("Error: Failed to allocate memory for medium property '%s'\n"),
    756756                                 ValueUnion.psz);
    757                     rc = E_FAIL;
     757                    hrc = E_FAIL;
    758758                }
    759759                break;
    … …  
    836836    /* Always open the medium if necessary, there is no other way. */
    837837    if (cmd == CMD_DISK)
    838         rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
    839                         AccessMode_ReadWrite, pMedium,
    840                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     838        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
     839                         AccessMode_ReadWrite, pMedium,
     840                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    841841    else if (cmd == CMD_DVD)
    842         rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
    843                         AccessMode_ReadOnly, pMedium,
    844                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     842        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
     843                         AccessMode_ReadOnly, pMedium,
     844                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    845845    else if (cmd == CMD_FLOPPY)
    846         rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
    847                         AccessMode_ReadWrite, pMedium,
    848                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     846        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
     847                         AccessMode_ReadWrite, pMedium,
     848                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    849849    else
    850         rc = E_INVALIDARG; /* cannot happen but make gcc happy */
    851     if (FAILED(rc))
     850        hrc = E_INVALIDARG; /* cannot happen but make gcc happy */
     851    if (FAILED(hrc))
    852852        return RTEXITCODE_FAILURE;
    853853    if (pMedium.isNull())
    … …  
    903903        ComPtr<IProgress> pProgress;
    904904        CHECK_ERROR(pMedium, Compact(pProgress.asOutParam()));
    905         if (SUCCEEDED(rc))
    906             rc = showProgress(pProgress);
    907         if (FAILED(rc))
    908         {
    909             if (rc == E_NOTIMPL)
     905        if (SUCCEEDED(hrc))
     906            hrc = showProgress(pProgress);
     907        if (FAILED(hrc))
     908        {
     909            if (hrc == E_NOTIMPL)
    910910                RTMsgError(Disk::tr("Compact medium operation is not implemented!"));
    911             else if (rc == VBOX_E_NOT_SUPPORTED)
     911            else if (hrc == VBOX_E_NOT_SUPPORTED)
    912912                RTMsgError(Disk::tr("Compact medium operation for this format is not implemented yet!"));
    913913            else if (!pProgress.isNull())
    … …  
    922922        ComPtr<IProgress> pProgress;
    923923        CHECK_ERROR(pMedium, Resize(cbResize, pProgress.asOutParam()));
    924         if (SUCCEEDED(rc))
    925             rc = showProgress(pProgress);
    926         if (FAILED(rc))
     924        if (SUCCEEDED(hrc))
     925            hrc = showProgress(pProgress);
     926        if (FAILED(hrc))
    927927        {
    928928            if (!pProgress.isNull())
    929929                CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to resize medium")));
    930             else if (rc == E_NOTIMPL)
     930            else if (hrc == E_NOTIMPL)
    931931                RTMsgError(Disk::tr("Resize medium operation is not implemented!"));
    932             else if (rc == VBOX_E_NOT_SUPPORTED)
     932            else if (hrc == VBOX_E_NOT_SUPPORTED)
    933933                RTMsgError(Disk::tr("Resize medium operation for this format is not implemented yet!"));
    934934            else
    … …  
    946946            CHECK_ERROR(pMedium, MoveTo(Bstr(strLocation).raw(), pProgress.asOutParam()));
    947947
    948             if (SUCCEEDED(rc) && !pProgress.isNull())
     948            if (SUCCEEDED(hrc) && !pProgress.isNull())
    949949            {
    950                 rc = showProgress(pProgress);
     950                hrc = showProgress(pProgress);
    951951                CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to move medium")));
    952952            }
    … …  
    978978    }
    979979
    980     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     980    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    981981}
    982982
    … …  
    997997RTEXITCODE handleCloneMedium(HandlerArg *a)
    998998{
    999     HRESULT rc;
     999    HRESULT hrc;
    10001000    int vrc;
    10011001    enum {
    … …  
    11001100
    11011101    if (cmd == CMD_DISK)
    1102         rc = openMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly, pSrcMedium,
    1103                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1102        hrc = openMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly, pSrcMedium,
     1103                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    11041104    else if (cmd == CMD_DVD)
    1105         rc = openMedium(a, pszSrc, DeviceType_DVD, AccessMode_ReadOnly, pSrcMedium,
    1106                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1105        hrc = openMedium(a, pszSrc, DeviceType_DVD, AccessMode_ReadOnly, pSrcMedium,
     1106                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    11071107    else if (cmd == CMD_FLOPPY)
    1108         rc = openMedium(a, pszSrc, DeviceType_Floppy, AccessMode_ReadOnly, pSrcMedium,
    1109                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1108        hrc = openMedium(a, pszSrc, DeviceType_Floppy, AccessMode_ReadOnly, pSrcMedium,
     1109                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    11101110    else
    1111         rc = E_INVALIDARG; /* cannot happen but make gcc happy */
    1112     if (FAILED(rc))
     1111        hrc = E_INVALIDARG; /* cannot happen but make gcc happy */
     1112    if (FAILED(hrc))
    11131113        return RTEXITCODE_FAILURE;
    11141114
    … …  
    11191119        {
    11201120            if (cmd == CMD_DISK)
    1121                 rc = openMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite, pDstMedium,
    1122                                 false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1121                hrc = openMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite, pDstMedium,
     1122                                 false /* fForceNewUuidOnOpen */, false /* fSilent */);
    11231123            else if (cmd == CMD_DVD)
    1124                 rc = openMedium(a, pszDst, DeviceType_DVD, AccessMode_ReadOnly, pDstMedium,
    1125                                 false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1124                hrc = openMedium(a, pszDst, DeviceType_DVD, AccessMode_ReadOnly, pDstMedium,
     1125                                 false /* fForceNewUuidOnOpen */, false /* fSilent */);
    11261126            else if (cmd == CMD_FLOPPY)
    1127                 rc = openMedium(a, pszDst, DeviceType_Floppy, AccessMode_ReadWrite, pDstMedium,
    1128                                 false /* fForceNewUuidOnOpen */, false /* fSilent */);
    1129             if (FAILED(rc))
     1127                hrc = openMedium(a, pszDst, DeviceType_Floppy, AccessMode_ReadWrite, pDstMedium,
     1128                                 false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1129            if (FAILED(hrc))
    11301130                break;
    11311131
    … …  
    11571157            Utf8Str strFormat(format);
    11581158            if (cmd == CMD_DISK)
    1159                 rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_HardDisk,
    1160                                   AccessMode_ReadWrite, pDstMedium);
     1159                hrc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_HardDisk,
     1160                                   AccessMode_ReadWrite, pDstMedium);
    11611161            else if (cmd == CMD_DVD)
    1162                 rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_DVD,
    1163                                   AccessMode_ReadOnly,  pDstMedium);
     1162                hrc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_DVD,
     1163                                   AccessMode_ReadOnly,  pDstMedium);
    11641164            else if (cmd == CMD_FLOPPY)
    1165                 rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_Floppy,
    1166                                   AccessMode_ReadWrite, pDstMedium);
    1167             if (FAILED(rc))
     1165                hrc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_Floppy,
     1166                                   AccessMode_ReadWrite, pDstMedium);
     1167            if (FAILED(hrc))
    11681168                break;
    11691169        }
    … …  
    11811181        CHECK_ERROR_BREAK(pSrcMedium, CloneTo(pDstMedium, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
    11821182
    1183         rc = showProgress(pProgress);
     1183        hrc = showProgress(pProgress);
    11841184        CHECK_PROGRESS_ERROR_BREAK(pProgress, (Disk::tr("Failed to clone medium")));
    11851185
    … …  
    11921192    while (0);
    11931193
    1194     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1194    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    11951195}
    11961196
    … …  
    13841384                       bool fOptLong)
    13851385{
    1386     HRESULT rc = S_OK;
     1386    HRESULT hrc = S_OK;
    13871387    do
    13881388    {
    … …  
    15341534        Bstr strCipher;
    15351535        Bstr strPasswordId;
    1536         HRESULT rc2 = pMedium->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
    1537         if (SUCCEEDED(rc2))
     1536        HRESULT hrc2 = pMedium->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
     1537        if (SUCCEEDED(hrc2))
    15381538        {
    15391539            RTPrintf(Disk::tr("Encryption:     enabled\n"));
    … …  
    16261626    while (0);
    16271627
    1628     return rc;
     1628    return hrc;
    16291629}
    16301630
    … …  
    17051705        return errorSyntax(Disk::tr("Medium name or UUID required"));
    17061706
    1707     HRESULT rc = S_OK; /* Prevents warning. */
     1707    HRESULT hrc = S_OK; /* Prevents warning. */
    17081708
    17091709    ComPtr<IMedium> pMedium;
    17101710    if (cmd == CMD_DISK)
    1711         rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
    1712                         AccessMode_ReadOnly, pMedium,
    1713                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1711        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
     1712                         AccessMode_ReadOnly, pMedium,
     1713                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    17141714    else if (cmd == CMD_DVD)
    1715         rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
    1716                         AccessMode_ReadOnly, pMedium,
    1717                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1715        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
     1716                         AccessMode_ReadOnly, pMedium,
     1717                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    17181718    else if (cmd == CMD_FLOPPY)
    1719         rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
    1720                         AccessMode_ReadOnly, pMedium,
    1721                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    1722     if (FAILED(rc))
     1719        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
     1720                         AccessMode_ReadOnly, pMedium,
     1721                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1722    if (FAILED(hrc))
    17231723        return RTEXITCODE_FAILURE;
    17241724
    … …  
    17331733    }
    17341734
    1735     rc = showMediumInfo(a->virtualBox, pMedium, strParentUUID.c_str(), true);
    1736 
    1737     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1735    hrc = showMediumInfo(a->virtualBox, pMedium, strParentUUID.c_str(), true);
     1736
     1737    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    17381738}
    17391739
    … …  
    17481748RTEXITCODE handleCloseMedium(HandlerArg *a)
    17491749{
    1750     HRESULT rc = S_OK;
     1750    HRESULT hrc = S_OK;
    17511751    enum {
    17521752        CMD_NONE,
    … …  
    18221822    ComPtr<IMedium> pMedium;
    18231823    if (cmd == CMD_DISK)
    1824         rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
    1825                         AccessMode_ReadWrite, pMedium,
    1826                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1824        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
     1825                         AccessMode_ReadWrite, pMedium,
     1826                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    18271827    else if (cmd == CMD_DVD)
    1828         rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
    1829                         AccessMode_ReadOnly, pMedium,
    1830                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1828        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
     1829                         AccessMode_ReadOnly, pMedium,
     1830                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    18311831    else if (cmd == CMD_FLOPPY)
    1832         rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
    1833                         AccessMode_ReadWrite, pMedium,
    1834                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    1835 
    1836     if (SUCCEEDED(rc) && pMedium)
     1832        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
     1833                         AccessMode_ReadWrite, pMedium,
     1834                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1835
     1836    if (SUCCEEDED(hrc) && pMedium)
    18371837    {
    18381838        if (fDelete)
    … …  
    18401840            ComPtr<IProgress> pProgress;
    18411841            CHECK_ERROR(pMedium, DeleteStorage(pProgress.asOutParam()));
    1842             if (SUCCEEDED(rc))
     1842            if (SUCCEEDED(hrc))
    18431843            {
    1844                 rc = showProgress(pProgress);
     1844                hrc = showProgress(pProgress);
    18451845                CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to delete medium")));
    18461846            }
    18471847            else
    1848                 RTMsgError(Disk::tr("Failed to delete medium. Error code %Rrc"), rc);
     1848                RTMsgError(Disk::tr("Failed to delete medium. Error code %Rhrc"), hrc);
    18491849        }
    18501850        CHECK_ERROR(pMedium, Close());
    18511851    }
    18521852
    1853     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1853    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    18541854}
    18551855
    18561856RTEXITCODE handleMediumProperty(HandlerArg *a)
    18571857{
    1858     HRESULT rc = S_OK;
     1858    HRESULT hrc = S_OK;
    18591859    const char *pszCmd = NULL;
    18601860    enum {
    … …  
    19131913
    19141914    if (cmd == CMD_DISK)
    1915         rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
    1916                         AccessMode_ReadWrite, pMedium,
    1917                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1915        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
     1916                         AccessMode_ReadWrite, pMedium,
     1917                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    19181918    else if (cmd == CMD_DVD)
    1919         rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
    1920                         AccessMode_ReadOnly, pMedium,
    1921                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1919        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
     1920                         AccessMode_ReadOnly, pMedium,
     1921                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    19221922    else if (cmd == CMD_FLOPPY)
    1923         rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
    1924                         AccessMode_ReadWrite, pMedium,
    1925                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
    1926     if (SUCCEEDED(rc) && !pMedium.isNull())
     1923        hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
     1924                         AccessMode_ReadWrite, pMedium,
     1925                         false /* fForceNewUuidOnOpen */, false /* fSilent */);
     1926    if (SUCCEEDED(hrc) && !pMedium.isNull())
    19271927    {
    19281928        if (!RTStrICmp(pszAction, "set"))
    … …  
    19431943            Bstr strVal;
    19441944            CHECK_ERROR(pMedium, GetProperty(Bstr(pszProperty).raw(), strVal.asOutParam()));
    1945             if (SUCCEEDED(rc))
     1945            if (SUCCEEDED(hrc))
    19461946                RTPrintf("%s=%ls\n", pszProperty, strVal.raw());
    19471947        }
    … …  
    19531953    }
    19541954
    1955     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1955    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    19561956}
    19571957
    … …  
    19661966RTEXITCODE handleEncryptMedium(HandlerArg *a)
    19671967{
    1968     HRESULT rc;
     1968    HRESULT hrc;
    19691969    ComPtr<IMedium> hardDisk;
    19701970    const char *pszPasswordNew = NULL;
    … …  
    20772077
    20782078    /* Always open the medium if necessary, there is no other way. */
    2079     rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
    2080                     AccessMode_ReadWrite, hardDisk,
    2081                     false /* fForceNewUuidOnOpen */, false /* fSilent */);
    2082     if (FAILED(rc))
     2079    hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
     2080                     AccessMode_ReadWrite, hardDisk,
     2081                     false /* fForceNewUuidOnOpen */, false /* fSilent */);
     2082    if (FAILED(hrc))
    20832083        return RTEXITCODE_FAILURE;
    20842084    if (hardDisk.isNull())
    … …  
    20892089                                           Bstr(strPasswordNew).raw(), Bstr(pszNewPasswordId).raw(),
    20902090                                           progress.asOutParam()));
    2091     if (SUCCEEDED(rc))
    2092         rc = showProgress(progress);
    2093     if (FAILED(rc))
    2094     {
    2095         if (rc == E_NOTIMPL)
     2091    if (SUCCEEDED(hrc))
     2092        hrc = showProgress(progress);
     2093    if (FAILED(hrc))
     2094    {
     2095        if (hrc == E_NOTIMPL)
    20962096            RTMsgError(Disk::tr("Encrypt hard disk operation is not implemented!"));
    2097         else if (rc == VBOX_E_NOT_SUPPORTED)
     2097        else if (hrc == VBOX_E_NOT_SUPPORTED)
    20982098            RTMsgError(Disk::tr("Encrypt hard disk operation for this cipher is not implemented yet!"));
    20992099        else if (!progress.isNull())
    … …  
    21032103    }
    21042104
    2105     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     2105    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    21062106}
    21072107
    21082108RTEXITCODE handleCheckMediumPassword(HandlerArg *a)
    21092109{
    2110     HRESULT rc;
     2110    HRESULT hrc;
    21112111    ComPtr<IMedium> hardDisk;
    21122112    const char *pszFilenameOrUuid = NULL;
    … …  
    21362136
    21372137    /* Always open the medium if necessary, there is no other way. */
    2138     rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
    2139                     AccessMode_ReadWrite, hardDisk,
    2140                     false /* fForceNewUuidOnOpen */, false /* fSilent */);
    2141     if (FAILED(rc))
     2138    hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
     2139                     AccessMode_ReadWrite, hardDisk,
     2140                     false /* fForceNewUuidOnOpen */, false /* fSilent */);
     2141    if (FAILED(hrc))
    21422142        return RTEXITCODE_FAILURE;
    21432143    if (hardDisk.isNull())
    … …  
    21452145
    21462146    CHECK_ERROR(hardDisk, CheckEncryptionPassword(Bstr(strPassword).raw()));
    2147     if (SUCCEEDED(rc))
     2147    if (SUCCEEDED(hrc))
    21482148        RTPrintf(Disk::tr("The given password is correct\n"));
    2149     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     2149    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    21502150}
    21512151

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

    r94234 r95140  
    494494{
    495495    int vrc = VINF_SUCCESS;
    496     HRESULT rc;
     496    HRESULT hrc;
    497497
    498498    do
    … …  
    513513    } while(0);
    514514
    515     AssertMsgStmt(SUCCEEDED(rc), (GuestCtrl::tr("Could not lookup progress information\n")), vrc = VERR_COM_UNEXPECTED);
     515    AssertMsgStmt(SUCCEEDED(hrc), (GuestCtrl::tr("Could not lookup progress information\n")), vrc = VERR_COM_UNEXPECTED);
    516516
    517517    return vrc;
    … …  
    656656static RTEXITCODE gctlCtxInitVmSession(PGCTLCMDCTX pCtx)
    657657{
    658     HRESULT rc;
     658    HRESULT hrc;
    659659    AssertPtr(pCtx);
    660660    AssertPtr(pCtx->pArg);
    … …  
    665665    ComPtr<IMachine> machine;
    666666    CHECK_ERROR(pCtx->pArg->virtualBox, FindMachine(Bstr(pCtx->pszVmNameOrUuid).raw(), machine.asOutParam()));
    667     if (SUCCEEDED(rc))
     667    if (SUCCEEDED(hrc))
    668668    {
    669669        MachineState_T enmMachineState;
    670670        CHECK_ERROR(machine, COMGETTER(State)(&enmMachineState));
    671         if (   SUCCEEDED(rc)
     671        if (   SUCCEEDED(hrc)
    672672            && enmMachineState == MachineState_Running)
    673673        {
    … …  
    676676             */
    677677            CHECK_ERROR(machine, LockMachine(pCtx->pArg->session, LockType_Shared));
    678             if (SUCCEEDED(rc))
     678            if (SUCCEEDED(hrc))
    679679            {
    680680                pCtx->fLockedVmSession = true;
    681681                ComPtr<IConsole> ptrConsole;
    682682                CHECK_ERROR(pCtx->pArg->session, COMGETTER(Console)(ptrConsole.asOutParam()));
    683                 if (SUCCEEDED(rc))
     683                if (SUCCEEDED(hrc))
    684684                {
    685685                    if (ptrConsole.isNotNull())
    686686                    {
    687687                        CHECK_ERROR(ptrConsole, COMGETTER(Guest)(pCtx->pGuest.asOutParam()));
    688                         if (SUCCEEDED(rc))
     688                        if (SUCCEEDED(hrc))
    689689                            return RTEXITCODE_SUCCESS;
    690690                    }
    … …  
    694694            }
    695695        }
    696         else if (SUCCEEDED(rc))
     696        else if (SUCCEEDED(hrc))
    697697            RTMsgError(GuestCtrl::tr("Machine \"%s\" is not running (currently %s)!\n"),
    698698                       pCtx->pszVmNameOrUuid, machineStateToName(enmMachineState, false));
    … …  
    713713static RTEXITCODE gctlCtxInitGuestSession(PGCTLCMDCTX pCtx)
    714714{
    715     HRESULT rc;
     715    HRESULT hrc;
    716716    AssertPtr(pCtx);
    717717    Assert(!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS));
    … …  
    744744    {
    745745        RTMsgError(GuestCtrl::tr("Out of memory setting up IGuest::CreateSession call"));
    746         rc = E_OUTOFMEMORY;
    747     }
    748     if (SUCCEEDED(rc))
     746        hrc = E_OUTOFMEMORY;
     747    }
     748    if (SUCCEEDED(hrc))
    749749    {
    750750        /*
    … …  
    765765        {
    766766            RTMsgError(GuestCtrl::tr("Out of memory setting up IGuestSession::WaitForArray call"));
    767             rc = E_OUTOFMEMORY;
    768         }
    769         if (SUCCEEDED(rc))
     767            hrc = E_OUTOFMEMORY;
     768        }
     769        if (SUCCEEDED(hrc))
    770770        {
    771771            /* The WaitFlagNotSupported result may happen with GAs older than 4.3. */
    … …  
    777777                 */
    778778                CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Id)(&pCtx->uSessionID));
    779                 if (SUCCEEDED(rc))
     779                if (SUCCEEDED(hrc))
    780780                {
    781781                    if (pCtx->cVerbose)
    … …  
    790790                CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Status)(&enmSessionStatus));
    791791                RTMsgError(GuestCtrl::tr("Error starting guest session (current status is: %s)\n"),
    792                            SUCCEEDED(rc) ? gctlGuestSessionStatusToText(enmSessionStatus) : GuestCtrl::tr("<unknown>"));
     792                           SUCCEEDED(hrc) ? gctlGuestSessionStatusToText(enmSessionStatus) : GuestCtrl::tr("<unknown>"));
    793793            }
    794794        }
    … …  
    868868static void gctlCtxTerm(PGCTLCMDCTX pCtx)
    869869{
    870     HRESULT rc;
     870    HRESULT hrc;
    871871    AssertPtr(pCtx);
    872872
    … …  
    13271327        return rcExit;
    13281328
    1329     HRESULT rc;
     1329    HRESULT hrc;
    13301330
    13311331    try
    … …  
    15441544    catch (std::bad_alloc &)
    15451545    {
    1546         rc = E_OUTOFMEMORY;
     1546        hrc = E_OUTOFMEMORY;
    15471547    }
    15481548
    … …  
    15561556     * For the 'run' command the guest process quits with us.
    15571557     */
    1558     if (!fRunCmd && SUCCEEDED(rc) && !g_fGuestCtrlCanceled)
     1558    if (!fRunCmd && SUCCEEDED(hrc) && !g_fGuestCtrlCanceled)
    15591559        pCtx->fDetachGuestSession = true;
    15601560
    15611561    /* Make sure we return failure on failure. */
    1562     if (FAILED(rc) && rcExit == RTEXITCODE_SUCCESS)
     1562    if (FAILED(hrc) && rcExit == RTEXITCODE_SUCCESS)
    15631563        rcExit = RTEXITCODE_FAILURE;
    15641564    return rcExit;
    … …  
    16741674    }
    16751675
    1676     HRESULT rc = S_OK;
     1676    HRESULT hrc = S_OK;
    16771677
    16781678    bool fDstIsDir = false;
    … …  
    16891689    {
    16901690        BOOL fDirExists = FALSE;
    1691         rc = pCtx->pGuestSession->DirectoryExists(Bstr(pszDst).raw(), TRUE /* fFollowSymlinks */, &fDirExists);
    1692         if (SUCCEEDED(rc))
     1691        hrc = pCtx->pGuestSession->DirectoryExists(Bstr(pszDst).raw(), TRUE /* fFollowSymlinks */, &fDirExists);
     1692        if (SUCCEEDED(hrc))
    16931693            fDstIsDir = RT_BOOL(fDirExists);
    16941694    }
    … …  
    17361736
    17371737                        SafeArray<FileCopyFlag_T> aCopyFlags;
    1738                         rc = pCtx->pGuestSession->FileCopyToGuest(Bstr(szAbsSrc).raw(), Bstr(pszDst).raw(),
    1739                                                                   ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
     1738                        hrc = pCtx->pGuestSession->FileCopyToGuest(Bstr(szAbsSrc).raw(), Bstr(pszDst).raw(),
     1739                                                                   ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
    17401740                    }
    17411741                    else if (RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
    … …  
    17501750                        if (fFollow)
    17511751                            aCopyFlags.push_back(DirectoryCopyFlag_FollowLinks);
    1752                         rc = pCtx->pGuestSession->DirectoryCopyToGuest(Bstr(szAbsSrc).raw(), Bstr(pszDst).raw(),
    1753                                                                        ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
     1752                        hrc = pCtx->pGuestSession->DirectoryCopyToGuest(Bstr(szAbsSrc).raw(), Bstr(pszDst).raw(),
     1753                                                                        ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
    17541754                    }
    17551755                    else
    … …  
    17691769            /* We need to query the source type on the guest first in order to know which copy flavor we need. */
    17701770            ComPtr<IGuestFsObjInfo> pFsObjInfo;
    1771             rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(pszSource).raw(), TRUE  /* fFollowSymlinks */, pFsObjInfo.asOutParam());
    1772             if (SUCCEEDED(rc))
     1771            hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(pszSource).raw(), TRUE  /* fFollowSymlinks */, pFsObjInfo.asOutParam());
     1772            if (SUCCEEDED(hrc))
    17731773            {
    17741774                FsObjType_T enmObjType;
    17751775                CHECK_ERROR(pFsObjInfo,COMGETTER(Type)(&enmObjType));
    1776                 if (SUCCEEDED(rc))
     1776                if (SUCCEEDED(hrc))
    17771777                {
    17781778                    /* Take action according to source file. */
    … …  
    17881788                        if (fFollow)
    17891789                            aCopyFlags.push_back(DirectoryCopyFlag_FollowLinks);
    1790                         rc = pCtx->pGuestSession->DirectoryCopyFromGuest(Bstr(pszSource).raw(), Bstr(pszDst).raw(),
    1791                                                                          ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
     1790                        hrc = pCtx->pGuestSession->DirectoryCopyFromGuest(Bstr(pszSource).raw(), Bstr(pszDst).raw(),
     1791                                                                          ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
    17921792                    }
    17931793                    else if (enmObjType == FsObjType_File)
    … …  
    17991799                        if (fFollow)
    18001800                            aCopyFlags.push_back(FileCopyFlag_FollowLinks);
    1801                         rc = pCtx->pGuestSession->FileCopyFromGuest(Bstr(pszSource).raw(), Bstr(pszDst).raw(),
    1802                                                                     ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
     1801                        hrc = pCtx->pGuestSession->FileCopyFromGuest(Bstr(pszSource).raw(), Bstr(pszDst).raw(),
     1802                                                                     ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam());
    18031803                    }
    18041804                    else
    … …  
    18091809            }
    18101810            else
    1811                 rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("FsObjQueryInfo failed on '%s': %Rhrc"), pszSource, rc);
    1812         }
    1813 
    1814         if (FAILED(rc))
     1811                rcExit = RTMsgErrorExitFailure(GuestCtrl::tr("FsObjQueryInfo failed on '%s': %Rhrc"), pszSource, hrc);
     1812        }
     1813
     1814        if (FAILED(hrc))
    18151815        {
    18161816            vrc = gctlPrintError(pCtx->pGuestSession, COM_IIDOF(IGuestSession));
    … …  
    18191819        {
    18201820            if (pCtx->cVerbose)
    1821                 rc = showProgress(pProgress);
     1821                hrc = showProgress(pProgress);
    18221822            else
    1823                 rc = pProgress->WaitForCompletion(-1 /* No timeout */);
    1824             if (SUCCEEDED(rc))
     1823                hrc = pProgress->WaitForCompletion(-1 /* No timeout */);
     1824            if (SUCCEEDED(hrc))
    18251825                CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("File copy failed")));
    18261826            vrc = gctlPrintProgressError(pProgress);
    … …  
    19121912                try
    19131913                {
    1914                     HRESULT rc;
     1914                    HRESULT hrc;
    19151915                    CHECK_ERROR(pCtx->pGuestSession, DirectoryCreate(Bstr(ValueUnion.psz).raw(),
    19161916                                                                     fDirMode, ComSafeArrayAsInParam(aDirCreateFlags)));
    1917                     if (FAILED(rc))
     1917                    if (FAILED(hrc))
    19181918                        rcExit = RTEXITCODE_FAILURE;
    19191919                }
    … …  
    19901990
    19911991                cDirRemoved++;
    1992                 HRESULT rc;
     1992                HRESULT hrc;
    19931993                if (!fRecursive)
    19941994                {
    … …  
    20272027                                                                                  ComSafeArrayAsInParam(aRemRecFlags),
    20282028                                                                                  ptrProgress.asOutParam()));
    2029                         if (SUCCEEDED(rc))
     2029                        if (SUCCEEDED(hrc))
    20302030                        {
    20312031                            if (pCtx->cVerbose)
    2032                                 rc = showProgress(ptrProgress);
     2032                                hrc = showProgress(ptrProgress);
    20332033                            else
    2034                                 rc = ptrProgress->WaitForCompletion(-1 /* indefinitely */);
    2035                             if (SUCCEEDED(rc))
     2034                                hrc = ptrProgress->WaitForCompletion(-1 /* indefinitely */);
     2035                            if (SUCCEEDED(hrc))
    20362036                                CHECK_PROGRESS_ERROR(ptrProgress, (GuestCtrl::tr("Directory deletion failed")));
    20372037                            ptrProgress.setNull();
    … …  
    20472047                 * This command returns immediately on failure since it's destructive in nature.
    20482048                 */
    2049                 if (FAILED(rc))
     2049                if (FAILED(hrc))
    20502050                    return RTEXITCODE_FAILURE;
    20512051                break;
    … …  
    21182118                    /** @todo How does IGuestSession::FsObjRemove work with read-only files? Do we
    21192119                     *        need to do some chmod or whatever to better emulate the --force flag? */
    2120                     HRESULT rc;
     2120                    HRESULT hrc;
    21212121                    CHECK_ERROR(pCtx->pGuestSession, FsObjRemove(Bstr(ValueUnion.psz).raw()));
    2122                     if (FAILED(rc) && !fForce)
     2122                    if (FAILED(hrc) && !fForce)
    21232123                        return RTEXITCODE_FAILURE;
    21242124                }
    … …  
    22092209    cSources = vecSources.size();
    22102210
    2211     HRESULT rc = S_OK;
     2211    HRESULT hrc = S_OK;
    22122212
    22132213    /* Destination must be a directory when specifying multiple sources. */
    … …  
    22152215    {
    22162216        ComPtr<IGuestFsObjInfo> pFsObjInfo;
    2217         rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(pszDst).raw(), FALSE /*followSymlinks*/, pFsObjInfo.asOutParam());
    2218         if (FAILED(rc))
     2217        hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(pszDst).raw(), FALSE /*followSymlinks*/, pFsObjInfo.asOutParam());
     2218        if (FAILED(hrc))
    22192219        {
    22202220            return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Destination does not exist\n"));
    … …  
    22232223        {
    22242224            FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */
    2225             rc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
    2226             if (SUCCEEDED(rc))
     2225            hrc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
     2226            if (SUCCEEDED(hrc))
    22272227            {
    22282228                if (enmObjType != FsObjType_Directory)
    … …  
    22332233                return RTMsgErrorExit(RTEXITCODE_FAILURE,
    22342234                                      GuestCtrl::tr("Unable to determine destination type: %Rhrc\n"),
    2235                                       rc);
     2235                                      hrc);
    22362236        }
    22372237    }
    … …  
    22522252        ComPtr<IGuestFsObjInfo> pFsObjInfo;
    22532253        FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */
    2254         rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(strSrcCur).raw(), FALSE /*followSymlinks*/, pFsObjInfo.asOutParam());
    2255         if (SUCCEEDED(rc))
    2256             rc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
    2257         if (FAILED(rc))
     2254        hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(strSrcCur).raw(), FALSE /*followSymlinks*/, pFsObjInfo.asOutParam());
     2255        if (SUCCEEDED(hrc))
     2256            hrc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
     2257        if (FAILED(hrc))
    22582258        {
    22592259            RTPrintf(GuestCtrl::tr("Cannot stat \"%s\": No such file or directory\n"), strSrcCur.c_str());
    … …  
    22972297    }
    22982298
    2299     return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
     2299    return FAILED(hrc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
    23002300}
    23012301
    … …  
    23902390    }
    23912391
    2392     HRESULT rc = S_OK;
     2392    HRESULT hrc = S_OK;
    23932393    if (fDirectory)
    23942394    {
    … …  
    23982398                                                             fSecure,
    23992399                                                             bstrDirectory.asOutParam()));
    2400         if (SUCCEEDED(rc))
     2400        if (SUCCEEDED(hrc))
    24012401            RTPrintf(GuestCtrl::tr("Directory name: %ls\n"), bstrDirectory.raw());
    24022402    }
    … …  
    24062406        /** @todo implement temporary file creation (we fend it off above, no
    24072407         *        worries). */
    2408         rc = E_FAIL;
    2409     }
    2410 
    2411     return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
     2408        hrc = E_FAIL;
     2409    }
     2410
     2411    return FAILED(hrc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
    24122412}
    24132413
    … …  
    25682568    try
    25692569    {
    2570         HRESULT rc = S_OK;
     2570        HRESULT hrc = S_OK;
    25712571        /** Whether we need to actually wait for the run level or if we already reached it. */
    25722572        bool fWait = false;
    … …  
    27452745        RTPrintf(GuestCtrl::tr("Updating Guest Additions ...\n"));
    27462746
    2747     HRESULT rc = S_OK;
     2747    HRESULT hrc = S_OK;
    27482748    while (strSource.isEmpty())
    27492749    {
    … …  
    27732773        ComPtr<IGuest> guest;
    27742774        rc = pConsole->COMGETTER(Guest)(guest.asOutParam());
    2775         if (SUCCEEDED(rc) && !guest.isNull())
     2775        if (SUCCEEDED(hrc) && !guest.isNull())
    27762776        {
    27772777            SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", GuestCtrl::tr("OS type:"));
    … …  
    27792779            AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
    27802780            rc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
    2781             if (SUCCEEDED(rc))
     2781            if (SUCCEEDED(hrc))
    27822782                SHOW_ULONG_VALUE("GuestAdditionsRunLevel", GuestCtrl::tr("Additions run level:"), (ULONG)guestRunLevel, "");
    27832783
    27842784            Bstr guestString;
    27852785            rc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
    2786             if (   SUCCEEDED(rc)
     2786            if (   SUCCEEDED(hrc)
    27872787                && !guestString.isEmpty())
    27882788            {
    27892789                ULONG uRevision;
    27902790                rc = guest->COMGETTER(AdditionsRevision)(&uRevision);
    2791                 if (FAILED(rc))
     2791                if (FAILED(hrc))
    27922792                    uRevision = 0;
    27932793                RTStrPrintf(szValue, sizeof(szValue), "%ls r%u", guestString.raw(), uRevision);
    … …  
    28222822            Bstr  strGstVerCur;
    28232823            ULONG uGstRevCur   = 0;
    2824             rc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerCur.asOutParam());
    2825             if (   SUCCEEDED(rc)
     2824            hrc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerCur.asOutParam());
     2825            if (   SUCCEEDED(hrc)
    28262826                && !strGstVerCur.isEmpty())
    28272827            {
    2828                 rc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevCur);
    2829                 if (SUCCEEDED(rc))
     2828                hrc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevCur);
     2829                if (SUCCEEDED(hrc))
    28302830                {
    28312831                    if (pCtx->cVerbose)
    … …  
    28442844                                                           ComSafeArrayAsInParam(aUpdateFlags),
    28452845                                                           pProgress.asOutParam()));
    2846             if (FAILED(rc))
     2846            if (FAILED(hrc))
    28472847                vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest));
    28482848            else
    28492849            {
    28502850                if (pCtx->cVerbose)
    2851                     rc = showProgress(pProgress);
     2851                    hrc = showProgress(pProgress);
    28522852                else
    2853                     rc = pProgress->WaitForCompletion((int32_t)cMsTimeout);
    2854 
    2855                 if (SUCCEEDED(rc))
     2853                    hrc = pProgress->WaitForCompletion((int32_t)cMsTimeout);
     2854
     2855                if (SUCCEEDED(hrc))
    28562856                    CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("Guest Additions update failed")));
    28572857                vrc = gctlPrintProgressError(pProgress);
    … …  
    28682868                        aShutdownFlags.push_back(GuestShutdownFlag_Reboot);
    28692869                        CHECK_ERROR(pCtx->pGuest, Shutdown(ComSafeArrayAsInParam(aShutdownFlags)));
    2870                         if (FAILED(rc))
     2870                        if (FAILED(hrc))
    28712871                        {
    2872                             if (rc == VBOX_E_NOT_SUPPORTED)
     2872                            if (hrc == VBOX_E_NOT_SUPPORTED)
    28732873                            {
    28742874                                RTPrintf(GuestCtrl::tr("Current installed Guest Additions don't support automatic rebooting. "
    … …  
    28972897                                        Bstr strGstVerNew;
    28982898                                        ULONG uGstRevNew   = 0;
    2899                                         rc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerNew.asOutParam());
    2900                                         if (   SUCCEEDED(rc)
     2899                                        hrc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerNew.asOutParam());
     2900                                        if (   SUCCEEDED(hrc)
    29012901                                            && !strGstVerNew.isEmpty())
    29022902                                        {
    2903                                             rc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevNew);
    2904                                             if (FAILED(rc))
     2903                                            hrc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevNew);
     2904                                            if (FAILED(hrc))
    29052905                                                uGstRevNew = 0;
    29062906                                        }
    … …  
    30843084    /** @todo Do we need a machine-readable output here as well? */
    30853085
    3086     HRESULT rc;
     3086    HRESULT hrc;
    30873087    size_t cTotalProcs = 0;
    30883088    size_t cTotalFiles = 0;
    … …  
    30903090    SafeIfaceArray <IGuestSession> collSessions;
    30913091    CHECK_ERROR(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
    3092     if (SUCCEEDED(rc))
     3092    if (SUCCEEDED(hrc))
    30933093    {
    30943094        size_t const cSessions = collSessions.size();
    … …  
    31863186    }
    31873187
    3188     if (FAILED(rc)) /** @todo yeah, right... Only the last error? */
     3188    if (FAILED(hrc)) /** @todo yeah, right... Only the last error? */
    31893189        rcExit = RTEXITCODE_FAILURE;
    31903190
    … …  
    32763276        return rcExit;
    32773277
    3278     HRESULT rc = S_OK;
     3278    HRESULT hrc = S_OK;
    32793279
    32803280    ComPtr<IGuestSession> pSession;
    … …  
    33633363    pSession.setNull();
    33643364
    3365     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     3365    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    33663366}
    33673367
    … …  
    34303430        return rcExit;
    34313431
    3432     HRESULT rc = S_OK;
     3432    HRESULT hrc = S_OK;
    34333433
    34343434    do
    … …  
    34753475        {
    34763476            RTPrintf(GuestCtrl::tr("No guest session(s) found\n"));
    3477             rc = E_ABORT; /* To set exit code accordingly. */
     3477            hrc = E_ABORT; /* To set exit code accordingly. */
    34783478        }
    34793479
    34803480    } while (0);
    34813481
    3482     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     3482    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    34833483}
    34843484
    … …  
    35273527        return rcExit;
    35283528
    3529     HRESULT rc;
     3529    HRESULT hrc;
    35303530
    35313531    try
    … …  
    35863586    catch (std::bad_alloc &)
    35873587    {
    3588         rc = E_OUTOFMEMORY;
    3589     }
    3590 
    3591     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     3588        hrc = E_OUTOFMEMORY;
     3589    }
     3590
     3591    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    35923592}
    35933593

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrlListener.cpp

    r94234 r95140  
    8888        case VBoxEventType_OnGuestFileStateChanged:
    8989        {
    90             HRESULT rc;
     90            HRESULT hrc;
    9191            do
    9292            {
    … …  
    144144        case VBoxEventType_OnGuestProcessStateChanged:
    145145        {
    146             HRESULT rc;
     146            HRESULT hrc;
    147147            do
    148148            {
    … …  
    196196        if (!itProc->first.isNull())
    197197        {
    198             HRESULT rc;
     198            HRESULT hrc;
    199199            do
    200200            {
    … …  
    216216        if (!itFile->first.isNull())
    217217        {
    218             HRESULT rc;
     218            HRESULT hrc;
    219219            do
    220220            {
    … …  
    238238        case VBoxEventType_OnGuestFileRegistered:
    239239        {
    240             HRESULT rc;
     240            HRESULT hrc;
    241241            do
    242242            {
    … …  
    302302        case VBoxEventType_OnGuestProcessRegistered:
    303303        {
    304             HRESULT rc;
     304            HRESULT hrc;
    305305            do
    306306            {
    … …  
    366366        case VBoxEventType_OnGuestSessionStateChanged:
    367367        {
    368             HRESULT rc;
     368            HRESULT hrc;
    369369            do
    370370            {
    … …  
    418418        if (!itSession->first.isNull())
    419419        {
    420             HRESULT rc;
     420            HRESULT hrc;
    421421            do
    422422            {
    … …  
    441441        case VBoxEventType_OnGuestSessionRegistered:
    442442        {
    443             HRESULT rc;
     443            HRESULT hrc;
    444444            do
    445445            {
    … …  
    537537    Assert(mRunLevelTarget != AdditionsRunLevelType_None);
    538538
    539     HRESULT rc;
     539    HRESULT hrc;
    540540
    541541    switch (aType)

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp

    r94234 r95140  
    5252static RTEXITCODE handleGetGuestProperty(HandlerArg *a)
    5353{
    54     HRESULT rc = S_OK;
     54    HRESULT hrc = S_OK;
    5555
    5656    setCurrentSubcommand(HELP_SCOPE_GUESTPROPERTY_GET);
    … …  
    9191        }
    9292    }
    93     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     93    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    9494}
    9595
    9696static RTEXITCODE handleSetGuestProperty(HandlerArg *a)
    9797{
    98     HRESULT rc = S_OK;
     98    HRESULT hrc = S_OK;
    9999
    100100    setCurrentSubcommand(HELP_SCOPE_GUESTPROPERTY_SET);
    … …  
    146146                                                  Bstr(pszFlags).raw()));
    147147
    148         if (SUCCEEDED(rc))
     148        if (SUCCEEDED(hrc))
    149149            CHECK_ERROR(machine, SaveSettings());
    150150
    151151        a->session->UnlockMachine();
    152152    }
    153     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     153    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    154154}
    155155
    156156static RTEXITCODE handleDeleteGuestProperty(HandlerArg *a)
    157157{
    158     HRESULT rc = S_OK;
     158    HRESULT hrc = S_OK;
    159159
    160160    setCurrentSubcommand(HELP_SCOPE_GUESTPROPERTY_UNSET);
    … …  
    186186        CHECK_ERROR(machine, DeleteGuestProperty(Bstr(pszName).raw()));
    187187
    188         if (SUCCEEDED(rc))
     188        if (SUCCEEDED(hrc))
    189189            CHECK_ERROR(machine, SaveSettings());
    190190
    191191        a->session->UnlockMachine();
    192192    }
    193     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     193    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    194194}
    195195
    … …  
    226226     */
    227227    ComPtr<IMachine> machine;
    228     HRESULT rc;
     228    HRESULT hrc;
    229229    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    230230                                           machine.asOutParam()));
    … …  
    246246                                                      ComSafeArrayAsOutParam(timestamps),
    247247                                                      ComSafeArrayAsOutParam(flags)));
    248         if (SUCCEEDED(rc))
     248        if (SUCCEEDED(hrc))
    249249        {
    250250            if (names.size() == 0)
    … …  
    255255        }
    256256    }
    257     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     257    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    258258}
    259259
    … …  
    280280        pszPatterns = a->argv[1];
    281281    ComPtr<IMachine> machine;
    282     HRESULT rc;
     282    HRESULT hrc;
    283283    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
    284284                                           machine.asOutParam()));
    … …  
    334334
    335335        ComPtr<IEvent> ev;
    336         rc = es->GetEvent(listener, cMsWait, ev.asOutParam());
    337         if (ev)
     336        hrc = es->GetEvent(listener, cMsWait, ev.asOutParam());
     337        if (ev) /** @todo r=andy Why not using SUCCEEDED(hrc) here? */
    338338        {
    339339            VBoxEventType_T aType;
    340             rc = ev->COMGETTER(Type)(&aType);
     340            hrc = ev->COMGETTER(Type)(&aType);
    341341            switch (aType)
    342342            {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r94660 r95140  
    10771077                   VMINFO_DETAILS details /*= VMINFO_NONE*/)
    10781078{
    1079     HRESULT rc;
     1079    HRESULT hrc;
    10801080    ComPtr<IConsole> pConsole;
    10811081    if (pSession)
    … …  
    11181118            {
    11191119                Bstr settingsFilePath;
    1120                 rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
     1120                hrc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
    11211121                RTPrintf(Info::tr("Config file:     %ls\n"), settingsFilePath.raw());
    11221122
    11231123                Bstr strCipher;
    11241124                Bstr strPasswordId;
    1125                 HRESULT rc2 = machine->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
    1126                 if (SUCCEEDED(rc2))
     1125                HRESULT hrc2 = machine->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
     1126                if (SUCCEEDED(hrc2))
    11271127                {
    11281128                    RTPrintf("Encryption:     enabled\n");
    … …  
    11341134
    11351135                ComPtr<IVirtualBoxErrorInfo> accessError;
    1136                 rc = machine->COMGETTER(AccessError)(accessError.asOutParam());
     1136                hrc = machine->COMGETTER(AccessError)(accessError.asOutParam());
    11371137                RTPrintf(Info::tr("Access error details:\n"));
    11381138                ErrorInfo ei(accessError);
    … …  
    11591159        Bstr strCipher;
    11601160        Bstr strPasswordId;
    1161         HRESULT rc2 = machine->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
    1162         if (SUCCEEDED(rc2))
     1161        HRESULT hrc2 = machine->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
     1162        if (SUCCEEDED(hrc2))
    11631163        {
    11641164            RTPrintf("Encryption:     enabled\n");
    … …  
    12501250    {
    12511251        ULONG uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX;
    1252         rc = machine->GetCPUIDLeafByOrdinal(uOrdinal, &uLeaf, &uSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
    1253         if (SUCCEEDED(rc))
     1252        hrc = machine->GetCPUIDLeafByOrdinal(uOrdinal, &uLeaf, &uSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
     1253        if (SUCCEEDED(hrc))
    12541254        {
    12551255            if (details == VMINFO_MACHINEREADABLE)
    … …  
    12641264        else
    12651265        {
    1266             if (rc != E_INVALIDARG)
    1267                 com::GlueHandleComError(machine, "GetCPUIDLeaf", rc, __FILE__, __LINE__);
     1266            if (hrc != E_INVALIDARG)
     1267                com::GlueHandleComError(machine, "GetCPUIDLeaf", hrc, __FILE__, __LINE__);
    12681268            break;
    12691269        }
    … …  
    14181418
    14191419    GraphicsControllerType_T enmGraphics;
    1420     rc = pGraphicsAdapter->COMGETTER(GraphicsControllerType)(&enmGraphics);
    1421     if (SUCCEEDED(rc))
     1420    hrc = pGraphicsAdapter->COMGETTER(GraphicsControllerType)(&enmGraphics);
     1421    if (SUCCEEDED(hrc))
    14221422    {
    14231423        const char *pszCtrl;
    … …  
    15591559                         storageControllerTypeToName(enmCtlType, false), uInstance, cPorts, cMaxPorts,
    15601560                         fBootable ? Info::tr("Bootable") : Info::tr("Not bootable"));
    1561                 rc = showMediumAttachments(machine, storageCtl, details);
    1562                 if (FAILED(rc))
    1563                     return rc;
     1561                hrc = showMediumAttachments(machine, storageCtl, details);
     1562                if (FAILED(hrc))
     1563                    return hrc;
    15641564            }
    15651565        }
    … …  
    15711571        for (size_t j = 0; j < storageCtls.size(); ++ j)
    15721572        {
    1573             rc = showMediumAttachments(machine, storageCtls[j], details);
    1574             if (FAILED(rc))
    1575                 return rc;
     1573            hrc = showMediumAttachments(machine, storageCtls[j], details);
     1574            if (FAILED(hrc))
     1575                return hrc;
    15761576        }
    15771577
    … …  
    15821582    {
    15831583        ComPtr<INetworkAdapter> nic;
    1584         rc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam());
    1585         if (SUCCEEDED(rc) && nic)
     1584        hrc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam());
     1585        if (SUCCEEDED(hrc) && nic)
    15861586        {
    15871587            FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "nic%u" : Info::tr("NIC %u:"), currentNIC + 1);
    … …  
    17661766                            com::SafeArray<BSTR> aProperties;
    17671767                            com::SafeArray<BSTR> aValues;
    1768                             rc = nic->GetProperties(NULL,
    1769                                                     ComSafeArrayAsOutParam(aProperties),
    1770                                                     ComSafeArrayAsOutParam(aValues));
    1771                             if (SUCCEEDED(rc))
     1768                            hrc = nic->GetProperties(NULL,
     1769                                                     ComSafeArrayAsOutParam(aProperties),
     1770                                                     ComSafeArrayAsOutParam(aValues));
     1771                            if (SUCCEEDED(hrc))
    17721772                            {
    17731773                                strAttachment += " { ";
    … …  
    20032003    {
    20042004        ComPtr<ISerialPort> uart;
    2005         rc = machine->GetSerialPort(currentUART, uart.asOutParam());
    2006         if (SUCCEEDED(rc) && uart)
     2005        hrc = machine->GetSerialPort(currentUART, uart.asOutParam());
     2006        if (SUCCEEDED(hrc) && uart)
    20072007        {
    20082008            FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "uart%u" : Info::tr("UART %u:"), currentUART + 1);
    … …  
    21092109    {
    21102110        ComPtr<IParallelPort> lpt;
    2111         rc = machine->GetParallelPort(currentLPT, lpt.asOutParam());
    2112         if (SUCCEEDED(rc) && lpt)
     2111        hrc = machine->GetParallelPort(currentLPT, lpt.asOutParam());
     2112        if (SUCCEEDED(hrc) && lpt)
    21132113        {
    21142114            FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "lpt%u" : Info::tr("LPT %u:"), currentLPT + 1);
    … …  
    21452145
    21462146    ComPtr<IAudioAdapter> AudioAdapter;
    2147     rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());
    2148     if (SUCCEEDED(rc))
     2147    hrc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());
     2148    if (SUCCEEDED(hrc))
    21492149    {
    21502150        const char *pszDrv   = Info::tr("Unknown");
    … …  
    21522152        const char *pszCodec = Info::tr("Unknown");
    21532153        BOOL fEnabled;
    2154         rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
    2155         if (SUCCEEDED(rc) && fEnabled)
     2154        hrc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
     2155        if (SUCCEEDED(hrc) && fEnabled)
    21562156        {
    21572157            AudioDriverType_T enmDrvType;
    2158             rc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType);
     2158            hrc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType);
    21592159            switch (enmDrvType)
    21602160            {
    … …  
    22132213            }
    22142214            AudioControllerType_T enmCtrlType;
    2215             rc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType);
     2215            hrc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType);
    22162216            switch (enmCtrlType)
    22172217            {
    … …  
    22382238            }
    22392239            AudioCodecType_T enmCodecType;
    2240             rc = AudioAdapter->COMGETTER(AudioCodec)(&enmCodecType);
     2240            hrc = AudioAdapter->COMGETTER(AudioCodec)(&enmCodecType);
    22412241            switch (enmCodecType)
    22422242            {
    … …  
    22772277        const char *psz;
    22782278        ClipboardMode_T enmMode = (ClipboardMode_T)0;
    2279         rc = machine->COMGETTER(ClipboardMode)(&enmMode);
     2279        hrc = machine->COMGETTER(ClipboardMode)(&enmMode);
    22802280        switch (enmMode)
    22812281        {
    … …  
    23062306        const char *psz;
    23072307        DnDMode_T enmMode;
    2308         rc = machine->COMGETTER(DnDMode)(&enmMode);
     2308        hrc = machine->COMGETTER(DnDMode)(&enmMode);
    23092309        switch (enmMode)
    23102310        {
    … …  
    23302330    {
    23312331        SessionState_T sessState;
    2332         rc = machine->COMGETTER(SessionState)(&sessState);
    2333         if (SUCCEEDED(rc) && sessState != SessionState_Unlocked)
     2332        hrc = machine->COMGETTER(SessionState)(&sessState);
     2333        if (SUCCEEDED(hrc) && sessState != SessionState_Unlocked)
    23342334        {
    23352335            Bstr sessName;
    2336             rc = machine->COMGETTER(SessionName)(sessName.asOutParam());
    2337             if (SUCCEEDED(rc) && !sessName.isEmpty())
     2336            hrc = machine->COMGETTER(SessionName)(sessName.asOutParam());
     2337            if (SUCCEEDED(hrc) && !sessName.isEmpty())
    23382338                SHOW_BSTR_STRING("SessionName", Info::tr("Session name:"), sessName);
    23392339        }
    … …  
    23452345        {
    23462346            ComPtr<IDisplay> display;
    2347             rc = pConsole->COMGETTER(Display)(display.asOutParam());
    2348             if (rc == E_ACCESSDENIED || display.isNull())
     2347            hrc = pConsole->COMGETTER(Display)(display.asOutParam());
     2348            if (hrc == E_ACCESSDENIED || display.isNull())
    23492349                break; /* VM not powered up */
    2350             if (FAILED(rc))
    2351             {
    2352                 com::GlueHandleComError(pConsole, "COMGETTER(Display)(display.asOutParam())", rc, __FILE__, __LINE__);
    2353                 return rc;
     2350            if (FAILED(hrc))
     2351            {
     2352                com::GlueHandleComError(pConsole, "COMGETTER(Display)(display.asOutParam())", hrc, __FILE__, __LINE__);
     2353                return hrc;
    23542354            }
    23552355            ULONG xRes, yRes, bpp;
    23562356            LONG xOrigin, yOrigin;
    23572357            GuestMonitorStatus_T monitorStatus;
    2358             rc = display->GetScreenResolution(0, &xRes, &yRes, &bpp, &xOrigin, &yOrigin, &monitorStatus);
    2359             if (rc == E_ACCESSDENIED)
     2358            hrc = display->GetScreenResolution(0, &xRes, &yRes, &bpp, &xOrigin, &yOrigin, &monitorStatus);
     2359            if (hrc == E_ACCESSDENIED)
    23602360                break; /* VM not powered up */
    2361             if (FAILED(rc))
     2361            if (FAILED(hrc))
    23622362            {
    23632363                com::ErrorInfo info(display, COM_IIDOF(IDisplay));
    23642364                GluePrintErrorInfo(info);
    2365                 return rc;
     2365                return hrc;
    23662366            }
    23672367            if (details == VMINFO_MACHINEREADABLE)
    … …  
    23872387     */
    23882388    ComPtr<IVRDEServer> vrdeServer;
    2389     rc = machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
    2390     if (SUCCEEDED(rc) && vrdeServer)
     2389    hrc = machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
     2390    if (SUCCEEDED(hrc) && vrdeServer)
    23912391    {
    23922392        BOOL fEnabled = false;
    … …  
    24422442            {
    24432443                ComPtr<IVRDEServerInfo> vrdeServerInfo;
    2444                 CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), rc);
     2444                CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), hrc);
    24452445                if (!vrdeServerInfo.isNull())
    24462446                {
    2447                     rc = vrdeServerInfo->COMGETTER(Port)(&currentPort);
    2448                     if (rc == E_ACCESSDENIED)
     2447                    hrc = vrdeServerInfo->COMGETTER(Port)(&currentPort);
     2448                    if (hrc == E_ACCESSDENIED)
    24492449                    {
    24502450                        currentPort = -1; /* VM not powered up */
    24512451                    }
    2452                     else if (FAILED(rc))
     2452                    else if (FAILED(hrc))
    24532453                    {
    24542454                        com::ErrorInfo info(vrdeServerInfo, COM_IIDOF(IVRDEServerInfo));
    24552455                        GluePrintErrorInfo(info);
    2456                         return rc;
     2456                        return hrc;
    24572457                    }
    24582458                }
    … …  
    25232523     */
    25242524    SafeIfaceArray<IUSBController> USBCtlColl;
    2525     rc = machine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(USBCtlColl));
    2526     if (SUCCEEDED(rc))
     2525    hrc = machine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(USBCtlColl));
     2526    if (SUCCEEDED(hrc))
    25272527    {
    25282528        bool fOhciEnabled = false;
    … …  
    25342534            USBControllerType_T enmType;
    25352535
    2536             rc = USBCtlColl[i]->COMGETTER(Type)(&enmType);
    2537             if (SUCCEEDED(rc))
     2536            hrc = USBCtlColl[i]->COMGETTER(Type)(&enmType);
     2537            if (SUCCEEDED(hrc))
    25382538            {
    25392539                switch (enmType)
    … …  
    25602560
    25612561    ComPtr<IUSBDeviceFilters> USBFlts;
    2562     rc = machine->COMGETTER(USBDeviceFilters)(USBFlts.asOutParam());
    2563     if (SUCCEEDED(rc))
     2562    hrc = machine->COMGETTER(USBDeviceFilters)(USBFlts.asOutParam());
     2563    if (SUCCEEDED(hrc))
    25642564    {
    25652565        SafeIfaceArray <IUSBDeviceFilter> Coll;
    2566         rc = USBFlts->COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll));
    2567         if (SUCCEEDED(rc))
     2566        hrc = USBFlts->COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll));
     2567        if (SUCCEEDED(hrc))
    25682568        {
    25692569            if (Coll.size() > 0)
    … …  
    25892589                    {
    25902590                        ULONG fMaskedIfs;
    2591                         CHECK_ERROR_RET(DevPtr, COMGETTER(MaskedInterfaces)(&fMaskedIfs), rc);
     2591                        CHECK_ERROR_RET(DevPtr, COMGETTER(MaskedInterfaces)(&fMaskedIfs), hrc);
    25922592                        if (fMaskedIfs)
    25932593                            RTPrintf("%-28s %#010x\n", Info::tr("Masked Interfaces:"), fMaskedIfs);
    … …  
    26032603            {
    26042604                SafeIfaceArray<IHostUSBDevice> coll;
    2605                 CHECK_ERROR_RET(pConsole, COMGETTER(RemoteUSBDevices)(ComSafeArrayAsOutParam(coll)), rc);
    2606                 rc = showUsbDevices(coll, "USBRemote", Info::tr("Available remote USB devices:"), details);
    2607                 if (FAILED(rc))
    2608                     return rc;
     2605                CHECK_ERROR_RET(pConsole, COMGETTER(RemoteUSBDevices)(ComSafeArrayAsOutParam(coll)), hrc);
     2606                hrc = showUsbDevices(coll, "USBRemote", Info::tr("Available remote USB devices:"), details);
     2607                if (FAILED(hrc))
     2608                    return hrc;
    26092609            }
    26102610
    26112611            {
    26122612                SafeIfaceArray<IUSBDevice> coll;
    2613                 CHECK_ERROR_RET(pConsole, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)), rc);
     2613                CHECK_ERROR_RET(pConsole, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)), hrc);
    26142614                showUsbDevices(coll, "USBAttach", Info::tr("Currently attached USB devices:"), details);
    2615                 if (FAILED(rc))
    2616                     return rc;
     2615                if (FAILED(hrc))
     2616                    return hrc;
    26172617            }
    26182618        }
    … …  
    26232623    {
    26242624         SafeIfaceArray <IPCIDeviceAttachment> assignments;
    2625          rc = machine->COMGETTER(PCIDeviceAssignments)(ComSafeArrayAsOutParam(assignments));
    2626          if (SUCCEEDED(rc))
     2625         hrc = machine->COMGETTER(PCIDeviceAssignments)(ComSafeArrayAsOutParam(assignments));
     2626         if (SUCCEEDED(hrc))
    26272627         {
    26282628             if (assignments.size() > 0 && (details != VMINFO_MACHINEREADABLE))
    … …  
    26662666    {
    26672667        ComPtr<IBandwidthControl> bwCtrl;
    2668         CHECK_ERROR_RET(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()), rc);
    2669 
    2670         rc = showBandwidthGroups(bwCtrl, details);
     2668        CHECK_ERROR_RET(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()), hrc);
     2669
     2670        hrc = showBandwidthGroups(bwCtrl, details);
    26712671    }
    26722672
    … …  
    26942694    {
    26952695        com::SafeIfaceArray <ISharedFolder> folders;
    2696         CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
     2696        CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), hrc);
    26972697        for (size_t i = 0; i < folders.size(); ++i)
    26982698        {
    … …  
    27062706    {
    27072707        com::SafeIfaceArray <ISharedFolder> folders;
    2708         CHECK_ERROR_RET(pConsole, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
     2708        CHECK_ERROR_RET(pConsole, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), hrc);
    27092709        for (size_t i = 0; i < folders.size(); ++i)
    27102710        {
    … …  
    27282728         */
    27292729        ComPtr<IVRDEServerInfo> vrdeServerInfo;
    2730         CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), rc);
     2730        CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), hrc);
    27312731        BOOL    fActive = FALSE;
    27322732        ULONG   cNumberOfClients = 0;
    … …  
    27462746        if (!vrdeServerInfo.isNull())
    27472747        {
    2748             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Active)(&fActive), rc);
    2749             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(NumberOfClients)(&cNumberOfClients), rc);
    2750             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BeginTime)(&BeginTime), rc);
    2751             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EndTime)(&EndTime), rc);
    2752             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSent)(&BytesSent), rc);
    2753             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSentTotal)(&BytesSentTotal), rc);
    2754             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceived)(&BytesReceived), rc);
    2755             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceivedTotal)(&BytesReceivedTotal), rc);
    2756             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(User)(User.asOutParam()), rc);
    2757             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Domain)(Domain.asOutParam()), rc);
    2758             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientName)(ClientName.asOutParam()), rc);
    2759             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientIP)(ClientIP.asOutParam()), rc);
    2760             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientVersion)(&ClientVersion), rc);
    2761             CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EncryptionStyle)(&EncryptionStyle), rc);
     2748            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Active)(&fActive), hrc);
     2749            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(NumberOfClients)(&cNumberOfClients), hrc);
     2750            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BeginTime)(&BeginTime), hrc);
     2751            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EndTime)(&EndTime), hrc);
     2752            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSent)(&BytesSent), hrc);
     2753            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSentTotal)(&BytesSentTotal), hrc);
     2754            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceived)(&BytesReceived), hrc);
     2755            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceivedTotal)(&BytesReceivedTotal), hrc);
     2756            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(User)(User.asOutParam()), hrc);
     2757            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Domain)(Domain.asOutParam()), hrc);
     2758            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientName)(ClientName.asOutParam()), hrc);
     2759            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientIP)(ClientIP.asOutParam()), hrc);
     2760            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientVersion)(&ClientVersion), hrc);
     2761            CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EncryptionStyle)(&EncryptionStyle), hrc);
    27622762        }
    27632763
    … …  
    28142814
    28152815        ComPtr<IRecordingSettings> recordingSettings;
    2816         CHECK_ERROR_RET(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()), rc);
     2816        CHECK_ERROR_RET(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()), hrc);
    28172817
    28182818        SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens;
    2819         CHECK_ERROR_RET(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)), rc);
     2819        CHECK_ERROR_RET(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)), hrc);
    28202820
    28212821        /* For now all screens have the same configuration; so take screen 0 and work with that. */
    28222822        ULONG fFeatures;
    2823         CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Features)(&fFeatures), rc);
     2823        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Features)(&fFeatures), hrc);
    28242824        ULONG Width;
    2825         CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoWidth)(&Width), rc);
     2825        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoWidth)(&Width), hrc);
    28262826        ULONG Height;
    2827         CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoHeight)(&Height), rc);
     2827        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoHeight)(&Height), hrc);
    28282828        ULONG Rate;
    2829         CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoRate)(&Rate), rc);
     2829        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoRate)(&Rate), hrc);
    28302830        ULONG Fps;
    2831         CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoFPS)(&Fps), rc);
     2831        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoFPS)(&Fps), hrc);
    28322832        Bstr  bstrFile;
    2833         CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Filename)(bstrFile.asOutParam()), rc);
     2833        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Filename)(bstrFile.asOutParam()), hrc);
    28342834        Bstr  bstrOptions;
    2835         CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Options)(bstrOptions.asOutParam()), rc);
     2835        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Options)(bstrOptions.asOutParam()), hrc);
    28362836
    28372837        Utf8Str strOptions(bstrOptions);
    … …  
    28602860        {
    28612861            BOOL fEnabled;
    2862             CHECK_ERROR_RET(saRecordingScreenScreens[i], COMGETTER(Enabled)(&fEnabled), rc);
     2862            CHECK_ERROR_RET(saRecordingScreenScreens[i], COMGETTER(Enabled)(&fEnabled), hrc);
    28632863            if (fEnabled && off < sizeof(szValue) - 3)
    28642864                off += RTStrPrintf(&szValue[off], sizeof(szValue) - off, off ? ",%zu" : "%zu", i);
    … …  
    29232923     */
    29242924    ComPtr<ISnapshot> snapshot;
    2925     rc = machine->FindSnapshot(Bstr().raw(), snapshot.asOutParam());
    2926     if (SUCCEEDED(rc) && snapshot)
     2925    hrc = machine->FindSnapshot(Bstr().raw(), snapshot.asOutParam());
     2926    if (SUCCEEDED(hrc) && snapshot)
    29272927    {
    29282928        ComPtr<ISnapshot> currentSnapshot;
    2929         rc = machine->COMGETTER(CurrentSnapshot)(currentSnapshot.asOutParam());
    2930         if (SUCCEEDED(rc))
     2929        hrc = machine->COMGETTER(CurrentSnapshot)(currentSnapshot.asOutParam());
     2930        if (SUCCEEDED(hrc))
    29312931        {
    29322932            if (details != VMINFO_MACHINEREADABLE)
    … …  
    29482948    {
    29492949        ComPtr<IGuest> guest;
    2950         rc = pConsole->COMGETTER(Guest)(guest.asOutParam());
    2951         if (SUCCEEDED(rc) && !guest.isNull())
     2950        hrc = pConsole->COMGETTER(Guest)(guest.asOutParam());
     2951        if (SUCCEEDED(hrc) && !guest.isNull())
    29522952        {
    29532953            SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", Info::tr("OS type:"));
    29542954
    29552955            AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
    2956             rc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
    2957             if (SUCCEEDED(rc))
     2956            hrc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
     2957            if (SUCCEEDED(hrc))
    29582958                SHOW_ULONG_VALUE("GuestAdditionsRunLevel", Info::tr("Additions run level:"), (ULONG)guestRunLevel, "");
    29592959
    29602960            Bstr guestString;
    2961             rc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
    2962             if (   SUCCEEDED(rc)
     2961            hrc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
     2962            if (   SUCCEEDED(hrc)
    29632963                && !guestString.isEmpty())
    29642964            {
    29652965                ULONG uRevision;
    2966                 rc = guest->COMGETTER(AdditionsRevision)(&uRevision);
    2967                 if (FAILED(rc))
     2966                hrc = guest->COMGETTER(AdditionsRevision)(&uRevision);
     2967                if (FAILED(hrc))
    29682968                    uRevision = 0;
    29692969                RTStrPrintf(szValue, sizeof(szValue), "%ls r%u", guestString.raw(), uRevision);
    … …  
    29732973            /* Print information about known Guest Additions facilities: */
    29742974            SafeIfaceArray <IAdditionsFacility> collFac;
    2975             CHECK_ERROR_RET(guest, COMGETTER(Facilities)(ComSafeArrayAsOutParam(collFac)), rc);
     2975            CHECK_ERROR_RET(guest, COMGETTER(Facilities)(ComSafeArrayAsOutParam(collFac)), hrc);
    29762976            if (collFac.size() > 0)
    29772977            {
    … …  
    29862986                    if (fac)
    29872987                    {
    2988                         CHECK_ERROR_RET(fac, COMGETTER(Name)(guestString.asOutParam()), rc);
     2988                        CHECK_ERROR_RET(fac, COMGETTER(Name)(guestString.asOutParam()), hrc);
    29892989                        if (!guestString.isEmpty())
    29902990                        {
    2991                             CHECK_ERROR_RET(fac, COMGETTER(Status)(&curStatus), rc);
    2992                             CHECK_ERROR_RET(fac, COMGETTER(LastUpdated)(&lLastUpdatedMS), rc);
     2991                            CHECK_ERROR_RET(fac, COMGETTER(Status)(&curStatus), hrc);
     2992                            CHECK_ERROR_RET(fac, COMGETTER(LastUpdated)(&lLastUpdatedMS), hrc);
    29932993                            if (details == VMINFO_MACHINEREADABLE)
    29942994                                RTPrintf("GuestAdditionsFacility_%ls=%u,%lld\n",
    … …  
    30383038RTEXITCODE handleShowVMInfo(HandlerArg *a)
    30393039{
    3040     HRESULT rc;
     3040    HRESULT hrc;
    30413041    const char *VMNameOrUuid = NULL;
    30423042    bool fLog = false;
    … …  
    30983098    CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid).raw(),
    30993099                                           machine.asOutParam()));
    3100     if (FAILED(rc))
     3100    if (FAILED(hrc))
    31013101        return RTEXITCODE_FAILURE;
    31023102
    … …  
    31763176
    31773177        /* open an existing session for the VM */
    3178         rc = machine->LockMachine(a->session, LockType_Shared);
    3179         if (SUCCEEDED(rc))
     3178        hrc = machine->LockMachine(a->session, LockType_Shared);
     3179        if (SUCCEEDED(hrc))
    31803180            /* get the session machine */
    3181             rc = a->session->COMGETTER(Machine)(machine.asOutParam());
    3182 
    3183         rc = showVMInfo(a->virtualBox, machine, a->session, details);
     3181            hrc = a->session->COMGETTER(Machine)(machine.asOutParam());
     3182
     3183        hrc = showVMInfo(a->virtualBox, machine, a->session, details);
    31843184
    31853185        a->session->UnlockMachine();
    31863186    }
    31873187
    3188     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     3188    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    31893189}
    31903190

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

    r94714 r95140  
    104104static HRESULT listInternalNetworks(const ComPtr<IVirtualBox> pVirtualBox)
    105105{
    106     HRESULT rc;
     106    HRESULT hrc;
    107107    com::SafeArray<BSTR> internalNetworks;
    108108    CHECK_ERROR(pVirtualBox, COMGETTER(InternalNetworks)(ComSafeArrayAsOutParam(internalNetworks)));
    … …  
    111111        RTPrintf(List::tr("Name:        %ls\n"), internalNetworks[i]);
    112112    }
    113     return rc;
     113    return hrc;
    114114}
    115115
    … …  
    126126                                     bool fIsBridged)
    127127{
    128     HRESULT rc;
     128    HRESULT hrc;
    129129    ComPtr<IHost> host;
    130130    CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
    … …  
    191191#endif
    192192    }
    193     return rc;
     193    return hrc;
    194194}
    195195
    … …  
    205205static HRESULT listHostOnlyNetworks(const ComPtr<IVirtualBox> pVirtualBox)
    206206{
    207     HRESULT rc;
     207    HRESULT hrc;
    208208    com::SafeIfaceArray<IHostOnlyNetwork> hostOnlyNetworks;
    209209    CHECK_ERROR(pVirtualBox, COMGETTER(HostOnlyNetworks)(ComSafeArrayAsOutParam(hostOnlyNetworks)));
    … …  
    251251static HRESULT listCloudNetworks(const ComPtr<IVirtualBox> pVirtualBox)
    252252{
    253     HRESULT rc;
     253    HRESULT hrc;
    254254    com::SafeIfaceArray<ICloudNetwork> cloudNetworks;
    255255    CHECK_ERROR(pVirtualBox, COMGETTER(CloudNetworks)(ComSafeArrayAsOutParam(cloudNetworks)));
    … …  
    279279        RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
    280280    }
    281     return rc;
     281    return hrc;
    282282}
    283283#endif /* VBOX_WITH_CLOUD_NET */
    … …  
    307307        { ProcessorFeature_VirtVmsaveVmload, List::tr("virt. vmsave/vmload") },
    308308    };
    309     HRESULT rc;
     309    HRESULT hrc;
    310310    ComPtr<IHost> Host;
    311311    CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
    … …  
    365365    CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
    366366    RTPrintf(List::tr("Operating system version: %ls\n"), oSVersion.raw());
    367     return rc;
     367    return hrc;
    368368}
    369369
    … …  
    383383                         bool fOptLong)
    384384{
    385     HRESULT rc = S_OK;
     385    HRESULT hrc = S_OK;
    386386    for (size_t i = 0; i < aMedia.size(); ++i)
    387387    {
    388388        ComPtr<IMedium> pMedium = aMedia[i];
    389389
    390         rc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
     390        hrc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
    391391
    392392        RTPrintf("\n");
    … …  
    400400
    401401            // depth first listing of child media
    402             rc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
    403         }
    404     }
    405 
    406     return rc;
     402            hrc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
     403        }
     404    }
     405
     406    return hrc;
    407407}
    408408
    … …  
    416416static HRESULT listHddBackends(const ComPtr<IVirtualBox> pVirtualBox)
    417417{
    418     HRESULT rc;
     418    HRESULT hrc;
    419419    ComPtr<ISystemProperties> systemProperties;
    420420    CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
    … …  
    494494        RTPrintf(")\n");
    495495    }
    496     return rc;
     496    return hrc;
    497497}
    498498
    … …  
    506506static HRESULT listUsbHost(const ComPtr<IVirtualBox> &pVirtualBox)
    507507{
    508     HRESULT rc;
     508    HRESULT hrc;
    509509    ComPtr<IHost> Host;
    510510    CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(Host.asOutParam()), 1);
    … …  
    631631        }
    632632    }
    633     return rc;
     633    return hrc;
    634634}
    635635
    … …  
    643643static HRESULT listUsbFilters(const ComPtr<IVirtualBox> &pVirtualBox)
    644644{
    645     HRESULT rc;
     645    HRESULT hrc;
    646646
    647647    RTPrintf(List::tr("Global USB Device Filters:\n\n"));
    … …  
    704704        }
    705705    }
    706     return rc;
     706    return hrc;
    707707}
    708708
    … …  
    12781278static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> &pVirtualBox)
    12791279{
    1280     HRESULT rc;
     1280    HRESULT hrc;
    12811281    ComPtr<IHost> host;
    12821282    CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
    … …  
    12951295        RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
    12961296    }
    1297     return rc;
     1297    return hrc;
    12981298}
    12991299
    … …  
    13061306static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> &pVirtualBox)
    13071307{
    1308     HRESULT rc = S_OK;
     1308    HRESULT hrc = S_OK;
    13091309    ComPtr<ISystemProperties> systemProperties;
    13101310    CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
    … …  
    13241324        RTPrintf("    BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
    13251325    }
    1326     return rc;
     1326    return hrc;
    13271327}
    13281328
    … …  
    13351335static HRESULT listCloudProviders(const ComPtr<IVirtualBox> &pVirtualBox)
    13361336{
    1337     HRESULT rc = S_OK;
     1337    HRESULT hrc = S_OK;
    13381338    ComPtr<ICloudProviderManager> pCloudProviderManager;
    13391339    CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
    … …  
    13561356        RTPrintf("\n");
    13571357    }
    1358     return rc;
     1358    return hrc;
    13591359}
    13601360
    … …  
    13691369static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> &pVirtualBox, bool fOptLong)
    13701370{
    1371     HRESULT rc = S_OK;
     1371    HRESULT hrc = S_OK;
    13721372    ComPtr<ICloudProviderManager> pCloudProviderManager;
    13731373    CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
    … …  
    14131413        }
    14141414    }
    1415     return rc;
     1415    return hrc;
    14161416}
    14171417
    … …  
    16821682static HRESULT listHostDrives(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
    16831683{
    1684     HRESULT rc = S_OK;
     1684    HRESULT hrc = S_OK;
    16851685    ComPtr<IHost> pHost;
    16861686    CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()), hrcCheck);
    … …  
    16951695        com::Bstr bstrDrivePath;
    16961696        CHECK_ERROR(pHostDrive,COMGETTER(DrivePath)(bstrDrivePath.asOutParam()));
    1697         if (SUCCEEDED(rc))
     1697        if (SUCCEEDED(hrc))
    16981698            RTPrintf(List::tr("%sDrive:       %ls\n"), i > 0 ? "\n" : "", bstrDrivePath.raw());
    16991699        else
    1700             RTPrintf(List::tr("%sDrive:       %Rhrc\n"), i > 0 ? "\n" : "", rc);
     1700            RTPrintf(List::tr("%sDrive:       %Rhrc\n"), i > 0 ? "\n" : "", hrc);
    17011701
    17021702        com::Bstr bstrModel;
    17031703        CHECK_ERROR(pHostDrive,COMGETTER(Model)(bstrModel.asOutParam()));
    1704         if (FAILED(rc))
    1705             RTPrintf(List::tr("Model:       %Rhrc\n"), rc);
     1704        if (FAILED(hrc))
     1705            RTPrintf(List::tr("Model:       %Rhrc\n"), hrc);
    17061706        else if (bstrModel.isNotEmpty())
    17071707            RTPrintf(List::tr("Model:       \"%ls\"\n"), bstrModel.raw());
    … …  
    17121712           with E_ACCESSDENIED.  Typically means the user cannot read the drive. */
    17131713        com::Bstr bstrUuidDisk;
    1714         rc = pHostDrive->COMGETTER(Uuid)(bstrUuidDisk.asOutParam());
    1715         if (SUCCEEDED(rc) && !com::Guid(bstrUuidDisk).isZero())
     1714        hrc = pHostDrive->COMGETTER(Uuid)(bstrUuidDisk.asOutParam());
     1715        if (SUCCEEDED(hrc) && !com::Guid(bstrUuidDisk).isZero())
    17161716            RTPrintf("UUID:        %ls\n", bstrUuidDisk.raw());
    1717         else if (rc == E_ACCESSDENIED)
     1717        else if (hrc == E_ACCESSDENIED)
    17181718        {
    17191719            RTPrintf(List::tr("Further disk and partitioning information is not available for drive \"%ls\". (E_ACCESSDENIED)\n"),
    … …  
    17211721            continue;
    17221722        }
    1723         else if (FAILED(rc))
    1724         {
    1725             RTPrintf("UUID:        %Rhrc\n", rc);
    1726             com::GlueHandleComErrorNoCtx(pHostDrive, rc);
     1723        else if (FAILED(hrc))
     1724        {
     1725            RTPrintf("UUID:        %Rhrc\n", hrc);
     1726            com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
    17271727        }
    17281728
    17291729        LONG64 cbSize = 0;
    1730         rc = pHostDrive->COMGETTER(Size)(&cbSize);
    1731         if (SUCCEEDED(rc) && fOptLong)
     1730        hrc = pHostDrive->COMGETTER(Size)(&cbSize);
     1731        if (SUCCEEDED(hrc) && fOptLong)
    17321732            RTPrintf(List::tr("Size:        %llu bytes (%Rhcb)\n", "", cbSize), cbSize, cbSize);
    1733         else if (SUCCEEDED(rc))
     1733        else if (SUCCEEDED(hrc))
    17341734            RTPrintf(List::tr("Size:        %Rhcb\n"), cbSize);
    17351735        else
    17361736        {
    1737             RTPrintf(List::tr("Size:        %Rhrc\n"), rc);
    1738             com::GlueHandleComErrorNoCtx(pHostDrive, rc);
     1737            RTPrintf(List::tr("Size:        %Rhrc\n"), hrc);
     1738            com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
    17391739        }
    17401740
    17411741        ULONG cbSectorSize = 0;
    1742         rc = pHostDrive->COMGETTER(SectorSize)(&cbSectorSize);
    1743         if (SUCCEEDED(rc))
     1742        hrc = pHostDrive->COMGETTER(SectorSize)(&cbSectorSize);
     1743        if (SUCCEEDED(hrc))
    17441744            RTPrintf(List::tr("Sector Size: %u bytes\n", "", cbSectorSize), cbSectorSize);
    17451745        else
    17461746        {
    1747             RTPrintf(List::tr("Sector Size: %Rhrc\n"), rc);
    1748             com::GlueHandleComErrorNoCtx(pHostDrive, rc);
     1747            RTPrintf(List::tr("Sector Size: %Rhrc\n"), hrc);
     1748            com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
    17491749        }
    17501750
    17511751        PartitioningType_T partitioningType = (PartitioningType_T)9999;
    1752         rc = pHostDrive->COMGETTER(PartitioningType)(&partitioningType);
    1753         if (SUCCEEDED(rc))
     1752        hrc = pHostDrive->COMGETTER(PartitioningType)(&partitioningType);
     1753        if (SUCCEEDED(hrc))
    17541754            RTPrintf(List::tr("Scheme:      %s\n"), partitioningType == PartitioningType_MBR ? "MBR" : "GPT");
    17551755        else
    17561756        {
    1757             RTPrintf(List::tr("Scheme:      %Rhrc\n"), rc);
    1758             com::GlueHandleComErrorNoCtx(pHostDrive, rc);
     1757            RTPrintf(List::tr("Scheme:      %Rhrc\n"), hrc);
     1758            com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
    17591759        }
    17601760
    17611761        com::SafeIfaceArray<IHostDrivePartition> apHostDrivesPartitions;
    1762         rc = pHostDrive->COMGETTER(Partitions)(ComSafeArrayAsOutParam(apHostDrivesPartitions));
    1763         if (FAILED(rc))
    1764         {
    1765             RTPrintf(List::tr("Partitions:  %Rhrc\n"), rc);
    1766             com::GlueHandleComErrorNoCtx(pHostDrive, rc);
     1762        hrc = pHostDrive->COMGETTER(Partitions)(ComSafeArrayAsOutParam(apHostDrivesPartitions));
     1763        if (FAILED(hrc))
     1764        {
     1765            RTPrintf(List::tr("Partitions:  %Rhrc\n"), hrc);
     1766            com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
    17671767        }
    17681768        else if (apHostDrivesPartitions.size() == 0)
    … …  
    18831883        }
    18841884    }
    1885     return rc;
     1885    return hrc;
    18861886}
    18871887
    … …  
    19441944static HRESULT produceList(enum ListType_T enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
    19451945{
    1946     HRESULT rc = S_OK;
     1946    HRESULT hrc = S_OK;
    19471947    switch (enmCommand)
    19481948    {
    … …  
    19571957             */
    19581958            com::SafeIfaceArray<IMachine> machines;
    1959             rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
    1960             if (SUCCEEDED(rc))
     1959            hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
     1960            if (SUCCEEDED(hrc))
    19611961            {
    19621962                /*
    … …  
    19671967                    for (size_t i = 0; i < machines.size(); ++i)
    19681968                        if (machines[i])
    1969                             rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
     1969                            hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
    19701970                }
    19711971                else
    … …  
    19891989
    19901990                    for (size_t i = 0; i < sortedMachines.size(); ++i)
    1991                         rc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
     1991                        hrc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
    19921992                }
    19931993            }
    … …  
    20012001             */
    20022002            com::SafeIfaceArray<IMachine> machines;
    2003             rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
     2003            hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
    20042004            com::SafeArray<MachineState_T> states;
    2005             if (SUCCEEDED(rc))
    2006                 rc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
    2007             if (SUCCEEDED(rc))
     2005            if (SUCCEEDED(hrc))
     2006                hrc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
     2007            if (SUCCEEDED(hrc))
    20082008            {
    20092009                /*
    … …  
    20222022                            case MachineState_Paused:
    20232023                            case MachineState_TeleportingPausedVM:
    2024                                 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
     2024                                hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
    20252025                                break;
    20262026                            default: break; /* Shut up MSC */
    … …  
    20352035        {
    20362036            com::SafeIfaceArray<IGuestOSType> coll;
    2037             rc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
    2038             if (SUCCEEDED(rc))
     2037            hrc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
     2038            if (SUCCEEDED(hrc))
    20392039            {
    20402040                /*
    … …  
    20722072            com::SafeIfaceArray<IMedium> coll;
    20732073            CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
    2074             if (SUCCEEDED(rc))
     2074            if (SUCCEEDED(hrc))
    20752075            {
    20762076                for (size_t i = 0; i < coll.size(); ++i)
    … …  
    20942094            com::SafeIfaceArray<IMedium> coll;
    20952095            CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
    2096             if (SUCCEEDED(rc))
     2096            if (SUCCEEDED(hrc))
    20972097            {
    20982098                for (size_t i = 0; i < coll.size(); ++i)
    … …  
    21112111
    21122112        case kListInternalNetworks:
    2113             rc = listInternalNetworks(pVirtualBox);
     2113            hrc = listInternalNetworks(pVirtualBox);
    21142114            break;
    21152115
    … …  
    21182118        case kListHostOnlyInterfaces:
    21192119#endif
    2120             rc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
     2120            hrc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
    21212121            break;
    21222122
    21232123#if defined(VBOX_WITH_VMNET)
    21242124        case kListHostOnlyNetworks:
    2125             rc = listHostOnlyNetworks(pVirtualBox);
     2125            hrc = listHostOnlyNetworks(pVirtualBox);
    21262126            break;
    21272127#endif
    … …  
    21292129#if defined(VBOX_WITH_CLOUD_NET)
    21302130        case kListCloudNetworks:
    2131             rc = listCloudNetworks(pVirtualBox);
     2131            hrc = listCloudNetworks(pVirtualBox);
    21322132            break;
    21332133#endif
    21342134        case kListHostInfo:
    2135             rc = listHostInfo(pVirtualBox);
     2135            hrc = listHostInfo(pVirtualBox);
    21362136            break;
    21372137
    … …  
    21662166
    21672167        case kListHddBackends:
    2168             rc = listHddBackends(pVirtualBox);
     2168            hrc = listHddBackends(pVirtualBox);
    21692169            break;
    21702170
    … …  
    21732173            com::SafeIfaceArray<IMedium> hdds;
    21742174            CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
    2175             rc = listMedia(pVirtualBox, hdds, List::tr("base"), fOptLong);
     2175            hrc = listMedia(pVirtualBox, hdds, List::tr("base"), fOptLong);
    21762176            break;
    21772177        }
    … …  
    21812181            com::SafeIfaceArray<IMedium> dvds;
    21822182            CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
    2183             rc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
     2183            hrc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
    21842184            break;
    21852185        }
    … …  
    21892189            com::SafeIfaceArray<IMedium> floppies;
    21902190            CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
    2191             rc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
     2191            hrc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
    21922192            break;
    21932193        }
    21942194
    21952195        case kListUsbHost:
    2196             rc = listUsbHost(pVirtualBox);
     2196            hrc = listUsbHost(pVirtualBox);
    21972197            break;
    21982198
    21992199        case kListUsbFilters:
    2200             rc = listUsbFilters(pVirtualBox);
     2200            hrc = listUsbFilters(pVirtualBox);
    22012201            break;
    22022202
    22032203        case kListSystemProperties:
    2204             rc = listSystemProperties(pVirtualBox);
     2204            hrc = listSystemProperties(pVirtualBox);
    22052205            break;
    22062206
    22072207#ifdef VBOX_WITH_UPDATE_AGENT
    22082208        case kListUpdateAgents:
    2209             rc = listUpdateAgents(pVirtualBox);
     2209            hrc = listUpdateAgents(pVirtualBox);
    22102210            break;
    22112211#endif
    22122212        case kListDhcpServers:
    2213             rc = listDhcpServers(pVirtualBox);
     2213            hrc = listDhcpServers(pVirtualBox);
    22142214            break;
    22152215
    22162216        case kListExtPacks:
    2217             rc = listExtensionPacks(pVirtualBox);
     2217            hrc = listExtensionPacks(pVirtualBox);
    22182218            break;
    22192219
    22202220        case kListGroups:
    2221             rc = listGroups(pVirtualBox);
     2221            hrc = listGroups(pVirtualBox);
    22222222            break;
    22232223
    22242224        case kListNatNetworks:
    2225             rc = listNATNetworks(fOptLong, fOptSorted, pVirtualBox);
     2225            hrc = listNATNetworks(fOptLong, fOptSorted, pVirtualBox);
    22262226            break;
    22272227
    22282228        case kListVideoInputDevices:
    2229             rc = listVideoInputDevices(pVirtualBox);
     2229            hrc = listVideoInputDevices(pVirtualBox);
    22302230            break;
    22312231
    22322232        case kListScreenShotFormats:
    2233             rc = listScreenShotFormats(pVirtualBox);
     2233            hrc = listScreenShotFormats(pVirtualBox);
    22342234            break;
    22352235
    22362236        case kListCloudProviders:
    2237             rc = listCloudProviders(pVirtualBox);
     2237            hrc = listCloudProviders(pVirtualBox);
    22382238            break;
    22392239
    22402240        case kListCloudProfiles:
    2241             rc = listCloudProfiles(pVirtualBox, fOptLong);
     2241            hrc = listCloudProfiles(pVirtualBox, fOptLong);
    22422242            break;
    22432243
    22442244        case kListCPUProfiles:
    2245             rc = listCPUProfiles(pVirtualBox, fOptLong, fOptSorted);
     2245            hrc = listCPUProfiles(pVirtualBox, fOptLong, fOptSorted);
    22462246            break;
    22472247
    22482248        case kListHostDrives:
    2249             rc = listHostDrives(pVirtualBox, fOptLong);
     2249            hrc = listHostDrives(pVirtualBox, fOptLong);
    22502250            break;
    22512251        /* No default here, want gcc warnings. */
    … …  
    22532253    } /* end switch */
    22542254
    2255     return rc;
     2255    return hrc;
    22562256}
    22572257

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMetrics.cpp

    r94236 r95140  
    5050                                     ComSafeArrayOut(IUnknown *, outObjects))
    5151{
    52     HRESULT rc = S_OK;
     52    HRESULT hrc = S_OK;
    5353    com::SafeArray<BSTR> retMetrics(1);
    5454    com::SafeIfaceArray <IUnknown> retObjects;
    … …  
    7979        {
    8080            ComPtr<IMachine> machine;
    81             rc = aVirtualBox->FindMachine(Bstr(argv[0]).raw(),
    82                                           machine.asOutParam());
    83             if (SUCCEEDED(rc))
     81            hrc = aVirtualBox->FindMachine(Bstr(argv[0]).raw(),
     82                                           machine.asOutParam());
     83            if (SUCCEEDED(hrc))
    8484            {
    8585                retObjects.reset(1);
    … …  
    8989            {
    9090                errorArgument(Metrics::tr("Invalid machine name: '%s'"), argv[0]);
    91                 return rc;
     91                return hrc;
    9292            }
    9393        }
    … …  
    9898    retObjects.detachTo(ComSafeArrayOutArg(outObjects));
    9999
    100     return rc;
     100    return hrc;
    101101}
    102102
    … …  
    122122static Bstr getObjectName(ComPtr<IUnknown> aObject)
    123123{
    124     HRESULT rc;
     124    HRESULT hrc;
    125125
    126126    ComPtr<IHost> host = aObject;
    … …  
    133133        Bstr name;
    134134        CHECK_ERROR(machine, COMGETTER(Name)(name.asOutParam()));
    135         if (SUCCEEDED(rc))
     135        if (SUCCEEDED(hrc))
    136136            return name;
    137137    }
    … …  
    141141static void listAffectedMetrics(ComSafeArrayIn(IPerformanceMetric*, aMetrics))
    142142{
    143     HRESULT rc;
     143    HRESULT hrc;
    144144    com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics));
    145145    if (metrics.size())
    … …  
    172172                             ComPtr<IPerformanceCollector> performanceCollector)
    173173{
    174     HRESULT rc;
     174    HRESULT hrc;
    175175    com::SafeArray<BSTR>          metrics;
    176176    com::SafeIfaceArray<IUnknown> objects;
    … …  
    178178    setCurrentSubcommand(HELP_SCOPE_METRICS_LIST);
    179179
    180     rc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox,
     180    hrc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox,
    181181                               ComSafeArrayAsOutParam(metrics),
    182182                               ComSafeArrayAsOutParam(objects));
    183     if (FAILED(rc))
     183    if (FAILED(hrc))
    184184        return RTEXITCODE_FAILURE;
    185185
    … …  
    223223                                     ComPtr<IPerformanceCollector> performanceCollector)
    224224{
    225     HRESULT rc;
     225    HRESULT hrc;
    226226    com::SafeArray<BSTR>          metrics;
    227227    com::SafeIfaceArray<IUnknown> objects;
    … …  
    259259    }
    260260
    261     rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
    262                                ComSafeArrayAsOutParam(metrics),
    263                                ComSafeArrayAsOutParam(objects));
    264     if (FAILED(rc))
     261    hrc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
     262                                ComSafeArrayAsOutParam(metrics),
     263                                ComSafeArrayAsOutParam(objects));
     264    if (FAILED(hrc))
    265265        return RTEXITCODE_FAILURE;
    266266
    … …  
    270270                     ComSafeArrayAsInParam(objects), period, samples,
    271271                     ComSafeArrayAsOutParam(affectedMetrics)));
    272     if (FAILED(rc))
     272    if (FAILED(hrc))
    273273        return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */
    274274
    … …  
    286286                                     ComPtr<IPerformanceCollector> performanceCollector)
    287287{
    288     HRESULT rc;
     288    HRESULT hrc;
    289289    com::SafeArray<BSTR>          metrics;
    290290    com::SafeIfaceArray<IUnknown> objects;
    … …  
    292292    setCurrentSubcommand(HELP_SCOPE_METRICS_QUERY);
    293293
    294     rc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox,
    295                                ComSafeArrayAsOutParam(metrics),
    296                                ComSafeArrayAsOutParam(objects));
    297     if (FAILED(rc))
     294    hrc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox,
     295                                ComSafeArrayAsOutParam(metrics),
     296                                ComSafeArrayAsOutParam(objects));
     297    if (FAILED(hrc))
    298298        return RTEXITCODE_FAILURE;
    299299
    … …  
    395395                                       ComPtr<IPerformanceCollector> performanceCollector)
    396396{
    397     HRESULT rc;
     397    HRESULT hrc;
    398398    com::SafeArray<BSTR>          metrics;
    399399    com::SafeIfaceArray<IUnknown> objects;
    … …  
    434434    }
    435435
    436     rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
    437                                ComSafeArrayAsOutParam(metrics),
    438                                ComSafeArrayAsOutParam(objects));
    439     if (FAILED(rc))
     436    hrc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
     437                                ComSafeArrayAsOutParam(metrics),
     438                                ComSafeArrayAsOutParam(objects));
     439    if (FAILED(hrc))
    440440        return RTEXITCODE_FAILURE;
    441441
    … …  
    471471                     ComSafeArrayAsInParam(objectsFiltered), period, samples,
    472472                     ComSafeArrayAsOutParam(affectedMetrics)));
    473     if (FAILED(rc))
     473    if (FAILED(hrc))
    474474        return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */
    475475
    … …  
    551551                                      ComPtr<IPerformanceCollector> performanceCollector)
    552552{
    553     HRESULT rc;
     553    HRESULT hrc;
    554554    com::SafeArray<BSTR>          metrics;
    555555    com::SafeIfaceArray<IUnknown> objects;
    … …  
    568568    }
    569569
    570     rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
    571                                ComSafeArrayAsOutParam(metrics),
    572                                ComSafeArrayAsOutParam(objects));
    573     if (FAILED(rc))
     570    hrc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
     571                                ComSafeArrayAsOutParam(metrics),
     572                                ComSafeArrayAsOutParam(objects));
     573    if (FAILED(hrc))
    574574        return RTEXITCODE_FAILURE;
    575575
    … …  
    579579                      ComSafeArrayAsInParam(objects),
    580580                      ComSafeArrayAsOutParam(affectedMetrics)));
    581     if (FAILED(rc))
     581    if (FAILED(hrc))
    582582        return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */
    583583
    … …  
    595595                                       ComPtr<IPerformanceCollector> performanceCollector)
    596596{
    597     HRESULT rc;
     597    HRESULT hrc;
    598598    com::SafeArray<BSTR>          metrics;
    599599    com::SafeIfaceArray<IUnknown> objects;
    … …  
    612612    }
    613613
    614     rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
    615                                ComSafeArrayAsOutParam(metrics),
    616                                ComSafeArrayAsOutParam(objects));
    617     if (FAILED(rc))
     614    hrc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
     615                                ComSafeArrayAsOutParam(metrics),
     616                                ComSafeArrayAsOutParam(objects));
     617    if (FAILED(hrc))
    618618        return RTEXITCODE_FAILURE;
    619619
    … …  
    623623                       ComSafeArrayAsInParam(objects),
    624624                       ComSafeArrayAsOutParam(affectedMetrics)));
    625     if (FAILED(rc))
     625    if (FAILED(hrc))
    626626        return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */
    627627

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp

    r94992 r95140  
    6666RTEXITCODE handleRegisterVM(HandlerArg *a)
    6767{
    68     HRESULT rc;
     68    HRESULT hrc;
    6969    const char *VMName = NULL;
    7070
    … …  
    131131     * and the client's interpretation of relative paths. Remove after the API
    132132     * has been redesigned. */
    133     rc = a->virtualBox->OpenMachine(Bstr(a->argv[0]).raw(),
    134                                     Bstr(strPassword).raw(),
    135                                     machine.asOutParam());
    136     if (rc == VBOX_E_FILE_ERROR)
     133    hrc = a->virtualBox->OpenMachine(Bstr(a->argv[0]).raw(),
     134                                     Bstr(strPassword).raw(),
     135                                     machine.asOutParam());
     136    if (hrc == VBOX_E_FILE_ERROR)
    137137    {
    138138        char szVMFileAbs[RTPATH_MAX] = "";
    … …  
    145145                                               machine.asOutParam()));
    146146    }
    147     else if (FAILED(rc))
     147    else if (FAILED(hrc))
    148148        CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(a->argv[0]).raw(),
    149149                                               Bstr(strPassword).raw(),
    150150                                               machine.asOutParam()));
    151     if (SUCCEEDED(rc))
     151    if (SUCCEEDED(hrc))
    152152    {
    153153        ASSERT(machine);
    154154        CHECK_ERROR(a->virtualBox, RegisterMachine(machine));
    155155    }
    156     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     156    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    157157}
    158158
    … …  
    165165RTEXITCODE handleUnregisterVM(HandlerArg *a)
    166166{
    167     HRESULT rc;
     167    HRESULT hrc;
    168168    const char *VMName = NULL;
    169169    bool fDelete = false;
    … …  
    223223                        RTEXITCODE_FAILURE);
    224224
    225         rc = showProgress(pProgress);
     225        hrc = showProgress(pProgress);
    226226        CHECK_PROGRESS_ERROR_RET(pProgress, (Misc::tr("Machine delete failed")), RTEXITCODE_FAILURE);
    227227    }
    … …  
    236236            IMedium *pMedium = aMedia[i];
    237237            if (pMedium)
    238                 rc = pMedium->Close();
    239         }
    240         rc = S_OK;
     238                hrc = pMedium->Close();
     239        }
     240        hrc = S_OK; /** @todo r=andy Why overwriting the result from closing the medium above? */
    241241    }
    242242    return RTEXITCODE_SUCCESS;
    … …  
    268268RTEXITCODE handleCreateVM(HandlerArg *a)
    269269{
    270     HRESULT rc;
     270    HRESULT hrc;
    271271    Bstr bstrBaseFolder;
    272272    Bstr bstrName;
    … …  
    412412    while (0);
    413413
    414     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     414    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    415415}
    416416
    … …  
    423423RTEXITCODE handleMoveVM(HandlerArg *a)
    424424{
    425     HRESULT                        rc;
     425    HRESULT                        hrc;
    426426    const char                    *pszSrcName      = NULL;
    427427    const char                    *pszType         = NULL;
    … …  
    499499                               progress.asOutParam()),
    500500                        RTEXITCODE_FAILURE);
    501         rc = showProgress(progress);
     501        hrc = showProgress(progress);
    502502        CHECK_PROGRESS_ERROR_RET(progress, (Misc::tr("Move VM failed")), RTEXITCODE_FAILURE);
    503503
    … …  
    577577RTEXITCODE handleCloneVM(HandlerArg *a)
    578578{
    579     HRESULT                        rc;
     579    HRESULT                        hrc;
    580580    const char                    *pszSrcName       = NULL;
    581581    const char                    *pszSnapshotName  = NULL;
    … …  
    704704                                        progress.asOutParam()),
    705705                    RTEXITCODE_FAILURE);
    706     rc = showProgress(progress);
     706    hrc = showProgress(progress);
    707707    CHECK_PROGRESS_ERROR_RET(progress, (Misc::tr("Clone VM failed")), RTEXITCODE_FAILURE);
    708708
    … …  
    719719RTEXITCODE handleStartVM(HandlerArg *a)
    720720{
    721     HRESULT rc = S_OK;
     721    HRESULT hrc = S_OK;
    722722    std::list<const char *> VMs;
    723723    Bstr sessionType;
    … …  
    846846         ++it)
    847847    {
    848         HRESULT rc2 = rc;
     848        HRESULT hrc2 = hrc;
    849849        const char *pszVM = *it;
    850850        ComPtr<IMachine> machine;
    … …  
    856856            {
    857857                CHECK_ERROR(machine, AddEncryptionPassword(Bstr(pszPasswordId).raw(), Bstr(strPassword).raw()));
    858                 if (rc == VBOX_E_PASSWORD_INCORRECT)
     858                if (hrc == VBOX_E_PASSWORD_INCORRECT)
    859859                    RTMsgError("Password incorrect!");
    860860            }
    861             if (SUCCEEDED(rc))
     861            if (SUCCEEDED(hrc))
    862862            {
    863863                ComPtr<IProgress> progress;
    864864                CHECK_ERROR(machine, LaunchVMProcess(a->session, sessionType.raw(),
    865865                                                     ComSafeArrayAsInParam(aBstrEnv), progress.asOutParam()));
    866                 if (SUCCEEDED(rc) && !progress.isNull())
     866                if (SUCCEEDED(hrc) && !progress.isNull())
    867867                {
    868868                    RTPrintf("Waiting for VM \"%s\" to power on...\n", pszVM);
    869869                    CHECK_ERROR(progress, WaitForCompletion(-1));
    870                     if (SUCCEEDED(rc))
     870                    if (SUCCEEDED(hrc))
    871871                    {
    872872                        BOOL completed = true;
    873873                        CHECK_ERROR(progress, COMGETTER(Completed)(&completed));
    874                         if (SUCCEEDED(rc))
     874                        if (SUCCEEDED(hrc))
    875875                        {
    876876                            ASSERT(completed);
    … …  
    878878                            LONG iRc;
    879879                            CHECK_ERROR(progress, COMGETTER(ResultCode)(&iRc));
    880                             if (SUCCEEDED(rc))
     880                            if (SUCCEEDED(hrc))
    881881                            {
    882882                                if (SUCCEEDED(iRc))
    … …  
    887887                                    com::GluePrintErrorInfo(info);
    888888                                }
    889                                 rc = iRc;
     889                                hrc = iRc;
    890890                            }
    891891                        }
    … …  
    899899
    900900        /* make sure that we remember the failed state */
    901         if (FAILED(rc2))
    902             rc = rc2;
    903     }
    904 
    905     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     901        if (FAILED(hrc2))
     902            hrc = hrc2;
     903    }
     904
     905    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    906906}
    907907
    … …  
    918918RTEXITCODE handleSetVMEncryption(HandlerArg *a, const char *pszFilenameOrUuid)
    919919{
    920     HRESULT           rc;
     920    HRESULT           hrc;
    921921    ComPtr<IMachine>  machine;
    922922    const char       *pszPasswordNew = NULL;
    … …  
    10321032                                              Bstr(strPasswordNew).raw(), Bstr(pszNewPasswordId).raw(),
    10331033                                              fForce, progress.asOutParam()));
    1034         if (SUCCEEDED(rc))
    1035             rc = showProgress(progress);
    1036         if (FAILED(rc))
    1037         {
    1038             if (rc == E_NOTIMPL)
     1034        if (SUCCEEDED(hrc))
     1035            hrc = showProgress(progress);
     1036        if (FAILED(hrc))
     1037        {
     1038            if (hrc == E_NOTIMPL)
    10391039                RTMsgError("Encrypt VM operation is not implemented!");
    1040             else if (rc == VBOX_E_NOT_SUPPORTED)
     1040            else if (hrc == VBOX_E_NOT_SUPPORTED)
    10411041                RTMsgError("Encrypt VM operation for this cipher is not implemented yet!");
    10421042            else if (!progress.isNull())
    … …  
    10461046        }
    10471047    }
    1048     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1048    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    10491049}
    10501050
    10511051RTEXITCODE handleCheckVMPassword(HandlerArg *a, const char *pszFilenameOrUuid)
    10521052{
    1053     HRESULT rc;
     1053    HRESULT hrc;
    10541054    ComPtr<IMachine> machine;
    10551055    Utf8Str strPassword;
    … …  
    10801080    {
    10811081        CHECK_ERROR(machine, CheckEncryptionPassword(Bstr(strPassword).raw()));
    1082         if (SUCCEEDED(rc))
     1082        if (SUCCEEDED(hrc))
    10831083            RTPrintf("The given password is correct\n");
    10841084    }
    1085     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1085    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    10861086}
    10871087
    … …  
    10941094RTEXITCODE handleAddVMPassword(HandlerArg *a, const char *pszFilenameOrUuid)
    10951095{
    1096     HRESULT rc;
     1096    HRESULT hrc;
    10971097    ComPtr<IMachine> machine;
    10981098    const char *pszPassword = NULL;
    … …  
    11671167        ComPtr<IProgress> progress;
    11681168        CHECK_ERROR(machine, AddEncryptionPassword(Bstr(pszPasswordId).raw(), Bstr(strPassword).raw()));
    1169         if (rc == VBOX_E_PASSWORD_INCORRECT)
     1169        if (hrc == VBOX_E_PASSWORD_INCORRECT)
    11701170            RTMsgError("Password incorrect!");
    11711171    }
    1172     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1172    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    11731173}
    11741174
    11751175RTEXITCODE handleRemoveVMPassword(HandlerArg *a, const char *pszFilenameOrUuid)
    11761176{
    1177     HRESULT rc;
     1177    HRESULT hrc;
    11781178    ComPtr<IMachine> machine;
    11791179
    … …  
    11861186    {
    11871187        CHECK_ERROR(machine, RemoveEncryptionPassword(Bstr(a->argv[0]).raw()));
    1188         if (rc == VBOX_E_INVALID_VM_STATE)
     1188        if (hrc == VBOX_E_INVALID_VM_STATE)
    11891189            RTMsgError("The machine is in online or transient state\n");
    11901190    }
    1191     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1191    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    11921192}
    11931193
    … …  
    12161216RTEXITCODE handleDiscardState(HandlerArg *a)
    12171217{
    1218     HRESULT rc;
     1218    HRESULT hrc;
    12191219
    12201220    if (a->argc != 1)
    … …  
    12401240    }
    12411241
    1242     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1242    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    12431243}
    12441244
    12451245RTEXITCODE handleAdoptState(HandlerArg *a)
    12461246{
    1247     HRESULT rc;
     1247    HRESULT hrc;
    12481248
    12491249    if (a->argc != 2)
    … …  
    12751275    }
    12761276
    1277     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1277    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    12781278}
    12791279
    12801280RTEXITCODE handleGetExtraData(HandlerArg *a)
    12811281{
    1282     HRESULT rc = S_OK;
     1282    HRESULT hrc = S_OK;
    12831283
    12841284    if (a->argc > 2 || a->argc < 1)
    … …  
    13541354        }
    13551355    }
    1356     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1356    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    13571357}
    13581358
    13591359RTEXITCODE handleSetExtraData(HandlerArg *a)
    13601360{
    1361     HRESULT rc = S_OK;
     1361    HRESULT hrc = S_OK;
    13621362
    13631363    if (a->argc < 2)
    … …  
    14001400        }
    14011401    }
    1402     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1402    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    14031403}
    14041404
    14051405RTEXITCODE handleSetProperty(HandlerArg *a)
    14061406{
    1407     HRESULT rc;
     1407    HRESULT hrc;
    14081408
    14091409    /* there must be two arguments: property name and value */
    … …  
    15361536        return errorSyntax(Misc::tr("Invalid parameter '%s'"), a->argv[0]);
    15371537
    1538     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1538    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    15391539}
    15401540

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyNvram.cpp

    r94236 r95140  
    422422RTEXITCODE handleModifyNvram(HandlerArg *a)
    423423{
    424     HRESULT rc = S_OK;
     424    HRESULT hrc = S_OK;
    425425    ComPtr<IMachine> machine;
    426426    ComPtr<INvramStore> nvramStore;
    … …  
    438438    /* get the mutable session machine */
    439439    a->session->COMGETTER(Machine)(machine.asOutParam());
    440     rc = machine->COMGETTER(NonVolatileStore)(nvramStore.asOutParam());
    441     if (FAILED(rc)) goto leave;
     440    hrc = machine->COMGETTER(NonVolatileStore)(nvramStore.asOutParam());
     441    if (FAILED(hrc)) goto leave;
    442442
    443443    if (!strcmp(a->argv[1], "inituefivarstore"))
    444444    {
    445445        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_INITUEFIVARSTORE);
    446         rc = handleModifyNvramInitUefiVarStore(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     446        hrc = handleModifyNvramInitUefiVarStore(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    447447    }
    448448    else if (!strcmp(a->argv[1], "enrollmssignatures"))
    449449    {
    450450        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_ENROLLMSSIGNATURES);
    451         rc = handleModifyNvramEnrollMsSignatures(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     451        hrc = handleModifyNvramEnrollMsSignatures(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    452452    }
    453453    else if (!strcmp(a->argv[1], "enrollpk"))
    454454    {
    455455        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_ENROLLPK);
    456         rc = handleModifyNvramEnrollPlatformKey(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     456        hrc = handleModifyNvramEnrollPlatformKey(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    457457    }
    458458    else if (!strcmp(a->argv[1], "enrollorclpk"))
    459459    {
    460460        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_ENROLLORCLPK);
    461         rc = handleModifyNvramEnrollOraclePlatformKey(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     461        hrc = handleModifyNvramEnrollOraclePlatformKey(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    462462    }
    463463    else if (!strcmp(a->argv[1], "listvars"))
    464464    {
    465465        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_LISTVARS);
    466         rc = handleModifyNvramListUefiVars(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     466        hrc = handleModifyNvramListUefiVars(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    467467    }
    468468    else if (!strcmp(a->argv[1], "queryvar"))
    469469    {
    470470        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_QUERYVAR);
    471         rc = handleModifyNvramQueryUefiVar(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     471        hrc = handleModifyNvramQueryUefiVar(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    472472    }
    473473    else if (!strcmp(a->argv[1], "deletevar"))
    474474    {
    475475        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_DELETEVAR);
    476         rc = handleModifyNvramDeleteUefiVar(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     476        hrc = handleModifyNvramDeleteUefiVar(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    477477    }
    478478    else if (!strcmp(a->argv[1], "changevar"))
    479479    {
    480480        setCurrentSubcommand(HELP_SCOPE_MODIFYNVRAM_CHANGEVAR);
    481         rc = handleModifyNvramChangeUefiVar(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     481        hrc = handleModifyNvramChangeUefiVar(a, nvramStore) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    482482    }
    483483    else
    … …  
    485485
    486486    /* commit changes */
    487     if (SUCCEEDED(rc))
     487    if (SUCCEEDED(hrc))
    488488        CHECK_ERROR(machine, SaveSettings());
    489489
    … …  
    492492    a->session->UnlockMachine();
    493493
    494     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    495 }
     494    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     495}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r94234 r95140  
    599599{
    600600    int c;
    601     HRESULT rc;
     601    HRESULT hrc;
    602602    Bstr name;
    603603
    … …  
    634634
    635635    RTGETOPTUNION ValueUnion;
    636     while (   SUCCEEDED (rc)
     636    while (   SUCCEEDED (hrc)
    637637           && (c = RTGetOpt(&GetOptState, &ValueUnion)))
    638638    {
    … …  
    669669                {
    670670                    RTMsgError(ModifyVM::tr("Cannot open file \"%s\": %Rrc"), ValueUnion.psz, vrc);
    671                     rc = E_FAIL;
     671                    hrc = E_FAIL;
    672672                    break;
    673673                }
    … …  
    677677                {
    678678                    RTMsgError(ModifyVM::tr("Cannot get size of file \"%s\": %Rrc"), ValueUnion.psz, vrc);
    679                     rc = E_FAIL;
     679                    hrc = E_FAIL;
    680680                    break;
    681681                }
    … …  
    683683                {
    684684                    RTMsgError(ModifyVM::tr("File \"%s\" is bigger than 256KByte"), ValueUnion.psz);
    685                     rc = E_FAIL;
     685                    hrc = E_FAIL;
    686686                    break;
    687687                }
    688688                SafeArray<BYTE> icon((size_t)cbSize);
    689                 rc = RTFileRead(iconFile, icon.raw(), (size_t)cbSize, NULL);
     689                hrc = RTFileRead(iconFile, icon.raw(), (size_t)cbSize, NULL);
    690690                if (RT_FAILURE(vrc))
    691691                {
    692692                    RTMsgError(ModifyVM::tr("Cannot read contents of file \"%s\": %Rrc"), ValueUnion.psz, vrc);
    693                     rc = E_FAIL;
     693                    hrc = E_FAIL;
    694694                    break;
    695695                }
    … …  
    742742                {
    743743                    errorArgument(ModifyVM::tr("Invalid --firmware argument '%s'"), ValueUnion.psz);
    744                     rc = E_FAIL;
     744                    hrc = E_FAIL;
    745745                }
    746746                break;
    … …  
    813813                {
    814814                    errorArgument(ModifyVM::tr("Invalid --paravirtprovider argument '%s'"), ValueUnion.psz);
    815                     rc = E_FAIL;
     815                    hrc = E_FAIL;
    816816                }
    817817                break;
    … …  
    984984                {
    985985                    errorArgument(ModifyVM::tr("Invalid --graphicscontroller argument '%s'"), ValueUnion.psz);
    986                     rc = E_FAIL;
     986                    hrc = E_FAIL;
    987987                }
    988988                break;
    … …  
    10501050                {
    10511051                    errorArgument(ModifyVM::tr("Invalid --biosbootmenu argument '%s'"), ValueUnion.psz);
    1052                     rc = E_FAIL;
     1052                    hrc = E_FAIL;
    10531053                }
    10541054                break;
    … …  
    10741074                {
    10751075                    errorArgument(ModifyVM::tr("Invalid --biosapic argument '%s'"), ValueUnion.psz);
    1076                     rc = E_FAIL;
     1076                    hrc = E_FAIL;
    10771077                }
    10781078                break;
    … …  
    11611161                {
    11621162                    ComPtr<IMedium> hardDisk;
    1163                     rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
     1163                    hrc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
    11641164                                    AccessMode_ReadWrite, hardDisk,
    11651165                                    false /* fForceNewUuidOnOpen */,
    11661166                                    false /* fSilent */);
    1167                     if (FAILED(rc))
     1167                    if (FAILED(hrc))
    11681168                        break;
    11691169                    if (hardDisk)
    … …  
    11751175                    }
    11761176                    else
    1177                         rc = E_FAIL;
     1177                        hrc = E_FAIL;
    11781178                }
    11791179                break;
    … …  
    12011201                {
    12021202                    errorArgument(ModifyVM::tr("Invalid --idecontroller argument '%s'"), ValueUnion.psz);
    1203                     rc = E_FAIL;
     1203                    hrc = E_FAIL;
    12041204                }
    12051205                break;
    … …  
    12121212                                                                SataCtl.asOutParam()));
    12131213
    1214                 if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
     1214                if (SUCCEEDED(hrc) && ValueUnion.u32 > 0)
    12151215                    CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
    12161216                break;
    … …  
    12381238                if (!RTStrICmp(ValueUnion.psz, "none"))
    12391239                {
    1240                     rc = sessionMachine->DetachDevice(Bstr("LsiLogic").raw(),
     1240                    hrc = sessionMachine->DetachDevice(Bstr("LsiLogic").raw(),
    12411241                                               GetOptState.uIndex, 0);
    1242                     if (FAILED(rc))
     1242                    if (FAILED(hrc))
    12431243                        CHECK_ERROR(sessionMachine, DetachDevice(Bstr("BusLogic").raw(),
    12441244                                                          GetOptState.uIndex, 0));
    … …  
    12471247                {
    12481248                    ComPtr<IMedium> hardDisk;
    1249                     rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
     1249                    hrc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
    12501250                                    AccessMode_ReadWrite, hardDisk,
    12511251                                    false /* fForceNewUuidOnOpen */,
    12521252                                    false /* fSilent */);
    1253                     if (FAILED(rc))
     1253                    if (FAILED(hrc))
    12541254                        break;
    12551255                    if (hardDisk)
    12561256                    {
    1257                         rc = sessionMachine->AttachDevice(Bstr("LsiLogic").raw(),
     1257                        hrc = sessionMachine->AttachDevice(Bstr("LsiLogic").raw(),
    12581258                                                   GetOptState.uIndex, 0,
    12591259                                                   DeviceType_HardDisk,
    12601260                                                   hardDisk);
    1261                         if (FAILED(rc))
     1261                        if (FAILED(hrc))
    12621262                            CHECK_ERROR(sessionMachine,
    12631263                                        AttachDevice(Bstr("BusLogic").raw(),
    … …  
    12671267                    }
    12681268                    else
    1269                         rc = E_FAIL;
     1269                        hrc = E_FAIL;
    12701270                }
    12711271                break;
    … …  
    12781278                if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
    12791279                {
    1280                     rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
    1281                     if (FAILED(rc))
     1280                    hrc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
     1281                    if (FAILED(hrc))
    12821282                        CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
    12831283
    … …  
    12871287                                                      ctl.asOutParam()));
    12881288
    1289                     if (SUCCEEDED(rc))
     1289                    if (SUCCEEDED(hrc))
    12901290                        CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
    12911291                }
    12921292                else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
    12931293                {
    1294                     rc = sessionMachine->RemoveStorageController(Bstr("LsiLogic").raw());
    1295                     if (FAILED(rc))
     1294                    hrc = sessionMachine->RemoveStorageController(Bstr("LsiLogic").raw());
     1295                    if (FAILED(hrc))
    12961296                        CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("BusLogic").raw()));
    12971297
    … …  
    13011301                                                      ctl.asOutParam()));
    13021302
    1303                     if (SUCCEEDED(rc))
     1303                    if (SUCCEEDED(hrc))
    13041304                        CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
    13051305                }
    … …  
    13181318                                                              StorageBus_SCSI,
    13191319                                                              ctl.asOutParam()));
    1320                     if (SUCCEEDED(rc))
     1320                    if (SUCCEEDED(hrc))
    13211321                        CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
    13221322                }
    13231323                else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
    13241324                {
    1325                     rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
    1326                     if (FAILED(rc))
     1325                    hrc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
     1326                    if (FAILED(hrc))
    13271327                        CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
    13281328                }
    … …  
    13521352                    ComPtr<IHost> host;
    13531353                    CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
    1354                     rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
     1354                    hrc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
    13551355                                                dvdMedium.asOutParam());
    13561356                    if (!dvdMedium)
    … …  
    13611361                        {
    13621362                            errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
    1363                             rc = E_FAIL;
     1363                            hrc = E_FAIL;
    13641364                            break;
    13651365                        }
    1366                         rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
     1366                        hrc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
    13671367                                                    dvdMedium.asOutParam());
    13681368                        if (!dvdMedium)
    13691369                        {
    13701370                            errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
    1371                             rc = E_FAIL;
     1371                            hrc = E_FAIL;
    13721372                            break;
    13731373                        }
    … …  
    13761376                else
    13771377                {
    1378                     rc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
     1378                    hrc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
    13791379                                    AccessMode_ReadOnly, dvdMedium,
    13801380                                    false /* fForceNewUuidOnOpen */,
    13811381                                    false /* fSilent */);
    1382                     if (FAILED(rc))
     1382                    if (FAILED(hrc))
    13831383                        break;
    13841384                    if (!dvdMedium)
    13851385                    {
    1386                         rc = E_FAIL;
     1386                        hrc = E_FAIL;
    13871387                        break;
    13881388                    }
    … …  
    14301430                        ComPtr<IHost> host;
    14311431                        CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
    1432                         rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
     1432                        hrc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
    14331433                                                       floppyMedium.asOutParam());
    14341434                        if (!floppyMedium)
    14351435                        {
    14361436                            errorArgument(ModifyVM::tr("Invalid host floppy drive name \"%s\""), ValueUnion.psz + 5);
    1437                             rc = E_FAIL;
     1437                            hrc = E_FAIL;
    14381438                            break;
    14391439                        }
    … …  
    14411441                    else
    14421442                    {
    1443                         rc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
     1443                        hrc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
    14441444                                        AccessMode_ReadWrite, floppyMedium,
    14451445                                        false /* fForceNewUuidOnOpen */,
    14461446                                        false /* fSilent */);
    1447                         if (FAILED(rc))
     1447                        if (FAILED(hrc))
    14481448                            break;
    14491449                        if (!floppyMedium)
    14501450                        {
    1451                             rc = E_FAIL;
     1451                            hrc = E_FAIL;
    14521452                            break;
    14531453                        }
    … …  
    15151515                        {
    15161516                            errorArgument(ModifyVM::tr("Invalid --nicproperty%d argument '%s'"), GetOptState.uIndex, ValueUnion.psz);
    1517                             rc = E_FAIL;
     1517                            hrc = E_FAIL;
    15181518                        }
    15191519                        RTStrFree(pszProperty);
    … …  
    15231523                        RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for --nicproperty%d '%s'\n"),
    15241524                                     GetOptState.uIndex, ValueUnion.psz);
    1525                         rc = E_FAIL;
     1525                        hrc = E_FAIL;
    15261526                    }
    15271527                }
    … …  
    15971597                    errorArgument(ModifyVM::tr("Invalid NIC type '%s' specified for NIC %u"),
    15981598                                  ValueUnion.psz, GetOptState.uIndex);
    1599                     rc = E_FAIL;
     1599                    hrc = E_FAIL;
    16001600                }
    16011601                break;
    … …  
    16311631                {
    16321632                    errorArgument(ModifyVM::tr("Invalid boot priority '%u' specfied for NIC %u"), ValueUnion.u32, GetOptState.uIndex);
    1633                     rc = E_FAIL;
     1633                    hrc = E_FAIL;
    16341634                }
    16351635                else
    … …  
    16531653                {
    16541654                    errorArgument(ModifyVM::tr("Unknown promiscuous mode policy '%s'"), ValueUnion.psz);
    1655                     rc = E_INVALIDARG;
     1655                    hrc = E_INVALIDARG;
    16561656                    break;
    16571657                }
    … …  
    16891689                    CHECK_ERROR(sessionMachine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
    16901690
    1691                     if (SUCCEEDED(rc))
     1691                    if (SUCCEEDED(hrc))
    16921692                    {
    16931693                        CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(ValueUnion.psz).raw(), bwGroup.asOutParam()));
    1694                         if (SUCCEEDED(rc))
     1694                        if (SUCCEEDED(hrc))
    16951695                        {
    16961696                            CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(bwGroup));
    … …  
    17881788                {
    17891789                    errorArgument(ModifyVM::tr("Invalid type '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
    1790                     rc = E_FAIL;
     1790                    hrc = E_FAIL;
    17911791                }
    17921792                break;
    … …  
    20722072                    {
    20732073                        errorArgument(ModifyVM::tr("Invalid proto '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
    2074                         rc = E_FAIL;
     2074                        hrc = E_FAIL;
    20752075                        break;
    20762076                    }
    … …  
    22682268                {
    22692269                    CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse));
    2270                     if (SUCCEEDED(rc))
     2270                    if (SUCCEEDED(hrc))
    22712271                        fEnableUsb = true;
    22722272                }
    … …  
    22742274                {
    22752275                    CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet));
    2276                     if (SUCCEEDED(rc))
     2276                    if (SUCCEEDED(hrc))
    22772277                        fEnableUsb = true;
    22782278                }
    … …  
    22802280                {
    22812281                    CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouch));
    2282                     if (SUCCEEDED(rc))
     2282                    if (SUCCEEDED(hrc))
    22832283                        fEnableUsb = true;
    22842284                }
    … …  
    22902290                {
    22912291                    errorArgument(ModifyVM::tr("Invalid type '%s' specfied for pointing device"), ValueUnion.psz);
    2292                     rc = E_FAIL;
     2292                    hrc = E_FAIL;
    22932293                }
    22942294                if (fEnableUsb)
    … …  
    22972297                    ULONG cOhciCtrls = 0;
    22982298                    ULONG cXhciCtrls = 0;
    2299                     rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
    2300                     if (SUCCEEDED(rc)) {
    2301                         rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
    2302                         if (   SUCCEEDED(rc)
     2299                    hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
     2300                    if (SUCCEEDED(hrc)) {
     2301                        hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
     2302                        if (   SUCCEEDED(hrc)
    23032303                            && cOhciCtrls + cXhciCtrls == 0)
    23042304                        {
    … …  
    23232323                {
    23242324                    CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard));
    2325                     if (SUCCEEDED(rc))
     2325                    if (SUCCEEDED(hrc))
    23262326                        fEnableUsb = true;
    23272327                }
    … …  
    23292329                {
    23302330                    CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_None));
    2331                     if (SUCCEEDED(rc))
     2331                    if (SUCCEEDED(hrc))
    23322332                        fEnableUsb = true;
    23332333                }
    … …  
    23352335                {
    23362336                    errorArgument(ModifyVM::tr("Invalid type '%s' specfied for keyboard"), ValueUnion.psz);
    2337                     rc = E_FAIL;
     2337                    hrc = E_FAIL;
    23382338                }
    23392339                if (fEnableUsb)
    … …  
    23422342                    ULONG cOhciCtrls = 0;
    23432343                    ULONG cXhciCtrls = 0;
    2344                     rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
    2345                     if (SUCCEEDED(rc)) {
    2346                         rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
    2347                         if (   SUCCEEDED(rc)
     2344                    hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
     2345                    if (SUCCEEDED(hrc)) {
     2346                        hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
     2347                        if (   SUCCEEDED(hrc)
    23482348                            && cOhciCtrls + cXhciCtrls == 0)
    23492349                        {
    … …  
    25382538                {
    25392539                    errorArgument(ModifyVM::tr("Invalid --audiocontroller argument '%s'"), ValueUnion.psz);
    2540                     rc = E_FAIL;
     2540                    hrc = E_FAIL;
    25412541                }
    25422542                break;
    … …  
    25602560                {
    25612561                    errorArgument(ModifyVM::tr("Invalid --audiocodec argument '%s'"), ValueUnion.psz);
    2562                     rc = E_FAIL;
     2562                    hrc = E_FAIL;
    25632563                }
    25642564                break;
    … …  
    26322632                {
    26332633                    errorArgument(ModifyVM::tr("Invalid --audio argument '%s'"), ValueUnion.psz);
    2634                     rc = E_FAIL;
     2634                    hrc = E_FAIL;
    26352635                }
    26362636                break;
    … …  
    26722672                {
    26732673                    errorArgument(ModifyVM::tr("Invalid --clipboard-mode argument '%s'"), ValueUnion.psz);
    2674                     rc = E_FAIL;
    2675                 }
    2676                 if (SUCCEEDED(rc))
     2674                    hrc = E_FAIL;
     2675                }
     2676                if (SUCCEEDED(hrc))
    26772677                {
    26782678                    CHECK_ERROR(sessionMachine, COMSETTER(ClipboardMode)(mode));
    … …  
    26922692                {
    26932693                    errorArgument(ModifyVM::tr("Invalid --clipboard-file-transfers argument '%s'"), ValueUnion.psz);
    2694                     rc = E_FAIL;
    2695                 }
    2696                 if (SUCCEEDED(rc))
     2694                    hrc = E_FAIL;
     2695                }
     2696                if (SUCCEEDED(hrc))
    26972697                {
    26982698                    CHECK_ERROR(sessionMachine, COMSETTER(ClipboardFileTransfersEnabled)(fEnabled));
    … …  
    27172717                {
    27182718                    errorArgument(ModifyVM::tr("Invalid --draganddrop argument '%s'"), ValueUnion.psz);
    2719                     rc = E_FAIL;
    2720                 }
    2721                 if (SUCCEEDED(rc))
     2719                    hrc = E_FAIL;
     2720                }
     2721                if (SUCCEEDED(hrc))
    27222722                {
    27232723                    CHECK_ERROR(sessionMachine, COMSETTER(DnDMode)(mode));
    … …  
    27712771
    27722772                            errorArgument(ModifyVM::tr("Invalid --vrdeproperty argument '%s'"), ValueUnion.psz);
    2773                             rc = E_FAIL;
     2773                            hrc = E_FAIL;
    27742774                            break;
    27752775                        }
    … …  
    27802780                        RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for VRDE property '%s'\n"),
    27812781                                     ValueUnion.psz);
    2782                         rc = E_FAIL;
     2782                        hrc = E_FAIL;
    27832783                    }
    27842784                }
    … …  
    28412841                {
    28422842                    errorArgument(ModifyVM::tr("Invalid --vrdeauthtype argument '%s'"), ValueUnion.psz);
    2843                     rc = E_FAIL;
     2843                    hrc = E_FAIL;
    28442844                }
    28452845                break;
    … …  
    29592959                {
    29602960                    errorArgument(ModifyVM::tr("Invalid --usbrename parameters, nothing renamed"));
    2961                     rc = E_FAIL;
     2961                    hrc = E_FAIL;
    29622962                }
    29632963                break;
    … …  
    29672967            {
    29682968                ULONG cXhciCtrls = 0;
    2969                 rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
    2970                 if (SUCCEEDED(rc))
     2969                hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
     2970                if (SUCCEEDED(hrc))
    29712971                {
    29722972                    if (!cXhciCtrls && ValueUnion.f)
    … …  
    30003000            {
    30013001                ULONG cEhciCtrls = 0;
    3002                 rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls);
    3003                 if (SUCCEEDED(rc))
     3002                hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls);
     3003                if (SUCCEEDED(hrc))
    30043004                {
    30053005                    if (!cEhciCtrls && ValueUnion.f)
    … …  
    30333033            {
    30343034                ULONG cOhciCtrls = 0;
    3035                 rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
    3036                 if (SUCCEEDED(rc))
     3035                hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
     3036                if (SUCCEEDED(hrc))
    30373037                {
    30383038                    if (!cOhciCtrls && ValueUnion.f)
    … …  
    31013101                RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password);
    31023102                if (rcExit != RTEXITCODE_SUCCESS)
    3103                     rc = E_FAIL;
     3103                    hrc = E_FAIL;
    31043104                else
    31053105                    CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(password).raw()));
    … …  
    31693169                {
    31703170                    errorArgument(ModifyVM::tr("Invalid --chipset argument '%s' (valid: piix3,ich9)"), ValueUnion.psz);
    3171                     rc = E_FAIL;
     3171                    hrc = E_FAIL;
    31723172                }
    31733173                break;
    … …  
    31873187#else
    31883188                    errorArgument(ModifyVM::tr("Invalid --iommu argument '%s' (valid: none,amd,automatic)"), ValueUnion.psz);
    3189                     rc = E_FAIL;
     3189                    hrc = E_FAIL;
    31903190#endif
    31913191                }
    … …  
    32013201                {
    32023202                    errorArgument(ModifyVM::tr("Invalid --iommu argument '%s'"), ValueUnion.psz);
    3203                     rc = E_FAIL;
     3203                    hrc = E_FAIL;
    32043204                }
    32053205                break;
    … …  
    32263226                {
    32273227                    errorArgument(ModifyVM::tr("Invalid --tpm-type argument '%s'"), ValueUnion.psz);
    3228                     rc = E_FAIL;
     3228                    hrc = E_FAIL;
    32293229                }
    32303230                break;
    … …  
    32833283                        {
    32843284                            errorArgument(ModifyVM::tr("Invalid list of screens specified\n"));
    3285                             rc = E_FAIL;
     3285                            hrc = E_FAIL;
    32863286                            break;
    32873287                        }
    … …  
    33053305                            {
    33063306                                errorArgument(ModifyVM::tr("Cannot convert filename \"%s\" to absolute path\n"), ValueUnion.psz);
    3307                                 rc = E_FAIL;
     3307                                hrc = E_FAIL;
    33083308                                break;
    33093309                            }
    … …  
    33363336                            errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
    33373337                                          ValueUnion.psz);
    3338                             rc = E_FAIL;
     3338                            hrc = E_FAIL;
    33393339                            break;
    33403340                        }
    … …  
    33453345                            errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
    33463346                                          ValueUnion.psz);
    3347                             rc = E_FAIL;
     3347                            hrc = E_FAIL;
    33483348                            break;
    33493349                        }
    … …  
    34203420                    errorArgument(ModifyVM::tr("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)"),
    34213421                                  ValueUnion.psz);
    3422                     rc = E_FAIL;
    3423                 }
    3424 
    3425                 if (SUCCEEDED(rc))
     3422                    hrc = E_FAIL;
     3423                }
     3424
     3425                if (SUCCEEDED(hrc))
    34263426                    CHECK_ERROR(sessionMachine, COMSETTER(AutostopType)(enmAutostopType));
    34273427                break;
    … …  
    34403440                    errorArgument(ModifyVM::tr("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')"),
    34413441                                  ValueUnion.psz);
    3442                     rc = E_FAIL;
     3442                    hrc = E_FAIL;
    34433443                }
    34443444                else
    … …  
    34573457                {
    34583458                    errorArgument(ModifyVM::tr("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')"), ValueUnion.psz);
    3459                     rc = E_FAIL;
     3459                    hrc = E_FAIL;
    34603460                }
    34613461                else
    … …  
    34913491                {
    34923492                    errorArgument(ModifyVM::tr("Invalid --vm-process-priority '%s'"), ValueUnion.psz);
    3493                     rc = E_FAIL;
     3493                    hrc = E_FAIL;
    34943494                }
    34953495                else
    … …  
    35013501
    35023502            case MODIFYVM_TESTING_ENABLED:
    3503                 rc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled", ValueUnion.f ? "1" : "");
     3503                hrc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled", ValueUnion.f ? "1" : "");
    35043504                break;
    35053505
    35063506            case MODIFYVM_TESTING_MMIO:
    3507                 rc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingMMIO", ValueUnion.f ? "1" : "");
     3507                hrc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingMMIO", ValueUnion.f ? "1" : "");
    35083508                break;
    35093509
    … …  
    35163516                    char szValue[32];
    35173517                    RTStrPrintf(szValue, sizeof(szValue), "%u", ValueUnion.u32);
    3518                     rc = setExtraData(sessionMachine, szVar, szValue);
    3519                 }
    3520                 else
    3521                     rc = errorArgumentHr(ModifyVM::tr("--testing-cfg-dword index %u is out of range: 0 thru 9"),
     3518                    hrc = setExtraData(sessionMachine, szVar, szValue);
     3519                }
     3520                else
     3521                    hrc = errorArgumentHr(ModifyVM::tr("--testing-cfg-dword index %u is out of range: 0 thru 9"),
    35223522                                         GetOptState.uIndex);
    35233523                break;
    … …  
    35253525            default:
    35263526                errorGetOpt(c, &ValueUnion);
    3527                 rc = E_FAIL;
     3527                hrc = E_FAIL;
    35283528                break;
    35293529        }
    … …  
    35313531
    35323532    /* commit changes */
    3533     if (SUCCEEDED(rc))
     3533    if (SUCCEEDED(hrc))
    35343534        CHECK_ERROR(sessionMachine, SaveSettings());
    35353535
    … …  
    35373537    a->session->UnlockMachine();
    35383538
    3539     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     3539    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    35403540}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageNATNetwork.cpp

    r94322 r95140  
    8686                               bool fLong = true)
    8787{
    88     HRESULT rc;
     88    HRESULT hrc;
    8989
    9090    do
    … …  
    157157    } while (0);
    158158
    159     return rc;
     159    return hrc;
    160160}
    161161
    162162static RTEXITCODE handleNATList(HandlerArg *a)
    163163{
    164     HRESULT rc;
     164    HRESULT hrc;
    165165
    166166    RTPrintf(Nat::tr("NAT Networks:\n\n"));
    … …  
    188188        }
    189189
    190         rc = printNATNetwork(pNATNet);
    191         if (FAILED(rc))
     190        hrc = printNATNetwork(pNATNet);
     191        if (FAILED(hrc))
    192192            break;
    193193
    … …  
    195195    }
    196196
    197     if (SUCCEEDED(rc))
     197    if (SUCCEEDED(hrc))
    198198        RTPrintf(Nat::tr("%zu %s found\n"), cFound, cFound == 1 ? Nat::tr("network") : Nat::tr("networks", "", cFound));
    199199
    200     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     200    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    201201}
    202202
    … …  
    397397    }
    398398
    399     HRESULT rc;
     399    HRESULT hrc;
    400400    Bstr NetName;
    401401    NetName = Bstr(pNetName);
    402402
    403403    ComPtr<INATNetwork> net;
    404     rc = a->virtualBox->FindNATNetworkByName(NetName.mutableRaw(), net.asOutParam());
     404    hrc = a->virtualBox->FindNATNetworkByName(NetName.mutableRaw(), net.asOutParam());
    405405    if (enmCode == OP_ADD)
    406406    {
    407         if (SUCCEEDED(rc))
     407        if (SUCCEEDED(hrc))
    408408            return errorArgument(Nat::tr("NATNetwork server already exists"));
    409409
    410410        CHECK_ERROR(a->virtualBox, CreateNATNetwork(NetName.raw(), net.asOutParam()));
    411         if (FAILED(rc))
     411        if (FAILED(hrc))
    412412            return errorArgument(Nat::tr("Failed to create the NAT network service"));
    413413    }
    414     else if (FAILED(rc))
     414    else if (FAILED(hrc))
    415415        return errorArgument(Nat::tr("NATNetwork server does not exist"));
    416416
    … …  
    423423            {
    424424                CHECK_ERROR(net, COMSETTER(Network)(Bstr(pPrefixIPv4).raw()));
    425                 if (FAILED(rc))
     425                if (FAILED(hrc))
    426426                    return errorArgument(Nat::tr("Failed to set configuration"));
    427427            }
    … …  
    429429            {
    430430                CHECK_ERROR(net, COMSETTER(NeedDhcpServer) ((BOOL)dhcp));
    431                 if (FAILED(rc))
     431                if (FAILED(hrc))
    432432                    return errorArgument(Nat::tr("Failed to set configuration"));
    433433            }
    … …  
    441441            {
    442442                CHECK_ERROR(net, COMSETTER(IPv6Enabled)(FALSE));
    443                 if (FAILED(rc))
     443                if (FAILED(hrc))
    444444                    return errorArgument(Nat::tr("Failed to set configuration"));
    445445            }
    … …  
    448448            {
    449449                CHECK_ERROR(net, COMSETTER(IPv6Prefix)(Bstr(pPrefixIPv6).raw()));
    450                 if (FAILED(rc))
     450                if (FAILED(hrc))
    451451                    return errorArgument(Nat::tr("Failed to set configuration"));
    452452            }
    … …  
    459459            {
    460460                CHECK_ERROR(net, COMSETTER(IPv6Enabled)(TRUE));
    461                 if (FAILED(rc))
     461                if (FAILED(hrc))
    462462                    return errorArgument(Nat::tr("Failed to set configuration"));
    463463            }
    … …  
    467467                BOOL fIPv6Default = RT_BOOL(ipv6_default);
    468468                CHECK_ERROR(net, COMSETTER(AdvertiseDefaultIPv6RouteEnabled)(fIPv6Default));
    469                 if (FAILED(rc))
     469                if (FAILED(hrc))
    470470                    return errorArgument(Nat::tr("Failed to set configuration"));
    471471            }
    … …  
    478478                    CHECK_ERROR(net, RemovePortForwardRule((BOOL)(*it).fIPv6,
    479479                                                           Bstr((*it).szName).raw()));
    480                     if (FAILED(rc))
     480                    if (FAILED(hrc))
    481481                        return errorArgument(Nat::tr("Failed to delete pf"));
    482482                }
    … …  
    503503                                                        Bstr((*it).szPfrGuestAddr).raw(),
    504504                                                        (*it).u16PfrGuestPort));
    505                     if (FAILED(rc))
     505                    if (FAILED(hrc))
    506506                        return errorArgument(Nat::tr("Failed to add pf"));
    507507                }
    … …  
    562562            {
    563563                CHECK_ERROR(net, COMSETTER(Enabled) ((BOOL)enable));
    564                 if (FAILED(rc))
     564                if (FAILED(hrc))
    565565                    return errorArgument(Nat::tr("Failed to set configuration"));
    566566            }
    … …  
    570570        {
    571571            CHECK_ERROR(a->virtualBox, RemoveNATNetwork(net));
    572             if (FAILED(rc))
     572            if (FAILED(hrc))
    573573                return errorArgument(Nat::tr("Failed to remove nat network"));
    574574            break;
    … …  
    577577        {
    578578            CHECK_ERROR(net, Start());
    579             if (FAILED(rc))
     579            if (FAILED(hrc))
    580580                return errorArgument(Nat::tr("Failed to start network"));
    581581            break;
    … …  
    584584        {
    585585            CHECK_ERROR(net, Stop());
    586             if (FAILED(rc))
     586            if (FAILED(hrc))
    587587                return errorArgument(Nat::tr("Failed to stop network"));
    588588            break;
    … …  
    645645                           const ComPtr<IVirtualBox> &pVirtualBox)
    646646{
    647     HRESULT rc;
     647    HRESULT hrc;
    648648
    649649    com::SafeIfaceArray<INATNetwork> aNets;

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp

    r93115 r95140  
    5656                                     uint32_t uSnapshotLevel)
    5757{
    58     HRESULT rc;
     58    HRESULT hrc;
    5959
    6060    do
    … …  
    134134                            uint32_t uLevel)
    135135{
    136     HRESULT rc;
     136    HRESULT hrc;
    137137    do
    138138    {
    … …  
    219219void DumpSnapshot(ComPtr<IMachine> &pMachine)
    220220{
    221     HRESULT rc;
     221    HRESULT hrc;
    222222
    223223    do
    … …  
    316316RTEXITCODE handleSnapshot(HandlerArg *a)
    317317{
    318     HRESULT rc;
     318    HRESULT hrc;
    319319
    320320/** @todo r=bird: sub-standard command line parsing here!
    … …  
    358358            {
    359359                errorSyntax(Snapshot::tr("Missing snapshot name"));
    360                 rc = E_FAIL;
     360                hrc = E_FAIL;
    361361                break;
    362362            }
    … …  
    382382            RTGETOPTUNION Value;
    383383            int vrc;
    384             while (   SUCCEEDED(rc)
     384            while (   SUCCEEDED(hrc)
    385385                   && (ch = RTGetOpt(&GetOptState, &Value)))
    386386            {
    … …  
    407407                    default:
    408408                        errorGetOpt(ch, &Value);
    409                         rc = E_FAIL;
     409                        hrc = E_FAIL;
    410410                        break;
    411411                }
    412412            }
    413             if (FAILED(rc))
     413            if (FAILED(hrc))
    414414                break;
    415415
    … …  
    417417            {
    418418                ComPtr<ISnapshot> pSnapshot;
    419                 rc = sessionMachine->FindSnapshot(name.raw(),
    420                                                   pSnapshot.asOutParam());
    421                 if (SUCCEEDED(rc) || (enmUnique & SnapshotUniqueFlags_Force))
     419                hrc = sessionMachine->FindSnapshot(name.raw(),
     420                                                   pSnapshot.asOutParam());
     421                if (SUCCEEDED(hrc) || (enmUnique & SnapshotUniqueFlags_Force))
    422422                {
    423423                    /* there is a duplicate, need to create a unique name */
    … …  
    455455                            tryName = BstrFmt("%ls%s", name.raw(), suffix.c_str());
    456456                        count++;
    457                         rc = sessionMachine->FindSnapshot(tryName.raw(),
    458                                                           pSnapshot.asOutParam());
    459                         if (FAILED(rc))
     457                        hrc = sessionMachine->FindSnapshot(tryName.raw(),
     458                                                           pSnapshot.asOutParam());
     459                        if (FAILED(hrc))
    460460                        {
    461461                            name = tryName;
    … …  
    463463                        }
    464464                    }
    465                     if (SUCCEEDED(rc))
     465                    if (SUCCEEDED(hrc))
    466466                    {
    467467                        errorArgument(Snapshot::tr("Failed to generate a unique snapshot name"));
    468                         rc = E_FAIL;
     468                        hrc = E_FAIL;
    469469                        break;
    470470                    }
    471471                }
    472                 rc = S_OK;
     472                hrc = S_OK;
    473473            }
    474474
    … …  
    479479                                                           progress.asOutParam()));
    480480
    481             rc = showProgress(progress);
    482             if (SUCCEEDED(rc))
     481            hrc = showProgress(progress);
     482            if (SUCCEEDED(hrc))
    483483                RTPrintf(Snapshot::tr("Snapshot taken. UUID: %ls\n"), snapId.raw());
    484484            else
    … …  
    499499                {
    500500                    errorSyntax(Snapshot::tr("Too many arguments"));
    501                     rc = E_FAIL;
     501                    hrc = E_FAIL;
    502502                    break;
    503503                }
    … …  
    507507            {
    508508                errorSyntax(Snapshot::tr("Expecting snapshot name only"));
    509                 rc = E_FAIL;
     509                hrc = E_FAIL;
    510510                break;
    511511            }
    … …  
    551551            }
    552552
    553             rc = showProgress(pProgress);
     553            hrc = showProgress(pProgress);
    554554            CHECK_PROGRESS_ERROR(pProgress, (Snapshot::tr("Snapshot operation failed")));
    555555        }
    … …  
    560560            {
    561561                errorSyntax(Snapshot::tr("Missing snapshot name"));
    562                 rc = E_FAIL;
     562                hrc = E_FAIL;
    563563                break;
    564564            }
    … …  
    583583            int ch;
    584584            RTGETOPTUNION Value;
    585             while (   SUCCEEDED(rc)
     585            while (   SUCCEEDED(hrc)
    586586                   && (ch = RTGetOpt(&GetOptState, &Value)))
    587587            {
    … …  
    611611                    default:
    612612                        errorGetOpt(ch, &Value);
    613                         rc = E_FAIL;
     613                        hrc = E_FAIL;
    614614                        break;
    615615                }
    616616            }
    617617
    618             if (FAILED(rc))
     618            if (FAILED(hrc))
    619619                break;
    620620        }
    … …  
    627627            {
    628628                errorSyntax(Snapshot::tr("Expecting snapshot name only"));
    629                 rc = E_FAIL;
     629                hrc = E_FAIL;
    630630                break;
    631631            }
    … …  
    644644        {
    645645            setCurrentSubcommand(HELP_SCOPE_SNAPSHOT_LIST);
    646             rc = handleSnapshotList(a, sessionMachine) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
     646            hrc = handleSnapshotList(a, sessionMachine) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
    647647        }
    648648        else if (!strcmp(a->argv[1], "dump"))          // undocumented parameter to debug snapshot info
    … …  
    651651        {
    652652            errorSyntax(Snapshot::tr("Invalid parameter '%s'"), a->argv[1]);
    653             rc = E_FAIL;
     653            hrc = E_FAIL;
    654654        }
    655655    } while (0);
    … …  
    657657    a->session->UnlockMachine();
    658658
    659     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     659    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    660660}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp

    r94236 r95140  
    7777{
    7878    int c = VERR_INTERNAL_ERROR;        /* initialized to shut up gcc */
    79     HRESULT rc = S_OK;
     79    HRESULT hrc = S_OK;
    8080    ULONG port   = ~0U;
    8181    ULONG device = ~0U;
    … …  
    118118                 RT_ELEMENTS(g_aStorageAttachOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
    119119
    120     while (   SUCCEEDED(rc)
     120    while (   SUCCEEDED(hrc)
    121121           && (c = RTGetOpt(&GetState, &ValueUnion)))
    122122    {
    … …  
    128128                    pszCtl = ValueUnion.psz;
    129129                else
    130                     rc = E_FAIL;
     130                    hrc = E_FAIL;
    131131                break;
    132132            }
    … …  
    149149                    pszMedium = ValueUnion.psz;
    150150                else
    151                     rc = E_FAIL;
     151                    hrc = E_FAIL;
    152152                break;
    153153            }
    … …  
    167167                }
    168168                else
    169                     rc = E_FAIL;
     169                    hrc = E_FAIL;
    170170                break;
    171171            }
    … …  
    176176                    pszPassThrough = ValueUnion.psz;
    177177                else
    178                     rc = E_FAIL;
     178                    hrc = E_FAIL;
    179179                break;
    180180            }
    … …  
    185185                    pszTempEject = ValueUnion.psz;
    186186                else
    187                     rc = E_FAIL;
     187                    hrc = E_FAIL;
    188188                break;
    189189            }
    … …  
    194194                    pszNonRotational = ValueUnion.psz;
    195195                else
    196                     rc = E_FAIL;
     196                    hrc = E_FAIL;
    197197                break;
    198198            }
    … …  
    203203                    pszDiscard = ValueUnion.psz;
    204204                else
    205                     rc = E_FAIL;
     205                    hrc = E_FAIL;
    206206                break;
    207207            }
    … …  
    212212                    pszHotPluggable = ValueUnion.psz;
    213213                else
    214                     rc = E_FAIL;
     214                    hrc = E_FAIL;
    215215                break;
    216216            }
    … …  
    221221                    pszBandwidthGroup = ValueUnion.psz;
    222222                else
    223                     rc = E_FAIL;
     223                    hrc = E_FAIL;
    224224                break;
    225225            }
    … …  
    235235                    bstrComment = ValueUnion.psz;
    236236                else
    237                     rc = E_FAIL;
     237                    hrc = E_FAIL;
    238238                break;
    239239
    … …  
    245245                }
    246246                else
    247                     rc = E_FAIL;
     247                    hrc = E_FAIL;
    248248                break;
    249249
    … …  
    255255                }
    256256                else
    257                     rc = E_FAIL;
     257                    hrc = E_FAIL;
    258258                break;
    259259
    … …  
    291291                RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &utf8Password);
    292292                if (rcExit != RTEXITCODE_SUCCESS)
    293                     rc = E_FAIL;
     293                    hrc = E_FAIL;
    294294                bstrPassword = utf8Password;
    295295                break;
    … …  
    315315            {
    316316                errorGetOpt(c, &ValueUnion);
    317                 rc = E_FAIL;
     317                hrc = E_FAIL;
    318318                break;
    319319            }
    … …  
    321321    }
    322322
    323     if (FAILED(rc))
     323    if (FAILED(hrc))
    324324        return RTEXITCODE_FAILURE;
    325325
    … …  
    351351
    352352        /* check if the storage controller is present */
    353         rc = machine->GetStorageControllerByName(Bstr(pszCtl).raw(),
    354                                                  storageCtl.asOutParam());
    355         if (FAILED(rc))
     353        hrc = machine->GetStorageControllerByName(Bstr(pszCtl).raw(),
     354                                                  storageCtl.asOutParam());
     355        if (FAILED(hrc))
    356356            throw Utf8StrFmt(Storage::tr("Could not find a controller named '%s'\n"), pszCtl);
    357357
    … …  
    408408                ComPtr<IMediumAttachment> mediumAttachment;
    409409                DeviceType_T deviceType = DeviceType_Null;
    410                 rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, device,
    411                                                   mediumAttachment.asOutParam());
    412                 if (SUCCEEDED(rc))
     410                hrc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, device,
     411                                                   mediumAttachment.asOutParam());
     412                if (SUCCEEDED(hrc))
    413413                {
    414414                    mediumAttachment->COMGETTER(Type)(&deviceType);
    … …  
    435435                }
    436436
    437                 if (   FAILED(rc)
     437                if (   FAILED(hrc)
    438438                    || !(   deviceType == DeviceType_DVD
    439439                         || deviceType == DeviceType_Floppy)
    … …  
    496496                     */
    497497                    ComPtr<IMediumAttachment> mediumAttachment;
    498                     rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
    499                                                       device,
    500                                                       mediumAttachment.asOutParam());
    501                     if (SUCCEEDED(rc))
     498                    hrc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
     499                                                       device,
     500                                                       mediumAttachment.asOutParam());
     501                    if (SUCCEEDED(hrc))
    502502                    {
    503503                        DeviceType_T deviceType;
    … …  
    520520                            }
    521521                            ComPtr<IMedium> pExistingMedium;
    522                             rc = openMedium(a, pszMedium, deviceType,
    523                                             AccessMode_ReadWrite,
    524                                             pExistingMedium,
    525                                             false /* fForceNewUuidOnOpen */,
    526                                             true /* fSilent */);
    527                             if (SUCCEEDED(rc) && pExistingMedium)
     522                            hrc = openMedium(a, pszMedium, deviceType,
     523                                             AccessMode_ReadWrite,
     524                                             pExistingMedium,
     525                                             false /* fForceNewUuidOnOpen */,
     526                                             true /* fSilent */);
     527                            if (SUCCEEDED(hrc) && pExistingMedium)
    528528                            {
    529529                                if (    (deviceType == DeviceType_DVD)
    … …  
    547547
    548548                CHECK_ERROR(systemProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes)));
    549                 if (SUCCEEDED(rc))
     549                if (SUCCEEDED(hrc))
    550550                {
    551551                    ULONG driveCheck = 0;
    … …  
    569569                if (devTypeRequested == DeviceType_DVD)
    570570                {
    571                     rc = host->FindHostDVDDrive(Bstr(pszMedium + 5).raw(),
    572                                                 pMedium2Mount.asOutParam());
     571                    hrc = host->FindHostDVDDrive(Bstr(pszMedium + 5).raw(),
     572                                                 pMedium2Mount.asOutParam());
    573573                    if (!pMedium2Mount)
    574574                    {
    … …  
    577577                        if (RT_FAILURE(RTPathReal(pszMedium + 5, szPathReal, sizeof(szPathReal))))
    578578                            throw Utf8StrFmt(Storage::tr("Invalid host DVD drive name \"%s\""), pszMedium + 5);
    579                         rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
    580                                                     pMedium2Mount.asOutParam());
     579                        hrc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
     580                                                     pMedium2Mount.asOutParam());
    581581                        if (!pMedium2Mount)
    582582                            throw Utf8StrFmt(Storage::tr("Invalid host DVD drive name \"%s\""), pszMedium + 5);
    … …  
    586586                {
    587587                    // floppy
    588                     rc = host->FindHostFloppyDrive(Bstr(pszMedium + 5).raw(),
    589                                                    pMedium2Mount.asOutParam());
     588                    hrc = host->FindHostFloppyDrive(Bstr(pszMedium + 5).raw(),
     589                                                    pMedium2Mount.asOutParam());
    590590                    if (!pMedium2Mount)
    591591                        throw Utf8StrFmt(Storage::tr("Invalid host floppy drive name \"%s\""), pszMedium + 5);
    … …  
    616616                                                        DeviceType_HardDisk,
    617617                                                        pMedium2Mount.asOutParam()));
    618                 if (FAILED(rc)) goto leave;
     618                if (FAILED(hrc)) goto leave; /** @todo r=andy Argh!! Why not using exceptions here? */
    619619                if (!bstrPort.isEmpty())
    620620                    bstrServer = BstrFmt("%ls:%ls", bstrServer.raw(), bstrPort.raw());
    … …  
    659659                CHECK_ERROR(pMedium2Mount, SetProperties(ComSafeArrayAsInParam(names),
    660660                                                         ComSafeArrayAsInParam(values)));
    661                 if (FAILED(rc)) goto leave;
     661                if (FAILED(hrc)) goto leave;
    662662                Bstr guid;
    663663                CHECK_ERROR(pMedium2Mount, COMGETTER(Id)(guid.asOutParam()));
    664                 if (FAILED(rc)) goto leave;
     664                if (FAILED(hrc)) goto leave;
    665665                RTPrintf(Storage::tr("iSCSI disk created. UUID: %s\n"), Utf8Str(guid).c_str());
    666666            }
    … …  
    670670                {
    671671                    ComPtr<IMediumAttachment> mediumAttachment;
    672                     rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
    673                                                       device,
    674                                                       mediumAttachment.asOutParam());
    675                     if (FAILED(rc))
     672                    hrc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
     673                                                       device,
     674                                                       mediumAttachment.asOutParam());
     675                    if (FAILED(hrc))
    676676                        throw Utf8Str(Storage::tr("Missing --medium argument"));
    677677                }
    … …  
    679679                {
    680680                    Bstr bstrMedium(pszMedium);
    681                     rc = openMedium(a, pszMedium, devTypeRequested,
    682                                     AccessMode_ReadWrite, pMedium2Mount,
    683                                     fSetNewUuid, false /* fSilent */);
    684                     if (FAILED(rc) || !pMedium2Mount)
     681                    hrc = openMedium(a, pszMedium, devTypeRequested,
     682                                     AccessMode_ReadWrite, pMedium2Mount,
     683                                     fSetNewUuid, false /* fSilent */);
     684                    if (FAILED(hrc) || !pMedium2Mount)
    685685                        throw Utf8StrFmt(Storage::tr("Invalid UUID or filename \"%s\""), pszMedium);
    686686                }
    … …  
    692692                CHECK_ERROR(pMedium2Mount, SetIds(fSetNewUuid, bstrNewUuid.raw(),
    693693                                                  fSetNewParentUuid, bstrNewParentUuid.raw()));
    694                 if (FAILED(rc))
     694                if (FAILED(hrc))
    695695                    throw  Utf8Str(Storage::tr("Failed to set the medium/parent medium UUID"));
    696696            }
    … …  
    701701                MediumType_T enmMediumTypeOld;
    702702                CHECK_ERROR(pMedium2Mount, COMGETTER(Type)(&enmMediumTypeOld));
    703                 if (SUCCEEDED(rc))
     703                if (SUCCEEDED(hrc))
    704704                {
    705705                    if (enmMediumTypeOld != enmMediumType)
    706706                    {
    707707                        CHECK_ERROR(pMedium2Mount, COMSETTER(Type)(enmMediumType));
    708                         if (FAILED(rc))
     708                        if (FAILED(hrc))
    709709                            throw  Utf8Str(Storage::tr("Failed to set the medium type"));
    710710                    }
    … …  
    728728                            ComPtr<IMediumAttachment> mediumAttachment;
    729729                            // check if there is a dvd/floppy drive at the given location, if not attach one first
    730                             rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(),
    731                                                               port,
    732                                                               device,
    733                                                               mediumAttachment.asOutParam());
    734                             if (SUCCEEDED(rc))
     730                            hrc = machine->GetMediumAttachment(Bstr(pszCtl).raw(),
     731                                                               port,
     732                                                               device,
     733                                                               mediumAttachment.asOutParam());
     734                            if (SUCCEEDED(hrc))
    735735                            {
    736736                                DeviceType_T deviceType;
    … …  
    739739                                {
    740740                                    machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
    741                                     rc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(),
    742                                                                             port,
    743                                                                             device,
    744                                                                             devTypeRequested);    // DeviceType_DVD or DeviceType_Floppy
     741                                    hrc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(),
     742                                                                             port,
     743                                                                             device,
     744                                                                             devTypeRequested);    // DeviceType_DVD or DeviceType_Floppy
    745745                                }
    746746                            }
    747747                            else
    748748                            {
    749                                 rc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(),
    750                                                                         port,
    751                                                                         device,
    752                                                                         devTypeRequested);    // DeviceType_DVD or DeviceType_Floppy
     749                                hrc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(),
     750                                                                         port,
     751                                                                         device,
     752                                                                         devTypeRequested);    // DeviceType_DVD or DeviceType_Floppy
    753753                            }
    754754                        }
    … …  
    783783
    784784        if (   pszPassThrough
    785             && (SUCCEEDED(rc)))
     785            && (SUCCEEDED(hrc)))
    786786        {
    787787            ComPtr<IMediumAttachment> mattach;
    … …  
    789789                                                     device, mattach.asOutParam()));
    790790
    791             if (SUCCEEDED(rc))
     791            if (SUCCEEDED(hrc))
    792792            {
    793793                if (!RTStrICmp(pszPassThrough, "on"))
    … …  
    809809
    810810        if (   pszTempEject
    811             && (SUCCEEDED(rc)))
     811            && (SUCCEEDED(hrc)))
    812812        {
    813813            ComPtr<IMediumAttachment> mattach;
    … …  
    815815                                                     device, mattach.asOutParam()));
    816816
    817             if (SUCCEEDED(rc))
     817            if (SUCCEEDED(hrc))
    818818            {
    819819                if (!RTStrICmp(pszTempEject, "on"))
    … …  
    835835
    836836        if (   pszNonRotational
    837             && (SUCCEEDED(rc)))
     837            && (SUCCEEDED(hrc)))
    838838        {
    839839            ComPtr<IMediumAttachment> mattach;
    … …  
    841841                                                     device, mattach.asOutParam()));
    842842
    843             if (SUCCEEDED(rc))
     843            if (SUCCEEDED(hrc))
    844844            {
    845845                if (!RTStrICmp(pszNonRotational, "on"))
    … …  
    861861
    862862        if (   pszDiscard
    863             && (SUCCEEDED(rc)))
     863            && (SUCCEEDED(hrc)))
    864864        {
    865865            ComPtr<IMediumAttachment> mattach;
    … …  
    867867                                                     device, mattach.asOutParam()));
    868868
    869             if (SUCCEEDED(rc))
     869            if (SUCCEEDED(hrc))
    870870            {
    871871                if (!RTStrICmp(pszDiscard, "on"))
    … …  
    887887
    888888        if (   pszHotPluggable
    889             && (SUCCEEDED(rc)))
     889            && (SUCCEEDED(hrc)))
    890890        {
    891891            ComPtr<IMediumAttachment> mattach;
    … …  
    893893                                                     device, mattach.asOutParam()));
    894894
    895             if (SUCCEEDED(rc))
     895            if (SUCCEEDED(hrc))
    896896            {
    897897                if (!RTStrICmp(pszHotPluggable, "on"))
    … …  
    914914        if (   pszBandwidthGroup
    915915            && !fRunTime
    916             && SUCCEEDED(rc))
     916            && SUCCEEDED(hrc))
    917917        {
    918918
    … …  
    930930                CHECK_ERROR(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
    931931
    932                 if (SUCCEEDED(rc))
     932                if (SUCCEEDED(hrc))
    933933                {
    934934                    CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(pszBandwidthGroup).raw(), bwGroup.asOutParam()));
    935                     if (SUCCEEDED(rc))
     935                    if (SUCCEEDED(hrc))
    936936                    {
    937937                        CHECK_ERROR(machine, SetBandwidthGroupForDevice(Bstr(pszCtl).raw(),
    … …  
    943943
    944944        /* commit changes */
    945         if (SUCCEEDED(rc))
     945        if (SUCCEEDED(hrc))
    946946            CHECK_ERROR(machine, SaveSettings());
    947947    }
    … …  
    949949    {
    950950        errorArgument("%s", strError.c_str());
    951         rc = E_FAIL;
     951        hrc = E_FAIL;
    952952    }
    953953
    … …  
    956956    a->session->UnlockMachine();
    957957
    958     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     958    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    959959}
    960960
    … …  
    10381038    }
    10391039
    1040     HRESULT rc;
     1040    HRESULT hrc;
    10411041
    10421042    /* try to find the given machine */
    … …  
    11181118            {
    11191119                errorArgument(Storage::tr("Invalid --add argument '%s'"), pszBusType);
    1120                 rc = E_FAIL;
     1120                hrc = E_FAIL;
    11211121            }
    11221122        }
    11231123
    11241124        if (   pszCtlType
    1125             && SUCCEEDED(rc))
     1125            && SUCCEEDED(hrc))
    11261126        {
    11271127            ComPtr<IStorageController> ctl;
    … …  
    11301130                                                            ctl.asOutParam()));
    11311131
    1132             if (SUCCEEDED(rc))
     1132            if (SUCCEEDED(hrc))
    11331133            {
    11341134                if (!RTStrICmp(pszCtlType, "lsilogic"))
    … …  
    11791179                {
    11801180                    errorArgument(Storage::tr("Invalid --type argument '%s'"), pszCtlType);
    1181                     rc = E_FAIL;
     1181                    hrc = E_FAIL;
    11821182                }
    11831183            }
    … …  
    11851185            {
    11861186                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    1187                 rc = E_FAIL;
     1187                hrc = E_FAIL;
    11881188            }
    11891189        }
    11901190
    11911191        if (   (portcount != ~0U)
    1192             && SUCCEEDED(rc))
     1192            && SUCCEEDED(hrc))
    11931193        {
    11941194            ComPtr<IStorageController> ctl;
    … …  
    11971197                                                            ctl.asOutParam()));
    11981198
    1199             if (SUCCEEDED(rc))
     1199            if (SUCCEEDED(hrc))
    12001200            {
    12011201                CHECK_ERROR(ctl, COMSETTER(PortCount)(portcount));
    … …  
    12041204            {
    12051205                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    1206                 rc = E_FAIL;
     1206                hrc = E_FAIL; /** @todo r=andy Overwrites original hrc. */
    12071207            }
    12081208        }
    12091209
    12101210        if (   pszHostIOCache
    1211             && SUCCEEDED(rc))
     1211            && SUCCEEDED(hrc))
    12121212        {
    12131213            ComPtr<IStorageController> ctl;
    … …  
    12161216                                                            ctl.asOutParam()));
    12171217
    1218             if (SUCCEEDED(rc))
     1218            if (SUCCEEDED(hrc))
    12191219            {
    12201220                if (!RTStrICmp(pszHostIOCache, "on"))
    … …  
    12291229                {
    12301230                    errorArgument(Storage::tr("Invalid --hostiocache argument '%s'"), pszHostIOCache);
    1231                     rc = E_FAIL;
     1231                    hrc = E_FAIL;
    12321232                }
    12331233            }
    … …  
    12351235            {
    12361236                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    1237                 rc = E_FAIL;
     1237                hrc = E_FAIL; /** @todo r=andy Ditto. */
    12381238            }
    12391239        }
    12401240
    12411241        if (   pszBootable
    1242             && SUCCEEDED(rc))
    1243         {
    1244             if (SUCCEEDED(rc))
     1242            && SUCCEEDED(hrc))
     1243        {
     1244            if (SUCCEEDED(hrc))
    12451245            {
    12461246                if (!RTStrICmp(pszBootable, "on"))
    … …  
    12551255                {
    12561256                    errorArgument(Storage::tr("Invalid --bootable argument '%s'"), pszBootable);
    1257                     rc = E_FAIL;
     1257                    hrc = E_FAIL;
    12581258                }
    12591259            }
    … …  
    12611261            {
    12621262                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    1263                 rc = E_FAIL;
     1263                hrc = E_FAIL;
    12641264            }
    12651265        }
    12661266
    12671267        if (   pszCtlNewName
    1268             && SUCCEEDED(rc))
     1268            && SUCCEEDED(hrc))
    12691269        {
    12701270            ComPtr<IStorageController> ctl;
    … …  
    12731273                                                            ctl.asOutParam()));
    12741274
    1275             if (SUCCEEDED(rc))
     1275            if (SUCCEEDED(hrc))
    12761276            {
    12771277                CHECK_ERROR(ctl, COMSETTER(Name)(Bstr(pszCtlNewName).raw()));
    … …  
    12801280            {
    12811281                errorArgument(Storage::tr("Couldn't find the controller with the name: '%s'\n"), pszCtl);
    1282                 rc = E_FAIL;
     1282                hrc = E_FAIL;
    12831283            }
    12841284        }
    … …  
    12871287
    12881288    /* commit changes */
    1289     if (SUCCEEDED(rc))
     1289    if (SUCCEEDED(hrc))
    12901290        CHECK_ERROR(machine, SaveSettings());
    12911291
    … …  
    12931293    a->session->UnlockMachine();
    12941294
    1295     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1295    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    12961296}

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUSB.cpp

    r94213 r95140  
    171171RTEXITCODE handleUSBFilter(HandlerArg *a)
    172172{
    173     HRESULT rc = S_OK;
     173    HRESULT hrc = S_OK;
    174174    USBFilterCmd cmd;
    175175
    … …  
    551551    if (cmd.mMachine)
    552552    {
    553         if (SUCCEEDED(rc))
     553        if (SUCCEEDED(hrc))
    554554        {
    555555            /* commit the session */
    … …  
    560560    }
    561561
    562     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     562    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    563563}
    564564
    565565RTEXITCODE handleUSBDevSource(HandlerArg *a)
    566566{
    567     HRESULT rc = S_OK;
     567    HRESULT hrc = S_OK;
    568568
    569569    /* at least: 0: command, 1: source id */
    … …  
    612612    }
    613613
    614     return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     614    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    615615}
    616616

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUpdateCheck.cpp

    r94981 r95140  
    277277     */
    278278    ComPtr<IProgress> pProgress;
    279     HRESULT rc = pUpdateAgent->CheckFor(pProgress.asOutParam());
    280     if (FAILED(rc))
     279    HRESULT hrc = pUpdateAgent->CheckFor(pProgress.asOutParam());
     280    if (FAILED(hrc))
    281281    {
    282282        if (pProgress.isNull())
    283             RTStrmPrintf(g_pStdErr, UpdateCheck::tr("Failed to create update progress object: %Rhrc\n"), rc);
     283            RTStrmPrintf(g_pStdErr, UpdateCheck::tr("Failed to create update progress object: %Rhrc\n"), hrc);
    284284        else
    285285            com::GlueHandleComError(pUpdateAgent, "HostUpdate(UpdateChannel_Stable, pProgress.asOutParam())",
    286                                     rc, __FILE__, __LINE__);
     286                                    hrc, __FILE__, __LINE__);
    287287        return RTEXITCODE_FAILURE;
    288288    }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUtils.cpp

    r94234 r95140  
    3535    ULONG NetworkAdapterCount = 0;
    3636    do {
    37         HRESULT rc;
     37        HRESULT hrc;
    3838
    3939        ComPtr<ISystemProperties> info;

  • trunk/src/VBox/Main/testcase/tstAPI.cpp

    r93115 r95140  
    5757HRESULT readAndChangeMachineSettings(IMachine *machine, IMachine *readonlyMachine = 0)
    5858{
    59     HRESULT rc = S_OK;
     59    HRESULT hrc = S_OK;
    6060
    6161    Bstr name;
    6262    RTPrintf("Getting machine name...\n");
    63     CHECK_ERROR_RET(machine, COMGETTER(Name)(name.asOutParam()), rc);
     63    CHECK_ERROR_RET(machine, COMGETTER(Name)(name.asOutParam()), hrc);
    6464    RTPrintf("Name: {%ls}\n", name.raw());
    6565
    … …  
    6767    Bstr guid;
    6868    CHECK_ERROR(machine, COMGETTER(Id)(guid.asOutParam()));
    69     if (SUCCEEDED(rc) && !guid.isEmpty()) {
     69    if (SUCCEEDED(hrc) && !guid.isEmpty()) {
    7070        RTPrintf("Guid::toString(): {%s}\n", Utf8Str(guid).c_str());
    7171    } else {
    … …  
    7575    ULONG memorySize;
    7676    RTPrintf("Getting memory size...\n");
    77     CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySize), rc);
     77    CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySize), hrc);
    7878    RTPrintf("Memory size: %d\n", memorySize);
    7979
    8080    MachineState_T machineState;
    8181    RTPrintf("Getting machine state...\n");
    82     CHECK_ERROR_RET(machine, COMGETTER(State)(&machineState), rc);
     82    CHECK_ERROR_RET(machine, COMGETTER(State)(&machineState), hrc);
    8383    RTPrintf("Machine state: %d\n", machineState);
    8484
    … …  
    8686    RTPrintf("Are any settings modified?...\n");
    8787    CHECK_ERROR(machine, COMGETTER(SettingsModified)(&modified));
    88     if (SUCCEEDED(rc))
     88    if (SUCCEEDED(hrc))
    8989        RTPrintf("%s\n", modified ? "yes" : "no");
    9090
    … …  
    9393    CHECK_ERROR(machine, COMSETTER(MemorySize)(memorySizeBig));
    9494
    95     if (SUCCEEDED(rc))
     95    if (SUCCEEDED(hrc))
    9696    {
    9797        RTPrintf("Are any settings modified now?...\n");
    98         CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
     98        CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), hrc);
    9999        RTPrintf("%s\n", modified ? "yes" : "no");
    100100        ASSERT_RET(modified, 0);
    … …  
    102102        ULONG memorySizeGot;
    103103        RTPrintf("Getting memory size again...\n");
    104         CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), rc);
     104        CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), hrc);
    105105        RTPrintf("Memory size: %d\n", memorySizeGot);
    106106        ASSERT_RET(memorySizeGot == memorySizeBig, 0);
    … …  
    116116
    117117        RTPrintf("Discarding recent changes...\n");
    118         CHECK_ERROR_RET(machine, DiscardSettings(), rc);
     118        CHECK_ERROR_RET(machine, DiscardSettings(), hrc);
    119119        RTPrintf("Are any settings modified after discarding?...\n");
    120         CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
     120        CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), hrc);
    121121        RTPrintf("%s\n", modified ? "yes" : "no");
    122122        ASSERT_RET(!modified, 0);
    123123
    124124        RTPrintf("Getting memory size once more...\n");
    125         CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), rc);
     125        CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), hrc);
    126126        RTPrintf("Memory size: %d\n", memorySizeGot);
    127127        ASSERT_RET(memorySizeGot == memorySize, 0);
    … …  
    129129        memorySize = memorySize > 128 ? memorySize / 2 : memorySize * 2;
    130130        RTPrintf("Changing memory size to %d...\n", memorySize);
    131         CHECK_ERROR_RET(machine, COMSETTER(MemorySize)(memorySize), rc);
     131        CHECK_ERROR_RET(machine, COMSETTER(MemorySize)(memorySize), hrc);
    132132    }
    133133
    134134    Bstr desc;
    135135    RTPrintf("Getting description...\n");
    136     CHECK_ERROR_RET(machine, COMGETTER(Description)(desc.asOutParam()), rc);
     136    CHECK_ERROR_RET(machine, COMGETTER(Description)(desc.asOutParam()), hrc);
    137137    RTPrintf("Description is: \"%ls\"\n", desc.raw());
    138138
    139139    desc = L"This is an exemplary description (changed).";
    140140    RTPrintf("Setting description to \"%ls\"...\n", desc.raw());
    141     CHECK_ERROR_RET(machine, COMSETTER(Description)(desc.raw()), rc);
     141    CHECK_ERROR_RET(machine, COMSETTER(Description)(desc.raw()), hrc);
    142142
    143143    RTPrintf("Saving machine settings...\n");
    144144    CHECK_ERROR(machine, SaveSettings());
    145     if (SUCCEEDED(rc))
     145    if (SUCCEEDED(hrc))
    146146    {
    147147        RTPrintf("Are any settings modified after saving?...\n");
    148         CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
     148        CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), hrc);
    149149        RTPrintf("%s\n", modified ? "yes" : "no");
    150150        ASSERT_RET(!modified, 0);
    … …  
    162162    Bstr extraData;
    163163    RTPrintf("Getting extra data key {%ls}...\n", extraDataKey.raw());
    164     CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), rc);
     164    CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), hrc);
    165165    if (!extraData.isEmpty()) {
    166166        RTPrintf("Extra data value: {%ls}\n", extraData.raw());
    … …  
    177177    CHECK_ERROR(machine, SetExtraData(extraDataKey.raw(), extraData.raw()));
    178178
    179     if (SUCCEEDED(rc)) {
     179    if (SUCCEEDED(hrc)) {
    180180        RTPrintf("Getting extra data key {%ls} again...\n", extraDataKey.raw());
    181         CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), rc);
     181        CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), hrc);
    182182        if (!extraData.isEmpty()) {
    183183            RTPrintf("Extra data value: {%ls}\n", extraData.raw());
    … …  
    187187    }
    188188
    189     return rc;
     189    return hrc;
    190190}
    191191
    … …  
    201201    RTR3InitExe(argc, &argv, 0);
    202202
    203     HRESULT rc;
     203    HRESULT hrc;
    204204
    205205    {
    … …  
    211211    RTPrintf("Initializing COM...\n");
    212212
    213     rc = com::Initialize();
    214     if (FAILED(rc))
     213    hrc = com::Initialize();
     214    if (FAILED(hrc))
    215215    {
    216216        RTPrintf("ERROR: failed to initialize COM!\n");
    217         return rc;
     217        return hrc;
    218218    }
    219219
    … …  
    243243
    244244    RTPrintf("Creating VirtualBox object...\n");
    245     rc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
    246     if (SUCCEEDED(rc))
    247         rc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
    248     if (FAILED(rc))
     245    hrc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
     246    if (SUCCEEDED(hrc))
     247        hrc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
     248    if (FAILED(hrc))
    249249        RTPrintf("ERROR: failed to create the VirtualBox object!\n");
    250250    else
    251251    {
    252         rc = session.createInprocObject(CLSID_Session);
    253         if (FAILED(rc))
     252        hrc = session.createInprocObject(CLSID_Session);
     253        if (FAILED(hrc))
    254254            RTPrintf("ERROR: failed to create a session object!\n");
    255255    }
    256256
    257     if (FAILED(rc))
     257    if (FAILED(hrc))
    258258    {
    259259        com::ErrorInfo info;
    260260        if (!info.isFullAvailable() && !info.isBasicAvailable())
    261261        {
    262             com::GluePrintRCMessage(rc);
     262            com::GluePrintRCMessage(hrc);
    263263            RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
    264264        }
    … …  
    15921592    RTPrintf("tstAPI FINISHED.\n");
    15931593
    1594     return rc;
     1594    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
    15951595}
    15961596

  • trunk/src/VBox/Main/testcase/tstVBoxAPI.cpp

    r94660 r95140  
    5757static BOOL tstApiIVirtualBox(IVirtualBox *pVBox)
    5858{
    59     HRESULT rc;
     59    HRESULT hrc;
    6060    Bstr bstrTmp;
    6161    ULONG ulTmp;
    … …  
    6363    RTTestSub(g_hTest, "IVirtualBox::version");
    6464    CHECK_ERROR(pVBox, COMGETTER(Version)(bstrTmp.asOutParam()));
    65     if (SUCCEEDED(rc))
     65    if (SUCCEEDED(hrc))
    6666        RTTestPassed(g_hTest, "IVirtualBox::version");
    6767    else
    … …  
    7070    RTTestSub(g_hTest, "IVirtualBox::versionNormalized");
    7171    CHECK_ERROR(pVBox, COMGETTER(VersionNormalized)(bstrTmp.asOutParam()));
    72     if (SUCCEEDED(rc))
     72    if (SUCCEEDED(hrc))
    7373        RTTestPassed(g_hTest, "IVirtualBox::versionNormalized");
    7474    else
    … …  
    7777    RTTestSub(g_hTest, "IVirtualBox::revision");
    7878    CHECK_ERROR(pVBox, COMGETTER(Revision)(&ulTmp));
    79     if (SUCCEEDED(rc))
     79    if (SUCCEEDED(hrc))
    8080        RTTestPassed(g_hTest, "IVirtualBox::revision");
    8181    else
    … …  
    8484    RTTestSub(g_hTest, "IVirtualBox::packageType");
    8585    CHECK_ERROR(pVBox, COMGETTER(PackageType)(bstrTmp.asOutParam()));
    86     if (SUCCEEDED(rc))
     86    if (SUCCEEDED(hrc))
    8787        RTTestPassed(g_hTest, "IVirtualBox::packageType");
    8888    else
    … …  
    9191    RTTestSub(g_hTest, "IVirtualBox::APIVersion");
    9292    CHECK_ERROR(pVBox, COMGETTER(APIVersion)(bstrTmp.asOutParam()));
    93     if (SUCCEEDED(rc))
     93    if (SUCCEEDED(hrc))
    9494        RTTestPassed(g_hTest, "IVirtualBox::APIVersion");
    9595    else
    … …  
    9898    RTTestSub(g_hTest, "IVirtualBox::homeFolder");
    9999    CHECK_ERROR(pVBox, COMGETTER(HomeFolder)(bstrTmp.asOutParam()));
    100     if (SUCCEEDED(rc))
     100    if (SUCCEEDED(hrc))
    101101        RTTestPassed(g_hTest, "IVirtualBox::homeFolder");
    102102    else
    … …  
    105105    RTTestSub(g_hTest, "IVirtualBox::settingsFilePath");
    106106    CHECK_ERROR(pVBox, COMGETTER(SettingsFilePath)(bstrTmp.asOutParam()));
    107     if (SUCCEEDED(rc))
     107    if (SUCCEEDED(hrc))
    108108        RTTestPassed(g_hTest, "IVirtualBox::settingsFilePath");
    109109    else
    … …  
    113113    RTTestSub(g_hTest, "IVirtualBox::guestOSTypes");
    114114    CHECK_ERROR(pVBox, COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(guestOSTypes)));
    115     if (SUCCEEDED(rc))
     115    if (SUCCEEDED(hrc))
    116116        RTTestPassed(g_hTest, "IVirtualBox::guestOSTypes");
    117117    else
    … …  
    132132                                     NULL,                          /** Password */
    133133                                     ptrMachine.asOutParam()));     /** Machine */
    134     if (SUCCEEDED(rc))
     134    if (SUCCEEDED(hrc))
    135135        RTTestPassed(g_hTest, "IVirtualBox::CreateMachine");
    136136    else
    … …  
    142142    RTTestSub(g_hTest, "IVirtualBox::RegisterMachine");
    143143    CHECK_ERROR(pVBox, RegisterMachine(ptrMachine));
    144     if (SUCCEEDED(rc))
     144    if (SUCCEEDED(hrc))
    145145        RTTestPassed(g_hTest, "IVirtualBox::RegisterMachine");
    146146    else
    … …  
    153153    RTTestSub(g_hTest, "IVirtualBox::host");
    154154    CHECK_ERROR(pVBox, COMGETTER(Host)(host.asOutParam()));
    155     if (SUCCEEDED(rc))
     155    if (SUCCEEDED(hrc))
    156156    {
    157157        /** @todo Add IHost testing here. */
    … …  
    164164    RTTestSub(g_hTest, "IVirtualBox::systemProperties");
    165165    CHECK_ERROR(pVBox, COMGETTER(SystemProperties)(sysprop.asOutParam()));
    166     if (SUCCEEDED(rc))
     166    if (SUCCEEDED(hrc))
    167167    {
    168168        /** @todo Add ISystemProperties testing here. */
    … …  
    175175    RTTestSub(g_hTest, "IVirtualBox::machines");
    176176    CHECK_ERROR(pVBox, COMGETTER(Machines)(ComSafeArrayAsOutParam(machines)));
    177     if (SUCCEEDED(rc))
     177    if (SUCCEEDED(hrc))
    178178    {
    179179        bool bFound = FALSE;
    … …  
    183183            {
    184184                Bstr tmpName;
    185                 rc = machines[i]->COMGETTER(Name)(tmpName.asOutParam());
    186                 if (SUCCEEDED(rc))
     185                hrc = machines[i]->COMGETTER(Name)(tmpName.asOutParam());
     186                if (SUCCEEDED(hrc))
    187187                {
    188188                    if (tmpName == tstMachineName)
    … …  
    219219    RTTestSub(g_hTest, "IVirtualBox::hardDisks");
    220220    CHECK_ERROR(pVBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hardDisks)));
    221     if (SUCCEEDED(rc))
     221    if (SUCCEEDED(hrc))
    222222    {
    223223        /** @todo Add hardDisks testing here. */
    … …  
    230230    RTTestSub(g_hTest, "IVirtualBox::DVDImages");
    231231    CHECK_ERROR(pVBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(DVDImages)));
    232     if (SUCCEEDED(rc))
     232    if (SUCCEEDED(hrc))
    233233    {
    234234        /** @todo Add DVDImages testing here. */
    … …  
    241241    RTTestSub(g_hTest, "IVirtualBox::floppyImages");
    242242    CHECK_ERROR(pVBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppyImages)));
    243     if (SUCCEEDED(rc))
     243    if (SUCCEEDED(hrc))
    244244    {
    245245        /** @todo Add floppyImages testing here. */
    … …  
    252252    RTTestSub(g_hTest, "IVirtualBox::progressOperations");
    253253    CHECK_ERROR(pVBox, COMGETTER(ProgressOperations)(ComSafeArrayAsOutParam(progressOperations)));
    254     if (SUCCEEDED(rc))
     254    if (SUCCEEDED(hrc))
    255255    {
    256256        /** @todo Add IProgress testing here. */
    … …  
    263263    RTTestSub(g_hTest, "IVirtualBox::performanceCollector");
    264264    CHECK_ERROR(pVBox, COMGETTER(PerformanceCollector)(performanceCollector.asOutParam()));
    265     if (SUCCEEDED(rc))
     265    if (SUCCEEDED(hrc))
    266266    {
    267267        /** @todo Add IPerformanceCollector testing here. */
    … …  
    274274    RTTestSub(g_hTest, "IVirtualBox::DHCPServers");
    275275    CHECK_ERROR(pVBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(DHCPServers)));
    276     if (SUCCEEDED(rc))
     276    if (SUCCEEDED(hrc))
    277277    {
    278278        /** @todo Add IDHCPServers testing here. */
    … …  
    285285    RTTestSub(g_hTest, "IVirtualBox::NATNetworks");
    286286    CHECK_ERROR(pVBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(NATNetworks)));
    287     if (SUCCEEDED(rc))
     287    if (SUCCEEDED(hrc))
    288288    {
    289289        /** @todo Add INATNetworks testing here. */
    … …  
    296296    RTTestSub(g_hTest, "IVirtualBox::eventSource");
    297297    CHECK_ERROR(pVBox, COMGETTER(EventSource)(eventSource.asOutParam()));
    298     if (SUCCEEDED(rc))
     298    if (SUCCEEDED(hrc))
    299299    {
    300300        /** @todo Add IEventSource testing here. */
    … …  
    307307    RTTestSub(g_hTest, "IVirtualBox::extensionPackManager");
    308308    CHECK_ERROR(pVBox, COMGETTER(ExtensionPackManager)(extensionPackManager.asOutParam()));
    309     if (SUCCEEDED(rc))
     309    if (SUCCEEDED(hrc))
    310310    {
    311311        /** @todo Add IExtPackManager testing here. */
    … …  
    318318    RTTestSub(g_hTest, "IVirtualBox::internalNetworks");
    319319    CHECK_ERROR(pVBox, COMGETTER(InternalNetworks)(ComSafeArrayAsOutParam(internalNetworks)));
    320     if (SUCCEEDED(rc))
     320    if (SUCCEEDED(hrc))
    321321    {
    322322        RTTestPassed(g_hTest, "IVirtualBox::internalNetworks");
    … …  
    328328    RTTestSub(g_hTest, "IVirtualBox::genericNetworkDrivers");
    329329    CHECK_ERROR(pVBox, COMGETTER(GenericNetworkDrivers)(ComSafeArrayAsOutParam(genericNetworkDrivers)));
    330     if (SUCCEEDED(rc))
     330    if (SUCCEEDED(hrc))
    331331    {
    332332        RTTestPassed(g_hTest, "IVirtualBox::genericNetworkDrivers");
    … …  
    341341static BOOL tstApiClean(IVirtualBox *pVBox)
    342342{
    343     HRESULT rc;
     343    HRESULT hrc;
    344344
    345345    /** Delete created VM and its files */
Note: See TracChangeset for help on using the changeset viewer.

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