/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include "Interface.h"

#include "InterfacePrivate.h"

#include "Coder.h"

#include "NativeType.h"

#include "CString.h"

////////////////////////////////////////////////////////////////////////////////

// Includes

// Imports

// Definitions

// Support

// Wrappers

// Exports

////////////////////////////////////////////////////////////////////////////////

static const char *name_to_cname(NameRef p_type)

{

static char *s_buffer = nil;

MCCStringFree(s_buffer);

MCCStringClone(NameGetCString(p_type), s_buffer);

for(uint32_t i = 0; s_buffer[i] != '\0'; i++)

if (s_buffer[i] == '-')

s_buffer[i] = '_';

return s_buffer;

}

static const char *type_to_cstring(NameRef p_type, bool p_is_ref)

{

if (NameEqualToCString(p_type, "boolean"))

return "bool";

else if (NameEqualToCString(p_type, "c-string"))

return p_is_ref ? "char *" : "const char *";

else if (NameEqualToCString(p_type, "c-data"))

return "LCBytes";

else if (NameEqualToCString(p_type, "lc-array"))

return p_is_ref ? "LCArrayRef" : "const LCArrayRef";

else if (NameEqualToCString(p_type, "integer"))

return "int";

else if (NameEqualToCString(p_type, "real"))

return "double";

else if (NameEqualToCString(p_type, "objc-string"))

return "NSString*";

else if (NameEqualToCString(p_type, "objc-number"))

return "NSNumber*";

else if (NameEqualToCString(p_type, "objc-data"))

return "NSData*";

else if (NameEqualToCString(p_type, "objc-array"))

return "NSArray*";

else if (NameEqualToCString(p_type, "objc-dictionary"))

return "NSDictionary*";

return "int";

}

static NativeType map_native_type(HandlerMapping p_mapping, NameRef p_type)

{

if (NameEqualToCString(p_type, "string"))

{

switch(p_mapping)

{

case kHandlerMappingC:

return kNativeTypeCString;

case kHandlerMappingObjC:

return kNativeTypeObjcString;

case kHandlerMappingJava:

return kNativeTypeJavaString;

}

}

else if (NameEqualToCString(p_type, "number"))

{

switch(p_mapping)

{

case kHandlerMappingC:

return kNativeTypeReal;

case kHandlerMappingObjC:

return kNativeTypeObjcNumber;

case kHandlerMappingJava:

return kNativeTypeJavaNumber;

}

}

else if (NameEqualToCString(p_type, "data"))

{

switch(p_mapping)

{

case kHandlerMappingC:

return kNativeTypeCData;

case kHandlerMappingObjC:

return kNativeTypeObjcData;

case kHandlerMappingJava:

return kNativeTypeJavaData;

}

}

else if (NameEqualToCString(p_type, "array"))

{

switch(p_mapping)

{

case kHandlerMappingC:

return kNativeTypeCArray;

case kHandlerMappingObjC:

return kNativeTypeObjcArray;

case kHandlerMappingJava:

return kNativeTypeJavaArray;

}

}

else if (NameEqualToCString(p_type, "dictionary"))

{

switch(p_mapping)

{

case kHandlerMappingC:

return kNativeTypeCDictionary;

case kHandlerMappingObjC:

return kNativeTypeObjcDictionary;

case kHandlerMappingJava:

return kNativeTypeJavaDictionary;

}

}

else if (p_mapping == kHandlerMappingJava)

{

switch(NativeTypeFromName(p_type))

{

case kNativeTypeCString:

return kNativeTypeJavaString;

case kNativeTypeUTF8CString:

return kNativeTypeJavaUTF8String;

case kNativeTypeUTF16CString:

return kNativeTypeJavaUTF16String;

case kNativeTypeCData:

return kNativeTypeJavaData;

case kNativeTypeUTF8CData:

return kNativeTypeJavaUTF8Data;

case kNativeTypeUTF16CData:

return kNativeTypeJavaUTF16Data;

default:

break;

}

}

return NativeTypeFromName(p_type);

}

