stringutils.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Applications
 * LICENSE:     LGPL - See COPYING in the top level directory
 * FILE:        base/applications/msconfig_new/stringutils.c
 * PURPOSE:     ANSI & UNICODE String Utility Functions
 * COPYRIGHT:   Copyright 2011-2012 Hermes BELUSCA - MAITO <hermes.belusca@sfr.fr>
 */
 
#include "precomp.h"
#include "utils.h"
#include "stringutils.h"
 
//
// String formatting
//
LPTSTR FormatStringV(LPCTSTR str, va_list args)
{
    LPTSTR lpszString;
    size_t strLenPlusNull;
 
    if (!str) return NULL;
 
    strLenPlusNull = _vsctprintf(str, args) + 1;
 
    lpszString = (LPTSTR)MemAlloc(0, strLenPlusNull * sizeof(TCHAR));
    if (!lpszString) return NULL;
 
    StringCchVPrintf(lpszString, strLenPlusNull, str, args);
 
    return lpszString;
}
 
LPTSTR FormatString(LPCTSTR str, ...)
{
    LPTSTR lpszString;
    va_list args;
 
    va_start(args, str);
    lpszString = FormatStringV(str, args);
    va_end(args);
 
    return lpszString;
}
 
//
// String handling (ANSI <-> Unicode UTF16)
//
LPSTR UnicodeToAnsi(LPCWSTR strW)
{
    LPSTR strA;
    int iNeededChars;
 
    if (!strW) return NULL;
 
    iNeededChars = WideCharToMultiByte(CP_ACP,
                                       WC_COMPOSITECHECK /* | WC_NO_BEST_FIT_CHARS */,
                                       strW, -1, NULL, 0, NULL, NULL);
 
    strA = (LPSTR)MemAlloc(0, iNeededChars * sizeof(CHAR));
    if (!strA) return NULL;
 
    WideCharToMultiByte(CP_ACP,
                        WC_COMPOSITECHECK /* | WC_NO_BEST_FIT_CHARS */,
                        strW, -1, strA, iNeededChars, NULL, NULL);
 
    return strA;
}
 
LPWSTR AnsiToUnicode(LPCSTR strA)
{
    LPWSTR strW;
    int iNeededChars;
 
    if (!strA) return NULL;
 
    iNeededChars = MultiByteToWideChar(CP_ACP,
                                       MB_PRECOMPOSED,
                                       strA, -1, NULL, 0);
 
    strW = (LPWSTR)MemAlloc(0, iNeededChars * sizeof(WCHAR));
    if (!strW) return NULL;
 
    MultiByteToWideChar(CP_ACP,
                        MB_PRECOMPOSED,
                        strA, -1, strW, iNeededChars);
 
    return strW;
}
 
LPSTR DuplicateStringA(LPCSTR str)
{
    LPSTR dupStr;
    size_t strSizePlusNull;
 
    if (!str) return NULL;
 
    strSizePlusNull = strlen(str) + 1;
 
    dupStr = (LPSTR)MemAlloc(0, strSizePlusNull * sizeof(CHAR));
    if (!dupStr) return NULL;
 
    StringCchCopyA(dupStr, strSizePlusNull, str);
 
    return dupStr;
}
 
LPWSTR DuplicateStringW(LPCWSTR str)
{
    LPWSTR dupStr;
    size_t strSizePlusNull;
 
    if (!str) return NULL;
 
    strSizePlusNull = wcslen(str) + 1;
 
    dupStr = (LPWSTR)MemAlloc(0, strSizePlusNull * sizeof(WCHAR));
    if (!dupStr) return NULL;
 
    StringCchCopyW(dupStr, strSizePlusNull, str);
 
    return dupStr;
}
 
LPSTR DuplicateStringAEx(LPCSTR str, size_t numOfChars)
{
    LPSTR dupStr;
    size_t strSize;
 
    if (!str) return NULL;
 
    strSize = min(strlen(str), numOfChars);
 
    dupStr = (LPSTR)MemAlloc(0, (strSize + 1) * sizeof(CHAR));
    if (!dupStr) return NULL;
 
    StringCchCopyNA(dupStr, strSize + 1, str, strSize);
    dupStr[strSize] = '\0';
 
    return dupStr;
}
 
LPWSTR DuplicateStringWEx(LPCWSTR str, size_t numOfChars)
{
    LPWSTR dupStr;
    size_t strSize;
 
    if (!str) return NULL;
 
    strSize = min(wcslen(str), numOfChars);
 
    dupStr = (LPWSTR)MemAlloc(0, (strSize + 1) * sizeof(WCHAR));
    if (!dupStr) return NULL;
 
    StringCchCopyNW(dupStr, strSize + 1, str, strSize);
    dupStr[strSize] = L'\0';
 
    return dupStr;
}
 
//
// String search functions
//
/***
*wchar_t *wcsstr(string1, string2) - search for string2 in string1
*       (wide strings)
*
*Purpose:
*       finds the first occurrence of string2 in string1 (wide strings)
*
*Entry:
*       wchar_t *string1 - string to search in
*       wchar_t *string2 - string to search for
*
*Exit:
*       returns a pointer to the first occurrence of string2 in
*       string1, or NULL if string2 does not occur in string1
*
*Uses:
*
*Exceptions:
*
*******************************************************************************/
LPTSTR FindSubStrI(LPCTSTR str, LPCTSTR strSearch)
{
    LPTSTR cp = (LPTSTR)str;
    LPTSTR s1, s2;
 
    if (!*strSearch)
        return (LPTSTR)str;
 
    while (*cp)
    {
        s1 = cp;
        s2 = (LPTSTR)strSearch;
 
        while (*s1 && *s2 && (_totupper(*s1) == _totupper(*s2)))
            ++s1, ++s2;
 
        if (!*s2)
            return cp;
 
        ++cp;
    }
 
    return NULL;
}
 
/*************************************************************************
 * AppendPathSeparator
 *
 * Append a backslash ('\') to a path if one doesn't exist.
 *
 * PARAMS
 *  lpszPath [I/O] The path to append a backslash to.
 *
 * RETURNS
 *  Success: The position of the last backslash in the path.
 *  Failure: NULL, if lpszPath is NULL or the path is too large.
 */
LPTSTR AppendPathSeparator(LPTSTR lpszPath)
{
    size_t iLen = 0;
 
    if (!lpszPath || (iLen = _tcslen(lpszPath)) >= MAX_PATH)
        return NULL;
 
    if (iLen >= 1)
    {
        lpszPath += iLen - 1;
        if (*lpszPath++ != _T('\\'))
        {
            *lpszPath++ = _T('\\');
            *lpszPath   = _T('\0');
        }
    }
 
    return lpszPath;
}