Commit 22fb0167 authored by Andrew Twyman's avatar Andrew Twyman

Merge branch 'github-master' into AT/WIP/EnumFix

# Conflicts:
#	test-suite/objc/DjinniObjcTest.xcodeproj/project.pbxproj
parents 20356700 f4ce7601
......@@ -145,7 +145,7 @@ class CppMarshal(spec: Spec) extends Marshal(spec) {
}
def base(m: Meta): String = m match {
case p: MPrimitive => p.cName
case MString => "std::string"
case MString => if (spec.cppUseWideStrings) "std::wstring" else "std::string"
case MDate => "std::chrono::system_clock::time_point"
case MBinary => "std::vector<uint8_t>"
case MOptional => spec.cppOptionalTemplate
......
......@@ -98,7 +98,7 @@ class JNIMarshal(spec: Spec) extends Marshal(spec) {
}
case MOptional => "Optional"
case MBinary => "Binary"
case MString => "String"
case MString => if (spec.cppUseWideStrings) "WString" else "String"
case MDate => "Date"
case MList => "List"
case MSet => "Set"
......
......@@ -35,6 +35,7 @@ object Main {
var cppNnHeader: Option[String] = None
var cppNnType: Option[String] = None
var cppNnCheckExpression: Option[String] = None
var cppUseWideStrings: Boolean = false
var javaOutFolder: Option[File] = None
var javaPackage: Option[String] = None
var javaCppException: Option[String] = None
......@@ -133,6 +134,8 @@ object Main {
.text("The type to use for non-nullable pointers (as a substitute for std::shared_ptr)")
opt[String]("cpp-nn-check-expression").valueName("<header>").foreach(x => cppNnCheckExpression = Some(x))
.text("The expression to use for building non-nullable pointers")
opt[Boolean]( "cpp-use-wide-strings").valueName("<true/false>").foreach(x => cppUseWideStrings = x)
.text("Use wide strings in C++ code (default: false)")
note("")
opt[File]("jni-out").valueName("<out-folder>").foreach(x => jniOutFolder = Some(x))
.text("The folder for the JNI C++ output files (Generator disabled if unspecified).")
......@@ -293,6 +296,7 @@ object Main {
cppNnHeader,
cppNnType,
cppNnCheckExpression,
cppUseWideStrings,
jniOutFolder,
jniHeaderOutFolder,
jniIncludePrefix,
......
......@@ -58,7 +58,7 @@ class ObjcMarshal(spec: Spec) extends Marshal(spec) {
List(ImportRef(include(d.name)))
case DInterface =>
val ext = d.body.asInstanceOf[Interface].ext
if (ext.cpp && !ext.objc) {
if (!ext.objc) {
List(ImportRef("<Foundation/Foundation.h>"), DeclRef(s"@class ${typename(d.name, d.body)};", None))
}
else {
......@@ -119,7 +119,7 @@ class ObjcMarshal(spec: Spec) extends Marshal(spec) {
case DRecord => (idObjc.ty(d.name), true)
case DInterface =>
val ext = d.body.asInstanceOf[Interface].ext
if (ext.cpp && !ext.objc)
if (!ext.objc)
(idObjc.ty(d.name), true)
else
(s"id<${idObjc.ty(d.name)}>", false)
......
......@@ -77,6 +77,7 @@ class ObjcppGenerator(spec: Spec) extends BaseObjcGenerator(spec) {
refs.privHeader.add("#include <memory>")
refs.privHeader.add("!#include " + q(spec.objcppIncludeCppPrefix + spec.cppFileIdentStyle(ident) + "." + spec.cppHeaderExt))
refs.body.add("!#import " + q(spec.objcppIncludeObjcPrefix + headerName(ident)))
refs.body.add("!#import " + q(spec.objcppIncludePrefix + objcppMarshal.privateHeaderName(ident.name)))
spec.cppNnHeader match {
case Some(nnHdr) => refs.privHeader.add("#include " + nnHdr)
......@@ -124,7 +125,6 @@ class ObjcppGenerator(spec: Spec) extends BaseObjcGenerator(spec) {
})
if (i.ext.cpp) {
refs.body.add("!#import " + q(spec.objcppIncludePrefix + objcppMarshal.privateHeaderName(ident.name)))
refs.body.add("#import " + q(spec.objcBaseLibIncludePrefix + "DJICppWrapperCache+Private.h"))
refs.body.add("#include <utility>")
refs.body.add("#import " + q(spec.objcBaseLibIncludePrefix + "DJIError.h"))
......@@ -133,7 +133,10 @@ class ObjcppGenerator(spec: Spec) extends BaseObjcGenerator(spec) {
if (i.ext.objc) {
refs.body.add("#import " + q(spec.objcBaseLibIncludePrefix + "DJIObjcWrapperCache+Private.h"))
refs.body.add("!#import " + q(spec.objcppIncludePrefix + objcppMarshal.privateHeaderName(ident.name)))
}
if (!i.ext.cpp && !i.ext.objc) {
refs.body.add("#import " + q(spec.objcBaseLibIncludePrefix + "DJIError.h"))
}
writeObjcFile(privateBodyName(ident.name), origin, refs.body, w => {
......@@ -253,7 +256,7 @@ class ObjcppGenerator(spec: Spec) extends BaseObjcGenerator(spec) {
// we don't have to do any casting at all, just access cppRef directly.
w.wl("return " + nnCheck("objc->_cppRefHandle.get()") + ";")
//w.wl(s"return ${spec.cppNnCheckExpression.getOrElse("")}(objc->_cppRefHandle.get());")
} else {
} else if (i.ext.cpp || i.ext.objc) {
// ObjC only, or ObjC and C++.
if (i.ext.cpp) {
// If it could be implemented in C++, we might have to unwrap a proxy object.
......@@ -264,6 +267,9 @@ class ObjcppGenerator(spec: Spec) extends BaseObjcGenerator(spec) {
}
val getProxyExpr = s"::djinni::get_objc_proxy<ObjcProxy>(objc)"
w.wl(s"return ${nnCheck(getProxyExpr)};")
} else {
// Neither ObjC nor C++. Unusable, but generate compilable code.
w.wl("DJINNI_UNIMPLEMENTED(@\"Interface not implementable in any language.\");")
}
}
w.wl
......@@ -276,7 +282,7 @@ class ObjcppGenerator(spec: Spec) extends BaseObjcGenerator(spec) {
// ObjC only. In this case we *must* unwrap a proxy object - the dynamic_cast will
// throw bad_cast if we gave it something of the wrong type.
w.wl(s"return dynamic_cast<ObjcProxy&>(*cpp).Handle::get();")
} else {
} else if (i.ext.objc || i.ext.cpp) {
// C++ only, or C++ and ObjC.
if (i.ext.objc) {
// If it could be implemented in ObjC, we might have to unwrap a proxy object.
......@@ -285,6 +291,9 @@ class ObjcppGenerator(spec: Spec) extends BaseObjcGenerator(spec) {
}
}
w.wl(s"return ::djinni::get_cpp_proxy<$objcSelf>(cpp);")
} else {
// Neither ObjC nor C++. Unusable, but generate compilable code.
w.wl("DJINNI_UNIMPLEMENTED(@\"Interface not implementable in any language.\");")
}
}
})
......
......@@ -74,7 +74,7 @@ class ObjcppMarshal(spec: Spec) extends Marshal(spec) {
case MOptional => "Optional"
case MBinary => "Binary"
case MDate => "Date"
case MString => "String"
case MString => if (spec.cppUseWideStrings) "WString" else "String"
case MList => "List"
case MSet => "Set"
case MMap => "Map"
......
......@@ -49,6 +49,7 @@ package object generatorTools {
cppNnHeader: Option[String],
cppNnType: Option[String],
cppNnCheckExpression: Option[String],
cppUseWideStrings: Boolean,
jniOutFolder: Option[File],
jniHeaderOutFolder: Option[File],
jniIncludePrefix: String,
......
......@@ -178,6 +178,25 @@ namespace djinni
}
};
struct WString
{
using CppType = std::wstring;
using JniType = jstring;
using Boxed = WString;
static CppType toCpp(JNIEnv* jniEnv, JniType j)
{
assert(j != nullptr);
return jniWStringFromString(jniEnv, j);
}
static LocalRef<JniType> fromCpp(JNIEnv* jniEnv, const CppType& c)
{
return {jniEnv, jniStringFromWString(jniEnv, c)};
}
};
struct Binary
{
using CppType = std::vector<uint8_t>;
......
......@@ -371,6 +371,46 @@ jstring jniStringFromUTF8(JNIEnv * env, const std::string & str) {
return res;
}
template<int wcharTypeSize>
static std::u16string implWStringToUTF16(std::wstring::const_iterator, std::wstring::const_iterator)
{
static_assert(wcharTypeSize == 2 || wcharTypeSize == 4, "wchar_t must be represented by UTF-16 or UTF-32 encoding");
return {}; // unreachable
}
template<>
inline std::u16string implWStringToUTF16<2>(std::wstring::const_iterator begin, std::wstring::const_iterator end) {
// case when wchar_t is represented by utf-16 encoding
return std::u16string(begin, end);
}
template<>
inline std::u16string implWStringToUTF16<4>(std::wstring::const_iterator begin, std::wstring::const_iterator end) {
// case when wchar_t is represented by utf-32 encoding
std::u16string utf16;
utf16.reserve(std::distance(begin, end));
for(; begin != end; ++begin)
utf16_encode(static_cast<char32_t>(*begin), utf16);
return utf16;
}
inline std::u16string wstringToUTF16(const std::wstring & str) {
// hide "defined but not used" warnings
(void)implWStringToUTF16<2>;
(void)implWStringToUTF16<4>;
// Note: The template helper operates on iterators to work around a compiler issue we saw on Mac.
// It triggered undefined symbols if wstring methods were called directly in the template function.
return implWStringToUTF16<sizeof(wchar_t)>(str.cbegin(), str.cend());
}
jstring jniStringFromWString(JNIEnv * env, const std::wstring & str) {
std::u16string utf16 = wstringToUTF16(str);
jstring res = env->NewString(
reinterpret_cast<const jchar *>(utf16.data()), utf16.length());
DJINNI_ASSERT(res, env);
return res;
}
// UTF-16 decode helpers.
static inline bool is_high_surrogate(char16_t c) { return (c >= 0xD800) && (c < 0xDC00); }
static inline bool is_low_surrogate(char16_t c) { return (c >= 0xDC00) && (c < 0xE000); }
......@@ -378,7 +418,7 @@ static inline bool is_low_surrogate(char16_t c) { return (c >= 0xDC00) && (c <
/*
* Like utf8_decode_check, but for UTF-16.
*/
static offset_pt utf16_decode_check(const std::u16string & str, std::u16string::size_type i) {
static offset_pt utf16_decode_check(const char16_t * str, std::u16string::size_type i) {
if (is_high_surrogate(str[i]) && is_low_surrogate(str[i+1])) {
// High surrogate followed by low surrogate
char32_t pt = (((str[i] - 0xD800) << 10) | (str[i+1] - 0xDC00)) + 0x10000;
......@@ -391,7 +431,7 @@ static offset_pt utf16_decode_check(const std::u16string & str, std::u16string::
}
}
static char32_t utf16_decode(const std::u16string & str, std::u16string::size_type & i) {
static char32_t utf16_decode(const char16_t * str, std::u16string::size_type & i) {
offset_pt res = utf16_decode_check(str, i);
if (res.offset < 0) {
i += 1;
......@@ -437,10 +477,52 @@ std::string jniUTF8FromString(JNIEnv * env, const jstring jstr) {
std::string out;
out.reserve(str.length() * 3 / 2); // estimate
for (std::u16string::size_type i = 0; i < str.length(); )
utf8_encode(utf16_decode(str, i), out);
utf8_encode(utf16_decode(str.data(), i), out);
return out;
}
template<int wcharTypeSize>
static std::wstring implUTF16ToWString(const char16_t * data, size_t length)
{
static_assert(wcharTypeSize == 2 || wcharTypeSize == 4, "wchar_t must be represented by UTF-16 or UTF-32 encoding");
return {}; // unreachable
}
template<>
inline std::wstring implUTF16ToWString<2>(const char16_t * data, size_t length) {
// case when wchar_t is represented by utf-16 encoding
return std::wstring(data, data + length);
}
template<>
inline std::wstring implUTF16ToWString<4>(const char16_t * data, size_t length) {
// case when wchar_t is represented by utf-32 encoding
std::wstring result;
result.reserve(length);
for (size_t i = 0; i < length; )
result += static_cast<wchar_t>(utf16_decode(data, i));
return result;
}
inline std::wstring UTF16ToWString(const char16_t * data, size_t length) {
// hide "defined but not used" warnings
(void)implUTF16ToWString<2>;
(void)implUTF16ToWString<4>;
return implUTF16ToWString<sizeof(wchar_t)>(data, length);
}
std::wstring jniWStringFromString(JNIEnv * env, const jstring jstr) {
DJINNI_ASSERT(jstr, env);
const jsize length = env->GetStringLength(jstr);
jniExceptionCheck(env);
const auto deleter = [env, jstr] (const jchar * c) { env->ReleaseStringChars(jstr, c); };
std::unique_ptr<const jchar, decltype(deleter)> ptr(env->GetStringChars(jstr, nullptr),
deleter);
const char16_t * data = reinterpret_cast<const char16_t *>(ptr.get());
return UTF16ToWString(data, length);
}
DJINNI_WEAK_DEFINITION
void jniSetPendingFromCurrent(JNIEnv * env, const char * ctx) noexcept {
jniDefaultSetPendingFromCurrent(env, ctx);
......
......@@ -543,6 +543,9 @@ private:
jstring jniStringFromUTF8(JNIEnv * env, const std::string & str);
std::string jniUTF8FromString(JNIEnv * env, const jstring jstr);
jstring jniStringFromWString(JNIEnv * env, const std::wstring & str);
std::wstring jniWStringFromString(JNIEnv * env, const jstring jstr);
class JniEnum {
public:
/*
......
......@@ -18,11 +18,17 @@
namespace djinni {
// Throws an exception for an unimplemented method call.
[[noreturn]] void throwUnimplemented(const char * ctx, NSString * msg);
// Helper function for exception translation. Do not call directly!
[[noreturn]] void throwNSExceptionFromCurrent(const char * ctx);
} // namespace djinni
#define DJINNI_UNIMPLEMENTED(msg) \
::djinni::throwUnimplemented(__PRETTY_FUNCTION__, msg);
#define DJINNI_TRANSLATE_EXCEPTIONS() \
catch (const std::exception & e) { \
::djinni::throwNSExceptionFromCurrent(__PRETTY_FUNCTION__); \
......
......@@ -21,6 +21,11 @@ static_assert(__has_feature(objc_arc), "Djinni requires ARC to be enabled for th
namespace djinni {
[[noreturn]] __attribute__((weak)) void throwUnimplemented(const char * /*ctx*/, NSString * message) {
[NSException raise:NSInternalInconsistencyException format:@"Unimplemented: %@", message];
__builtin_unreachable();
}
[[noreturn]] __attribute__((weak)) void throwNSExceptionFromCurrent(const char * /*ctx*/) {
try {
throw;
......
......@@ -118,6 +118,54 @@ struct String {
}
};
template<int wcharTypeSize>
static CFStringEncoding getWCharEncoding()
{
static_assert(wcharTypeSize == 2 || wcharTypeSize == 4, "wchar_t must be represented by UTF-16 or UTF-32 encoding");
return {}; // unreachable
}
template<>
inline CFStringEncoding getWCharEncoding<2>() {
// case when wchar_t is represented by utf-16 encoding
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
return NSUTF16BigEndianStringEncoding;
#else
return NSUTF16LittleEndianStringEncoding;
#endif
}
template<>
inline CFStringEncoding getWCharEncoding<4>() {
// case when wchar_t is represented by utf-32 encoding
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
return NSUTF32BigEndianStringEncoding;
#else
return NSUTF32LittleEndianStringEncoding;
#endif
}
struct WString {
using CppType = std::wstring;
using ObjcType = NSString*;
using Boxed = WString;
static CppType toCpp(ObjcType string) {
assert(string);
NSStringEncoding encoding = CFStringConvertEncodingToNSStringEncoding(getWCharEncoding<sizeof(wchar_t)>());
NSData* data = [string dataUsingEncoding:encoding];
return std::wstring((wchar_t*)[data bytes], [data length] / sizeof (wchar_t));
}
static ObjcType fromCpp(const CppType& string) {
assert(string.size() <= std::numeric_limits<NSUInteger>::max());
return [[NSString alloc] initWithBytes:string.data()
length:string.size() * sizeof(wchar_t)
encoding:getWCharEncoding<sizeof(wchar_t)>()];
}
};
struct Date {
using CppType = std::chrono::system_clock::time_point;
using ObjcType = NSDate*;
......
......@@ -5,5 +5,7 @@ java_only_listener = interface +j {}
# on references to interfaces they don't need.
uses_single_language_listeners = interface +o +j +c {
callForObjC(l: objc_only_listener);
returnForObjC(): objc_only_listener;
callForJava(l: java_only_listener);
returnForJava(): java_only_listener;
}
wchar_test_rec = record {
s: string;
}
wchar_test_helpers = interface +c {
static get_record() : wchar_test_rec;
static get_string() : string;
static check_string(str: string) : bool;
static check_record(rec: wchar_test_rec) : bool;
}
......@@ -20,7 +20,11 @@ public:
virtual void callForObjC(const std::shared_ptr<ObjcOnlyListener> & l) = 0;
virtual std::shared_ptr<ObjcOnlyListener> returnForObjC() = 0;
virtual void callForJava(const std::shared_ptr<JavaOnlyListener> & l) = 0;
virtual std::shared_ptr<JavaOnlyListener> returnForJava() = 0;
};
} // namespace testsuite
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#pragma once
#include <string>
namespace testsuite {
struct WcharTestRec;
class WcharTestHelpers {
public:
virtual ~WcharTestHelpers() {}
static WcharTestRec get_record();
static std::wstring get_string();
static bool check_string(const std::wstring & str);
static bool check_record(const WcharTestRec & rec);
};
} // namespace testsuite
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#pragma once
#include <string>
#include <utility>
namespace testsuite {
struct WcharTestRec final {
std::wstring s;
WcharTestRec(std::wstring s_)
: s(std::move(s_))
{}
};
} // namespace testsuite
......@@ -14,8 +14,14 @@ import javax.annotation.Nonnull;
public abstract class UsesSingleLanguageListeners {
public abstract void callForObjC(@CheckForNull ObjcOnlyListener l);
@CheckForNull
public abstract ObjcOnlyListener returnForObjC();
public abstract void callForJava(@CheckForNull JavaOnlyListener l);
@CheckForNull
public abstract JavaOnlyListener returnForJava();
private static final class CppProxy extends UsesSingleLanguageListeners
{
private final long nativeRef;
......@@ -47,6 +53,14 @@ public abstract class UsesSingleLanguageListeners {
}
private native void native_callForObjC(long _nativeRef, ObjcOnlyListener l);
@Override
public ObjcOnlyListener returnForObjC()
{
assert !this.destroyed.get() : "trying to use a destroyed object";
return native_returnForObjC(this.nativeRef);
}
private native ObjcOnlyListener native_returnForObjC(long _nativeRef);
@Override
public void callForJava(JavaOnlyListener l)
{
......@@ -54,5 +68,13 @@ public abstract class UsesSingleLanguageListeners {
native_callForJava(this.nativeRef, l);
}
private native void native_callForJava(long _nativeRef, JavaOnlyListener l);
@Override
public JavaOnlyListener returnForJava()
{
assert !this.destroyed.get() : "trying to use a destroyed object";
return native_returnForJava(this.nativeRef);
}
private native JavaOnlyListener native_returnForJava(long _nativeRef);
}
}
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
package com.dropbox.djinni.test;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
public abstract class WcharTestHelpers {
@Nonnull
public static native WcharTestRec getRecord();
@Nonnull
public static native String getString();
public static native boolean checkString(@Nonnull String str);
public static native boolean checkRecord(@Nonnull WcharTestRec rec);
private static final class CppProxy extends WcharTestHelpers
{
private final long nativeRef;
private final AtomicBoolean destroyed = new AtomicBoolean(false);
private CppProxy(long nativeRef)
{
if (nativeRef == 0) throw new RuntimeException("nativeRef is zero");
this.nativeRef = nativeRef;
}
private native void nativeDestroy(long nativeRef);
public void destroy()
{
boolean destroyed = this.destroyed.getAndSet(true);
if (!destroyed) nativeDestroy(this.nativeRef);
}
protected void finalize() throws java.lang.Throwable
{
destroy();
super.finalize();
}
}
}
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
package com.dropbox.djinni.test;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
public class WcharTestRec {
/*package*/ final String mS;
public WcharTestRec(
@Nonnull String s) {
this.mS = s;
}
@Nonnull
public String getS() {
return mS;
}
@Override
public String toString() {
return "WcharTestRec{" +
"mS=" + mS +
"}";
}
}
......@@ -23,6 +23,14 @@ void NativeUsesSingleLanguageListeners::JavaProxy::callForObjC(const std::shared
::djinni::get(::djinni_generated::NativeObjcOnlyListener::fromCpp(jniEnv, c_l)));
::djinni::jniExceptionCheck(jniEnv);
}
std::shared_ptr<::testsuite::ObjcOnlyListener> NativeUsesSingleLanguageListeners::JavaProxy::returnForObjC() {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
const auto& data = ::djinni::JniClass<::djinni_generated::NativeUsesSingleLanguageListeners>::get();
auto jret = jniEnv->CallObjectMethod(Handle::get().get(), data.method_returnForObjC);
::djinni::jniExceptionCheck(jniEnv);
return ::djinni_generated::NativeObjcOnlyListener::toCpp(jniEnv, jret);
}
void NativeUsesSingleLanguageListeners::JavaProxy::callForJava(const std::shared_ptr<::testsuite::JavaOnlyListener> & c_l) {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
......@@ -31,6 +39,14 @@ void NativeUsesSingleLanguageListeners::JavaProxy::callForJava(const std::shared
::djinni::get(::djinni_generated::NativeJavaOnlyListener::fromCpp(jniEnv, c_l)));
::djinni::jniExceptionCheck(jniEnv);
}
std::shared_ptr<::testsuite::JavaOnlyListener> NativeUsesSingleLanguageListeners::JavaProxy::returnForJava() {
auto jniEnv = ::djinni::jniGetThreadEnv();
::djinni::JniLocalScope jscope(jniEnv, 10);
const auto& data = ::djinni::JniClass<::djinni_generated::NativeUsesSingleLanguageListeners>::get();
auto jret = jniEnv->CallObjectMethod(Handle::get().get(), data.method_returnForJava);
::djinni::jniExceptionCheck(jniEnv);
return ::djinni_generated::NativeJavaOnlyListener::toCpp(jniEnv, jret);
}
CJNIEXPORT void JNICALL Java_com_dropbox_djinni_test_UsesSingleLanguageListeners_00024CppProxy_nativeDestroy(JNIEnv* jniEnv, jobject /*this*/, jlong nativeRef)
{
......@@ -49,6 +65,16 @@ CJNIEXPORT void JNICALL Java_com_dropbox_djinni_test_UsesSingleLanguageListeners
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, )
}
CJNIEXPORT jobject JNICALL Java_com_dropbox_djinni_test_UsesSingleLanguageListeners_00024CppProxy_native_1returnForObjC(JNIEnv* jniEnv, jobject /*this*/, jlong nativeRef)
{
try {
DJINNI_FUNCTION_PROLOGUE1(jniEnv, nativeRef);
const auto& ref = ::djinni::objectFromHandleAddress<::testsuite::UsesSingleLanguageListeners>(nativeRef);
auto r = ref->returnForObjC();
return ::djinni::release(::djinni_generated::NativeObjcOnlyListener::fromCpp(jniEnv, r));
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, 0 /* value doesn't matter */)
}
CJNIEXPORT void JNICALL Java_com_dropbox_djinni_test_UsesSingleLanguageListeners_00024CppProxy_native_1callForJava(JNIEnv* jniEnv, jobject /*this*/, jlong nativeRef, jobject j_l)
{
try {
......@@ -58,4 +84,14 @@ CJNIEXPORT void JNICALL Java_com_dropbox_djinni_test_UsesSingleLanguageListeners
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, )
}
CJNIEXPORT jobject JNICALL Java_com_dropbox_djinni_test_UsesSingleLanguageListeners_00024CppProxy_native_1returnForJava(JNIEnv* jniEnv, jobject /*this*/, jlong nativeRef)
{
try {
DJINNI_FUNCTION_PROLOGUE1(jniEnv, nativeRef);
const auto& ref = ::djinni::objectFromHandleAddress<::testsuite::UsesSingleLanguageListeners>(nativeRef);
auto r = ref->returnForJava();
return ::djinni::release(::djinni_generated::NativeJavaOnlyListener::fromCpp(jniEnv, r));
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, 0 /* value doesn't matter */)
}
} // namespace djinni_generated
......@@ -34,7 +34,9 @@ private:
~JavaProxy();
void callForObjC(const std::shared_ptr<::testsuite::ObjcOnlyListener> & l) override;
std::shared_ptr<::testsuite::ObjcOnlyListener> returnForObjC() override;
void callForJava(const std::shared_ptr<::testsuite::JavaOnlyListener> & l) override;
std::shared_ptr<::testsuite::JavaOnlyListener> returnForJava() override;
private:
friend ::djinni::JniInterface<::testsuite::UsesSingleLanguageListeners, ::djinni_generated::NativeUsesSingleLanguageListeners>;
......@@ -42,7 +44,9 @@ private:
const ::djinni::GlobalRef<jclass> clazz { ::djinni::jniFindClass("com/dropbox/djinni/test/UsesSingleLanguageListeners") };
const jmethodID method_callForObjC { ::djinni::jniGetMethodID(clazz.get(), "callForObjC", "(Lcom/dropbox/djinni/test/ObjcOnlyListener;)V") };
const jmethodID method_returnForObjC { ::djinni::jniGetMethodID(clazz.get(), "returnForObjC", "()Lcom/dropbox/djinni/test/ObjcOnlyListener;") };
const jmethodID method_callForJava { ::djinni::jniGetMethodID(clazz.get(), "callForJava", "(Lcom/dropbox/djinni/test/JavaOnlyListener;)V") };
const jmethodID method_returnForJava { ::djinni::jniGetMethodID(clazz.get(), "returnForJava", "()Lcom/dropbox/djinni/test/JavaOnlyListener;") };
};
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#include "NativeWcharTestHelpers.hpp" // my header
#include "Marshal.hpp"
#include "NativeWcharTestRec.hpp"
namespace djinni_generated {
NativeWcharTestHelpers::NativeWcharTestHelpers() : ::djinni::JniInterface<::testsuite::WcharTestHelpers, NativeWcharTestHelpers>("com/dropbox/djinni/test/WcharTestHelpers$CppProxy") {}
NativeWcharTestHelpers::~NativeWcharTestHelpers() = default;
CJNIEXPORT void JNICALL Java_com_dropbox_djinni_test_WcharTestHelpers_00024CppProxy_nativeDestroy(JNIEnv* jniEnv, jobject /*this*/, jlong nativeRef)
{
try {
DJINNI_FUNCTION_PROLOGUE1(jniEnv, nativeRef);
delete reinterpret_cast<::djinni::CppProxyHandle<::testsuite::WcharTestHelpers>*>(nativeRef);
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, )
}
CJNIEXPORT jobject JNICALL Java_com_dropbox_djinni_test_WcharTestHelpers_getRecord(JNIEnv* jniEnv, jobject /*this*/)
{
try {
DJINNI_FUNCTION_PROLOGUE0(jniEnv);
auto r = ::testsuite::WcharTestHelpers::get_record();
return ::djinni::release(::djinni_generated::NativeWcharTestRec::fromCpp(jniEnv, r));
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, 0 /* value doesn't matter */)
}
CJNIEXPORT jstring JNICALL Java_com_dropbox_djinni_test_WcharTestHelpers_getString(JNIEnv* jniEnv, jobject /*this*/)
{
try {
DJINNI_FUNCTION_PROLOGUE0(jniEnv);
auto r = ::testsuite::WcharTestHelpers::get_string();
return ::djinni::release(::djinni::WString::fromCpp(jniEnv, r));
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, 0 /* value doesn't matter */)
}
CJNIEXPORT jboolean JNICALL Java_com_dropbox_djinni_test_WcharTestHelpers_checkString(JNIEnv* jniEnv, jobject /*this*/, jstring j_str)
{
try {
DJINNI_FUNCTION_PROLOGUE0(jniEnv);
auto r = ::testsuite::WcharTestHelpers::check_string(::djinni::WString::toCpp(jniEnv, j_str));
return ::djinni::release(::djinni::Bool::fromCpp(jniEnv, r));
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, 0 /* value doesn't matter */)
}
CJNIEXPORT jboolean JNICALL Java_com_dropbox_djinni_test_WcharTestHelpers_checkRecord(JNIEnv* jniEnv, jobject /*this*/, jobject j_rec)
{
try {
DJINNI_FUNCTION_PROLOGUE0(jniEnv);
auto r = ::testsuite::WcharTestHelpers::check_record(::djinni_generated::NativeWcharTestRec::toCpp(jniEnv, j_rec));
return ::djinni::release(::djinni::Bool::fromCpp(jniEnv, r));
} JNI_TRANSLATE_EXCEPTIONS_RETURN(jniEnv, 0 /* value doesn't matter */)
}
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#pragma once
#include "djinni_support.hpp"
#include "wchar_test_helpers.hpp"
namespace djinni_generated {
class NativeWcharTestHelpers final : ::djinni::JniInterface<::testsuite::WcharTestHelpers, NativeWcharTestHelpers> {
public:
using CppType = std::shared_ptr<::testsuite::WcharTestHelpers>;
using CppOptType = std::shared_ptr<::testsuite::WcharTestHelpers>;
using JniType = jobject;
using Boxed = NativeWcharTestHelpers;
~NativeWcharTestHelpers();
static CppType toCpp(JNIEnv* jniEnv, JniType j) { return ::djinni::JniClass<NativeWcharTestHelpers>::get()._fromJava(jniEnv, j); }
static ::djinni::LocalRef<JniType> fromCppOpt(JNIEnv* jniEnv, const CppOptType& c) { return {jniEnv, ::djinni::JniClass<NativeWcharTestHelpers>::get()._toJava(jniEnv, c)}; }
static ::djinni::LocalRef<JniType> fromCpp(JNIEnv* jniEnv, const CppType& c) { return fromCppOpt(jniEnv, c); }
private:
NativeWcharTestHelpers();
friend ::djinni::JniClass<NativeWcharTestHelpers>;
friend ::djinni::JniInterface<::testsuite::WcharTestHelpers, NativeWcharTestHelpers>;
};
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#include "NativeWcharTestRec.hpp" // my header
#include "Marshal.hpp"
namespace djinni_generated {
NativeWcharTestRec::NativeWcharTestRec() = default;
NativeWcharTestRec::~NativeWcharTestRec() = default;
auto NativeWcharTestRec::fromCpp(JNIEnv* jniEnv, const CppType& c) -> ::djinni::LocalRef<JniType> {
const auto& data = ::djinni::JniClass<NativeWcharTestRec>::get();
auto r = ::djinni::LocalRef<JniType>{jniEnv->NewObject(data.clazz.get(), data.jconstructor,
::djinni::get(::djinni::WString::fromCpp(jniEnv, c.s)))};
::djinni::jniExceptionCheck(jniEnv);
return r;
}
auto NativeWcharTestRec::toCpp(JNIEnv* jniEnv, JniType j) -> CppType {
::djinni::JniLocalScope jscope(jniEnv, 2);
assert(j != nullptr);
const auto& data = ::djinni::JniClass<NativeWcharTestRec>::get();
return {::djinni::WString::toCpp(jniEnv, (jstring)jniEnv->GetObjectField(j, data.field_mS))};
}
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#pragma once
#include "djinni_support.hpp"
#include "wchar_test_rec.hpp"
namespace djinni_generated {
class NativeWcharTestRec final {
public:
using CppType = ::testsuite::WcharTestRec;
using JniType = jobject;
using Boxed = NativeWcharTestRec;
~NativeWcharTestRec();
static CppType toCpp(JNIEnv* jniEnv, JniType j);
static ::djinni::LocalRef<JniType> fromCpp(JNIEnv* jniEnv, const CppType& c);
private:
NativeWcharTestRec();
friend ::djinni::JniClass<NativeWcharTestRec>;
const ::djinni::GlobalRef<jclass> clazz { ::djinni::jniFindClass("com/dropbox/djinni/test/WcharTestRec") };
const jmethodID jconstructor { ::djinni::jniGetMethodID(clazz.get(), "<init>", "(Ljava/lang/String;)V") };
const jfieldID field_mS { ::djinni::jniGetFieldID(clazz.get(), "mS", "Ljava/lang/String;") };
};
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from single_language_interfaces.djinni
#import "DBJavaOnlyListener+Private.h"
#import "DBJavaOnlyListener.h"
#import "DJIError.h"
static_assert(__has_feature(objc_arc), "Djinni requires ARC to be enabled for this file");
......@@ -12,7 +14,7 @@ auto JavaOnlyListener::toCpp(ObjcType objc) -> CppType
if (!objc) {
return nullptr;
}
return ::djinni::get_objc_proxy<ObjcProxy>(objc);
DJINNI_UNIMPLEMENTED(@"Interface not implementable in any language.");
}
auto JavaOnlyListener::fromCppOpt(const CppOptType& cpp) -> ObjcType
......@@ -20,7 +22,7 @@ auto JavaOnlyListener::fromCppOpt(const CppOptType& cpp) -> ObjcType
if (!cpp) {
return nil;
}
return ::djinni::get_cpp_proxy<DBJavaOnlyListener>(cpp);
DJINNI_UNIMPLEMENTED(@"Interface not implementable in any language.");
}
} // namespace djinni_generated
......@@ -37,12 +37,26 @@ static_assert(__has_feature(objc_arc), "Djinni requires ARC to be enabled for th
} DJINNI_TRANSLATE_EXCEPTIONS()
}
- (void)callForJava:(nullable id<DBJavaOnlyListener>)l {
- (nullable id<DBObjcOnlyListener>)returnForObjC {
try {
auto r = _cppRefHandle.get()->returnForObjC();
return ::djinni_generated::ObjcOnlyListener::fromCpp(r);
} DJINNI_TRANSLATE_EXCEPTIONS()
}
- (void)callForJava:(nullable DBJavaOnlyListener *)l {
try {
_cppRefHandle.get()->callForJava(::djinni_generated::JavaOnlyListener::toCpp(l));
} DJINNI_TRANSLATE_EXCEPTIONS()
}
- (nullable DBJavaOnlyListener *)returnForJava {
try {
auto r = _cppRefHandle.get()->returnForJava();
return ::djinni_generated::JavaOnlyListener::fromCpp(r);
} DJINNI_TRANSLATE_EXCEPTIONS()
}
namespace djinni_generated {
class UsesSingleLanguageListeners::ObjcProxy final
......@@ -57,12 +71,26 @@ public:
[Handle::get() callForObjC:(::djinni_generated::ObjcOnlyListener::fromCpp(c_l))];
}
}
std::shared_ptr<::testsuite::ObjcOnlyListener> returnForObjC() override
{
@autoreleasepool {
auto r = [Handle::get() returnForObjC];
return ::djinni_generated::ObjcOnlyListener::toCpp(r);
}
}
void callForJava(const std::shared_ptr<::testsuite::JavaOnlyListener> & c_l) override
{
@autoreleasepool {
[Handle::get() callForJava:(::djinni_generated::JavaOnlyListener::fromCpp(c_l))];
}
}
std::shared_ptr<::testsuite::JavaOnlyListener> returnForJava() override
{
@autoreleasepool {
auto r = [Handle::get() returnForJava];
return ::djinni_generated::JavaOnlyListener::toCpp(r);
}
}
};
} // namespace djinni_generated
......
......@@ -2,7 +2,7 @@
// This file generated by Djinni from single_language_interfaces.djinni
#import <Foundation/Foundation.h>
@protocol DBJavaOnlyListener;
@class DBJavaOnlyListener;
@protocol DBObjcOnlyListener;
......@@ -14,6 +14,10 @@
- (void)callForObjC:(nullable id<DBObjcOnlyListener>)l;
- (void)callForJava:(nullable id<DBJavaOnlyListener>)l;
- (nullable id<DBObjcOnlyListener>)returnForObjC;
- (void)callForJava:(nullable DBJavaOnlyListener *)l;
- (nullable DBJavaOnlyListener *)returnForJava;
@end
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#include "wchar_test_helpers.hpp"
#include <memory>
static_assert(__has_feature(objc_arc), "Djinni requires ARC to be enabled for this file");
@class DBWcharTestHelpers;
namespace djinni_generated {
class WcharTestHelpers
{
public:
using CppType = std::shared_ptr<::testsuite::WcharTestHelpers>;
using CppOptType = std::shared_ptr<::testsuite::WcharTestHelpers>;
using ObjcType = DBWcharTestHelpers*;
using Boxed = WcharTestHelpers;
static CppType toCpp(ObjcType objc);
static ObjcType fromCppOpt(const CppOptType& cpp);
static ObjcType fromCpp(const CppType& cpp) { return fromCppOpt(cpp); }
private:
class ObjcProxy;
};
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#import "DBWcharTestHelpers+Private.h"
#import "DBWcharTestHelpers.h"
#import "DBWcharTestRec+Private.h"
#import "DJICppWrapperCache+Private.h"
#import "DJIError.h"
#import "DJIMarshal+Private.h"
#include <exception>
#include <utility>
static_assert(__has_feature(objc_arc), "Djinni requires ARC to be enabled for this file");
@interface DBWcharTestHelpers ()
- (id)initWithCpp:(const std::shared_ptr<::testsuite::WcharTestHelpers>&)cppRef;
@end
@implementation DBWcharTestHelpers {
::djinni::CppProxyCache::Handle<std::shared_ptr<::testsuite::WcharTestHelpers>> _cppRefHandle;
}
- (id)initWithCpp:(const std::shared_ptr<::testsuite::WcharTestHelpers>&)cppRef
{
if (self = [super init]) {
_cppRefHandle.assign(cppRef);
}
return self;
}
+ (nonnull DBWcharTestRec *)getRecord {
try {
auto r = ::testsuite::WcharTestHelpers::get_record();
return ::djinni_generated::WcharTestRec::fromCpp(r);
} DJINNI_TRANSLATE_EXCEPTIONS()
}
+ (nonnull NSString *)getString {
try {
auto r = ::testsuite::WcharTestHelpers::get_string();
return ::djinni::WString::fromCpp(r);
} DJINNI_TRANSLATE_EXCEPTIONS()
}
+ (BOOL)checkString:(nonnull NSString *)str {
try {
auto r = ::testsuite::WcharTestHelpers::check_string(::djinni::WString::toCpp(str));
return ::djinni::Bool::fromCpp(r);
} DJINNI_TRANSLATE_EXCEPTIONS()
}
+ (BOOL)checkRecord:(nonnull DBWcharTestRec *)rec {
try {
auto r = ::testsuite::WcharTestHelpers::check_record(::djinni_generated::WcharTestRec::toCpp(rec));
return ::djinni::Bool::fromCpp(r);
} DJINNI_TRANSLATE_EXCEPTIONS()
}
namespace djinni_generated {
auto WcharTestHelpers::toCpp(ObjcType objc) -> CppType
{
if (!objc) {
return nullptr;
}
return objc->_cppRefHandle.get();
}
auto WcharTestHelpers::fromCppOpt(const CppOptType& cpp) -> ObjcType
{
if (!cpp) {
return nil;
}
return ::djinni::get_cpp_proxy<DBWcharTestHelpers>(cpp);
}
} // namespace djinni_generated
@end
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#import "DBWcharTestRec.h"
#import <Foundation/Foundation.h>
@interface DBWcharTestHelpers : NSObject
+ (nonnull DBWcharTestRec *)getRecord;
+ (nonnull NSString *)getString;
+ (BOOL)checkString:(nonnull NSString *)str;
+ (BOOL)checkRecord:(nonnull DBWcharTestRec *)rec;
@end
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#import "DBWcharTestRec.h"
#include "wchar_test_rec.hpp"
static_assert(__has_feature(objc_arc), "Djinni requires ARC to be enabled for this file");
@class DBWcharTestRec;
namespace djinni_generated {
struct WcharTestRec
{
using CppType = ::testsuite::WcharTestRec;
using ObjcType = DBWcharTestRec*;
using Boxed = WcharTestRec;
static CppType toCpp(ObjcType objc);
static ObjcType fromCpp(const CppType& cpp);
};
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#import "DBWcharTestRec+Private.h"
#import "DJIMarshal+Private.h"
#include <cassert>
namespace djinni_generated {
auto WcharTestRec::toCpp(ObjcType obj) -> CppType
{
assert(obj);
return {::djinni::WString::toCpp(obj.s)};
}
auto WcharTestRec::fromCpp(const CppType& cpp) -> ObjcType
{
return [[DBWcharTestRec alloc] initWithS:(::djinni::WString::fromCpp(cpp.s))];
}
} // namespace djinni_generated
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#import <Foundation/Foundation.h>
@interface DBWcharTestRec : NSObject
- (nonnull instancetype)initWithS:(nonnull NSString *)s;
+ (nonnull instancetype)wcharTestRecWithS:(nonnull NSString *)s;
@property (nonatomic, readonly, nonnull) NSString * s;
@end
// AUTOGENERATED FILE - DO NOT MODIFY!
// This file generated by Djinni from wchar_test.djinni
#import "DBWcharTestRec.h"
@implementation DBWcharTestRec
- (nonnull instancetype)initWithS:(nonnull NSString *)s
{
if (self = [super init]) {
_s = [s copy];
}
return self;
}
+ (nonnull instancetype)wcharTestRecWithS:(nonnull NSString *)s
{
return [[self alloc] initWithS:s];
}
- (NSString *)description
{
return [NSString stringWithFormat:@"<%@ %p s:%@>", self.class, (void *)self, self.s];
}
@end
#include "wchar_test_helpers.hpp"
#include "wchar_test_rec.hpp"
namespace testsuite {
static const wchar_t s1[] = L"some string with unicode \u0000, \u263A, \U0001F4A9 symbols";
static const std::wstring str1(s1, sizeof(s1) / sizeof(*s1) - 1);
static const std::wstring str2 = L"another string with unicode \u263B, \U0001F4A8 symbols";
WcharTestRec WcharTestHelpers::get_record()
{
return WcharTestRec(str1);
}
std::wstring WcharTestHelpers::get_string()
{
return str2;
}
bool WcharTestHelpers::check_string(const std::wstring & s)
{
return s == str2;
}
bool WcharTestHelpers::check_record(const WcharTestRec & r)
{
return r.s == str1;
}
} // namespace testsuite
......@@ -22,6 +22,7 @@ public class AllTests extends TestSuite {
mySuite.addTestSuite(TokenTest.class);
mySuite.addTestSuite(DurationTest.class);
mySuite.addTestSuite(MockRecordTest.class);
mySuite.addTestSuite(WcharTest.class);
return mySuite;
}
......
package com.dropbox.djinni.test;
import junit.framework.TestCase;
public class WcharTest extends TestCase {
private static final String STR1 = "some string with unicode \u0000, \u263A, \uD83D\uDCA9 symbols";
private static final String STR2 = "another string with unicode \u263B, \uD83D\uDCA8 symbols";
public void test() {
assertEquals(WcharTestHelpers.getRecord().getS(), STR1);
assertEquals(WcharTestHelpers.getString(), STR2);
assertEquals(WcharTestHelpers.checkString(STR2), true);
assertEquals(WcharTestHelpers.checkRecord(new WcharTestRec(STR1)), true);
}
}
#import <Foundation/Foundation.h>
#import "DBWcharTestHelpers.h"
#import "DBWcharTestRec.h"
#import <XCTest/XCTest.h>
@interface DBWcharTests : XCTestCase
@end
@implementation DBWcharTests
- (void)setUp
{
[super setUp];
}
- (void)tearDown
{
[super tearDown];
}
- (void)test
{
NSString *str1 = @"some string with unicode \0, \u263A, \U0001F4A9 symbols";
NSString *str2 = @"another string with unicode \u263B, \U0001F4A8 symbols";
XCTAssertEqualObjects([[DBWcharTestHelpers getRecord] s], str1);
XCTAssertEqualObjects([DBWcharTestHelpers getString], str2);
XCTAssertTrue([DBWcharTestHelpers checkString:str2]);
XCTAssertTrue([DBWcharTestHelpers checkRecord:[[DBWcharTestRec alloc] initWithS:str1]]);
}
@end
......@@ -17,12 +17,14 @@ base_dir=$(cd "`dirname "$loc"`" && pwd)
temp_out="$base_dir/djinni-output-temp"
in="$base_dir/djinni/all.djinni"
wchar_in="$base_dir/djinni/wchar_test.djinni"
# Relative version of in and temp_out are used for Djinni call below so that
# generated lists of infiles/outfiles are not machine-dependent. This
# is an artifact of the test suite, where we want the genereated files
# to be in git for examination.
in_relative="djinni/all.djinni"
wchar_in_relative="djinni/wchar_test.djinni"
temp_out_relative="djinni-output-temp"
cpp_out="$base_dir/generated-src/cpp"
......@@ -55,10 +57,41 @@ elif [ $# -eq 1 ]; then
exit
fi
# Build Djinni.
# Build Djinni
"$base_dir/../src/build"
# Run Djinni generation
[ ! -e "$temp_out" ] || rm -r "$temp_out"
(cd "$base_dir" && \
"$base_dir/../src/run-assume-built" \
--java-out "$temp_out_relative/java" \
--java-package $java_package \
--java-nullable-annotation "javax.annotation.CheckForNull" \
--java-nonnull-annotation "javax.annotation.Nonnull" \
--java-use-final-for-record false \
--ident-java-field mFooBar \
\
--cpp-out "$temp_out_relative/cpp" \
--cpp-namespace testsuite \
--ident-cpp-enum-type foo_bar \
--cpp-optional-template "std::experimental::optional" \
--cpp-optional-header "\"../../handwritten-src/cpp/optional.hpp\"" \
--cpp-extended-record-include-prefix "../../handwritten-src/cpp/" \
--cpp-use-wide-strings true \
\
--jni-out "$temp_out_relative/jni" \
--ident-jni-class NativeFooBar \
--ident-jni-file NativeFooBar \
\
--objc-out "$temp_out_relative/objc" \
--objcpp-out "$temp_out_relative/objc" \
--objc-type-prefix DB \
\
--yaml-out "$temp_out_relative/yaml" \
--yaml-out-file "yaml-test.yaml" \
--yaml-prefix "test_" \
\
--idl "$wchar_in_relative" && \
"$base_dir/../src/run-assume-built" \
--java-out "$temp_out_relative/java" \
--java-package $java_package \
......@@ -94,27 +127,29 @@ fi
# Make sure we can parse back our own generated YAML file
cp "$base_dir/djinni/yaml-test.djinni" "$temp_out/yaml"
(cd "$base_dir" && \
"$base_dir/../src/run-assume-built" \
--java-out "$temp_out/java" \
--java-out "$temp_out_relative/java" \
--java-package $java_package \
--ident-java-field mFooBar \
\
--cpp-out "$temp_out/cpp" \
--cpp-out "$temp_out_relative/cpp" \
--ident-cpp-enum-type foo_bar \
--cpp-optional-template "std::experimental::optional" \
--cpp-optional-header "\"../../handwritten-src/cpp/optional.hpp\"" \
\
--jni-out "$temp_out/jni" \
--jni-out "$temp_out_relative/jni" \
--ident-jni-class NativeFooBar \
--ident-jni-file NativeFooBar \
\
--objc-out "$temp_out/objc" \
--objcpp-out "$temp_out/objc" \
--objc-out "$temp_out_relative/objc" \
--objcpp-out "$temp_out_relative/objc" \
--objc-type-prefix DB \
\
--idl "$temp_out/yaml/yaml-test.djinni"
--idl "$temp_out_relative/yaml/yaml-test.djinni" \
)
# Copy changes from "$temp_output" to final dir.
# Copy changes from "$temp_out" to final dir.
mirror() {
local prefix="$1" ; shift
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment