ronantakizawa/codereview-bench huggingface dataset:
Repository: microsoft/terminal
File: src/cascadia/TerminalCore/ColorFix.cpp (C++)

Code before:
#include "pch.h"

#include <Windows.h>
#include <math.h>
#include "ColorFix.hpp"

const double gMinThreshold = 12.0;
const double gExpThreshold = 20.0;
const double gLStep = 5.0;

constexpr double rad006 = 0.104719755119659774;
constexpr double rad025 = 0.436332312998582394;
constexpr double rad030 = 0.523598775598298873;
constexpr double rad060 = 1.047197551196597746;
constexpr double rad063 = 1.099557428756427633;
constexpr double rad180 = 3.141592653589793238;
constexpr double rad275 = 4.799655442984406336;
constexpr double rad360 = 6.283185307179586476;

ColorFix::ColorFix(COLORREF color)
{
    rgb = color;
    _ToLab();
}

// Method Description:
// - Helper function to calculate HPrime
double ColorFix::_GetHPrimeFn(double x, double y)
{
    if (x == 0 && y == 0)
    {
        return 0;
    }


Review comment (suggestion):
I'd also leave a big ol' note at the top here pointing at the file from conemu that this is largely a reproduction of, so that we can go cress reference easily. Similar to the one at the top of `src\cascadia\WindowsTerminal\VirtualDesktopUtils.cpp`

Code after:
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

// A lot of code was taken from
// https://github.com/Maximus5/ConEmu/blob/master/src/ConEmu/ColorFix.cpp
// and then adjusted to fit our style guidelines

#include "pch.h"

#include <Windows.h>
#include "ColorFix.hpp"

static constexpr double gMinThreshold = 12.0;
static constexpr double gExpThreshold = 20.0;
static constexpr double gLStep = 5.0;

static constexpr double rad006 = 0.104719755119659774;
static constexpr double rad025 = 0.436332312998582394;
static constexpr double rad030 = 0.523598775598298873;
static constexpr double rad060 = 1.047197551196597746;
static constexpr double rad063 = 1.099557428756427633;
static constexpr double rad180 = 3.141592653589793238;
static constexpr double rad275 = 4.799655442984406336;
static constexpr double rad360 = 6.283185307179586476;

ColorFix::ColorFix(COLORREF color)
{
    rgb = color;
    _ToLab();
}

// Method Description:
// - Helper function to calculate HPrime
double ColorFix::_GetHPrimeFn(double x, double y)
Repository: microsoft/terminal
File: src/cascadia/TerminalSettingsModel/BaseVisualStudioGenerator.h (C/C++)

Code before:

--*/

#pragma once

#include "IDynamicProfileGenerator.h"
#include "VsSetupConfiguration.h"

namespace Microsoft::Terminal::Settings::Model
{
    class BaseVisualStudioGenerator : public IDynamicProfileGenerator
    {
        virtual bool IsInstanceValid(const VsSetupConfiguration::VsSetupInstance instance) const = 0;
        virtual std::wstring GetProfileName(const VsSetupConfiguration::VsSetupInstance instance) const = 0;
        virtual std::wstring GetProfileCommandLine(const VsSetupConfiguration::VsSetupInstance instance) const = 0;
        virtual std::wstring GetProfileGuidSeed(const VsSetupConfiguration::VsSetupInstance instance) const = 0;
        virtual std::wstring GetProfileIconPath() const = 0;

        // Inherited via IDynamicProfileGenerator
        virtual std::wstring_view GetNamespace() override = 0;
        std::vector<winrt::Microsoft::Terminal::Settings::Model::Profile> GenerateProfiles() override;

    private:
        inline static bool hasQueried = false;
        inline static std::vector<VsSetupConfiguration::VsSetupInstance> instances;

        winrt::Microsoft::Terminal::Settings::Model::Profile CreateProfile(const std::wstring_view instanceId);
    };
};


Review comment (suggestion):
```suggestion
        winrt::Microsoft::Terminal::Settings::Model::Profile _CreateProfile(const std::wstring_view instanceId);
```

Code after:

--*/

#pragma once

#include "IDynamicProfileGenerator.h"
#include "VsSetupConfiguration.h"

namespace Microsoft::Terminal::Settings::Model
{
    class BaseVisualStudioGenerator : public IDynamicProfileGenerator
    {
    public:
        // Inherited via IDynamicProfileGenerator
        std::wstring_view GetNamespace() override = 0;
        std::vector<winrt::Microsoft::Terminal::Settings::Model::Profile> GenerateProfiles() override;

    protected:
        virtual bool IsInstanceValid(const VsSetupConfiguration::VsSetupInstance& instance) const = 0;
        virtual std::wstring GetProfileName(const VsSetupConfiguration::VsSetupInstance& instance) const = 0;
        virtual std::wstring GetProfileCommandLine(const VsSetupConfiguration::VsSetupInstance& instance) const = 0;
        virtual std::wstring GetProfileGuidSeed(const VsSetupConfiguration::VsSetupInstance& instance) const = 0;
        virtual std::wstring GetProfileIconPath() const = 0;

    private:
        winrt::Microsoft::Terminal::Settings::Model::Profile CreateProfile(const std::wstring_view instanceId);
    };
};
Repository: microsoft/terminal
File: src/types/ScreenInfoUiaProviderBase.cpp (C++)

Code before:
        *ppRetVal = nullptr;
        return hr;
    }

    UiaTracing::TextProvider::GetSelection(*this, *range.Get());

    LONG currentIndex = 0;
    hr = SafeArrayPutElement(*ppRetVal, &currentIndex, range.Detach());
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
    }

    return S_OK;
}

