From 8f16ae75f3fc84be1e17bc66d267f4aa2385ea7e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 8 Oct 2020 18:21:13 -0700 Subject: [PATCH] Bump namespace to 05 --- Cargo.toml | 2 +- build.rs | 2 +- gen/build/src/lib.rs | 2 +- gen/src/write.rs | 106 ++++++++++++++++++------------------- include/cxx.h | 76 +++++++++++++------------- macro/src/expand.rs | 10 ++-- src/cxx.cc | 100 +++++++++++++++++----------------- src/cxx_string.rs | 4 +- src/cxx_vector.rs | 14 ++--- src/result.rs | 2 +- src/symbols/exception.rs | 2 +- src/symbols/rust_str.rs | 2 +- src/symbols/rust_string.rs | 12 ++--- src/symbols/rust_vec.rs | 10 ++-- src/unique_ptr.rs | 10 ++-- syntax/mangle.rs | 2 +- syntax/symbol.rs | 2 +- tests/cxx_gen.rs | 4 +- 18 files changed, 181 insertions(+), 181 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index d8b93f1f..54c968fc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,7 +3,7 @@ name = "cxx" version = "0.4.7" # remember to update html_root_url authors = ["David Tolnay "] edition = "2018" -links = "cxxbridge04" +links = "cxxbridge05" license = "MIT OR Apache-2.0" description = "Safe interop between Rust and C++" repository = "https://github.com/dtolnay/cxx" diff --git a/build.rs b/build.rs index 688b5b77..57b3e52f 100644 --- a/build.rs +++ b/build.rs @@ -7,7 +7,7 @@ fn main() { .cpp(true) .cpp_link_stdlib(None) // linked via link-cplusplus crate .flag_if_supported(cxxbridge_flags::STD) - .compile("cxxbridge04"); + .compile("cxxbridge05"); println!("cargo:rerun-if-changed=src/cxx.cc"); println!("cargo:rerun-if-changed=include/cxx.h"); println!("cargo:rustc-cfg=built_with_cargo"); diff --git a/gen/build/src/lib.rs b/gen/build/src/lib.rs index 135833b4..7148d7b1 100644 --- a/gen/build/src/lib.rs +++ b/gen/build/src/lib.rs @@ -263,7 +263,7 @@ fn make_include_dir(prj: &Project) -> Result { let include_dir = prj.out_dir.join("cxxbridge").join("include"); let cxx_h = include_dir.join("rust").join("cxx.h"); let ref shared_cxx_h = prj.shared_dir.join("rust").join("cxx.h"); - if let Some(ref original) = env::var_os("DEP_CXXBRIDGE04_HEADER") { + if let Some(ref original) = env::var_os("DEP_CXXBRIDGE05_HEADER") { out::symlink_file(original, cxx_h)?; out::symlink_file(original, shared_cxx_h)?; } else { diff --git a/gen/src/write.rs b/gen/src/write.rs index 10482722..9e6a297d 100644 --- a/gen/src/write.rs +++ b/gen/src/write.rs @@ -245,7 +245,7 @@ fn write_include_cxxbridge(out: &mut OutFile, apis: &[Api], types: &Types) { } out.begin_block("namespace rust"); - out.begin_block("inline namespace cxxbridge04"); + out.begin_block("inline namespace cxxbridge05"); if needs_panic || needs_rust_string @@ -263,22 +263,22 @@ fn write_include_cxxbridge(out: &mut OutFile, apis: &[Api], types: &Types) { writeln!(out, "// #include \"rust/cxx.h\""); } - include::write(out, needs_panic, "CXXBRIDGE04_PANIC"); + include::write(out, needs_panic, "CXXBRIDGE05_PANIC"); if needs_rust_string { out.next_section(); writeln!(out, "struct unsafe_bitcopy_t;"); } - include::write(out, needs_rust_string, "CXXBRIDGE04_RUST_STRING"); - include::write(out, needs_rust_str, "CXXBRIDGE04_RUST_STR"); - include::write(out, needs_rust_slice, "CXXBRIDGE04_RUST_SLICE"); - include::write(out, needs_rust_box, "CXXBRIDGE04_RUST_BOX"); - include::write(out, needs_unsafe_bitcopy, "CXXBRIDGE04_RUST_BITCOPY"); - include::write(out, needs_rust_vec, "CXXBRIDGE04_RUST_VEC"); - include::write(out, needs_rust_fn, "CXXBRIDGE04_RUST_FN"); - include::write(out, needs_rust_error, "CXXBRIDGE04_RUST_ERROR"); - include::write(out, needs_rust_isize, "CXXBRIDGE04_RUST_ISIZE"); + include::write(out, needs_rust_string, "CXXBRIDGE05_RUST_STRING"); + include::write(out, needs_rust_str, "CXXBRIDGE05_RUST_STR"); + include::write(out, needs_rust_slice, "CXXBRIDGE05_RUST_SLICE"); + include::write(out, needs_rust_box, "CXXBRIDGE05_RUST_BOX"); + include::write(out, needs_unsafe_bitcopy, "CXXBRIDGE05_RUST_BITCOPY"); + include::write(out, needs_rust_vec, "CXXBRIDGE05_RUST_VEC"); + include::write(out, needs_rust_fn, "CXXBRIDGE05_RUST_FN"); + include::write(out, needs_rust_error, "CXXBRIDGE05_RUST_ERROR"); + include::write(out, needs_rust_isize, "CXXBRIDGE05_RUST_ISIZE"); if needs_manually_drop { out.next_section(); @@ -304,7 +304,7 @@ fn write_include_cxxbridge(out: &mut OutFile, apis: &[Api], types: &Types) { writeln!(out, "}};"); } - out.end_block("namespace cxxbridge04"); + out.end_block("namespace cxxbridge05"); if needs_trycatch { out.begin_block("namespace behavior"); @@ -333,7 +333,7 @@ fn write_include_cxxbridge(out: &mut OutFile, apis: &[Api], types: &Types) { } fn write_struct(out: &mut OutFile, strct: &Struct) { - let guard = format!("CXXBRIDGE04_STRUCT_{}{}", out.namespace, strct.ident); + let guard = format!("CXXBRIDGE05_STRUCT_{}{}", out.namespace, strct.ident); writeln!(out, "#ifndef {}", guard); writeln!(out, "#define {}", guard); for line in strct.doc.to_string().lines() { @@ -358,7 +358,7 @@ fn write_struct_using(out: &mut OutFile, ident: &Ident) { } fn write_struct_with_methods(out: &mut OutFile, ety: &ExternType, methods: &[&ExternFn]) { - let guard = format!("CXXBRIDGE04_STRUCT_{}{}", out.namespace, ety.ident); + let guard = format!("CXXBRIDGE05_STRUCT_{}{}", out.namespace, ety.ident); writeln!(out, "#ifndef {}", guard); writeln!(out, "#define {}", guard); for line in ety.doc.to_string().lines() { @@ -379,7 +379,7 @@ fn write_struct_with_methods(out: &mut OutFile, ety: &ExternType, methods: &[&Ex } fn write_enum(out: &mut OutFile, enm: &Enum) { - let guard = format!("CXXBRIDGE04_ENUM_{}{}", out.namespace, enm.ident); + let guard = format!("CXXBRIDGE05_ENUM_{}{}", out.namespace, enm.ident); writeln!(out, "#ifndef {}", guard); writeln!(out, "#define {}", guard); for line in enm.doc.to_string().lines() { @@ -465,7 +465,7 @@ fn write_exception_glue(out: &mut OutFile, apis: &[Api]) { out.next_section(); writeln!( out, - "const char *cxxbridge04$exception(const char *, size_t);", + "const char *cxxbridge05$exception(const char *, size_t);", ); } } @@ -610,7 +610,7 @@ fn write_cxx_function_shim( writeln!(out, " throw$.len = ::std::strlen(catch$);"); writeln!( out, - " throw$.ptr = cxxbridge04$exception(catch$, throw$.len);", + " throw$.ptr = cxxbridge05$exception(catch$, throw$.len);", ); writeln!(out, " }});"); writeln!(out, " return throw$;"); @@ -1089,7 +1089,7 @@ fn write_generic_instantiations(out: &mut OutFile, types: &Types) { out.end_block("extern \"C\""); out.begin_block("namespace rust"); - out.begin_block("inline namespace cxxbridge04"); + out.begin_block("inline namespace cxxbridge05"); for ty in types { if let Type::RustBox(ty) = ty { if let Type::Ident(inner) = &ty.inner { @@ -1103,7 +1103,7 @@ fn write_generic_instantiations(out: &mut OutFile, types: &Types) { } } } - out.end_block("namespace cxxbridge04"); + out.end_block("namespace cxxbridge05"); out.end_block("namespace rust"); } @@ -1116,19 +1116,19 @@ fn write_rust_box_extern(out: &mut OutFile, ident: &Ident) { inner += &ident.to_string(); let instance = inner.replace("::", "$"); - writeln!(out, "#ifndef CXXBRIDGE04_RUST_BOX_{}", instance); - writeln!(out, "#define CXXBRIDGE04_RUST_BOX_{}", instance); + writeln!(out, "#ifndef CXXBRIDGE05_RUST_BOX_{}", instance); + writeln!(out, "#define CXXBRIDGE05_RUST_BOX_{}", instance); writeln!( out, - "void cxxbridge04$box${}$uninit(::rust::Box<{}> *ptr) noexcept;", + "void cxxbridge05$box${}$uninit(::rust::Box<{}> *ptr) noexcept;", instance, inner, ); writeln!( out, - "void cxxbridge04$box${}$drop(::rust::Box<{}> *ptr) noexcept;", + "void cxxbridge05$box${}$drop(::rust::Box<{}> *ptr) noexcept;", instance, inner, ); - writeln!(out, "#endif // CXXBRIDGE04_RUST_BOX_{}", instance); + writeln!(out, "#endif // CXXBRIDGE05_RUST_BOX_{}", instance); } fn write_rust_vec_extern(out: &mut OutFile, element: &Ident) { @@ -1136,34 +1136,34 @@ fn write_rust_vec_extern(out: &mut OutFile, element: &Ident) { let inner = to_typename(&out.namespace, &element); let instance = to_mangled(&out.namespace, &element); - writeln!(out, "#ifndef CXXBRIDGE04_RUST_VEC_{}", instance); - writeln!(out, "#define CXXBRIDGE04_RUST_VEC_{}", instance); + writeln!(out, "#ifndef CXXBRIDGE05_RUST_VEC_{}", instance); + writeln!(out, "#define CXXBRIDGE05_RUST_VEC_{}", instance); writeln!( out, - "void cxxbridge04$rust_vec${}$new(const ::rust::Vec<{}> *ptr) noexcept;", + "void cxxbridge05$rust_vec${}$new(const ::rust::Vec<{}> *ptr) noexcept;", instance, inner, ); writeln!( out, - "void cxxbridge04$rust_vec${}$drop(::rust::Vec<{}> *ptr) noexcept;", + "void cxxbridge05$rust_vec${}$drop(::rust::Vec<{}> *ptr) noexcept;", instance, inner, ); writeln!( out, - "size_t cxxbridge04$rust_vec${}$len(const ::rust::Vec<{}> *ptr) noexcept;", + "size_t cxxbridge05$rust_vec${}$len(const ::rust::Vec<{}> *ptr) noexcept;", instance, inner, ); writeln!( out, - "const {} *cxxbridge04$rust_vec${}$data(const ::rust::Vec<{0}> *ptr) noexcept;", + "const {} *cxxbridge05$rust_vec${}$data(const ::rust::Vec<{0}> *ptr) noexcept;", inner, instance, ); writeln!( out, - "size_t cxxbridge04$rust_vec${}$stride() noexcept;", + "size_t cxxbridge05$rust_vec${}$stride() noexcept;", instance, ); - writeln!(out, "#endif // CXXBRIDGE04_RUST_VEC_{}", instance); + writeln!(out, "#endif // CXXBRIDGE05_RUST_VEC_{}", instance); } fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) { @@ -1177,12 +1177,12 @@ fn write_rust_box_impl(out: &mut OutFile, ident: &Ident) { writeln!(out, "template <>"); writeln!(out, "void Box<{}>::uninit() noexcept {{", inner); - writeln!(out, " cxxbridge04$box${}$uninit(this);", instance); + writeln!(out, " cxxbridge05$box${}$uninit(this);", instance); writeln!(out, "}}"); writeln!(out, "template <>"); writeln!(out, "void Box<{}>::drop() noexcept {{", inner); - writeln!(out, " cxxbridge04$box${}$drop(this);", instance); + writeln!(out, " cxxbridge05$box${}$drop(this);", instance); writeln!(out, "}}"); } @@ -1193,35 +1193,35 @@ fn write_rust_vec_impl(out: &mut OutFile, element: &Ident) { writeln!(out, "template <>"); writeln!(out, "Vec<{}>::Vec() noexcept {{", inner); - writeln!(out, " cxxbridge04$rust_vec${}$new(this);", instance); + writeln!(out, " cxxbridge05$rust_vec${}$new(this);", instance); writeln!(out, "}}"); writeln!(out, "template <>"); writeln!(out, "void Vec<{}>::drop() noexcept {{", inner); writeln!( out, - " return cxxbridge04$rust_vec${}$drop(this);", + " return cxxbridge05$rust_vec${}$drop(this);", instance, ); writeln!(out, "}}"); writeln!(out, "template <>"); writeln!(out, "size_t Vec<{}>::size() const noexcept {{", inner); - writeln!(out, " return cxxbridge04$rust_vec${}$len(this);", instance); + writeln!(out, " return cxxbridge05$rust_vec${}$len(this);", instance); writeln!(out, "}}"); writeln!(out, "template <>"); writeln!(out, "const {} *Vec<{0}>::data() const noexcept {{", inner); writeln!( out, - " return cxxbridge04$rust_vec${}$data(this);", + " return cxxbridge05$rust_vec${}$data(this);", instance, ); writeln!(out, "}}"); writeln!(out, "template <>"); writeln!(out, "size_t Vec<{}>::stride() noexcept {{", inner); - writeln!(out, " return cxxbridge04$rust_vec${}$stride();", instance); + writeln!(out, " return cxxbridge05$rust_vec${}$stride();", instance); writeln!(out, "}}"); } @@ -1229,12 +1229,12 @@ fn write_unique_ptr(out: &mut OutFile, ident: &Ident, types: &Types) { let ty = Type::Ident(ident.clone()); let instance = to_mangled(&out.namespace, &ty); - writeln!(out, "#ifndef CXXBRIDGE04_UNIQUE_PTR_{}", instance); - writeln!(out, "#define CXXBRIDGE04_UNIQUE_PTR_{}", instance); + writeln!(out, "#ifndef CXXBRIDGE05_UNIQUE_PTR_{}", instance); + writeln!(out, "#define CXXBRIDGE05_UNIQUE_PTR_{}", instance); write_unique_ptr_common(out, &ty, types); - writeln!(out, "#endif // CXXBRIDGE04_UNIQUE_PTR_{}", instance); + writeln!(out, "#endif // CXXBRIDGE05_UNIQUE_PTR_{}", instance); } // Shared by UniquePtr and UniquePtr>. @@ -1261,7 +1261,7 @@ fn write_unique_ptr_common(out: &mut OutFile, ty: &Type, types: &Types) { ); writeln!( out, - "void cxxbridge04$unique_ptr${}$null(::std::unique_ptr<{}> *ptr) noexcept {{", + "void cxxbridge05$unique_ptr${}$null(::std::unique_ptr<{}> *ptr) noexcept {{", instance, inner, ); writeln!(out, " new (ptr) ::std::unique_ptr<{}>();", inner); @@ -1269,7 +1269,7 @@ fn write_unique_ptr_common(out: &mut OutFile, ty: &Type, types: &Types) { if can_construct_from_value { writeln!( out, - "void cxxbridge04$unique_ptr${}$new(::std::unique_ptr<{}> *ptr, {} *value) noexcept {{", + "void cxxbridge05$unique_ptr${}$new(::std::unique_ptr<{}> *ptr, {} *value) noexcept {{", instance, inner, inner, ); writeln!( @@ -1281,28 +1281,28 @@ fn write_unique_ptr_common(out: &mut OutFile, ty: &Type, types: &Types) { } writeln!( out, - "void cxxbridge04$unique_ptr${}$raw(::std::unique_ptr<{}> *ptr, {} *raw) noexcept {{", + "void cxxbridge05$unique_ptr${}$raw(::std::unique_ptr<{}> *ptr, {} *raw) noexcept {{", instance, inner, inner, ); writeln!(out, " new (ptr) ::std::unique_ptr<{}>(raw);", inner); writeln!(out, "}}"); writeln!( out, - "const {} *cxxbridge04$unique_ptr${}$get(const ::std::unique_ptr<{}>& ptr) noexcept {{", + "const {} *cxxbridge05$unique_ptr${}$get(const ::std::unique_ptr<{}>& ptr) noexcept {{", inner, instance, inner, ); writeln!(out, " return ptr.get();"); writeln!(out, "}}"); writeln!( out, - "{} *cxxbridge04$unique_ptr${}$release(::std::unique_ptr<{}>& ptr) noexcept {{", + "{} *cxxbridge05$unique_ptr${}$release(::std::unique_ptr<{}>& ptr) noexcept {{", inner, instance, inner, ); writeln!(out, " return ptr.release();"); writeln!(out, "}}"); writeln!( out, - "void cxxbridge04$unique_ptr${}$drop(::std::unique_ptr<{}> *ptr) noexcept {{", + "void cxxbridge05$unique_ptr${}$drop(::std::unique_ptr<{}> *ptr) noexcept {{", instance, inner, ); writeln!(out, " ptr->~unique_ptr();"); @@ -1314,18 +1314,18 @@ fn write_cxx_vector(out: &mut OutFile, vector_ty: &Type, element: &Ident, types: let inner = to_typename(&out.namespace, &element); let instance = to_mangled(&out.namespace, &element); - writeln!(out, "#ifndef CXXBRIDGE04_VECTOR_{}", instance); - writeln!(out, "#define CXXBRIDGE04_VECTOR_{}", instance); + writeln!(out, "#ifndef CXXBRIDGE05_VECTOR_{}", instance); + writeln!(out, "#define CXXBRIDGE05_VECTOR_{}", instance); writeln!( out, - "size_t cxxbridge04$std$vector${}$size(const ::std::vector<{}> &s) noexcept {{", + "size_t cxxbridge05$std$vector${}$size(const ::std::vector<{}> &s) noexcept {{", instance, inner, ); writeln!(out, " return s.size();"); writeln!(out, "}}"); writeln!( out, - "const {} *cxxbridge04$std$vector${}$get_unchecked(const ::std::vector<{}> &s, size_t pos) noexcept {{", + "const {} *cxxbridge05$std$vector${}$get_unchecked(const ::std::vector<{}> &s, size_t pos) noexcept {{", inner, instance, inner, ); writeln!(out, " return &s[pos];"); @@ -1333,5 +1333,5 @@ fn write_cxx_vector(out: &mut OutFile, vector_ty: &Type, element: &Ident, types: write_unique_ptr_common(out, vector_ty, types); - writeln!(out, "#endif // CXXBRIDGE04_VECTOR_{}", instance); + writeln!(out, "#endif // CXXBRIDGE05_VECTOR_{}", instance); } diff --git a/include/cxx.h b/include/cxx.h index b2e0eee5..0373a386 100644 --- a/include/cxx.h +++ b/include/cxx.h @@ -15,12 +15,12 @@ #endif namespace rust { -inline namespace cxxbridge04 { +inline namespace cxxbridge05 { struct unsafe_bitcopy_t; -#ifndef CXXBRIDGE04_RUST_STRING -#define CXXBRIDGE04_RUST_STRING +#ifndef CXXBRIDGE05_RUST_STRING +#define CXXBRIDGE05_RUST_STRING class String final { public: String() noexcept; @@ -49,10 +49,10 @@ private: // Size and alignment statically verified by rust_string.rs. std::array repr; }; -#endif // CXXBRIDGE04_RUST_STRING +#endif // CXXBRIDGE05_RUST_STRING -#ifndef CXXBRIDGE04_RUST_STR -#define CXXBRIDGE04_RUST_STR +#ifndef CXXBRIDGE05_RUST_STR +#define CXXBRIDGE05_RUST_STR class Str final { public: Str() noexcept; @@ -86,9 +86,9 @@ public: private: Repr repr; }; -#endif // CXXBRIDGE04_RUST_STR +#endif // CXXBRIDGE05_RUST_STR -#ifndef CXXBRIDGE04_RUST_SLICE +#ifndef CXXBRIDGE05_RUST_SLICE template class Slice final { public: @@ -117,9 +117,9 @@ public: private: Repr repr; }; -#endif // CXXBRIDGE04_RUST_SLICE +#endif // CXXBRIDGE05_RUST_SLICE -#ifndef CXXBRIDGE04_RUST_BOX +#ifndef CXXBRIDGE05_RUST_BOX template class Box final { public: @@ -158,9 +158,9 @@ private: void drop() noexcept; T *ptr; }; -#endif // CXXBRIDGE04_RUST_BOX +#endif // CXXBRIDGE05_RUST_BOX -#ifndef CXXBRIDGE04_RUST_VEC +#ifndef CXXBRIDGE05_RUST_VEC template class Vec final { public: @@ -218,10 +218,10 @@ private: // Size and alignment statically verified by rust_vec.rs. std::array repr; }; -#endif // CXXBRIDGE04_RUST_VEC +#endif // CXXBRIDGE05_RUST_VEC -#ifndef CXXBRIDGE04_RUST_FN -#define CXXBRIDGE04_RUST_FN +#ifndef CXXBRIDGE05_RUST_FN +#define CXXBRIDGE05_RUST_FN template class Fn; @@ -238,10 +238,10 @@ private: template using TryFn = Fn; -#endif // CXXBRIDGE04_RUST_FN +#endif // CXXBRIDGE05_RUST_FN -#ifndef CXXBRIDGE04_RUST_ERROR -#define CXXBRIDGE04_RUST_ERROR +#ifndef CXXBRIDGE05_RUST_ERROR +#define CXXBRIDGE05_RUST_ERROR class Error final : public std::exception { public: Error(const Error &); @@ -253,16 +253,16 @@ public: private: Str::Repr msg; }; -#endif // CXXBRIDGE04_RUST_ERROR +#endif // CXXBRIDGE05_RUST_ERROR -#ifndef CXXBRIDGE04_RUST_ISIZE -#define CXXBRIDGE04_RUST_ISIZE +#ifndef CXXBRIDGE05_RUST_ISIZE +#define CXXBRIDGE05_RUST_ISIZE #if defined(_WIN32) using isize = SSIZE_T; #else using isize = ssize_t; #endif -#endif // CXXBRIDGE04_RUST_ISIZE +#endif // CXXBRIDGE05_RUST_ISIZE std::ostream &operator<<(std::ostream &, const String &); std::ostream &operator<<(std::ostream &, const Str &); @@ -287,11 +287,11 @@ using try_fn = TryFn; //////////////////////////////////////////////////////////////////////////////// /// end public API, begin implementation details -#ifndef CXXBRIDGE04_PANIC -#define CXXBRIDGE04_PANIC +#ifndef CXXBRIDGE05_PANIC +#define CXXBRIDGE05_PANIC template void panic [[noreturn]] (const char *msg); -#endif // CXXBRIDGE04_PANIC +#endif // CXXBRIDGE05_PANIC template Ret Fn::operator()(Args... args) const noexcept(!Throws) { @@ -303,17 +303,17 @@ Fn Fn::operator*() const noexcept { return *this; } -#ifndef CXXBRIDGE04_RUST_BITCOPY -#define CXXBRIDGE04_RUST_BITCOPY +#ifndef CXXBRIDGE05_RUST_BITCOPY +#define CXXBRIDGE05_RUST_BITCOPY struct unsafe_bitcopy_t { explicit unsafe_bitcopy_t() = default; }; constexpr unsafe_bitcopy_t unsafe_bitcopy{}; -#endif // CXXBRIDGE04_RUST_BITCOPY +#endif // CXXBRIDGE05_RUST_BITCOPY -#ifndef CXXBRIDGE04_RUST_SLICE -#define CXXBRIDGE04_RUST_SLICE +#ifndef CXXBRIDGE05_RUST_SLICE +#define CXXBRIDGE05_RUST_SLICE template Slice::Slice() noexcept : repr(Repr{reinterpret_cast(this), 0}) {} @@ -351,10 +351,10 @@ template Slice::operator Repr() noexcept { return this->repr; } -#endif // CXXBRIDGE04_RUST_SLICE +#endif // CXXBRIDGE05_RUST_SLICE -#ifndef CXXBRIDGE04_RUST_BOX -#define CXXBRIDGE04_RUST_BOX +#ifndef CXXBRIDGE05_RUST_BOX +#define CXXBRIDGE05_RUST_BOX template Box::Box(const Box &other) : Box(*other) {} @@ -450,10 +450,10 @@ T *Box::into_raw() noexcept { template Box::Box() noexcept {} -#endif // CXXBRIDGE04_RUST_BOX +#endif // CXXBRIDGE05_RUST_BOX -#ifndef CXXBRIDGE04_RUST_VEC -#define CXXBRIDGE04_RUST_VEC +#ifndef CXXBRIDGE05_RUST_VEC +#define CXXBRIDGE05_RUST_VEC template Vec::Vec(Vec &&other) noexcept { this->repr = other.repr; @@ -558,7 +558,7 @@ typename Vec::const_iterator Vec::end() const noexcept { // Internal API only intended for the cxxbridge code generator. template Vec::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {} -#endif // CXXBRIDGE04_RUST_VEC +#endif // CXXBRIDGE05_RUST_VEC -} // namespace cxxbridge04 +} // namespace cxxbridge05 } // namespace rust diff --git a/macro/src/expand.rs b/macro/src/expand.rs index dd5350fe..20f166f7 100644 --- a/macro/src/expand.rs +++ b/macro/src/expand.rs @@ -727,7 +727,7 @@ fn type_id(namespace: &Namespace, ident: &Ident) -> TokenStream { } fn expand_rust_box(namespace: &Namespace, ident: &Ident) -> TokenStream { - let link_prefix = format!("cxxbridge04$box${}{}$", namespace, ident); + let link_prefix = format!("cxxbridge05$box${}{}$", namespace, ident); let link_uninit = format!("{}uninit", link_prefix); let link_drop = format!("{}drop", link_prefix); @@ -756,7 +756,7 @@ fn expand_rust_box(namespace: &Namespace, ident: &Ident) -> TokenStream { } fn expand_rust_vec(namespace: &Namespace, elem: &Ident) -> TokenStream { - let link_prefix = format!("cxxbridge04$rust_vec${}{}$", namespace, elem); + let link_prefix = format!("cxxbridge05$rust_vec${}{}$", namespace, elem); let link_new = format!("{}new", link_prefix); let link_drop = format!("{}drop", link_prefix); let link_len = format!("{}len", link_prefix); @@ -807,7 +807,7 @@ fn expand_unique_ptr( explicit_impl: Option<&Impl>, ) -> TokenStream { let name = ident.to_string(); - let prefix = format!("cxxbridge04$unique_ptr${}{}$", namespace, ident); + let prefix = format!("cxxbridge05$unique_ptr${}{}$", namespace, ident); let link_null = format!("{}null", prefix); let link_new = format!("{}new", prefix); let link_raw = format!("{}raw", prefix); @@ -890,10 +890,10 @@ fn expand_cxx_vector( ) -> TokenStream { let _ = explicit_impl; let name = elem.to_string(); - let prefix = format!("cxxbridge04$std$vector${}{}$", namespace, elem); + let prefix = format!("cxxbridge05$std$vector${}{}$", namespace, elem); let link_size = format!("{}size", prefix); let link_get_unchecked = format!("{}get_unchecked", prefix); - let unique_ptr_prefix = format!("cxxbridge04$unique_ptr$std$vector${}{}$", namespace, elem); + let unique_ptr_prefix = format!("cxxbridge05$unique_ptr$std$vector${}{}$", namespace, elem); let link_unique_ptr_null = format!("{}null", unique_ptr_prefix); let link_unique_ptr_raw = format!("{}raw", unique_ptr_prefix); let link_unique_ptr_get = format!("{}get", unique_ptr_prefix); diff --git a/src/cxx.cc b/src/cxx.cc index cd751626..715e0ce1 100644 --- a/src/cxx.cc +++ b/src/cxx.cc @@ -7,30 +7,30 @@ #include extern "C" { -const char *cxxbridge04$cxx_string$data(const std::string &s) noexcept { +const char *cxxbridge05$cxx_string$data(const std::string &s) noexcept { return s.data(); } -size_t cxxbridge04$cxx_string$length(const std::string &s) noexcept { +size_t cxxbridge05$cxx_string$length(const std::string &s) noexcept { return s.length(); } // rust::String -void cxxbridge04$string$new(rust::String *self) noexcept; -void cxxbridge04$string$clone(rust::String *self, +void cxxbridge05$string$new(rust::String *self) noexcept; +void cxxbridge05$string$clone(rust::String *self, const rust::String &other) noexcept; -bool cxxbridge04$string$from(rust::String *self, const char *ptr, +bool cxxbridge05$string$from(rust::String *self, const char *ptr, size_t len) noexcept; -void cxxbridge04$string$drop(rust::String *self) noexcept; -const char *cxxbridge04$string$ptr(const rust::String *self) noexcept; -size_t cxxbridge04$string$len(const rust::String *self) noexcept; +void cxxbridge05$string$drop(rust::String *self) noexcept; +const char *cxxbridge05$string$ptr(const rust::String *self) noexcept; +size_t cxxbridge05$string$len(const rust::String *self) noexcept; // rust::Str -bool cxxbridge04$str$valid(const char *ptr, size_t len) noexcept; +bool cxxbridge05$str$valid(const char *ptr, size_t len) noexcept; } // extern "C" namespace rust { -inline namespace cxxbridge04 { +inline namespace cxxbridge05 { template void panic [[noreturn]] (const char *msg) { @@ -44,42 +44,42 @@ void panic [[noreturn]] (const char *msg) { template void panic[[noreturn]] (const char *msg); -String::String() noexcept { cxxbridge04$string$new(this); } +String::String() noexcept { cxxbridge05$string$new(this); } String::String(const String &other) noexcept { - cxxbridge04$string$clone(this, other); + cxxbridge05$string$clone(this, other); } String::String(String &&other) noexcept { this->repr = other.repr; - cxxbridge04$string$new(&other); + cxxbridge05$string$new(&other); } -String::~String() noexcept { cxxbridge04$string$drop(this); } +String::~String() noexcept { cxxbridge05$string$drop(this); } String::String(const std::string &s) : String(s.data(), s.length()) {} String::String(const char *s) : String(s, std::strlen(s)) {} String::String(const char *s, size_t len) { - if (!cxxbridge04$string$from(this, s, len)) { + if (!cxxbridge05$string$from(this, s, len)) { panic("data for rust::String is not utf-8"); } } String &String::operator=(const String &other) noexcept { if (this != &other) { - cxxbridge04$string$drop(this); - cxxbridge04$string$clone(this, other); + cxxbridge05$string$drop(this); + cxxbridge05$string$clone(this, other); } return *this; } String &String::operator=(String &&other) noexcept { if (this != &other) { - cxxbridge04$string$drop(this); + cxxbridge05$string$drop(this); this->repr = other.repr; - cxxbridge04$string$new(&other); + cxxbridge05$string$new(&other); } return *this; } @@ -89,12 +89,12 @@ String::operator std::string() const { } const char *String::data() const noexcept { - return cxxbridge04$string$ptr(this); + return cxxbridge05$string$ptr(this); } -size_t String::size() const noexcept { return cxxbridge04$string$len(this); } +size_t String::size() const noexcept { return cxxbridge05$string$len(this); } -size_t String::length() const noexcept { return cxxbridge04$string$len(this); } +size_t String::length() const noexcept { return cxxbridge05$string$len(this); } String::String(unsafe_bitcopy_t, const String &bits) noexcept : repr(bits.repr) {} @@ -113,7 +113,7 @@ Str::Str(const std::string &s) : Str(s.data(), s.length()) {} Str::Str(const char *s) : Str(s, std::strlen(s)) {} Str::Str(const char *s, size_t len) : repr(Repr{s, len}) { - if (!cxxbridge04$str$valid(this->repr.ptr, this->repr.len)) { + if (!cxxbridge05$str$valid(this->repr.ptr, this->repr.len)) { panic("data for rust::Str is not utf-8"); } } @@ -143,7 +143,7 @@ std::ostream &operator<<(std::ostream &os, const Str &s) { } extern "C" { -const char *cxxbridge04$error(const char *ptr, size_t len) { +const char *cxxbridge05$error(const char *ptr, size_t len) { char *copy = new char[len]; strncpy(copy, ptr, len); return copy; @@ -153,7 +153,7 @@ const char *cxxbridge04$error(const char *ptr, size_t len) { Error::Error(Str::Repr msg) noexcept : msg(msg) {} Error::Error(const Error &other) { - this->msg.ptr = cxxbridge04$error(other.msg.ptr, other.msg.len); + this->msg.ptr = cxxbridge05$error(other.msg.ptr, other.msg.len); this->msg.len = other.msg.len; } @@ -168,96 +168,96 @@ Error::~Error() noexcept { delete[] this->msg.ptr; } const char *Error::what() const noexcept { return this->msg.ptr; } -} // namespace cxxbridge04 +} // namespace cxxbridge05 } // namespace rust extern "C" { -void cxxbridge04$unique_ptr$std$string$null( +void cxxbridge05$unique_ptr$std$string$null( std::unique_ptr *ptr) noexcept { new (ptr) std::unique_ptr(); } -void cxxbridge04$unique_ptr$std$string$raw(std::unique_ptr *ptr, +void cxxbridge05$unique_ptr$std$string$raw(std::unique_ptr *ptr, std::string *raw) noexcept { new (ptr) std::unique_ptr(raw); } -const std::string *cxxbridge04$unique_ptr$std$string$get( +const std::string *cxxbridge05$unique_ptr$std$string$get( const std::unique_ptr &ptr) noexcept { return ptr.get(); } -std::string *cxxbridge04$unique_ptr$std$string$release( +std::string *cxxbridge05$unique_ptr$std$string$release( std::unique_ptr &ptr) noexcept { return ptr.release(); } -void cxxbridge04$unique_ptr$std$string$drop( +void cxxbridge05$unique_ptr$std$string$drop( std::unique_ptr *ptr) noexcept { ptr->~unique_ptr(); } } // extern "C" #define STD_VECTOR_OPS(RUST_TYPE, CXX_TYPE) \ - size_t cxxbridge04$std$vector$##RUST_TYPE##$size( \ + size_t cxxbridge05$std$vector$##RUST_TYPE##$size( \ const std::vector &s) noexcept { \ return s.size(); \ } \ - const CXX_TYPE *cxxbridge04$std$vector$##RUST_TYPE##$get_unchecked( \ + const CXX_TYPE *cxxbridge05$std$vector$##RUST_TYPE##$get_unchecked( \ const std::vector &s, size_t pos) noexcept { \ return &s[pos]; \ } \ - void cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$null( \ + void cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$null( \ std::unique_ptr> *ptr) noexcept { \ new (ptr) std::unique_ptr>(); \ } \ - void cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$raw( \ + void cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$raw( \ std::unique_ptr> *ptr, \ std::vector *raw) noexcept { \ new (ptr) std::unique_ptr>(raw); \ } \ const std::vector \ - *cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$get( \ + *cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$get( \ const std::unique_ptr> &ptr) noexcept { \ return ptr.get(); \ } \ std::vector \ - *cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$release( \ + *cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$release( \ std::unique_ptr> &ptr) noexcept { \ return ptr.release(); \ } \ - void cxxbridge04$unique_ptr$std$vector$##RUST_TYPE##$drop( \ + void cxxbridge05$unique_ptr$std$vector$##RUST_TYPE##$drop( \ std::unique_ptr> *ptr) noexcept { \ ptr->~unique_ptr(); \ } #define RUST_VEC_EXTERNS(RUST_TYPE, CXX_TYPE) \ - void cxxbridge04$rust_vec$##RUST_TYPE##$new( \ + void cxxbridge05$rust_vec$##RUST_TYPE##$new( \ rust::Vec *ptr) noexcept; \ - void cxxbridge04$rust_vec$##RUST_TYPE##$drop( \ + void cxxbridge05$rust_vec$##RUST_TYPE##$drop( \ rust::Vec *ptr) noexcept; \ - size_t cxxbridge04$rust_vec$##RUST_TYPE##$len( \ + size_t cxxbridge05$rust_vec$##RUST_TYPE##$len( \ const rust::Vec *ptr) noexcept; \ - const CXX_TYPE *cxxbridge04$rust_vec$##RUST_TYPE##$data( \ + const CXX_TYPE *cxxbridge05$rust_vec$##RUST_TYPE##$data( \ const rust::Vec *ptr) noexcept; \ - size_t cxxbridge04$rust_vec$##RUST_TYPE##$stride() noexcept; + size_t cxxbridge05$rust_vec$##RUST_TYPE##$stride() noexcept; #define RUST_VEC_OPS(RUST_TYPE, CXX_TYPE) \ template <> \ Vec::Vec() noexcept { \ - cxxbridge04$rust_vec$##RUST_TYPE##$new(this); \ + cxxbridge05$rust_vec$##RUST_TYPE##$new(this); \ } \ template <> \ void Vec::drop() noexcept { \ - return cxxbridge04$rust_vec$##RUST_TYPE##$drop(this); \ + return cxxbridge05$rust_vec$##RUST_TYPE##$drop(this); \ } \ template <> \ size_t Vec::size() const noexcept { \ - return cxxbridge04$rust_vec$##RUST_TYPE##$len(this); \ + return cxxbridge05$rust_vec$##RUST_TYPE##$len(this); \ } \ template <> \ const CXX_TYPE *Vec::data() const noexcept { \ - return cxxbridge04$rust_vec$##RUST_TYPE##$data(this); \ + return cxxbridge05$rust_vec$##RUST_TYPE##$data(this); \ } \ template <> \ size_t Vec::stride() noexcept { \ - return cxxbridge04$rust_vec$##RUST_TYPE##$stride(); \ + return cxxbridge05$rust_vec$##RUST_TYPE##$stride(); \ } // Usize and isize are the same type as one of the below. @@ -290,7 +290,7 @@ FOR_EACH_RUST_VEC(RUST_VEC_EXTERNS) } // extern "C" namespace rust { -inline namespace cxxbridge04 { +inline namespace cxxbridge05 { FOR_EACH_RUST_VEC(RUST_VEC_OPS) -} // namespace cxxbridge04 +} // namespace cxxbridge05 } // namespace rust diff --git a/src/cxx_string.rs b/src/cxx_string.rs index 2c712f13..7b47feb7 100644 --- a/src/cxx_string.rs +++ b/src/cxx_string.rs @@ -5,9 +5,9 @@ use core::slice; use core::str::{self, Utf8Error}; extern "C" { - #[link_name = "cxxbridge04$cxx_string$data"] + #[link_name = "cxxbridge05$cxx_string$data"] fn string_data(_: &CxxString) -> *const u8; - #[link_name = "cxxbridge04$cxx_string$length"] + #[link_name = "cxxbridge05$cxx_string$length"] fn string_length(_: &CxxString) -> usize; } diff --git a/src/cxx_vector.rs b/src/cxx_vector.rs index a5fe5365..5fb08071 100644 --- a/src/cxx_vector.rs +++ b/src/cxx_vector.rs @@ -157,7 +157,7 @@ macro_rules! impl_vector_element { fn __vector_size(v: &CxxVector<$ty>) -> usize { extern "C" { attr! { - #[link_name = concat!("cxxbridge04$std$vector$", $segment, "$size")] + #[link_name = concat!("cxxbridge05$std$vector$", $segment, "$size")] fn __vector_size(_: &CxxVector<$ty>) -> usize; } } @@ -166,7 +166,7 @@ macro_rules! impl_vector_element { unsafe fn __get_unchecked(v: &CxxVector<$ty>, pos: usize) -> *const $ty { extern "C" { attr! { - #[link_name = concat!("cxxbridge04$std$vector$", $segment, "$get_unchecked")] + #[link_name = concat!("cxxbridge05$std$vector$", $segment, "$get_unchecked")] fn __get_unchecked(_: &CxxVector<$ty>, _: usize) -> *const $ty; } } @@ -175,7 +175,7 @@ macro_rules! impl_vector_element { fn __unique_ptr_null() -> *mut c_void { extern "C" { attr! { - #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$null")] + #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$null")] fn __unique_ptr_null(this: *mut *mut c_void); } } @@ -186,7 +186,7 @@ macro_rules! impl_vector_element { unsafe fn __unique_ptr_raw(raw: *mut CxxVector) -> *mut c_void { extern "C" { attr! { - #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$raw")] + #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$raw")] fn __unique_ptr_raw(this: *mut *mut c_void, raw: *mut CxxVector<$ty>); } } @@ -197,7 +197,7 @@ macro_rules! impl_vector_element { unsafe fn __unique_ptr_get(repr: *mut c_void) -> *const CxxVector { extern "C" { attr! { - #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$get")] + #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$get")] fn __unique_ptr_get(this: *const *mut c_void) -> *const CxxVector<$ty>; } } @@ -206,7 +206,7 @@ macro_rules! impl_vector_element { unsafe fn __unique_ptr_release(mut repr: *mut c_void) -> *mut CxxVector { extern "C" { attr! { - #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$release")] + #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$release")] fn __unique_ptr_release(this: *mut *mut c_void) -> *mut CxxVector<$ty>; } } @@ -215,7 +215,7 @@ macro_rules! impl_vector_element { unsafe fn __unique_ptr_drop(mut repr: *mut c_void) { extern "C" { attr! { - #[link_name = concat!("cxxbridge04$unique_ptr$std$vector$", $segment, "$drop")] + #[link_name = concat!("cxxbridge05$unique_ptr$std$vector$", $segment, "$drop")] fn __unique_ptr_drop(this: *mut *mut c_void); } } diff --git a/src/result.rs b/src/result.rs index 296d4a22..fcced769 100644 --- a/src/result.rs +++ b/src/result.rs @@ -34,7 +34,7 @@ unsafe fn to_c_error(msg: String) -> Result { let len = msg.len(); extern "C" { - #[link_name = "cxxbridge04$error"] + #[link_name = "cxxbridge05$error"] fn error(ptr: *const u8, len: usize) -> *const u8; } diff --git a/src/symbols/exception.rs b/src/symbols/exception.rs index da1c3f91..b408f255 100644 --- a/src/symbols/exception.rs +++ b/src/symbols/exception.rs @@ -2,7 +2,7 @@ use alloc::boxed::Box; use alloc::string::String; use core::slice; -#[export_name = "cxxbridge04$exception"] +#[export_name = "cxxbridge05$exception"] unsafe extern "C" fn exception(ptr: *const u8, len: usize) -> *const u8 { let slice = slice::from_raw_parts(ptr, len); let boxed = String::from_utf8_lossy(slice).into_owned().into_boxed_str(); diff --git a/src/symbols/rust_str.rs b/src/symbols/rust_str.rs index 823173ae..b6553818 100644 --- a/src/symbols/rust_str.rs +++ b/src/symbols/rust_str.rs @@ -1,7 +1,7 @@ use core::slice; use core::str; -#[export_name = "cxxbridge04$str$valid"] +#[export_name = "cxxbridge05$str$valid"] unsafe extern "C" fn str_valid(ptr: *const u8, len: usize) -> bool { let slice = slice::from_raw_parts(ptr, len); str::from_utf8(slice).is_ok() diff --git a/src/symbols/rust_string.rs b/src/symbols/rust_string.rs index 774b8245..e5ab9eaa 100644 --- a/src/symbols/rust_string.rs +++ b/src/symbols/rust_string.rs @@ -5,17 +5,17 @@ use core::ptr; use core::slice; use core::str; -#[export_name = "cxxbridge04$string$new"] +#[export_name = "cxxbridge05$string$new"] unsafe extern "C" fn string_new(this: &mut MaybeUninit) { ptr::write(this.as_mut_ptr(), String::new()); } -#[export_name = "cxxbridge04$string$clone"] +#[export_name = "cxxbridge05$string$clone"] unsafe extern "C" fn string_clone(this: &mut MaybeUninit, other: &String) { ptr::write(this.as_mut_ptr(), other.clone()); } -#[export_name = "cxxbridge04$string$from"] +#[export_name = "cxxbridge05$string$from"] unsafe extern "C" fn string_from( this: &mut MaybeUninit, ptr: *const u8, @@ -31,17 +31,17 @@ unsafe extern "C" fn string_from( } } -#[export_name = "cxxbridge04$string$drop"] +#[export_name = "cxxbridge05$string$drop"] unsafe extern "C" fn string_drop(this: &mut ManuallyDrop) { ManuallyDrop::drop(this); } -#[export_name = "cxxbridge04$string$ptr"] +#[export_name = "cxxbridge05$string$ptr"] unsafe extern "C" fn string_ptr(this: &String) -> *const u8 { this.as_ptr() } -#[export_name = "cxxbridge04$string$len"] +#[export_name = "cxxbridge05$string$len"] unsafe extern "C" fn string_len(this: &String) -> usize { this.len() } diff --git a/src/symbols/rust_vec.rs b/src/symbols/rust_vec.rs index 2304abf1..00a7f166 100644 --- a/src/symbols/rust_vec.rs +++ b/src/symbols/rust_vec.rs @@ -11,31 +11,31 @@ macro_rules! rust_vec_shims { const _: () = { attr! { - #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$new")] + #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$new")] unsafe extern "C" fn __new(this: *mut RustVec<$ty>) { ptr::write(this, RustVec { repr: Vec::new() }); } } attr! { - #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$drop")] + #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$drop")] unsafe extern "C" fn __drop(this: *mut RustVec<$ty>) { ptr::drop_in_place(this); } } attr! { - #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$len")] + #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$len")] unsafe extern "C" fn __len(this: *const RustVec<$ty>) -> usize { (*this).repr.len() } } attr! { - #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$data")] + #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$data")] unsafe extern "C" fn __data(this: *const RustVec<$ty>) -> *const $ty { (*this).repr.as_ptr() } } attr! { - #[export_name = concat!("cxxbridge04$rust_vec$", $segment, "$stride")] + #[export_name = concat!("cxxbridge05$rust_vec$", $segment, "$stride")] unsafe extern "C" fn __stride() -> usize { mem::size_of::<$ty>() } diff --git a/src/unique_ptr.rs b/src/unique_ptr.rs index 7408d40b..477c7169 100644 --- a/src/unique_ptr.rs +++ b/src/unique_ptr.rs @@ -174,15 +174,15 @@ pub unsafe trait UniquePtrTarget { } extern "C" { - #[link_name = "cxxbridge04$unique_ptr$std$string$null"] + #[link_name = "cxxbridge05$unique_ptr$std$string$null"] fn unique_ptr_std_string_null(this: *mut *mut c_void); - #[link_name = "cxxbridge04$unique_ptr$std$string$raw"] + #[link_name = "cxxbridge05$unique_ptr$std$string$raw"] fn unique_ptr_std_string_raw(this: *mut *mut c_void, raw: *mut CxxString); - #[link_name = "cxxbridge04$unique_ptr$std$string$get"] + #[link_name = "cxxbridge05$unique_ptr$std$string$get"] fn unique_ptr_std_string_get(this: *const *mut c_void) -> *const CxxString; - #[link_name = "cxxbridge04$unique_ptr$std$string$release"] + #[link_name = "cxxbridge05$unique_ptr$std$string$release"] fn unique_ptr_std_string_release(this: *mut *mut c_void) -> *mut CxxString; - #[link_name = "cxxbridge04$unique_ptr$std$string$drop"] + #[link_name = "cxxbridge05$unique_ptr$std$string$drop"] fn unique_ptr_std_string_drop(this: *mut *mut c_void); } diff --git a/syntax/mangle.rs b/syntax/mangle.rs index 1c8c9178..72233b32 100644 --- a/syntax/mangle.rs +++ b/syntax/mangle.rs @@ -3,7 +3,7 @@ use crate::syntax::symbol::{self, Symbol}; use crate::syntax::ExternFn; use proc_macro2::Ident; -const CXXBRIDGE: &str = "cxxbridge04"; +const CXXBRIDGE: &str = "cxxbridge05"; macro_rules! join { ($($segment:expr),*) => { diff --git a/syntax/symbol.rs b/syntax/symbol.rs index c8500b91..1e5b5131 100644 --- a/syntax/symbol.rs +++ b/syntax/symbol.rs @@ -4,7 +4,7 @@ use quote::ToTokens; use std::fmt::{self, Display, Write}; // A mangled symbol consisting of segments separated by '$'. -// For example: cxxbridge04$string$new +// For example: cxxbridge05$string$new pub struct Symbol(String); impl Display for Symbol { diff --git a/tests/cxx_gen.rs b/tests/cxx_gen.rs index 139950e2..527d7090 100644 --- a/tests/cxx_gen.rs +++ b/tests/cxx_gen.rs @@ -18,7 +18,7 @@ fn test_extern_c_function() { let output = str::from_utf8(&generated.implementation).unwrap(); // To avoid continual breakage we won't test every byte. // Let's look for the major features. - assert!(output.contains("void cxxbridge04$do_cpp_thing(::rust::Str::Repr foo)")); + assert!(output.contains("void cxxbridge05$do_cpp_thing(::rust::Str::Repr foo)")); } #[test] @@ -28,5 +28,5 @@ fn test_impl_annotation() { let source = BRIDGE0.parse().unwrap(); let generated = generate_header_and_cc(source, &opt).unwrap(); let output = str::from_utf8(&generated.implementation).unwrap(); - assert!(output.contains("ANNOTATION void cxxbridge04$do_cpp_thing(::rust::Str::Repr foo)")); + assert!(output.contains("ANNOTATION void cxxbridge05$do_cpp_thing(::rust::Str::Repr foo)")); }