////////////////////////////////////////////////////////////////////////////////

class TypeMapper

{

public:

virtual ~TypeMapper() {};

virtual const char *GetTypedef(ParameterType mode) = 0;

virtual void Initialize(CoderRef coder, ParameterType mode, const char *name) = 0;

virtual void Fetch(CoderRef coder, ParameterType mode, const char *name, const char *source) = 0;

virtual void Default(CoderRef coder, ParameterType mode, const char *name, ValueRef value) = 0;

virtual void Store(CoderRef coder, ParameterType mode, const char *name, const char *target) = 0;

virtual void Finalize(CoderRef coder, ParameterType mode, const char *name) = 0;

};

//////////

class PrimitiveTypeMapper: public TypeMapper

{

public:

virtual const char *GetTypedef(ParameterType mode)

{

return GetType();

}

virtual void Initialize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "%s %s", GetType(), p_name);

CoderWriteStatement(p_coder, "%s = %s", p_name, GetInitializer());

}

virtual void Fetch(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_source)

{

CoderWriteStatement(p_coder, "success = fetch__%s(name__%s, %s, %s)", GetTag(), p_name, p_source, p_name);

}

virtual void Store(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_target)

{

CoderWriteStatement(p_coder, "success = store__%s(%s, %s)", GetTag(), p_target, p_name);

}

virtual void Finalize(CoderRef coder, ParameterType mode, const char *name)

{

}

protected:

virtual const char *GetType(void) const = 0;

virtual const char *GetInitializer(void) const = 0;

virtual const char *GetTag(void) const = 0;

};

class BooleanTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "%s = %s", p_name, BooleanGetBool(p_value) ? "true" : "false");

}

protected:

virtual const char *GetType(void) const {return "bool";}

virtual const char *GetInitializer(void) const {return "false";}

virtual const char *GetTag(void) const {return "bool";}

};

class IntegerTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "%s = %lld", p_name, NumberGetInteger(p_value));

}

protected:

virtual const char *GetType(void) const {return "int";}

virtual const char *GetInitializer(void) const {return "0";}

virtual const char *GetTag(void) const {return "int";}

};

class RealTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "%s = %lf", p_name, NumberGetReal(p_value));

}

protected:

virtual const char *GetType(void) const {return "double";}

virtual const char *GetInitializer(void) const {return "0.0";}

virtual const char *GetTag(void) const {return "double";}

};

class ObjcStringTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "%s = @\"%s\"", p_name, StringGetCStringPtr(p_value));

}

protected:

virtual const char *GetType(void) const {return "NSString*";}

virtual const char *GetInitializer(void) const {return "nil";}

virtual const char *GetTag(void) const {return "objc_string";}

};

class ObjcDataTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = false");

}

protected:

virtual const char *GetType(void) const {return "NSData*";}

virtual const char *GetInitializer(void) const {return "nil";}

virtual const char *GetTag(void) const {return "objc_data";}

};

class ObjcNumberTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = false");

}

protected:

virtual const char *GetType(void) const {return "NSNumber*";}

virtual const char *GetInitializer(void) const {return "nil";}

virtual const char *GetTag(void) const {return "objc_number";}

};

class ObjcArrayTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = false");

}

protected:

virtual const char *GetType(void) const {return "NSArray*";}

virtual const char *GetInitializer(void) const {return "nil";}

virtual const char *GetTag(void) const {return "objc_array";}

};

class ObjcDictionaryTypeMapper: public PrimitiveTypeMapper

{

public:

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = false");

}

protected:

virtual const char *GetType(void) const {return "NSDictionary*";}

virtual const char *GetInitializer(void) const {return "nil";}

virtual const char *GetTag(void) const {return "objc_dictionary";}

};

//////////

class CTypesTypeMapper : public TypeMapper