IFACEMETHODIMP ScreenInfoUiaProviderBase::GetVisibleRanges(_Outptr_result_maybenull_ SAFEARRAY** ppRetVal)
{
    RETURN_HR_IF_NULL(E_INVALIDARG, ppRetVal);
    if (!_pData->IsUiaDataInitialized())
    {
        return E_FAIL;
    }

    _LockConsole();
    auto Unlock = wil::scope_exit([&]() noexcept {
        _UnlockConsole();
    });

    // make a safe array
    *ppRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 1);
    if (*ppRetVal == nullptr)
    {
        return E_OUTOFMEMORY;
    }

    WRL::ComPtr<UiaTextRangeBase> range;
    const auto bufferSize = _pData->GetTextBuffer().GetSize();
    const auto viewport = bufferSize.ConvertToOrigin(_getViewport());

    const COORD start{ viewport.Left(), viewport.Top() };
    const COORD end{ viewport.Left(), viewport.BottomExclusive() };

    auto hr = CreateTextRange(this, start, end, _wordDelimiters, &range);
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;

Review comment (bug):
Isn't this on the wrong side of the lock? Or alternatively, shouldn't the value be atomic or something?

Code after:
    LONG currentIndex = 0;
    hr = SafeArrayPutElement(*ppRetVal, &currentIndex, range.Detach());
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
    }

    return S_OK;
}

IFACEMETHODIMP ScreenInfoUiaProviderBase::GetVisibleRanges(_Outptr_result_maybenull_ SAFEARRAY** ppRetVal)
{
    RETURN_HR_IF_NULL(E_INVALIDARG, ppRetVal);
    *ppRetVal = nullptr;

    _LockConsole();
    auto Unlock = wil::scope_exit([&]() noexcept {
        _UnlockConsole();
    });
    RETURN_HR_IF(E_FAIL, !_pData->IsUiaDataInitialized());

    // make a safe array
    *ppRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 1);
    RETURN_HR_IF_NULL(E_OUTOFMEMORY, *ppRetVal);

    WRL::ComPtr<UiaTextRangeBase> range;
    const auto bufferSize = _pData->GetTextBuffer().GetSize();
    const auto viewport = bufferSize.ConvertToOrigin(_getViewport());

    const COORD start{ viewport.Left(), viewport.Top() };
    const COORD end{ viewport.Left(), viewport.BottomExclusive() };

    auto hr = CreateTextRange(this, start, end, _wordDelimiters, &range);
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
    }

    UiaTracing::TextProvider::GetVisibleRanges(*this, *range.Get());

    LONG currentIndex = 0;
    hr = SafeArrayPutElement(*ppRetVal, &currentIndex, range.Detach());
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
Repository: microsoft/terminal
File: src/types/ScreenInfoUiaProviderBase.cpp (C++)

