VirtualBox

Changeset 80764 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Sep 13, 2019 6:52:50 AM (5 years ago)
Author:
vboxsync
Message:

IPRT: Optimized RTEnvPutEx. bugref:9341

Location:
trunk/src/VBox/Runtime
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/generic/env-generic.cpp

    r76553 r80764  
    452452
    453453
    454 RTDECL(int) RTEnvPutEx(RTENV Env, const char *pszVarEqualValue)
    455 {
    456     int rc;
    457     AssertPtrReturn(pszVarEqualValue, VERR_INVALID_POINTER);
    458     const char *pszEq = strchr(pszVarEqualValue, '=');
    459     if (!pszEq)
    460         rc = RTEnvUnsetEx(Env, pszVarEqualValue);
    461     else
    462     {
    463         /*
    464          * Make a copy of the variable name so we can terminate it
    465          * properly and then pass the request on to RTEnvSetEx.
    466          */
    467         const char *pszValue = pszEq + 1;
    468 
    469         size_t cchVar = pszEq - pszVarEqualValue;
    470         Assert(cchVar < 1024);
    471         char *pszVar = (char *)alloca(cchVar + 1);
    472         memcpy(pszVar, pszVarEqualValue, cchVar);
    473         pszVar[cchVar] = '\0';
    474 
    475         rc = RTEnvSetEx(Env, pszVar, pszValue);
    476     }
    477     return rc;
    478 }
    479 RT_EXPORT_SYMBOL(RTEnvPutEx);
    480 
    481 
    482454/**
    483455 * Appends an already allocated string to papszEnv.
    … …  
    521493
    522494
    523 RTDECL(int) RTEnvSetEx(RTENV Env, const char *pszVar, const char *pszValue)
    524 {
    525     AssertPtrReturn(pszVar, VERR_INVALID_POINTER);
    526     AssertReturn(*pszVar, VERR_INVALID_PARAMETER);
    527     AssertPtrReturn(pszValue, VERR_INVALID_POINTER);
    528     AssertReturn(strchr(pszVar, '=') == NULL, VERR_ENV_INVALID_VAR_NAME);
    529 
     495/**
     496 * Worker for RTEnvSetEx and RTEnvPutEx.
     497 */
     498static int rtEnvSetExWorker(RTENV Env, const char *pchVar, size_t cchVar, const char *pszValue)
     499{
    530500    int rc;
    531501    if (Env == RTENV_DEFAULT)
    532502    {
    533503#ifdef RT_OS_WINDOWS
    534         rc = RTEnvSetUtf8(pszVar, pszValue);
     504        extern int rtEnvSetUtf8Worker(const char *pchVar, size_t cchVar, const char *pszValue);
     505        rc = rtEnvSetUtf8Worker(pchVar, cchVar, pszValue);
    535506#else
    536507        /*
    … …  
    540511         */
    541512        char *pszVarOtherCP;
    542         rc = RTStrUtf8ToCurrentCP(&pszVarOtherCP, pszVar);
     513        rc = RTStrUtf8ToCurrentCPEx(&pszVarOtherCP, pchVar, cchVar);
    543514        if (RT_SUCCESS(rc))
    544515        {
    … …  
    563534         * Create the variable string.
    564535         */
    565         const size_t cchVar = strlen(pszVar);
    566536        const size_t cchValue = strlen(pszValue);
    567537        char *pszEntry = (char *)RTMemAlloc(cchVar + cchValue + 2);
    568538        if (pszEntry)
    569539        {
    570             memcpy(pszEntry, pszVar, cchVar);
     540            memcpy(pszEntry, pchVar, cchVar);
    571541            pszEntry[cchVar] = '=';
    572542            memcpy(&pszEntry[cchVar + 1], pszValue, cchValue + 1);
    … …  
    580550            size_t iVar;
    581551            for (iVar = 0; iVar < pIntEnv->cVars; iVar++)
    582                 if (    !pIntEnv->pfnCompare(pIntEnv->papszEnv[iVar], pszVar, cchVar)
     552                if (    !pIntEnv->pfnCompare(pIntEnv->papszEnv[iVar], pchVar, cchVar)
    583553                    &&  (   pIntEnv->papszEnv[iVar][cchVar] == '='
    584554                         || pIntEnv->papszEnv[iVar][cchVar] == '\0') )
    … …  
    610580    }
    611581    return rc;
     582}
     583
     584
     585RTDECL(int) RTEnvSetEx(RTENV Env, const char *pszVar, const char *pszValue)
     586{
     587    AssertPtrReturn(pszVar, VERR_INVALID_POINTER);
     588    AssertReturn(*pszVar, VERR_INVALID_PARAMETER);
     589    AssertPtrReturn(pszValue, VERR_INVALID_POINTER);
     590    size_t const cchVar = strlen(pszVar);
     591    AssertReturn(memchr(pszVar, '=', cchVar) == NULL, VERR_ENV_INVALID_VAR_NAME);
     592
     593    return rtEnvSetExWorker(Env, pszVar, cchVar, pszValue);
    612594}
    613595RT_EXPORT_SYMBOL(RTEnvSetEx);
    … …  
    700682}
    701683RT_EXPORT_SYMBOL(RTEnvUnsetEx);
     684
     685
     686RTDECL(int) RTEnvPutEx(RTENV Env, const char *pszVarEqualValue)
     687{
     688    int rc;
     689    AssertPtrReturn(pszVarEqualValue, VERR_INVALID_POINTER);
     690    const char *pszEq = strchr(pszVarEqualValue, '=');
     691    if (!pszEq)
     692        rc = RTEnvUnsetEx(Env, pszVarEqualValue);
     693    else
     694        rc = rtEnvSetExWorker(Env, pszVarEqualValue, pszEq - pszVarEqualValue, pszEq + 1);
     695    return rc;
     696}
     697RT_EXPORT_SYMBOL(RTEnvPutEx);
    702698
    703699

  • trunk/src/VBox/Runtime/r3/posix/utf8-posix.cpp

    r76553 r80764  
    490490
    491491
    492 RTR3DECL(int)  RTStrCurrentCPToUtf8Tag(char **ppszString, const char *pszString, const char *pszTag)
     492RTR3DECL(int)  RTStrUtf8ToCurrentCPExTag(char **ppszString, const char *pszString, size_t cchString, const char *pszTag)
    493493{
    494494    Assert(ppszString);
    … …  
    497497
    498498    /*
    499      * Attempt with UTF-8 length of 2x the native length.
    500      */
    501     size_t cch = strlen(pszString);
    502     if (cch <= 0)
     499     * Assume result string length is not longer than UTF-8 string.
     500     */
     501    cchString = RTStrNLen(pszString, cchString);
     502    if (cchString < 1)
    503503    {
    504504        /* zero length string passed. */
    … …  
    508508        return VERR_NO_TMP_MEMORY;
    509509    }
     510    return rtStrConvertWrapper(pszString, cchString, "UTF-8", ppszString, 0, "", 1, RTSTRICONV_UTF8_TO_LOCALE);
     511}
     512
     513
     514RTR3DECL(int)  RTStrCurrentCPToUtf8Tag(char **ppszString, const char *pszString, const char *pszTag)
     515{
     516    Assert(ppszString);
     517    Assert(pszString);
     518    *ppszString = NULL;
     519
     520    /*
     521     * Attempt with UTF-8 length of 2x the native length.
     522     */
     523    size_t cch = strlen(pszString);
     524    if (cch <= 0)
     525    {
     526        /* zero length string passed. */
     527        *ppszString = (char *)RTMemTmpAllocZTag(sizeof(char), pszTag);
     528        if (*ppszString)
     529            return VINF_SUCCESS;
     530        return VERR_NO_TMP_MEMORY;
     531    }
    510532    return rtStrConvertWrapper(pszString, cch, "", ppszString, 0, "UTF-8", 2, RTSTRICONV_LOCALE_TO_UTF8);
    511533}

  • trunk/src/VBox/Runtime/r3/win/env-win.cpp

    r76553 r80764  
    173173}
    174174
    175 RTDECL(int) RTEnvSetUtf8(const char *pszVar, const char *pszValue)
    176 {
    177     AssertReturn(strchr(pszVar, '=') == NULL, VERR_ENV_INVALID_VAR_NAME);
    178 
     175
     176/**
     177 * Worker common to RTEnvSetUtf8() and rtEnvSetExWorker().
     178 */
     179int rtEnvSetUtf8Worker(const char *pchVar, size_t cchVar, const char *pszValue)
     180{
    179181    size_t cwcVar;
    180     int rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcVar);
     182    int rc = RTStrCalcUtf16LenEx(pchVar, cchVar, &cwcVar);
    181183    if (RT_SUCCESS(rc))
    182184    {
    183185        size_t cwcValue;
    184         rc = RTStrCalcUtf16LenEx(pszVar, RTSTR_MAX, &cwcValue);
     186        rc = RTStrCalcUtf16LenEx(pszValue, RTSTR_MAX, &cwcValue);
    185187        if (RT_SUCCESS(rc))
    186188        {
    … …  
    188190            if (pwszTmp)
    189191            {
    190                 rc = RTStrToUtf16Ex(pszVar, RTSTR_MAX, &pwszTmp, cwcVar + 1, NULL);
     192                rc = RTStrToUtf16Ex(pchVar, cchVar, &pwszTmp, cwcVar + 1, NULL);
    191193                if (RT_SUCCESS(rc))
    192194                {
    … …  
    212214
    213215
     216RTDECL(int) RTEnvSetUtf8(const char *pszVar, const char *pszValue)
     217{
     218    size_t cchVar = strlen(pszVar);
     219    AssertReturn(memchr(pszVar, '=', cchVar) == NULL, VERR_ENV_INVALID_VAR_NAME);
     220    return rtEnvSetUtf8Worker(pszVar, cchVar, pszValue);
     221}
     222
     223
    214224RTDECL(int) RTEnvUnsetBad(const char *pszVar)
    215225{

  • trunk/src/VBox/Runtime/r3/win/utf8-win.cpp

    r76553 r80764  
    3939
    4040
     41
    4142RTR3DECL(int)  RTStrUtf8ToCurrentCPTag(char **ppszString, const char *pszString, const char *pszTag)
     43{
     44    return RTStrUtf8ToCurrentCPExTag(ppszString, pszString, RTSTR_MAX, pszTag);
     45}
     46
     47
     48RTR3DECL(int)  RTStrUtf8ToCurrentCPExTag(char **ppszString, const char *pszString, size_t cchString, const char *pszTag)
    4249{
    4350    Assert(ppszString);
    … …  
    4754     * Check for zero length input string.
    4855     */
    49     if (!*pszString)
     56    if (cchString < 1 || !*pszString)
    5057    {
    5158        *ppszString = (char *)RTMemTmpAllocZTag(sizeof(char), pszTag);
    … …  
    6168     */
    6269    PRTUTF16 pwszString = NULL;
    63     int rc = RTStrToUtf16(pszString, &pwszString);
     70    int rc = RTStrToUtf16Ex(pszString, cchString, &pwszString, 0, NULL);
    6471    if (RT_FAILURE(rc))
    6572        return rc;
Note: See TracChangeset for help on using the changeset viewer.

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