{

public:

virtual void Fetch(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_source)

{

CoderWriteStatement(p_coder, "success = fetch__%s(name__%s, %s, %s)", GetTag(), p_name, p_source, p_name);

CodeInOutCopy(p_coder, p_mode, p_name);

}

virtual void Store(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_target)

{

CoderWriteStatement(p_coder, "success = store__%s(%s, %s)", GetTag(), p_target, p_name);

}

protected:

virtual const char *GetTag(void) = 0;

void CodeInOutCopy(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

if (p_mode != kParameterTypeInOut)

return;

CoderBeginIf(p_coder, "success");

CoderWriteStatement(p_coder, "original__%s = %s", p_name, p_name);

CoderEndIf(p_coder);

}

};

class CStringTypeMapper: public CTypesTypeMapper

{

public:

CStringTypeMapper(NativeType p_type)

{

m_tag = NativeTypeGetTag(p_type);

}

virtual const char *GetTypedef(ParameterType mode)

{

return mode == kParameterTypeIn ? "const char *" : "char *";

}

virtual void Initialize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

if (p_mode == kParameterTypeInOut)

{

CoderWriteStatement(p_coder, "char *%s, *original__%s", p_name, p_name);

CoderWriteStatement(p_coder, "original__%s = %s = nil;", p_name, p_name);

}

else

{

CoderWriteStatement(p_coder, "char *%s", p_name);

CoderWriteStatement(p_coder, "%s = nil", p_name);

}

}

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = default__%s(\"%s\", %s)", GetTag(), StringGetCStringPtr(p_value), p_name);

CodeInOutCopy(p_coder, p_mode, p_name);

}

virtual void Finalize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "free(%s)", p_name);

if (p_mode == kParameterTypeInOut)

{

CoderBeginIf(p_coder, "%s != original__%s", p_name, p_name);

CoderWriteStatement(p_coder, "free(original__%s)", p_name);

CoderEndIf(p_coder);

}

}

protected:

const char *GetTag(void) {return m_tag;}

private:

const char *m_tag;

};

class CDataTypeMapper: public CTypesTypeMapper

{

public:

CDataTypeMapper(NativeType p_type)

{

m_tag = NativeTypeGetTag(p_type);

}

virtual const char *GetTypedef(ParameterType mode)

{

return "LCBytes";

}

virtual void Initialize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

if (p_mode == kParameterTypeInOut)

{

CoderWriteStatement(p_coder, "LCBytes %s, original__%s", p_name, p_name);

CoderWriteStatement(p_coder, "original__%s . buffer = %s . buffer = nil;", p_name, p_name);

CoderWriteStatement(p_coder, "original__%s . length = %s . length = 0;", p_name, p_name);

}

else

{

CoderWriteStatement(p_coder, "LCBytes %s", p_name);

CoderWriteStatement(p_coder, "%s . buffer = nil", p_name);

CoderWriteStatement(p_coder, "%s . length = 0", p_name);

}

}

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = false", StringGetCStringPtr(p_value), p_name);

CodeInOutCopy(p_coder, p_mode, p_name);

}

virtual void Finalize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "free(%s . buffer)", p_name);

if (p_mode == kParameterTypeInOut)

{

CoderBeginIf(p_coder, "%s . buffer != original__%s . buffer", p_name, p_name);

CoderWriteStatement(p_coder, "free(original__%s . buffer)", p_name);

CoderEndIf(p_coder);

}

}

protected:

const char *GetTag(void) {return m_tag;}

private:

const char* m_tag;

};

class LCArrayTypeMapper: public CTypesTypeMapper

{

public:

LCArrayTypeMapper(NativeType p_type)

{

m_tag = NativeTypeGetTag(p_type);

}

virtual const char *GetTypedef(ParameterType mode)

{

return mode == kParameterTypeIn ? "const LCArrayRef" : "LCArrayRef";

}

virtual void Initialize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

if (p_mode == kParameterTypeInOut)

{

CoderWriteStatement(p_coder, "LCArrayRef %s, original__%s", p_name, p_name);

CoderWriteStatement(p_coder, "original__%s = %s = nil;", p_name, p_name);

}

else

{

CoderWriteStatement(p_coder, "LCArrayRef %s", p_name);

CoderWriteStatement(p_coder, "%s = nil", p_name);

}

}

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = false", StringGetCStringPtr(p_value), p_name);

