void CSModuleWriter::GenerateManagedModuleClass(String& sourceOut)
{
Indent();
String source;
String line = ToString("public static partial class %sModule\n", module_->GetName().CString());
source += IndentLine(line);
source += IndentLine("{\n");
Indent();
source += IndentLine("public static void Initialize()\n");
source += IndentLine("{\n");
Indent();
Vector<SharedPtr<JSBClass>> classes = module_->classes_.Values();
for (unsigned i = 0; i < classes.Size(); i++)
{
JSBClass* klass = classes.At(i);
JSBPackage* package = module_->GetPackage();
if (klass->IsNumberArray() || klass->IsAbstract())
continue;
line = ToString("NativeCore.RegisterNativeType(typeof(%s));\n", klass->GetName().CString());
source += IndentLine(line);
line = ToString("NativeCore.nativeClassIDToManagedConstructor [ %s.csb_%s_%s_GetClassIDStatic ()] = (IntPtr x) => {\n",
klass->GetName().CString(), package->GetName().CString(), klass->GetName().CString());
source += IndentLine(line);
Indent();
source += IndentLine(ToString("return new %s (x);\n", klass->GetName().CString()));
Dedent();
source += IndentLine("};\n");
}
Dedent();
source += IndentLine("}\n");
Dedent();
source += IndentLine("}\n");
sourceOut += source;
Dedent();
}
void JSBModuleWriter::WriteClassDeclaration(String& source)
{
Vector<SharedPtr<JSBClass>> classes = module_->classes_.Values();
source += "static void jsb_declare_classes(JSVM* vm)\n{\n";
source += "duk_context* ctx = vm->GetJSContext();\n";
String packageName = module_->GetPackage()->GetName();
for (unsigned i = 0; i < classes.Size(); i++)
{
JSBClass* klass = classes.At(i);
if (klass->IsNumberArray())
continue;
source.AppendWithFormat(" js_class_declare<%s>(vm, \"%s\", \"%s\", jsb_constructor_%s);\n", klass->GetNativeName().CString(), packageName.CString(), klass->GetName().CString(), klass->GetName().CString());
if (klass->HasProperties())
{
source.AppendWithFormat("js_class_push_propertyobject(vm, \"%s\", \"%s\");\n", packageName.CString(), klass->GetName().CString());
Vector<String> pnames;
klass->GetPropertyNames(pnames);
for (unsigned j = 0; j < pnames.Size(); j++)
{
JSBProperty* prop = klass->GetProperty(pnames[j]);
source.Append("duk_push_object(ctx);\n");
if (prop->getter_ && !prop->getter_->Skip())
{
source.AppendWithFormat("duk_push_c_function(ctx, jsb_class_%s_%s, 0);\n",
klass->GetName().CString(), prop->getter_->GetName().CString());
source.Append("duk_put_prop_string(ctx, -2, \"get\");\n");
}
if (prop->setter_ && !prop->setter_->Skip())
{
source.AppendWithFormat("duk_push_c_function(ctx, jsb_class_%s_%s, 1);\n",
klass->GetName().CString(), prop->setter_->GetName().CString());
source.Append("duk_put_prop_string(ctx, -2, \"set\");\n");
}
String propertyName = prop->GetCasePropertyName();
source.AppendWithFormat("duk_put_prop_string(ctx, -2, \"%s\");\n", propertyName.CString());
}
source.Append("duk_pop(ctx);\n");
}
}
source += "\n}\n\n";
}
void JSBModule::WriteClassDeclaration(String& source)
{
source += "static void jsb_declare_classes(JSVM* vm)\n{\n";
source += "duk_context* ctx = vm->GetJSContext();\n";
for (unsigned i = 0; i < classes_.Size(); i++)
{
JSBClass* klass = classes_.At(i);
if (klass->isNumberArray())
continue;
source.AppendWithFormat(" js_class_declare(vm, \"%s\", jsb_constructor_%s);\n", klass->GetName().CString(), klass->GetName().CString());
if (klass->hasProperties())
{
source.AppendWithFormat("js_class_push_propertyobject(vm, \"%s\");\n", klass->GetName().CString());
Vector<String> pnames;
klass->GetPropertyNames(pnames);
for (unsigned j = 0; j < pnames.Size(); j++)
{
JSBProperty* prop = klass->GetProperty(pnames[j]);
source.Append("duk_push_object(ctx);\n");
if (prop->getter_ && !prop->getter_->Skip())
{
source.AppendWithFormat("duk_push_c_function(ctx, jsb_class_%s_%s, 0);\n",
klass->GetName().CString(), prop->getter_->name_.CString());
source.Append("duk_put_prop_string(ctx, -2, \"get\");\n");
}
if (prop->setter_ && !prop->setter_->Skip())
{
source.AppendWithFormat("duk_push_c_function(ctx, jsb_class_%s_%s, 1);\n",
klass->GetName().CString(), prop->setter_->name_.CString());
source.Append("duk_put_prop_string(ctx, -2, \"set\");\n");
}
pnames[j][0] = tolower(pnames[j][0]);
source.AppendWithFormat("duk_put_prop_string(ctx, -2, \"%s\");\n", pnames[j].CString());
}
source.Append("duk_pop(ctx);\n");
}
}
source += "\n}\n\n";
}
void CSFunctionWriter::WriteManagedConstructor(String& source)
{
JSBClass* klass = function_->GetClass();
JSBPackage* package = klass->GetPackage();
if (klass->GetName() == "RefCounted")
return;
// wrapping constructor
String line;
line = ToString("public %s (IntPtr native) : base (native)\n", klass->GetName().CString());
source += IndentLine(line);
source += IndentLine("{\n");
source += IndentLine("}\n\n");
String sig;
GenManagedFunctionParameters(sig);
line = ToString("public %s (%s)\n", klass->GetName().CString(), sig.CString());
source += IndentLine(line);
source += IndentLine("{\n");
Indent();
WriteDefaultStructParameters(source);
line = ToString("if (typeof(%s) == this.GetType()", klass->GetName().CString());
line += ToString(" || (this.GetType().BaseType == typeof(%s) && !NativeCore.GetNativeType(this.GetType())))\n", klass->GetName().CString());
source += IndentLine(line);
source += IndentLine("{\n");
Indent();
String callSig;
GenPInvokeCallParameters(callSig);
line = ToString("nativeInstance = NativeCore.RegisterNative (csb_%s_%s_Constructor(%s), this);\n",
package->GetName().CString(), klass->GetName().CString(), callSig.CString());
source += IndentLine(line);
Dedent();
source += IndentLine("}\n");
Dedent();
source += IndentLine("}\n");
}
String CSTypeHelper::GetNativeFunctionSignature(JSBFunction* function, String& returnType)
{
if (function->Skip())
return String::EMPTY;
if (function->IsDestructor())
return String::EMPTY;
if (OmitFunction(function))
return String::EMPTY;
JSBClass* klass = function->GetClass();
JSBPackage* package = klass->GetPackage();
String fname = function->IsConstructor() ? "Constructor" : function->GetName();
returnType = "void";
if (function->IsConstructor())
{
returnType = "RefCounted*";
}
else if (function->GetReturnType())
{
if (function->IsConstructor())
{
returnType = ToString("%s*", klass->GetNativeName().CString());
}
else if (function->GetReturnClass())
{
if (!function->GetReturnClass()->IsNumberArray())
{
returnType = ToString("const %s*", function->GetReturnClass()->GetNativeName().CString());
}
}
else if (function->GetReturnType()->type_->asStringHashType())
{
returnType = "unsigned";
}
else
{
returnType = ToString("%s", CSTypeHelper::GetNativeTypeString(function->GetReturnType()).CString());
// ScriptVector is handled by a out parameter
if (returnType.Contains("ScriptVector"))
returnType = "void";
}
}
String sig;
GenNativeFunctionParameterSignature(function, sig);
String functionSig = ToString("csb_%s_%s_%s_%u(%s)",
package->GetName().CString(), klass->GetName().CString(),
fname.CString(), function->GetID(), sig.CString());
return functionSig;
}
void CSTypeHelper::GenNativeFunctionParameterSignature(JSBFunction* function, String& sig)
{
JSBClass* klass = function->GetClass();
const Vector<JSBFunctionType*>& parameters = function->GetParameters();
Vector<String> args;
if (!function->IsConstructor() && !function->IsStatic())
{
args.Push(ToString("%s* self", klass->GetNativeName().CString()));
}
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++)
{
JSBFunctionType* ptype = parameters.At(i);
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
continue;
}
args.Push(ToString("%s* %s", klass->GetNativeName().CString(), ptype->name_.CString()));
}
else
{
args.Push(CSTypeHelper::GetNativeTypeString(ptype) + " " + ptype->name_);
}
}
}
if (function->GetReturnClass() && function->GetReturnClass()->IsNumberArray())
{
args.Push(ToString("%s* returnValue", function->GetReturnClass()->GetNativeName().CString()));
}
if (function->GetReturnType())
{
JSBVectorType* vtype = function->GetReturnType()->type_->asVectorType();
if (vtype)
{
args.Push("ScriptVector* returnValue");
}
}
sig.Join(args, ", ");
}
void CSFunctionWriter::GenManagedFunctionParameters(String& sig)
{
// generate args
const Vector<JSBFunctionType*>& parameters = function_->GetParameters();
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++)
{
bool isStruct = false;
JSBFunctionType* ptype = parameters.At(i);
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
continue;
}
// TODO: we should have a better system for struct type in general
// This number array is really for JS
if (klass->IsNumberArray())
{
isStruct = true;
}
}
String managedTypeString = CSTypeHelper::GetManagedTypeString(ptype);
if (!ptype->isConst_ && (ptype->isReference_ && isStruct))
{
// pass by reference
managedTypeString = "ref " + managedTypeString;
}
sig += managedTypeString;
String init = ptype->initializer_;
if (init.Length())
{
init = MapDefaultParameter(ptype);
if (init.Length())
sig += " = " + init;
}
if (i + 1 != parameters.Size())
sig += ", ";
}
}
}
void JSPackageWriter::WriteProtoTypeRecursive(String &source, JSBClass* klass, Vector<JSBClass*>& written)
{
if (written.Contains(klass))
return;
if (klass->GetModule()->GetDotNetModule())
return;
PODVector<JSBClass*>& baseClasses = klass->GetBaseClasses();
Vector<JSBClass*>::Iterator itr = baseClasses.End() - 1 ;
while (itr != baseClasses.Begin() - 1)
{
WriteProtoTypeRecursive(source, (*itr), written);
itr--;
}
JSBClass* base = baseClasses.Size() ? baseClasses[0] : NULL;
if (!klass->IsNumberArray() && klass->GetPackage() == package_)
{
JSBModule* module = klass->GetModule();
String moduleGuard = module->GetModuleDefineGuard();
if (moduleGuard.Length())
{
source += ToString("\n%s\n", moduleGuard.CString());
}
if (module->Requires("3D"))
source += "\n#ifdef ATOMIC_3D\n";
String packageName = klass->GetModule()->GetPackage()->GetName();
String basePackage = base ? base->GetModule()->GetPackage()->GetName() : "";
source.AppendWithFormat(" js_setup_prototype(vm, \"%s\", \"%s\", \"%s\", \"%s\", %s);\n",
packageName.CString(), klass->GetName().CString(),
base ? basePackage.CString() : "", base ? base->GetName().CString() : "",
klass->HasProperties() ? "true" : "false");
if (module->Requires("3D"))
source += "#endif\n\n";
if (moduleGuard.Length())
{
source += ToString("\n#endif\n", moduleGuard.CString());
}
}
written.Push(klass);
}
String JSBTypeScript::GetScriptType(JSBFunctionType* ftype)
{
String scriptType = "number";
if (ftype->type_->asPrimitiveType())
{
JSBPrimitiveType* ptype = ftype->type_->asPrimitiveType();
if (ptype->kind_ == JSBPrimitiveType::Bool)
scriptType = "boolean";
}
if (ftype->type_->asStringHashType() || ftype->type_->asStringType())
scriptType = "string";
if (ftype->type_->asEnumType())
scriptType = ftype->type_->asEnumType()->enum_->GetName();
if (ftype->type_->asClassType())
{
JSBClass* klass = ftype->type_->asClassType()->class_;
scriptType = klass->GetName();
if (klass->GetPackage()->GetName() != package_->GetName())
{
scriptType = klass->GetPackage()->GetName() + "." + klass->GetName();
}
}
if (ftype->type_->asVectorType())
{
scriptType = "string[]";
}
return scriptType;
}
String JSBHaxe::GetScriptType(JSBFunctionType* ftype)
{
String scriptType = "Dynamic";
if (ftype->type_->asPrimitiveType())
{
JSBPrimitiveType* ptype = ftype->type_->asPrimitiveType();
scriptType = GetPrimitiveType(ptype);
return scriptType;
}
if (ftype->type_->asStringHashType() || ftype->type_->asStringType())
scriptType = "String";
if (ftype->type_->asEnumType())
scriptType = ftype->type_->asEnumType()->enum_->GetName();
if (ftype->type_->asClassType())
{
JSBClass* klass = ftype->type_->asClassType()->class_;
scriptType = klass->GetName();
if (klass->GetPackage()->GetName() != package_->GetName())
{
scriptType = klass->GetPackage()->GetName() + "." + klass->GetName();
}
}
if (ftype->type_->asVectorType())
{
JSBVectorType* vectorType = ftype->type_->asVectorType();
scriptType = "Array<String>";
}
return scriptType;
}
void JSBModuleWriter::WriteForwardDeclarations(String& source)
{
Vector<SharedPtr<JSBClass>> classes = module_->classes_.Values();
for (unsigned i = 0; i < classes.Size(); i++)
{
JSBClass* cls = classes.At(i);
if (cls->IsNumberArray())
continue;
source.AppendWithFormat("static duk_ret_t jsb_constructor_%s(duk_context* ctx);\n", cls->GetName().CString());
source.AppendWithFormat("static void jsb_class_define_%s(JSVM* vm);\n", cls->GetName().CString());
}
}
void JSBModule::WriteClassDefine(String& source)
{
source += "static void jsb_init_classes(JSVM* vm)\n{\n";
for (unsigned i = 0; i < classes_.Size(); i++)
{
JSBClass* klass = classes_.At(i);
if (klass->isNumberArray())
continue;
source.AppendWithFormat(" jsb_class_define_%s(vm);\n", klass->GetName().CString());
}
source += "\n}\n\n";
}
void JSBModuleWriter::WriteClassDefine(String& source)
{
Vector<SharedPtr<JSBClass>> classes = module_->classes_.Values();
source += "static void jsb_init_classes(JSVM* vm)\n{\n";
for (unsigned i = 0; i < classes.Size(); i++)
{
JSBClass* klass = classes.At(i);
if (klass->IsNumberArray())
continue;
source.AppendWithFormat(" jsb_class_define_%s(vm);\n", klass->GetName().CString());
}
source += "\n}\n\n";
}
void CSFunctionWriter::GenNativeCallParameters(String& sig)
{
JSBClass* klass = function_->GetClass();
Vector<JSBFunctionType*>& parameters = function_->GetParameters();
Vector<String> args;
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++)
{
JSBFunctionType* ptype = parameters.At(i);
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
continue;
}
if (klass->IsNumberArray())
args.Push(ToString("*%s", ptype->name_.CString()));
else
args.Push(ToString("%s", ptype->name_.CString()));
}
else
{
args.Push(ToString("%s", ptype->name_.CString()));
}
}
}
sig.Join(args, ", ");
}
void CSFunctionWriter::GenManagedFunctionParameters(String& sig)
{
// generate args
Vector<JSBFunctionType*>& parameters = function_->GetParameters();
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++)
{
JSBFunctionType* ptype = parameters.At(i);
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
continue;
}
}
sig += CSTypeHelper::GetManagedTypeString(ptype);
String init = ptype->initializer_;
if (init.Length())
{
init = MapDefaultParameter(ptype);
if (init.Length())
sig += " = " + init;
}
if (i + 1 != parameters.Size())
sig += ", ";
}
}
}
void CSFunctionWriter::WriteManagedPInvokeFunctionSignature(String& source)
{
JSBClass* klass = function_->GetClass();
JSBPackage* package = klass->GetPackage();
if (klass->IsInterface())
return;
source += "\n";
// CoreCLR has pinvoke security demand code commented out, so we do not (currently) need this optimization:
// https://github.com/dotnet/coreclr/issues/1605
// line = "[SuppressUnmanagedCodeSecurity]\n";
// source += IndentLine(line);
String line = "[DllImport (Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]\n";
source += IndentLine(line);
String returnType = CSTypeHelper::GetPInvokeTypeString(function_->GetReturnType());
// handled by out parameter
if (function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
returnType = "void";
if (returnType == "bool")
{
// default boolean marshal is 4 byte windows type BOOL and not 1 byte bool
// https://blogs.msdn.microsoft.com/jaredpar/2008/10/14/pinvoke-and-bool-or-should-i-say-bool/
source += IndentLine("[return: MarshalAs(UnmanagedType.I1)]\n");
}
if (returnType == "string")
returnType = "IntPtr";
if (function_->IsConstructor())
returnType = "IntPtr";
const Vector<JSBFunctionType*>& parameters = function_->GetParameters();
Vector<String> args;
if (!function_->IsConstructor() && !function_->IsStatic())
{
args.Push("IntPtr self");
}
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++)
{
JSBFunctionType* ptype = parameters.At(i);
String name = ptype->name_;
if (name == "object")
name = "_object";
else if (name == "readonly")
name = "readOnly";
else if (name == "params")
name = "parameters";
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
continue;
}
if (klass->IsNumberArray())
{
args.Push("ref " + klass->GetName() + " " + name);
}
else
{
args.Push("IntPtr " + name);
}
}
else
{
args.Push(CSTypeHelper::GetPInvokeTypeString(ptype) + " " + name);
}
}
}
if (function_->GetReturnClass())
{
JSBClass* retClass = function_->GetReturnClass();
if (retClass->IsNumberArray())
{
args.Push("ref " + retClass->GetName() + " retValue");
}
}
else if (function_->GetReturnType() && function_->GetReturnType()->type_->asVectorType())
{
args.Push("IntPtr returnValue");
}
String pstring;
pstring.Join(args, ", ");
String fname = function_->IsConstructor() ? "Constructor" : function_->GetName();
line = ToString("private static extern %s csb_%s_%s_%s_%u(%s);\n",
returnType.CString(), package->GetName().CString(), klass->GetName().CString(),
fname.CString(), function_->GetID(), pstring.CString());
source += IndentLine(line);
source += "\n";
}
void CSFunctionWriter::WriteManagedConstructor(String& source)
{
JSBClass* klass = function_->GetClass();
JSBPackage* package = klass->GetPackage();
if (klass->GetName() == "RefCounted")
return;
// wrapping constructor
String line;
if (!wroteConstructor_)
{
line = ToString("public %s (IntPtr native) : base (native)\n", klass->GetName().CString());
source += IndentLine(line);
source += IndentLine("{\n");
source += IndentLine("}\n\n");
}
// don't add wrapping constructor for overloads
wroteConstructor_ = true;
String sig;
GenManagedFunctionParameters(sig);
line = ToString("public %s (%s)\n", klass->GetName().CString(), sig.CString());
source += IndentLine(line);
source += IndentLine("{\n");
Indent();
WriteDefaultStructParameters(source);
source += IndentLine("if (nativeInstance == IntPtr.Zero)\n");
source += IndentLine("{\n");
Indent();
source += IndentLine(ToString("var classType = typeof(%s);\n", klass->GetName().CString()));
source += IndentLine("var thisType = this.GetType();\n");
source += IndentLine("var thisTypeIsNative = NativeCore.IsNativeType(thisType);\n");
source += IndentLine("var nativeAncsestorType = NativeCore.GetNativeAncestorType(thisType);\n");
source += IndentLine("if ( (thisTypeIsNative && (thisType == classType)) || (!thisTypeIsNative && (nativeAncsestorType == classType)))\n");
source += IndentLine("{\n");
Indent();
String callSig;
GenPInvokeCallParameters(callSig);
line = ToString("nativeInstance = NativeCore.RegisterNative (csb_%s_%s_Constructor_%u(%s), this);\n",
package->GetName().CString(), klass->GetName().CString(), function_->GetID(), callSig.CString());
source += IndentLine(line);
Dedent();
source += IndentLine("}\n");
Dedent();
source += IndentLine("}\n");
Dedent();
source += IndentLine("}\n");
}
void JSBTypeScript::ExportModuleClasses(JSBModule* module)
{
Vector<SharedPtr<JSBClass>> classes = module->GetClasses();
if (!classes.Size())
return;
source_ += "\n";
for (unsigned i = 0; i < classes.Size(); i++)
{
JSBClass* klass = classes.At(i);
source_ += " export class " + klass->GetName();
JSBClass* base = klass->GetBaseClass();
if (base)
{
if (klass->GetPackage() != base->GetPackage())
{
source_ += " extends " + base->GetPackage()->GetName() + "." + base->GetName();
}
else
{
source_ += " extends " + base->GetName();
}
}
source_ += " {\n\n";
Vector<String> propertyNames;
klass->GetPropertyNames(propertyNames);
for (unsigned j = 0; j < propertyNames.Size(); j++)
{
JSBProperty* prop = klass->GetProperty(propertyNames[j]);
JSBFunctionType* ftype = NULL;
if (prop->getter_ && !prop->getter_->Skip())
{
ftype = prop->getter_->GetReturnType();
}
else if (prop->setter_ && !prop->setter_->Skip())
ftype = prop->setter_->GetParameters()[0];
if (!ftype)
continue;
String scriptType = GetScriptType(ftype);
String scriptName = prop->GetCasePropertyName();
source_ += " " + scriptName + ": " + scriptType + ";\n";
}
if (propertyNames.Size())
source_ += "\n";
JSBFunction* constructor = klass->GetConstructor();
if (constructor)
{
ExportFunction(constructor);
source_ += "\n";
}
PODVector<JSBFunction*>& functions = klass->GetFunctions();
for (unsigned j = 0; j < functions.Size(); j++)
{
JSBFunction* func = functions[j];
if (func->IsConstructor() || func->IsDestructor() || func->Skip())
continue;
ExportFunction(func);
}
for (unsigned j = 0; j < klass->GetNumTypeScriptDecl(); j++)
{
source_ += " " + klass->GetTypeScriptDecl(j) + "\n";
}
source_ += "\n }\n\n";
}
source_ += "\n";
}
void JSFunctionWriter::WriteFunction(String& source)
{
JSBClass* klass = function_->class_;
source.AppendWithFormat("static int jsb_class_%s_%s(duk_context* ctx)\n{\n", klass->GetName().CString(), function_->name_.CString());
WriteParameterMarshal(source);
if (!function_->IsStatic())
{
source.Append("duk_push_this(ctx);\n");
source.AppendWithFormat("%s* native = js_to_class_instance<%s>(ctx, -1, 0);\n", klass->GetNativeName().CString(), klass->GetNativeName().CString());
}
// declare return value;
bool returnDeclared = false;
JSBFunctionType* returnType = function_->returnType_;
if (returnType)
{
if (returnType->type_->asStringType())
{
returnDeclared = true;
source.Append("const String& retValue = ");
}
else if (returnType->type_->asPrimitiveType())
{
returnDeclared = true;
JSBPrimitiveType* prtype = returnType->type_->asPrimitiveType();
if (prtype->kind_ == JSBPrimitiveType::Bool)
{
source.Append("bool retValue = ");
}
else
{
source.Append("double retValue = ");
}
}
else if (returnType->type_->asClassType())
{
JSBClassType* klassType = returnType->type_->asClassType();
if (returnType->isTemplate_)
{
returnDeclared = true;
source.AppendWithFormat("SharedPtr<%s> object = ", klassType->class_->GetNativeName().CString());
}
else if (klassType->class_->IsObject())
{
returnDeclared = true;
source.Append("const Object* object = ");
}
else if (klassType->class_->IsNumberArray())
{
returnDeclared = true;
if (returnType->isReference_)
source.AppendWithFormat("const %s& retValue = ", klassType->class_->GetName().CString());
else
source.AppendWithFormat(" %s retValue = ", klassType->class_->GetName().CString());
}
else
{
returnDeclared = true;
source.Append("const RefCounted* object = ");
}
}
else if (returnType->type_->asEnumType())
{
JSBEnumType* enumType = returnType->type_->asEnumType();
returnDeclared = true;
source.AppendWithFormat("%s retValue = ", enumType->enum_->GetName().CString());
}
else if (returnType->type_->asVectorType())
{
returnDeclared = true;
JSBVectorType* vtype = returnType->type_->asVectorType();
source.AppendWithFormat("const %s& retValue = ", vtype->ToString().CString());
}
}
const Vector<JSBFunctionType*>& parameters = function_->GetParameters();
if (function_->IsStatic())
{
source.AppendWithFormat("%s::%s(", klass->GetNativeName().CString(), function_->name_.CString());
}
else
{
if (function_->HasMutatedReturn())
{
source.AppendWithFormat("__arg%i = native->%s(", parameters.Size() - 1, function_->name_.CString());
}
else
{
source.AppendWithFormat("native->%s(", function_->name_.CString());
}
}
unsigned numParams = parameters.Size();
if (numParams && function_->HasMutatedReturn())
numParams--;
for (unsigned int i = 0; i < numParams; i++)
{
source.AppendWithFormat("__arg%i", i);
if (i != numParams - 1)
{
source += ", ";
}
}
source += ");\n";
if (!returnDeclared)
{
if (function_->HasMutatedReturn())
{
// this handles the VariantVector case currently, can be expanded
source.AppendWithFormat("__scriptVectorArg%i->AdaptFromVector(__arg%i);\n", parameters.Size() - 1, parameters.Size() - 1);
}
source += "return 0;\n";
}
else
{
if (returnType->type_->asStringType())
{
source.Append("duk_push_string(ctx, retValue.CString());\n");
}
else if (returnType->type_->asPrimitiveType())
{
JSBPrimitiveType* prtype = returnType->type_->asPrimitiveType();
if (prtype->kind_ == JSBPrimitiveType::Bool)
{
source.Append("duk_push_boolean(ctx, retValue ? 1 : 0);\n");
}
else
{
source.Append("duk_push_number(ctx, retValue);\n");
}
}
else if (returnType->type_->asClassType())
{
JSBClassType* klassType = returnType->type_->asClassType();
if (klassType->class_->IsObject())
{
returnDeclared = true;
source.Append("js_push_class_object_instance(ctx, object);\n");
}
else if (klassType->class_->IsNumberArray())
{
returnDeclared = true;
String elementType = klassType->class_->GetArrayElementType();
source.AppendWithFormat("const %s* arrayData = retValue.Data();\n", elementType.CString());
source.Append("duk_push_array(ctx);\n");
for (int i = 0; i < klassType->class_->GetNumberArrayElements(); i++)
{
source.AppendWithFormat("duk_push_number(ctx, arrayData[%i]);\n", i);
source.AppendWithFormat("duk_put_prop_index(ctx, -2, %i);\n", i);
}
}
else
{
returnDeclared = true;
source.AppendWithFormat("js_push_class_object_instance(ctx, object, \"%s\");\n", klassType->class_->GetName().CString());
}
}
else if (returnType->type_->asEnumType())
{
returnDeclared = true;
source.Append("duk_push_number(ctx, (double) retValue);\n");
}
else if (returnType->type_->asVectorType())
{
JSBType* vectorType = returnType->type_->asVectorType()->vectorType_;
source.Append("duk_push_array(ctx);\n");
source.Append("for (unsigned i = 0; i < retValue.Size(); i++)\n{\n");
if (vectorType->asClassType())
{
source.AppendWithFormat("js_push_class_object_instance(ctx, retValue[i], \"%s\");\n", vectorType->asClassType()->class_->GetName().CString());
}
else
{
source.Append("duk_push_string(ctx, retValue[i].CString());\n");
}
source.Append("duk_put_prop_index(ctx, -2, i);\n}\n");
}
source += "return 1;\n";
}
source.Append("}\n");
}
void CSFunctionWriter::WriteManagedPInvokeFunctionSignature(String& source)
{
source += "\n";
// CoreCLR has pinvoke security demand code commented out, so we do not (currently) need this optimization:
// https://github.com/dotnet/coreclr/issues/1605
// line = "[SuppressUnmanagedCodeSecurity]\n";
// source += IndentLine(line);
String line = "[DllImport (Constants.LIBNAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]\n";
source += IndentLine(line);
JSBClass* klass = function_->GetClass();
JSBPackage* package = klass->GetPackage();
String returnType = CSTypeHelper::GetPInvokeTypeString(function_->GetReturnType());
if (returnType == "string")
returnType = "IntPtr";
if (function_->IsConstructor())
returnType = "IntPtr";
Vector<JSBFunctionType*>& parameters = function_->GetParameters();
Vector<String> args;
if (!function_->IsConstructor() && !function_->IsStatic())
{
args.Push("IntPtr self");
}
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++)
{
JSBFunctionType* ptype = parameters.At(i);
String name = ptype->name_;
if (name == "object")
name = "_object";
else if (name == "readonly")
name = "readOnly";
else if (name == "params")
name = "parameters";
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
continue;
}
if (klass->IsNumberArray())
{
args.Push("ref " + klass->GetName() + " " + name);
}
else
{
args.Push("IntPtr " + name);
}
}
else
{
args.Push(CSTypeHelper::GetPInvokeTypeString(ptype) + " " + name);
}
}
}
if (function_->GetReturnClass())
{
JSBClass* retClass = function_->GetReturnClass();
if (retClass->IsNumberArray())
{
args.Push("ref " + retClass->GetName() + " retValue");
}
}
String pstring;
pstring.Join(args, ", ");
String fname = function_->IsConstructor() ? "Constructor" : function_->GetName();
line = ToString("private static extern %s csb_%s_%s_%s(%s);\n",
returnType.CString(), package->GetName().CString(), klass->GetName().CString(),
fname.CString(), pstring.CString());
source += IndentLine(line);
source += "\n";
}
void JSFunctionWriter::WriteParameterMarshal(String& source)
{
// generate args
const Vector<JSBFunctionType*>& parameters = function_->GetParameters();
int cparam = 0;
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++, cparam++)
{
JSBFunctionType * ptype = parameters.At(i);
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
cparam--;
continue;
}
}
String pstring = ptype->ToArgString(cparam);
const String& init = ptype->initializer_;
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (!klass->IsNumberArray())
{
if (init.Length())
{
source.AppendWithFormat("%s = duk_get_top(ctx) >= %i ? js_to_class_instance<%s>(ctx, %i, 0) : %s;\n",
pstring.CString(), cparam + 1, klass->GetNativeName().CString(), cparam, init.CString());
}
else
{
source.AppendWithFormat("%s = js_to_class_instance<%s>(ctx, %i, 0);\n",
pstring.CString(), klass->GetNativeName().CString(), cparam);
}
}
else
{
int elements = klass->GetNumberArrayElements();
String elementType = klass->GetArrayElementType();
source.AppendWithFormat("%s arrayData%i[%i];\n", elementType.CString(), cparam, elements);
if (init.Length())
{
source.AppendWithFormat("const %s& defaultArg%i = %s;\n", klass->GetNativeName().CString(), cparam, init.CString());
source.AppendWithFormat("if (duk_get_top(ctx) >= %i) {\n", cparam + 1);
}
for (int j = 0; j < elements; j++)
{
source.AppendWithFormat("duk_get_prop_index(ctx, %i, %i);\n", cparam, j);
source.AppendWithFormat("arrayData%i[%i] = (%s) duk_to_number(ctx, -1);\n", cparam, j, elementType.CString());
}
source.AppendWithFormat("duk_pop_n(ctx, %i);\n", elements);
if (init.Length())
{
source.Append("}\n");
source.AppendWithFormat("%s __arg%i(duk_get_top(ctx) >= %i ? (const %s *) arrayData%i : defaultArg%i.Data());\n",
klass->GetNativeName().CString(), cparam, cparam + 1, elementType.CString(), cparam, cparam);
}
else
{
source.AppendWithFormat("%s __arg%i(arrayData%i);\n", klass->GetNativeName().CString(), cparam, cparam);
}
}
}
else if (ptype->type_->asStringType() || ptype->type_->asStringHashType())
{
if (init.Length())
{
source.AppendWithFormat("%s = duk_get_top(ctx) >= %i ? duk_to_string(ctx, %i) : %s;\n", pstring.CString(), cparam + 1, cparam, init.CString());
}
else
{
source.AppendWithFormat("%s = duk_to_string(ctx, %i);\n", pstring.CString(), cparam);
}
}
else if (ptype->type_->asHeapPtrType())
{
if (init.Length())
{
source.AppendWithFormat("%s = duk_get_top(ctx) >= %i ? duk_get_heapptr(ctx, %i) : %s;\n", pstring.CString(), cparam + 1, cparam, init.CString());
}
else
{
source.AppendWithFormat("%s = duk_get_heapptr(ctx, %i);\n", pstring.CString(), cparam);
}
}
else if (ptype->type_->asPrimitiveType())
{
JSBPrimitiveType* prtype = ptype->type_->asPrimitiveType();
if (prtype->kind_ == JSBPrimitiveType::Bool)
{
if (init.Length())
{
source.AppendWithFormat("bool __arg%i = duk_get_top(ctx) >= %i ? (duk_to_boolean(ctx, %i) ? true : false) : %s;\n",
cparam, cparam + 1, cparam, init.CString());
}
else
{
source.AppendWithFormat("bool __arg%i = duk_to_boolean(ctx, %i) ? true : false;\n", cparam, cparam);
}
}
else
{
if (init.Length())
{
source.AppendWithFormat("double __arg%i = duk_get_top(ctx) >= %i ? (duk_to_number(ctx, %i)) : %s;\n",
cparam, cparam + 1, cparam, init.CString());
}
else
{
source.AppendWithFormat("double __arg%i = duk_to_number(ctx, %i);\n", cparam, cparam);
}
}
}
else if (ptype->type_->asEnumType())
{
JSBEnumType* etype = ptype->type_->asEnumType();
if (init.Length())
{
source.AppendWithFormat("%s __arg%i = duk_get_top(ctx) >= %i ? ((%s) ((int) duk_to_number(ctx, %i))) : %s;\n", etype->enum_->GetName().CString(),
cparam, cparam + 1, etype->enum_->GetName().CString(), cparam, init.CString());
}
else
{
source.AppendWithFormat("%s __arg%i = (%s) ((int)duk_to_number(ctx, %i));\n", etype->enum_->GetName().CString(),
cparam, etype->enum_->GetName().CString(), cparam);
}
}
else if (ptype->type_->asVectorType())
{
JSBVectorType* vtype = ptype->type_->asVectorType();
if (vtype->isVariantVector_)
{
// variant vector arguments
source.AppendWithFormat("VariantVector __arg%i;\nScriptVector* __scriptVectorArg%i = js_to_class_instance<ScriptVector>(ctx, %i, 0);\n", cparam, cparam, cparam);
if (!function_->HasMutatedReturn())
source.AppendWithFormat("__scriptVectorArg%i->AdaptToVector(__arg%i);\n", cparam, cparam);
}
else if (ptype->isConst_)
{
// JS/TS side needs work for vector parameters, right now we support const (read only)
// Vector of String/StringHash
source.AppendWithFormat("%s __arg%i;\n", vtype->ToString().CString(), cparam);
source.AppendWithFormat("if (duk_get_top(ctx) >= %i)\n{\n", cparam + 1);
source.AppendWithFormat("duk_require_object_coercible(ctx, %i);\n", cparam);
source.AppendWithFormat("unsigned sz = duk_get_length(ctx, %i);\n", cparam);
source.AppendWithFormat("for (unsigned i = 0; i < sz; i++)\n{\n");
source.AppendWithFormat("duk_get_prop_index(ctx, 2, i);\n");
if (vtype->vectorType_->asStringType() || vtype->vectorType_->asStringHashType() )
{
source.AppendWithFormat("__arg%i.Push(duk_get_string(ctx, -1));\n", cparam);
}
source.AppendWithFormat("duk_pop(ctx);\n");
source.AppendWithFormat("\n}\n");
source.AppendWithFormat("\n}\n");
}
}
}
}
}
void JSBTypeScript::ExportModuleClasses(const String& moduleName)
{
JSBModule* module = JSBindings::Instance()->GetModuleByName(moduleName);
if (!module->classes_.Size())
return;
source_ += "\n";
for (unsigned i = 0; i < module->classes_.Size(); i++)
{
JSBClass* klass = module->classes_.At(i);
source_ += " export class " + klass->GetName();
if (klass->GetBaseClass())
source_ += " extends " + klass->GetBaseClass()->GetName();
source_ += " {\n\n";
Vector<String> propertyNames;
klass->GetPropertyNames(propertyNames);
for (unsigned j = 0; j < propertyNames.Size(); j++)
{
JSBProperty* prop = klass->GetProperty(propertyNames[j]);
JSBFunctionType* ftype = NULL;
if (prop->getter_ && !prop->getter_->Skip())
{
ftype = prop->getter_->returnType_;
}
else if (prop->setter_ && !prop->setter_->Skip())
ftype = prop->setter_->parameters_[0];
if (!ftype)
continue;
String scriptType = GetScriptType(ftype);
String scriptName = propertyNames[j];
scriptName[0] = tolower(scriptName[0]);
source_ += " " + scriptName + ": " + scriptType + ";\n";
}
if (propertyNames.Size())
source_ += "\n";
JSBFunction* constructor = klass->GetConstructor();
if (constructor)
{
ExportFunction(constructor);
source_ += "\n";
}
for (unsigned j = 0; j < klass->GetFunctionCount(); j++)
{
JSBFunction* func = klass->GetFunction(j);
if (func->isConstructor_ || func->isDestructor_ || func->Skip())
continue;
ExportFunction(func);
}
source_ += "\n }\n\n";
}
source_ += "\n";
}
void CSFunctionWriter::GenPInvokeCallParameters(String& sig)
{
// generate args
Vector<JSBFunctionType*>& parameters = function_->GetParameters();
if (parameters.Size())
{
for (unsigned int i = 0; i < parameters.Size(); i++)
{
JSBFunctionType* ptype = parameters.At(i);
// ignore "Context" parameters
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
continue;
}
}
String name = ptype->name_;
if (name == "object")
name = "_object";
else if (name == "readonly")
name = "readOnly";
else if (name == "params")
name = "parameters";
if (ptype->type_->asClassType())
{
JSBClass* pclass = ptype->type_->asClassType()->class_;
if (pclass->IsNumberArray())
{
sig += "ref " + name;
}
else
{
sig += name + " == null ? IntPtr.Zero : " + name + ".nativeInstance";
}
}
else
{
sig += name;
}
if (i + 1 != parameters.Size())
sig += ", ";
}
}
// data marshaller
if (function_->GetReturnType() && !CSTypeHelper::IsSimpleReturn(function_->GetReturnType()))
{
if (function_->GetReturnClass()->IsNumberArray())
{
if (sig.Length())
sig += ", ";
JSBClass* klass = function_->GetClass();
sig += ToString("ref %s%sReturnValue", klass->GetName().CString(), function_->GetName().CString());
}
}
}
void JSBHaxe::ExportModuleClasses(JSBModule* module)
{
Vector<SharedPtr<JSBClass>> classes = module->GetClasses();
if (!classes.Size())
return;
source_ += "\n";
for (unsigned i = 0; i < classes.Size(); i++)
{
JSBClass* klass = classes.At(i);
if (klass->IsNumberArray()) {
source_ += "typedef " + klass->GetName() + " = Array<Float>;\n";
continue;
}
source_ += "@:native(\"Atomic." + klass->GetName() + "\")\n";
source_ += "extern class " + klass->GetName();
JSBClass* base = klass->GetBaseClass();
if (base)
{
source_ += " extends " + base->GetName();
}
source_ += " {\n\n";
Vector<String> propertyNames;
klass->GetPropertyNames(propertyNames);
for (unsigned j = 0; j < propertyNames.Size(); j++)
{
JSBProperty* prop = klass->GetProperty(propertyNames[j]);
JSBFunctionType* ftype = NULL;
if (prop->getter_ && !prop->getter_->Skip())
{
ftype = prop->getter_->GetReturnType();
}
else if (prop->setter_ && !prop->setter_->Skip())
ftype = prop->setter_->GetParameters()[0];
if (!ftype)
continue;
String scriptType = GetScriptType(ftype);
String scriptName = prop->GetCasePropertyName();
if (!checkV(klass, scriptName, scriptType)) {
//rename haxe reserved words
if (scriptName == "override") {
scriptName = "overide";
}
if (scriptName == "dynamic") {
scriptName = "dynamik";
}
source_ += " var " + scriptName + ": " + scriptType + ";\n";
}
}
if (propertyNames.Size())
source_ += "\n";
JSBFunction* constructor = klass->GetConstructor();
if (constructor)
{
ExportFunction(constructor);
source_ += "\n";
}
PODVector<JSBFunction*>& functions = klass->GetFunctions();
for (unsigned j = 0; j < functions.Size(); j++)
{
JSBFunction* func = functions[j];
if (func->IsConstructor() || func->IsDestructor() || func->Skip())
continue;
ExportFunction(func);
}
for (unsigned j = 0; j < klass->GetNumHaxeDecl(); j++)
{
source_ += " " + klass->GetHaxeDecl(j) + "\n";
}
source_ += "\n}\n\n";
}
source_ += "\n";
}
void JSFunctionWriter::WriteConstructor(String& source)
{
// TODO: refactor this
if (function_->name_ == "RefCounted")
{
source.Append("// finalizer may be called more than once\n" \
"static int jsb_finalizer_RefCounted(duk_context *ctx)\n" \
"{\n" \
"JSVM* vm = JSVM::GetJSVM(ctx);\n" \
\
"duk_get_prop_index(ctx, 0, JS_INSTANCE_INDEX_FINALIZED);\n" \
\
"if (!duk_is_boolean(ctx, -1))\n" \
"{\n" \
"RefCounted* ref = vm->GetObjectPtr(duk_get_heapptr(ctx, 0));\n" \
"vm->RemoveObject(ref);\n" \
"ref->ReleaseRef();\n" \
"duk_push_boolean(ctx, 1);\n" \
"duk_put_prop_index(ctx, 0, JS_INSTANCE_INDEX_FINALIZED);\n" \
"}\n" \
\
"return 0;\n" \
"}\n");
}
JSBClass* klass = function_->class_;
JSBClass* base = klass->GetBaseClass();
// Constructor
source.AppendWithFormat("duk_ret_t jsb_constructor_%s(duk_context* ctx)\n{\n", klass->GetName().CString());
source.Append( "\nJSVM* vm = JSVM::GetJSVM(ctx);\n" \
"duk_push_this(ctx);\n" \
"void *ptr = duk_get_heapptr(ctx, -1);\n" \
"duk_pop(ctx);\n\n");
source.Append(" if (!vm->GetObjectPtr(ptr, true))\n {\n");
if (!klass->IsAbstract() && !klass->IsNumberArray())
{
String marshal;
WriteParameterMarshal(marshal);
String sparams;
int cparam = 0;
const Vector<JSBFunctionType*>& parameters = function_->GetParameters();
for (unsigned i = 0; i < parameters.Size(); i++, cparam++)
{
JSBFunctionType * ptype = parameters.At(i);
String sarg;
if (ptype->type_->asClassType())
{
JSBClassType* classType = ptype->type_->asClassType();
JSBClass* klass = classType->class_;
if (klass->GetName() == "Context")
{
sarg = "vm->GetContext()";
cparam--;
}
}
if (!sarg.Length())
{
sarg.AppendWithFormat("__arg%i", cparam);
}
sparams += sarg;
if (i + 1 < parameters.Size())
sparams += ", ";
}
source.AppendWithFormat("if (!duk_get_top(ctx) || !duk_is_pointer(ctx, 0))\n"\
"{\n"\
"%s\n"\
"%s* native = new %s(%s);\n" \
"vm->AddObject(ptr, native, INSTANTIATION_JAVASCRIPT);\n"\
"}\n" \
"else if (duk_is_pointer(ctx, 0))\n" \
"{\n" \
"RefCounted* rc = (RefCounted*) duk_get_pointer(ctx, 0);\n" \
"vm->AddObject(ptr, rc, rc->GetInstantiationType());\n" \
"}\n", marshal.CString(), klass->GetNativeName().CString(), klass->GetNativeName().CString(), sparams.CString());
}
else
{
if (klass->IsAbstract())
source.Append("assert(0); // abstract class new'd\n");
if (klass->IsNumberArray())
source.Append("assert(0); // number array class new'd\n");
}
source.Append(" }\n");
if (base)
{
String basePackage = base->GetModule()->GetPackage()->GetName();
source.AppendWithFormat(" js_constructor_basecall(ctx, \"%s\", \"%s\");\n", basePackage.CString(), base->GetName().CString());
}
if (function_->name_ == "RefCounted")
{
source.Append("duk_push_this(ctx);\n "\
"duk_push_c_function(ctx, jsb_finalizer_RefCounted, 1);\n "\
"duk_set_finalizer(ctx, -2);\n "\
"duk_pop(ctx);\n");
}
source += " return 0;";
source += "\n}\n";
}