Code before:
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
    }

    UiaTracing::TextProvider::GetSelection(*this, *range.Get());

    LONG currentIndex = 0;
    hr = SafeArrayPutElement(*ppRetVal, &currentIndex, range.Detach());
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
    }

    return S_OK;
}

IFACEMETHODIMP ScreenInfoUiaProviderBase::GetVisibleRanges(_Outptr_result_maybenull_ SAFEARRAY** ppRetVal)
{
    RETURN_HR_IF_NULL(E_INVALIDARG, ppRetVal);
    if (!_pData->IsUiaDataInitialized())
    {
        return E_FAIL;
    }

    _LockConsole();
    auto Unlock = wil::scope_exit([&]() noexcept {
        _UnlockConsole();
    });

    // make a safe array
    *ppRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 1);
    if (*ppRetVal == nullptr)
    {
        return E_OUTOFMEMORY;
    }

    WRL::ComPtr<UiaTextRangeBase> range;
    const auto bufferSize = _pData->GetTextBuffer().GetSize();
    const auto viewport = bufferSize.ConvertToOrigin(_getViewport());

    const COORD start{ viewport.Left(), viewport.Top() };
    const COORD end{ viewport.Left(), viewport.BottomExclusive() };

    auto hr = CreateTextRange(this, start, end, _wordDelimiters, &range);
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;

Review comment (bug):
```suggestion
    RETURN_HR_IF(E_FAIL, !_pData->IsUiaDataInitialized())
```

et. al.

Code after:

    LONG currentIndex = 0;
    hr = SafeArrayPutElement(*ppRetVal, &currentIndex, range.Detach());
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
    }

    return S_OK;
}

IFACEMETHODIMP ScreenInfoUiaProviderBase::GetVisibleRanges(_Outptr_result_maybenull_ SAFEARRAY** ppRetVal)
{
    RETURN_HR_IF_NULL(E_INVALIDARG, ppRetVal);
    *ppRetVal = nullptr;

    _LockConsole();
    auto Unlock = wil::scope_exit([&]() noexcept {
        _UnlockConsole();
    });
    RETURN_HR_IF(E_FAIL, !_pData->IsUiaDataInitialized());

    // make a safe array
    *ppRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 1);
    RETURN_HR_IF_NULL(E_OUTOFMEMORY, *ppRetVal);

    WRL::ComPtr<UiaTextRangeBase> range;
    const auto bufferSize = _pData->GetTextBuffer().GetSize();
    const auto viewport = bufferSize.ConvertToOrigin(_getViewport());

    const COORD start{ viewport.Left(), viewport.Top() };
    const COORD end{ viewport.Left(), viewport.BottomExclusive() };

    auto hr = CreateTextRange(this, start, end, _wordDelimiters, &range);
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
        return hr;
    }

    UiaTracing::TextProvider::GetVisibleRanges(*this, *range.Get());

    LONG currentIndex = 0;
    hr = SafeArrayPutElement(*ppRetVal, &currentIndex, range.Detach());
    if (FAILED(hr))
    {
        SafeArrayDestroy(*ppRetVal);
        *ppRetVal = nullptr;
Repository: microsoft/terminal
File: src/cascadia/WinRTUtils/inc/WtExeUtils.h (C/C++)

Code before:
    return exePath;
}