CodeInOutCopy(p_coder, p_mode, p_name);

}

virtual void Finalize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "LCArrayRelease(%s)", p_name);

if (p_mode == kParameterTypeInOut)

{

CoderBeginIf(p_coder, "%s != original__%s", p_name, p_name);

CoderWriteStatement(p_coder, "LCArrayRelease(original__%s)", p_name);

CoderEndIf(p_coder);

}

}

protected:

const char *GetTag(void) {return m_tag;}

private:

const char* m_tag;

};

//////////

class EnumTypeMapper: public TypeMapper

{

public:

EnumTypeMapper(NameRef p_type_name, int64_t p_default)

{

m_type_name = p_type_name;

m_type_default = p_default;

}

virtual const char *GetTypedef(ParameterType mode)

{

return "int";

}

virtual void Initialize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "int %s", p_name);

CoderWriteStatement(p_coder, "%s = 0", p_name);

}

virtual void Fetch(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_source)

{

CoderWriteStatement(p_coder, "success = fetchenum__%s(name__%s, %s, %s)", name_to_cname(m_type_name), p_name, p_source, p_name);

}

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "%s = %lld", p_name, m_type_default);

}

virtual void Store(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_target)

{

CoderWriteStatement(p_coder, "success = storeenum__%s(%s, %s);", name_to_cname(m_type_name), p_target, p_name);

}

virtual void Finalize(CoderRef coder, ParameterType mode, const char *name)

{

}

private:

NameRef m_type_name;

int64_t m_type_default;

};

//////////

class JavaStringTypeMapper: public TypeMapper

{

public:

JavaStringTypeMapper(NativeType p_type)

{

m_tag = NativeTypeGetTag(p_type);

}

virtual const char *GetTypedef(ParameterType type)

{

return "__INTERNAL_ERROR__";

}

virtual void Initialize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "jobject %s", p_name);

CoderWriteStatement(p_coder, "%s = nil", p_name);

}

virtual void Fetch(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_source)

{

CoderWriteStatement(p_coder, "success = fetch__%s(__java_env, name__%s, %s, %s)", m_tag, p_name, p_source, p_name);

}

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = default__java_string(__java_env, \"%s\", %s)", StringGetCStringPtr(p_value), p_name);

}

virtual void Store(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_target)

{

CoderWriteStatement(p_coder, "success = store__%s(__java_env, %s, %s)", m_tag, p_target, p_name);

}

virtual void Finalize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "free__java_string(__java_env, %s)", p_name);

}

private:

const char* m_tag;

};

class JavaDataTypeMapper: public TypeMapper

{

public:

JavaDataTypeMapper(NativeType p_type)

{

m_tag = NativeTypeGetTag(p_type);

}

virtual const char *GetTypedef(ParameterType type)

{

return "__INTERNAL_ERROR__";

}

virtual void Initialize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "jobject %s", p_name);

CoderWriteStatement(p_coder, "%s = nil", p_name);

}

virtual void Fetch(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_source)

{

CoderWriteStatement(p_coder, "success = fetch__%s(__java_env, name__%s, %s, %s)", m_tag, p_name, p_source, p_name);

}

virtual void Default(CoderRef p_coder, ParameterType p_mode, const char *p_name, ValueRef p_value)

{

CoderWriteStatement(p_coder, "success = false", StringGetCStringPtr(p_value), p_name);

}

virtual void Store(CoderRef p_coder, ParameterType p_mode, const char *p_name, const char *p_target)

{

CoderWriteStatement(p_coder, "success = store__%s(__java_env, %s, %s)", m_tag, p_target, p_name);

}

