pimhwang
/
CppSharp
mirror of https://github.com/mono/CppSharp.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Use msclr string marshallers

pull/1893/head
duckdoom5 2 years ago
parent
7bbb4f5e77
commit
1bb086d340
1 changed files with 249 additions and 161 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 258
      include/CppSharp.h

258
include/CppSharp.h
Unescape View File

@ -13,7 +13,7 @@ @@ -13,7 +13,7 @@
#include <string>
#include <ostream>
#include <vcclr.h>
#include <msclr/marshal.h>
#include <msclr/marshal_cppstd.h>
public interface class ICppInstance
{
@ -24,6 +24,159 @@ public interface class ICppInstance @@ -24,6 +24,159 @@ public interface class ICppInstance
}
};
namespace msclr {
namespace interop {
namespace details
{
inline _Check_return_ size_t GetUTF8StringSize(System::String^ _str)
{
cli::pin_ptr<const wchar_t> _pinned_ptr = PtrToStringChars(_str);
auto _size = static_cast<size_t>(
::WideCharToMultiByte(CP_UTF8, WC_NO_BEST_FIT_CHARS, _pinned_ptr,
_str->Length, NULL, 0, NULL, NULL));
if (_size == 0 && _str->Length != 0)
{
throw gcnew System::ArgumentException(_EXCEPTION_WC2MB);
}
// adding 1 for terminating nul
_size += 1;
return _size;
}
inline _Check_return_ size_t GetUnicodeStringSizeUTF8Source(_In_reads_z_(_count + 1) const char* _str, size_t _count)
{
if (_count > INT_MAX)
{
throw gcnew System::ArgumentOutOfRangeException(_EXCEPTION_GREATER_THAN_INT_MAX);
}
auto _size = static_cast<size_t>(::MultiByteToWideChar(CP_UTF8, 0, _str, static_cast<int>(_count), NULL, 0));
if (_size == 0 && _count != 0)
{
throw gcnew System::ArgumentException(_EXCEPTION_MB2WC);
}
//adding 1 for terminating nul
_size += 1;
return _size;
}
inline void WriteUTF8String(_Out_writes_all_(_size) _Post_z_ char* _buf, size_t _size, System::String^ _str)
{
cli::pin_ptr<const wchar_t> _pinned_ptr = PtrToStringChars(_str);
//checking for overflow
if (_size > INT_MAX)
{
// this should never happen if _size was returned by GetAnsiStringSize()
throw gcnew System::ArgumentOutOfRangeException(_EXCEPTION_GREATER_THAN_INT_MAX);
}
const auto _written = static_cast<size_t>(::WideCharToMultiByte(CP_UTF8, WC_NO_BEST_FIT_CHARS,
_pinned_ptr, _str->Length, _buf, static_cast<int>(_size), NULL, NULL));
if (_written >= _size || (_written == 0 && _size != 1)) // allowing empty string
{
throw gcnew System::ArgumentException(_EXCEPTION_WC2MB);
}
_buf[_written] = '\0';
}
inline void WriteUnicodeStringUTF8Source(_Out_writes_all_(_size) _Post_z_ wchar_t* _dest, size_t _size, _In_reads_bytes_(_count)const char* _src, size_t _count)
{
//checking for overflow
if (_size > INT_MAX || _count > INT_MAX)
{
throw gcnew System::ArgumentOutOfRangeException(_EXCEPTION_GREATER_THAN_INT_MAX);
}
size_t _written = static_cast<size_t>(::MultiByteToWideChar(CP_UTF8, 0, _src,
static_cast<int>(_count), _dest, static_cast<int>(_size)));
if (_written >= _size || (_written == 0 && _size != 1)) // allowing empty string
{
throw gcnew System::ArgumentException(_EXCEPTION_MB2WC);
}
_dest[_written] = L'\0';
}
inline System::String^ InternalUTF8ToStringHelper(_In_reads_z_(_count + 1)const char* _src, size_t _count)
{
const size_t _size = details::GetUnicodeStringSizeUTF8Source(_src, _count);
if (_size > INT_MAX || _size <= 0)
{
throw gcnew System::ArgumentOutOfRangeException(_EXCEPTION_GREATER_THAN_INT_MAX);
}
details::char_buffer<wchar_t> _wchar_buf(_size);
if (_wchar_buf.get() == NULL)
{
throw gcnew System::InsufficientMemoryException();
}
details::WriteUnicodeStringUTF8Source(_wchar_buf.get(), _size, _src, _count);
return gcnew System::String(_wchar_buf.get(), 0, static_cast<int>(_size) - 1);
}
}
template <class _To_Type, class _From_Type>
inline _To_Type marshal_as_utf8(const _From_Type& _from_object);
template <>
inline std::string marshal_as_utf8(System::String^ const& _from_obj)
{
if (_from_obj == nullptr)
{
throw gcnew System::ArgumentNullException(_EXCEPTION_NULLPTR);
}
std::string _to_obj;
size_t _size = details::GetUTF8StringSize(_from_obj);
if (_size > 1)
{
// -1 because resize will automatically +1 for the NULL
_to_obj.resize(_size - 1);
char* _dest_buf = &(_to_obj[0]);
details::WriteUTF8String(_dest_buf, _size, _from_obj);
}
return _to_obj;
}
template <>
inline System::String^ marshal_as_utf8(char const* const& _from_obj)
{
return details::InternalUTF8ToStringHelper(_from_obj, strlen(_from_obj));
}
template <>
inline System::String^ marshal_as_utf8(const std::string& _from_obj)
{
return details::InternalUTF8ToStringHelper(_from_obj.c_str(), _from_obj.length());
}
template <>
inline System::String^ marshal_as_utf8(const std::string_view& _from_obj)
{
return details::InternalUTF8ToStringHelper(_from_obj.data(), _from_obj.length());
}
template <>
inline System::String^ marshal_as(const std::string_view& _from_obj)
{
return details::InternalAnsiToStringHelper(_from_obj.data(), _from_obj.length());
}
template <>
inline System::String^ marshal_as(const std::wstring_view& _from_obj)
{
return details::InternalUnicodeToStringHelper(_from_obj.data(), _from_obj.length());
}
}
}
// CLI extensions namespace
namespace clix {
@ -54,8 +207,8 @@ namespace clix { @@ -54,8 +207,8 @@ namespace clix {
/// that UTF-16 can still use more than two bytes for a character, so std::wstring::length()
/// might not reflect the actual length of the string.
/// </remarks>
E_UTF16, E_UNICODE = E_UTF16
E_UTF16,
E_UNICODE = E_UTF16
};
// Ignore this if you're just scanning the headers for informations!
@ -97,96 +250,33 @@ namespace clix { @@ -97,96 +250,33 @@ namespace clix {
template<MarshalingDirection direction> struct StringMarshaler;
// Marshals to .NET from C++ strings
template<> struct StringMarshaler<NetFromCxx> {
template<>
struct StringMarshaler<NetFromCxx> {
template<Encoding encoding, typename SourceType>
static System::String ^marshal(const SourceType& string) {
// Constructs a std::[w]string in case someone gave us a char * to choke on
return marshalCxxString<encoding, SourceType>(string);
}
template<Encoding encoding, typename SourceType>
static System::String ^marshalCxxString(
const typename StringTypeSelector<encoding>::Type &cxxString
) {
typedef typename StringTypeSelector<encoding>::Type SourceStringType;
size_t byteCount = cxxString.length() * sizeof(SourceStringType::value_type);
// Empty strings would cause trouble accessing the array below
if(byteCount == 0) {
return System::String::Empty;
}
// Copy the C++ string contents into a managed array of bytes
cli::array<unsigned char> ^bytes = gcnew cli::array<unsigned char>(byteCount);
{ pin_ptr<unsigned char> pinnedBytes = &bytes[0];
memcpy(pinnedBytes, cxxString.c_str(), byteCount);
}
// Now let one of .NET's encoding classes do the rest
return decode<encoding>(bytes);
}
private:
// Converts a byte array based on the selected encoding
template<Encoding encoding> static System::String ^decode(cli::array<unsigned char> ^bytes);
template<> static System::String ^decode<E_ANSI>(cli::array<unsigned char> ^bytes) {
return System::Text::Encoding::Default->GetString(bytes);
}
template<> static System::String ^decode<E_UTF8>(cli::array<unsigned char> ^bytes) {
return System::Text::Encoding::UTF8->GetString(bytes);
}
template<> static System::String ^decode<E_UTF16>(cli::array<unsigned char> ^bytes) {
return System::Text::Encoding::Unicode->GetString(bytes);
if constexpr (encoding == E_UTF8)
return msclr::interop::marshal_as_utf8<System::String^>(string);
else
return msclr::interop::marshal_as<System::String^>(string);
}
};
// Marshals to C++ strings from .NET
template<> struct StringMarshaler<CxxFromNet> {
template<>
struct StringMarshaler<CxxFromNet> {
template<Encoding encoding, typename SourceType>
static typename detail::StringTypeSelector<encoding>::Type marshal(
System::String^ string
) {
typedef typename StringTypeSelector<encoding>::Type StringType;
// Empty strings would cause a problem when accessing the empty managed array
if(!string || string->Length == 0) {
return StringType();
using ResultType = typename detail::StringTypeSelector<encoding>::Type;
return msclr::interop::marshal_as<ResultType>(string);
}
// First, we use .NET's encoding classes to convert the string into a byte array
cli::array<unsigned char> ^bytes = encode<encoding>(string);
// Then we construct our native string from that byte array
pin_ptr<unsigned char> pinnedBytes(&bytes[0]);
return StringType(
reinterpret_cast<StringType::value_type *>(static_cast<unsigned char *>(pinnedBytes)),
bytes->Length / sizeof(StringType::value_type)
);
}
template<> static std::wstring marshal<E_UTF16, System::String ^>(
System::String ^string
) {
// We can directly accesss the characters in the managed string
pin_ptr<const wchar_t> pinnedChars(::PtrToStringChars(string));
return std::wstring(pinnedChars, string->Length);
}
private:
// Converts a string based on the selected encoding
template<Encoding encoding> static cli::array<unsigned char> ^encode(System::String ^string);
template<> static cli::array<unsigned char> ^encode<E_ANSI>(System::String ^string) {
return System::Text::Encoding::Default->GetBytes(string);
}
template<> static cli::array<unsigned char> ^encode<E_UTF8>(System::String ^string) {
return System::Text::Encoding::UTF8->GetBytes(string);
}
template<> static cli::array<unsigned char> ^encode<E_UTF16>(System::String ^string) {
return System::Text::Encoding::Unicode->GetBytes(string);
template<>
static std::string marshal<E_UTF8, System::String^>(System::String^ string) {
return msclr::interop::marshal_as_utf8<std::string>(string);
}
};
} // namespace detail
@ -202,20 +292,18 @@ namespace clix { @@ -202,20 +292,18 @@ namespace clix {
/// </remarks>
/// <param name="string">String to be marshalled to the other side</param>
/// <returns>The marshaled representation of the string</returns>
template<Encoding encoding, typename SourceType>
template<Encoding encoding, typename SourceType, class ResultType =
typename detail::IfManaged<SourceType>::Select::Either<
typename detail::StringTypeSelector<encoding>::Type,
System::String ^
>::Type marshalString(SourceType string) {
System::String^>::Type
>
ResultType marshalString(SourceType string) {
constexpr detail::MarshalingDirection direction =
detail::IfManaged<SourceType>::Result ? detail::CxxFromNet : detail::NetFromCxx;
using StringMarshaler = detail::StringMarshaler<direction>;
// Pass on the call to our nifty template routines
return StringMarshaler::template marshal<encoding, SourceType>(string);
}
} // namespace clix
// std::ostream marshaling using a System::IO::TextWriter

Write Preview
Loading…
Cancel
Save