// Method Description:
// - Escapes the given string so that it can be used as a command-line arg within a quoted string.
// - e.g. given `";foo\` will return `\"\;foo\\` so that the caller can construct a command-line
//   using something such as `fmt::format(L"wt --title \"{}\"", EscapeCommandlineArg(TabTitle()))`.
// Arguments:
// - arg - the command-line argument to escape.
// Return Value:
// - the escaped command-line argument.
_TIL_INLINEPREFIX std::wstring EscapeCommandlineArg(const std::wstring_view arg)
{
    std::wstringstream stream;
    for (auto it = arg.cbegin(); it != arg.cend(); ++it)
    {
        if (*it == L';' || *it == L'"')
        {
            stream << L'\\';
        }
        stream << *it;
    }
    if (arg.back() == L'\\')
    {
        stream << L'\\';
    }
    return stream.str();
}


Review comment (security):
This function doesn't handle escaping of backslashes correctly. This should be correct:
```cpp
_TIL_INLINEPREFIX std::wstring EscapeCommandlineArg(const std::wstring_view& arg)
{
    std::wstring out;
    out.reserve(arg.size() + 2);
    out.push_back(L'"');

    size_t backslashes = 0;
    for (const auto ch : arg) {
        if (ch == L'\\') {
            backslashes++;
        } else {
            if (ch == L';' || ch == L'"') {
                out.append(backslashes + 1, L'\\');
            }
            backslashes = 0;
        }
        out.push_back(x);
    }

    out.append(backslashes, L'\\');
    out.push_back(L'"');
    return out;
}
```

I've included the addition of quotes to the function, because I felt this to be more consistent.
If you dislike that please remove the two occurrences of `out.push_back(L'"');` and the `+ 2`.

Code after:
    return exePath;
}

// Method Description:
// - Quotes and escapes the given string so that it can be used as a command-line arg.
// - e.g. given `\";foo\` will return `"\\\"\;foo\\"` so that the caller can construct a command-line
//   using something such as `fmt::format(L"wt --title {}", QuoteAndQuoteAndEscapeCommandlineArg(TabTitle()))`.
// Arguments:
// - arg - the command-line argument to quote and escape.
// Return Value:
// - the quoted and escaped command-line argument.
_TIL_INLINEPREFIX std::wstring QuoteAndEscapeCommandlineArg(const std::wstring_view& arg)
{
    std::wstring out;
    out.reserve(arg.size() + 2);
    out.push_back(L'"');

    size_t backslashes = 0;
    for (const auto ch : arg)
    {
        if (ch == L'\\')
        {
            backslashes++;
        }
        else
        {
            if (ch == L';' || ch == L'"')
            {
                out.append(backslashes + 1, L'\\');
            }
            backslashes = 0;
        }
        out.push_back(ch);
    }

    out.append(backslashes, L'\\');
    out.push_back(L'"');
    return out;
}
Repository: microsoft/terminal
File: src/cascadia/TerminalConnection/CTerminalHandoff.cpp (C++)

Code before:
        THROW_IF_FAILED(_duplicateHandle(in, in));
        THROW_IF_FAILED(_duplicateHandle(out, out));
        THROW_IF_FAILED(_duplicateHandle(signal, signal));
        THROW_IF_FAILED(_duplicateHandle(ref, ref));
        THROW_IF_FAILED(_duplicateHandle(server, server));
        THROW_IF_FAILED(_duplicateHandle(client, client));

        TraceLoggingWrite(
            g_hTerminalConnectionProvider,
            "ReceiveTerminalHandoff_Success",
            TraceLoggingDescription("successfully received a terminal handoff"),
            TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
            TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));


        // Call registered handler from when we started listening.
        return localPfnHandoff(in, out, signal, ref, server, client);
    }
    catch (...)
    {
        const auto hr = wil::ResultFromCaughtException();

        TraceLoggingWrite(
            g_hTerminalConnectionProvider,
            "ReceiveTerminalHandoff_Failed",
            TraceLoggingDescription("failed while receiving a terminal handoff"),
            TraceLoggingHResult(hr),
            TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
            TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));

        return hr;
    }
}