virtual void Finalize(CoderRef p_coder, ParameterType p_mode, const char *p_name)

{

CoderWriteStatement(p_coder, "free__java_data(__java_env, %s)", p_name);

}

private:

const char* m_tag;

};

////////////////////////////////////////////////////////////////////////////////

static const char *InterfaceGetExternPrefix(InterfaceRef self)

{

if (!self -> use_cpp_naming)

return "extern \"C\"";

return "extern";

}

static const char *InterfaceGetReferenceSuffix(InterfaceRef self)

{

if (self -> use_cpp_naming)

return "&";

return "*";

}

////////////////////////////////////////////////////////////////////////////////

extern "C" const char *g_support_template[];

static bool InterfaceGenerateSupport(InterfaceRef self, CoderRef p_coder)

{

if (self -> use_cpp_exceptions)

CoderWriteLine(p_coder, "#include <exception>");

for(int i = 0; g_support_template[i] != nil; i++)

CoderWrite(p_coder, "%s", g_support_template[i]);

return true;

}

////////////////////////////////////////////////////////////////////////////////

static bool InterfaceGenerateImports(InterfaceRef self, CoderRef p_coder)

{

const char *t_extern;

t_extern = InterfaceGetExternPrefix(self);

const char *t_reference;

t_reference = InterfaceGetReferenceSuffix(self);

if (self -> startup_hook != nil)

CoderWriteLine(p_coder, "%s bool %s(void);", t_extern, NameGetCString(self -> startup_hook));

if (self -> shutdown_hook != nil)

CoderWriteLine(p_coder, "%s void %s(void);", t_extern, NameGetCString(self -> shutdown_hook));

#if NOT_USED

for(uint32_t i = 0; i < self -> handler_count; i++)

for(uint32_t j = 0; j < self -> handlers[i] . variant_count; j++)

{

HandlerVariant *t_variant;

t_variant = &self -> handlers[i] . variants[j];

const char *t_return_type;

if (t_variant -> return_type == nil || t_variant -> return_type_indirect)

t_return_type = "void";

else

t_return_type = type_to_cstring(t_variant -> return_type, true);

CoderWrite(p_coder, "%s %s %s(", t_extern, t_return_type, NameGetCString(t_variant -> binding));

if (t_variant -> parameter_count != 0)

{

for(uint32_t k = 0; k < t_variant -> parameter_count; k++)

{

if (k > 0)

CoderWrite(p_coder, ", ");

CoderWrite(p_coder, "%s", type_to_cstring(t_variant -> parameters[k] . type, t_variant -> parameters[k] . mode != kParameterTypeIn));

if (t_variant -> parameters[k] . mode != kParameterTypeIn)

CoderWrite(p_coder, "%s", t_reference);

}

}

else if (t_variant -> return_type_indirect)

CoderWrite(p_coder, "%s%s", type_to_cstring(t_variant -> return_type, true), t_reference);

else

CoderWrite(p_coder, "void");

CoderWriteLine(p_coder, ");");

}

#endif

return true;

}

////////////////////////////////////////////////////////////////////////////////

static bool InterfaceGenerateEnums(InterfaceRef self, CoderRef p_coder)

