162 lines
3.7 KiB
C
162 lines
3.7 KiB
C
/*
|
|
* Copyright 2021 Hans-Kristian Arntzen for Valve Corporation
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#define VKD3D_DBG_CHANNEL VKD3D_DBG_CHANNEL_API
|
|
|
|
#include "vkd3d_string.h"
|
|
#include "vkd3d_memory.h"
|
|
|
|
STATIC_ASSERT(sizeof(WCHAR) == sizeof(uint16_t));
|
|
|
|
char *vkd3d_strdup(const char *str)
|
|
{
|
|
/* strdup() is actually not standard. */
|
|
char *duped;
|
|
size_t len;
|
|
|
|
len = strlen(str) + 1;
|
|
|
|
duped = vkd3d_malloc(len);
|
|
if (duped)
|
|
memcpy(duped, str, len);
|
|
return duped;
|
|
}
|
|
|
|
char *vkd3d_strdup_n(const char *str, size_t n)
|
|
{
|
|
char *duped;
|
|
size_t len;
|
|
|
|
len = strnlen(str, n);
|
|
|
|
duped = vkd3d_malloc(len + 1);
|
|
if (duped)
|
|
{
|
|
memcpy(duped, str, len);
|
|
duped[len] = '\0';
|
|
}
|
|
|
|
return duped;
|
|
}
|
|
|
|
WCHAR *vkd3d_wstrdup(const WCHAR *str)
|
|
{
|
|
WCHAR *duped;
|
|
size_t len;
|
|
|
|
len = vkd3d_wcslen(str) + 1;
|
|
|
|
duped = vkd3d_malloc(len * sizeof(WCHAR));
|
|
if (duped)
|
|
memcpy(duped, str, len * sizeof(WCHAR));
|
|
return duped;
|
|
}
|
|
|
|
bool vkd3d_export_strequal(const WCHAR *a, const WCHAR *b)
|
|
{
|
|
if (!a || !b)
|
|
return false;
|
|
|
|
while (*a != '\0' && *b != '\0')
|
|
{
|
|
if (*a != *b)
|
|
return false;
|
|
a++;
|
|
b++;
|
|
}
|
|
return *a == *b;
|
|
}
|
|
|
|
bool vkd3d_export_strequal_substr(const WCHAR *a, size_t expected_n, const WCHAR *b)
|
|
{
|
|
size_t n = 0;
|
|
|
|
if (!a || !b)
|
|
return false;
|
|
|
|
while (*a != '\0' && *b != '\0' && n < expected_n)
|
|
{
|
|
if (*a != *b)
|
|
return false;
|
|
a++;
|
|
b++;
|
|
n++;
|
|
}
|
|
|
|
return n == expected_n && *b == '\0';
|
|
}
|
|
|
|
WCHAR *vkd3d_dup_entry_point(const char *str)
|
|
{
|
|
return vkd3d_dup_entry_point_n(str, strlen(str));
|
|
}
|
|
|
|
WCHAR *vkd3d_dup_entry_point_n(const char *str, size_t len)
|
|
{
|
|
WCHAR *duped;
|
|
size_t i;
|
|
|
|
duped = vkd3d_malloc((len + 1) * sizeof(WCHAR));
|
|
if (!duped)
|
|
return NULL;
|
|
|
|
for (i = 0; i < len; i++)
|
|
duped[i] = (unsigned char)str[i];
|
|
duped[len] = 0;
|
|
return duped;
|
|
}
|
|
|
|
static bool is_valid_identifier_character(char v)
|
|
{
|
|
return (v >= 'a' && v <= 'z') || (v >= 'A' && v <= 'Z') || v == '_' || (v >= '0' && v <= '9');
|
|
}
|
|
|
|
static const char *vkd3d_manged_entry_point_scan(const char *entry, const char **out_end_entry)
|
|
{
|
|
const char *end_entry;
|
|
|
|
while (*entry != '\0' && !is_valid_identifier_character(*entry))
|
|
entry++;
|
|
|
|
end_entry = entry;
|
|
while (*end_entry != '\0' && is_valid_identifier_character(*end_entry))
|
|
end_entry++;
|
|
|
|
if (entry == end_entry)
|
|
return NULL;
|
|
|
|
*out_end_entry = end_entry;
|
|
return entry;
|
|
}
|
|
|
|
WCHAR *vkd3d_dup_demangled_entry_point(const char *entry)
|
|
{
|
|
const char *end_entry;
|
|
if (!(entry = vkd3d_manged_entry_point_scan(entry, &end_entry)))
|
|
return NULL;
|
|
return vkd3d_dup_entry_point_n(entry, end_entry - entry);
|
|
}
|
|
|
|
char *vkd3d_dup_demangled_entry_point_ascii(const char *entry)
|
|
{
|
|
const char *end_entry;
|
|
if (!(entry = vkd3d_manged_entry_point_scan(entry, &end_entry)))
|
|
return NULL;
|
|
return vkd3d_strdup_n(entry, end_entry - entry);
|
|
}
|