Review comment (bug):
I suppose this is more a "successfully received a handoff but failed somewhere afterwards"? Maybe I'll need to wait for `localPfnHandoff` to return an HR first as well?

Code after:
        THROW_IF_FAILED(_duplicateHandle(in, in));
        THROW_IF_FAILED(_duplicateHandle(out, out));
        THROW_IF_FAILED(_duplicateHandle(signal, signal));
        THROW_IF_FAILED(_duplicateHandle(ref, ref));
        THROW_IF_FAILED(_duplicateHandle(server, server));
        THROW_IF_FAILED(_duplicateHandle(client, client));

        // Call registered handler from when we started listening.
        THROW_IF_FAILED(localPfnHandoff(in, out, signal, ref, server, client));

#pragma warning(suppress : 26477)
        TraceLoggingWrite(
            g_hTerminalConnectionProvider,
            "ReceiveTerminalHandoff_Success",
            TraceLoggingDescription("successfully received a terminal handoff"),
            TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
            TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));

        return S_OK;
    }
    catch (...)
    {
        const auto hr = wil::ResultFromCaughtException();

#pragma warning(suppress : 26477)
        TraceLoggingWrite(
            g_hTerminalConnectionProvider,
            "ReceiveTerminalHandoff_Failed",
            TraceLoggingDescription("failed while receiving a terminal handoff"),
            TraceLoggingHResult(hr),
            TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
            TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));

        return hr;
    }
}
Repository: microsoft/terminal
File: src/cascadia/TerminalSettingsModel/DefaultTerminal.cpp (C++)

Code before:
        defaultTerminals.emplace_back(std::move(p));
    }

    return { std::move(defaultTerminals), std::move(defaultTerminal) };
}

bool DefaultTerminal::HasCurrent()
{
    std::vector<DelegationConfig::DelegationPackage> allPackages;
    DelegationConfig::DelegationPackage currentPackage;
    LOG_IF_FAILED(DelegationConfig::s_GetAvailablePackages(allPackages, currentPackage));

    // Good old conhost has a hardcoded GUID of {00000000-0000-0000-0000-000000000000}.
    return currentPackage.terminal.clsid != CLSID{};
}

void DefaultTerminal::Current(const Model::DefaultTerminal& term)
{
    THROW_IF_FAILED(DelegationConfig::s_SetDefaultByPackage(winrt::get_self<DefaultTerminal>(term)->_pkg, true));

    TraceLoggingWrite(g_hSettingsModelProvider,
                      "DefaultTerminalChanged",
                      TraceLoggingWideString(term.Name().c_str(), "default terminal name", "the name of the default terminal"),
                      TraceLoggingWideString(term.Version().c_str(), "default terminal version", "the version of the default terminal"),
                      TraceLoggingWideString(term.Author().c_str(), "default terminal author", "the author of the default terminal"),
                      TraceLoggingLevel(WINEVENT_LEVEL_VERBOSE),
                      TraceLoggingKeyword(TIL_KEYWORD_TRACE),
                      TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
}


Review comment (suggestion):
prefer to give these short `PascalCase` type names, instead of names with spaces in them :smile:

Code after:
        defaultTerminals.emplace_back(std::move(p));
    }

    return { std::move(defaultTerminals), std::move(defaultTerminal) };
}

bool DefaultTerminal::HasCurrent()
{
    std::vector<DelegationConfig::DelegationPackage> allPackages;
    DelegationConfig::DelegationPackage currentPackage;
    LOG_IF_FAILED(DelegationConfig::s_GetAvailablePackages(allPackages, currentPackage));

    // Good old conhost has a hardcoded GUID of {00000000-0000-0000-0000-000000000000}.
    return currentPackage.terminal.clsid != CLSID{};
}