{

for(uint32_t i = 0; i < self -> enum_count; i++)

{

Enum *t_enum;

t_enum = &self -> enums[i];

CoderWriteLine(p_coder, "static bool fetchenum__%s(const char *arg, MCVariableRef var, int& r_value)", name_to_cname(t_enum -> name));

CoderWriteLine(p_coder, "{");

CoderWriteLine(p_coder, "\tbool success;");

CoderWriteLine(p_coder, "\tsuccess = true;");

CoderWriteLine(p_coder, "\tchar *element;");

CoderWriteLine(p_coder, "\tif (!fetch__cstring(arg, var, element))");

CoderWriteLine(p_coder, "\t\treturn false;");

for(uint32_t j = 0; j < t_enum -> element_count; j++)

{

CoderWriteLine(p_coder, "\t%sif (strcasecmp(element, \"%s\") == 0)", j == 0 ? "" : "else ", StringGetCStringPtr(t_enum -> elements[j] . key));

CoderWriteLine(p_coder, "\t\tr_value = %lld;", t_enum -> elements[j] . value);

}

if (t_enum -> element_count > 0)

CoderWriteLine(p_coder, "\telse");

CoderWriteLine(p_coder, "\t\tsuccess = error__bad_enum_element(arg, element);");

CoderWriteLine(p_coder, "\tfree(element);");

CoderWriteLine(p_coder, "\treturn success;");

CoderWriteLine(p_coder, "}");

CoderWriteLine(p_coder, "static bool storeenum__%s(MCVariableRef var, int value)", name_to_cname(t_enum -> name));

CoderWriteLine(p_coder, "{");

for(uint32_t j = 0; j < t_enum -> element_count; j++)

{

CoderWriteLine(p_coder, "\t%sif (value == %lld)", j == 0 ? "" : "else ", t_enum -> elements[j] . value);

CoderWriteLine(p_coder, "\t\treturn store__cstring(var, \"%s\");", StringGetCStringPtr(t_enum -> elements[j] . key));

}

if (t_enum -> element_count > 0)

CoderWriteLine(p_coder, "\telse");

CoderWriteLine(p_coder, "\t\treturn store__int(var, value);");

CoderWriteLine(p_coder, "\treturn true;");

CoderWriteLine(p_coder, "}");

}

return true;

}

////////////////////////////////////////////////////////////////////////////////

static int64_t InterfaceResolveEnumElement(InterfaceRef self, NameRef p_name, ValueRef p_element)

{

for(uint32_t i = 0; i < self -> enum_count; i++)

if (NameEqual(p_name, self -> enums[i] . name))

{

for(uint32_t j = 0; j < self -> enums[i] . element_count; j++)

if (StringEqualCaseless(p_element, self -> enums[i] . elements[j] . key))

return self -> enums[i] . elements[j] . value;

}

return 0;

}

#if NOT_USED

static void InterfaceGenerateMethodStubContext(InterfaceRef self, CoderRef p_coder, Handler *p_handler, bool p_in)

{

NameRef t_name;

t_name = p_handler -> name;

HandlerVariant *t_variant;

t_variant = &p_handler -> variants[0];

CoderWriteLine(p_coder, "struct %s_context_t", NameGetCString(t_name));

CoderWriteLine(p_coder, "{");

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

{

const char *t_type;

if (p_in)

t_type = native_type_to_type_in_cstring(NativeTypeFromName(t_variant -> parameters[i] . type));

else

t_type = native_type_to_type_out_cstring(NativeTypeFromName(t_variant -> parameters[i] . type));

CoderWriteLine(p_coder, "\t%s arg_%d;", t_type, i);

}

if (t_variant -> return_type != nil)

CoderWriteLine(p_coder, "\t%s result;", native_type_to_type_out_cstring(NativeTypeFromName(t_variant -> return_type)));

CoderWriteLine(p_coder, "};");

CoderWriteLine(p_coder, "");

}

static void InterfaceGenerateMethodStubParameters(InterfaceRef self, CoderRef p_coder, Handler *p_handler, bool p_java)

{

HandlerVariant *t_variant;

t_variant = &p_handler -> variants[0];

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

{

if (i != 0)

CoderWrite(p_coder, ", ");

const char *t_type;

if (p_java)

t_type = native_type_to_java_type_cstring(NativeTypeFromName(t_variant -> parameters[i] . type));

else

t_type = native_type_to_type_in_cstring(NativeTypeFromName(t_variant -> parameters[i] . type));

CoderWrite(p_coder, "%s p_param_%d", t_type, i);

}

}

char *InterfaceGenerateJavaMethodSignature(InterfaceRef self, Handler *p_handler)