void DefaultTerminal::Current(const Model::DefaultTerminal& term)
{
    THROW_IF_FAILED(DelegationConfig::s_SetDefaultByPackage(winrt::get_self<DefaultTerminal>(term)->_pkg, true));

    TraceLoggingWrite(g_hSettingsModelProvider,
                      "DefaultTerminalChanged",
                      TraceLoggingWideString(term.Name().c_str(), "TerminalName", "the name of the default terminal"),
                      TraceLoggingWideString(term.Version().c_str(), "TerminalVersion", "the version of the default terminal"),
                      TraceLoggingWideString(term.Author().c_str(), "TerminalAuthor", "the author of the default terminal"),
                      TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
                      TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
}
Repository: microsoft/terminal
File: src/cascadia/TerminalSettingsModel/VsDevCmdGenerator.cpp (C++)

Code before:
        profile->StartingDirectory(winrt::hstring{ instance.GetInstallationPath() });
        profile->Icon(winrt::hstring{ GetProfileIconPath() });
        profile->Hidden(hidden);
        profiles.emplace_back(std::move(profile));
    }
    CATCH_LOG();
}

std::wstring VsDevCmdGenerator::GetProfileName(const VsSetupConfiguration::VsSetupInstance& instance) const
{
    std::wstring name{ L"Developer Command Prompt for VS " };
    name.append(instance.GetProfileNameSuffix());
    return name;
}

std::wstring VsDevCmdGenerator::GetProfileCommandLine(const VsSetupConfiguration::VsSetupInstance& instance) const
{
    std::wstring commandLine{ L"cmd.exe /k \"" + GetDevCmdScriptPath(instance) + L"\"" };

    return commandLine;
}

std::wstring VsDevCmdGenerator::GetDevCmdScriptPath(const VsSetupConfiguration::VsSetupInstance& instance) const
{
    return instance.ResolvePath(L"Common7\\Tools\\VsDevCmd.bat");
}


Review comment (suggestion):
Overall, I like this, but I do worry *slightly* that it departs from what the shortcuts do, even though this ends up doing the same thing *currently*. But this has to work for all past versions. With my previous change I made sure it would work back to Dev15 RTM by examining original package contents.

It's also a matter of whether the VC team is doing to continue to support calling the scripts exactly in this way. They might, but let's check with them to be sure.

Code after:
        profile->StartingDirectory(winrt::hstring{ instance.GetInstallationPath() });
        profile->Icon(winrt::hstring{ GetProfileIconPath() });
        profile->Hidden(hidden);
        profiles.emplace_back(std::move(profile));
    }
    CATCH_LOG();
}

std::wstring VsDevCmdGenerator::GetProfileName(const VsSetupConfiguration::VsSetupInstance& instance) const
{
    std::wstring name{ L"Developer Command Prompt for VS " };
    name.append(instance.GetProfileNameSuffix());
    return name;
}

std::wstring VsDevCmdGenerator::GetProfileCommandLine(const VsSetupConfiguration::VsSetupInstance& instance) const
{
    std::wstring commandLine;
    commandLine.reserve(256);
    commandLine.append(LR"("cmd.exe /k ")");
    commandLine.append(GetDevCmdScriptPath(instance));
#if defined(_M_ARM64)
    commandLine.append(LR"(" -arch=arm64 -host_arch=x64)");
#elif defined(_M_AMD64)
    commandLine.append(LR"(" -arch=x64 -host_arch=x64)");
#endif
    return commandLine;
}

std::wstring VsDevCmdGenerator::GetDevCmdScriptPath(const VsSetupConfiguration::VsSetupInstance& instance) const
{
    return instance.ResolvePath(L"Common7\\Tools\\VsDevCmd.bat");
}