{

HandlerVariant *t_variant;

t_variant = &p_handler -> variants[0];

char *t_signature;

t_signature = nil;

MCCStringAppend(t_signature, "(");

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

MCCStringAppend(t_signature, native_type_to_java_sig(NativeTypeFromName(t_variant -> parameters[i] . type)));

MCCStringAppend(t_signature, ")");

MCCStringAppend(t_signature, t_variant -> return_type != nil ? native_type_to_java_sig(NativeTypeFromName(t_variant -> return_type)) : "V");

return t_signature;

}

static void InterfaceGenerateJavaMethodStub(InterfaceRef self, CoderRef p_coder, Handler *p_handler)

{

NameRef t_name;

t_name = p_handler -> name;

HandlerVariant *t_variant;

t_variant = &p_handler -> variants[0];

InterfaceGenerateMethodStubContext(self, p_coder, p_handler, true);

CoderWriteLine(p_coder, "static void %s_callback(void *p_context)", NameGetCString(t_name));

CoderWriteLine(p_coder, "{");

CoderWriteLine(p_coder, "\t%s_context_t *ctxt = (%s_context_t *)p_context;", NameGetCString(t_name), NameGetCString(t_name));

CoderWriteLine(p_coder, "");

char *t_java_sig;

t_java_sig = InterfaceGenerateJavaMethodSignature(self, p_handler);

CoderWriteLine(p_coder, "\tstatic jmethodID s_method = 0;");

CoderWriteLine(p_coder, "\tif (s_method == 0)");

CoderWriteLine(p_coder, "\t\ts_method = s_android_env -> GetStaticMethodID(s_java_class, \"%s\", \"%s\");", NameGetCString(t_name), t_java_sig);

free(t_java_sig);

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

{

HandlerParameter *t_parameter;

t_parameter = &t_variant -> parameters[i];

NativeType t_param_native_type;

t_param_native_type = NativeTypeFromName(t_parameter -> type);

const char *t_java_param_type;

t_java_param_type = native_type_to_java_type_cstring(t_param_native_type);

CoderWriteLine(p_coder, "\t%s t_param_%d;", t_java_param_type, i);

CoderWriteLine(p_coder, "\tt_param_%d = java_from__%s(s_android_env, ctxt -> arg_%d);", i, NativeTypeGetTag(t_param_native_type), i);

}

const char *t_java_method_type, *t_c_return_type, *t_java_return_type;

if (t_variant -> return_type != nil)

{

t_java_method_type = native_type_to_java_method_type_cstring(NativeTypeFromName(t_variant -> return_type));

t_c_return_type = native_type_to_type_out_cstring(NativeTypeFromName(t_variant -> return_type));

t_java_return_type = native_type_to_java_type_cstring(NativeTypeFromName(t_variant -> return_type));

}

else

{

t_java_method_type = "Void";

t_c_return_type = "void";

t_java_return_type = "void";

}

if (t_variant -> return_type != nil)

CoderWriteLine(p_coder, "\t%s t_result;", t_java_return_type);

if (t_variant -> return_type != nil)

CoderWrite(p_coder, "\tt_result = s_android_env -> CallStatic%sMethod(s_java_class, s_method", t_java_method_type);

else

CoderWrite(p_coder, "\ts_android_env -> CallStatic%sMethod(s_java_class, s_method", t_java_method_type);

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

CoderWrite(p_coder, ", t_param_%d", i);

CoderWrite(p_coder, ");\n");

if (t_variant -> return_type != nil)

{

CoderWriteLine(p_coder, "\tctxt -> result = java_to__%s(s_android_env, t_result);", NativeTypeGetTag(NativeTypeFromName(t_variant -> return_type)));

CoderWriteLine(p_coder, "\tjava_free__%s(s_android_env, t_result);", NativeTypeGetTag(NativeTypeFromName(t_variant -> return_type)));

}

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

CoderWriteLine(p_coder, "\tjava_free__%s(s_android_env, t_param_%d);", NativeTypeGetTag(NativeTypeFromName(t_variant -> parameters[i] . type)), i);

CoderWriteLine(p_coder, "}");

CoderWrite(p_coder, "%s %s(", t_c_return_type, NameGetCString(t_name));

InterfaceGenerateMethodStubParameters(self, p_coder, p_handler, false);

CoderWriteLine(p_coder, ")");

CoderWriteLine(p_coder, "{");

CoderWriteLine(p_coder, "\t%s_context_t ctxt;", NameGetCString(t_name));

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

CoderWriteLine(p_coder, "\tctxt . arg_%d = p_param_%d;", i, i);

CoderWriteLine(p_coder, "\ts_interface -> engine_run_on_main_thread((void *)%s_callback, &ctxt, kMCRunOnMainThreadJumpToUI);", NameGetCString(t_name));

if (t_variant -> return_type != nil)

CoderWriteLine(p_coder, "\treturn ctxt . result;");

CoderWriteLine(p_coder, "}");

}

static void InterfaceGenerateNativeMethodStub(InterfaceRef self, CoderRef p_coder, Handler *p_handler)

{

NameRef t_name;

t_name = p_handler -> name;

HandlerVariant *t_variant;

t_variant = &p_handler -> variants[0];

char *t_native_name;

MCCStringFormat(t_native_name, "Java_%s_%s", NameGetCString(self -> qualified_name), NameGetCString(t_name));

for(uindex_t i = 0; t_native_name[i] != '\0'; i++)

if (t_native_name[i] == '.')

t_native_name[i] = '_';

const char *t_c_return_type, *t_java_return_type;

if (t_variant -> return_type != nil)

{

t_c_return_type = native_type_to_type_out_cstring(NativeTypeFromName(t_variant -> return_type));

t_java_return_type = native_type_to_java_type_cstring(NativeTypeFromName(t_variant -> return_type));

}

else

{

t_c_return_type = "void";

t_java_return_type = "void";

}

CoderWrite(p_coder, "extern \"C\" JNIEXPORT %s JNICALL %s(JNIEnv *, jobject", t_java_return_type, t_native_name);

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

CoderWrite(p_coder, ", %s", native_type_to_java_type_cstring(NativeTypeFromName(t_variant -> parameters[i] . type)));

CoderWrite(p_coder, ") __attribute__((visibility(\"default\")));\n");

CoderWrite(p_coder, "");

InterfaceGenerateMethodStubContext(self, p_coder, p_handler, false);

CoderWriteLine(p_coder, "static void %s_callback(void *p_context)", NameGetCString(t_name));

CoderWriteLine(p_coder, "{");

CoderWriteLine(p_coder, "\t%s_context_t *ctxt = (%s_context_t *)p_context;", NameGetCString(t_name), NameGetCString(t_name));

if (t_variant -> return_type != nil)

CoderWrite(p_coder, "\tctxt -> result = ");

else

CoderWrite(p_coder, "\t");

CoderWrite(p_coder, "%s(", NameGetCString(t_name));

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

{

if (i != 0)

CoderWrite(p_coder, ", ");

CoderWrite(p_coder, "ctxt -> arg_%d", i);

}

CoderWrite(p_coder, ");\n");

CoderWriteLine(p_coder, "}");

CoderWrite(p_coder, "JNIEXPORT %s JNICALL %s(JNIEnv *env, jobject obj", t_java_return_type, t_native_name);

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

CoderWrite(p_coder, ", %s p_param_%d", native_type_to_java_type_cstring(NativeTypeFromName(t_variant -> parameters[i] . type)), i);

CoderWrite(p_coder, ")\n");

CoderWriteLine(p_coder, "{");

CoderWriteLine(p_coder, "\t%s_context_t ctxt;", NameGetCString(t_name));

for(uindex_t i = 0; i < t_variant -> parameter_count; i++)

{

HandlerParameter *t_parameter;

t_parameter = &t_variant -> parameters[i];

NativeType t_param_native_type;

t_param_native_type = NativeTypeFromName(t_parameter -> type);