void CSFunctionWriter::WriteManagedFunction(String& source)
{
JSBClass* klass = function_->GetClass();
JSBPackage* package = klass->GetPackage();
String sig;
String returnType = CSTypeHelper::GetManagedTypeString(function_->GetReturnType());
GenManagedFunctionParameters(sig);
String line = "public ";
if (function_->IsStatic())
{
line += "static ";
}
bool marked = false;
JSBClass* baseClass = klass->GetBaseClass();
if (baseClass)
{
JSBFunction* override = baseClass->MatchFunction(function_, true);
if (override)
{
marked = true;
if (override->IsVirtual())
line += "override ";
else
line += "new ";
}
}
void JSBModule::ProcessHaxeDecl()
{
// Haxe declarations
JSONValue root = moduleJSON_->GetRoot();
JSONValue decl = root.GetChild("haxe_decl");
if (decl.IsObject())
{
Vector<String> childNames = decl.GetChildNames();
for (unsigned j = 0; j < childNames.Size(); j++)
{
String classname = childNames.At(j);
JSBClass* klass = GetClass(classname);
if (!klass)
{
ErrorExit("Bad Haxe decl class");
}
JSONValue classdecl = decl.GetChild(classname);
for (unsigned k = 0; k < classdecl.GetSize(); k++)
{
klass->AddHaxeDecl(classdecl.GetString(k));
}
}
}
}
bool JSBHaxe::checkV(JSBClass* clazz, const String name, const String type) {
PODVector<JSBClass*>& base = clazz->GetBaseClasses();
for (unsigned j = 0; j < base.Size(); j++)
{
JSBClass* baseClass = base[j];
Vector<String> propertyNames;
baseClass->GetPropertyNames(propertyNames);
for (unsigned i = 0; i < propertyNames.Size(); i++)
{
JSBProperty* prop = baseClass->GetProperty(propertyNames[i]);
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 scriptName = prop->GetCasePropertyName();
if (scriptName == name)
{
return true;
}
}
}
return false;
}
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);
}
void JSBModule::ProcessExcludes()
{
// excludes
JSONValue root = moduleJSON_->GetRoot();
JSONValue excludes = root.GetChild("excludes");
if (excludes.IsObject())
{
Vector<String> childNames = excludes.GetChildNames();
for (unsigned j = 0; j < childNames.Size(); j++)
{
String classname = childNames.At(j);
JSBClass* klass = GetClass(classname);
if (!klass)
{
ErrorExit("Bad exclude klass");
}
JSONValue classexcludes = excludes.GetChild(classname);
Vector<String> functionNames = classexcludes.GetChildNames();
for (unsigned k = 0; k < functionNames.Size(); k++)
{
JSONValue sig = classexcludes.GetChild(functionNames[k]);
if (!sig.IsArray())
{
ErrorExit("Bad exclude defintion");
}
Vector<String> values;
for (unsigned x = 0; x < sig.GetSize(); x++)
{
values.Push(sig.GetString(x));
}
JSBFunctionSignature* fe = new JSBFunctionSignature(functionNames[k], values);
klass->AddFunctionExclude(fe);
}
}
}
}
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::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 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 CSModuleWriter::GenerateManagedClasses(String& source)
{
Vector<SharedPtr<JSBClass>> classes = module_->classes_.Values();
for (unsigned i = 0; i < classes.Size(); i++)
{
JSBClass* klass = classes.At(i);
if (klass->IsNumberArray())
continue;
CSClassWriter clsWriter(klass);
clsWriter.GenerateManagedSource(source);
}
}
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::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 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";
}
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 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::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");
}
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 += ", ";
}
}
}
JSBFunction* JSBHaxe::findFunctionInBase(JSBFunction* function) {
PODVector<JSBClass*>& base = function->GetClass()->GetBaseClasses();
for (unsigned j = 0; j < base.Size(); j++)
{
JSBClass* klass = base[j];
PODVector<JSBFunction*>& functions = klass->GetFunctions();
for (unsigned j = 0; j < functions.Size(); j++)
{
JSBFunction* func = functions[j];
if (func->IsConstructor() || func->IsDestructor() )
continue;
if (func->GetName() == function->GetName()) {
return func;
}
}
}
return NULL;
}
void JSBModule::Load(const String &moduleJSONFilename)
{
ResourceCache* cache = JSBind::context_->GetSubsystem<ResourceCache>();
JSONFile* moduleJSONFile = cache->GetResource<JSONFile>(moduleJSONFilename);
if (!moduleJSONFile)
{
LOGERRORF("Couldn't load module json: %s", moduleJSONFilename.CString());
ErrorExit("Couldn't load module json");
}
JSONValue moduleJSON = moduleJSONFile->GetRoot();
JSONValue sources = moduleJSON.GetChild("sources");
JSONValue classes = moduleJSON.GetChild("classes");
JSONValue includes = moduleJSON.GetChild("includes");
JSONValue classes_rename = moduleJSON.GetChild("classes_rename");
JSONValue overloads = moduleJSON.GetChild("overloads");
JSONValue requires = moduleJSON.GetChild("requires");
HashMap<String, String> rename;
if (requires.IsArray())
{
for (unsigned j = 0; j < requires.GetSize(); j++)
{
requirements_.Push(requires.GetString(j));
}
}
if (classes_rename.IsObject())
{
Vector<String> childNames = classes_rename.GetValueNames();
for (unsigned j = 0; j < childNames.Size(); j++)
{
String classname = childNames.At(j);
String crename = classes_rename.GetString(classname);
rename[classname] = crename;
}
}
if (includes.IsArray())
{
for (unsigned j = 0; j < includes.GetSize(); j++)
{
includes_.Push(includes.GetString(j));
}
}
if (classes.IsArray())
{
for (unsigned j = 0; j < classes.GetSize(); j++)
{
String classname = classes.GetString(j);
if (rename.Contains(classname))
bindings_->RegisterClass(classname, rename[classname]);
else
bindings_->RegisterClass(classname);
}
}
if (overloads.IsObject())
{
Vector<String> childNames = overloads.GetChildNames();
for (unsigned j = 0; j < childNames.Size(); j++)
{
String classname = childNames.At(j);
JSBClass* klass = bindings_->GetClass(classname);
if (!klass)
{
ErrorExit("Bad overload klass");
}
JSONValue classoverloads = overloads.GetChild(classname);
Vector<String> functionNames = classoverloads.GetChildNames();
for (unsigned k = 0; k < functionNames.Size(); k++)
{
JSONValue sig = classoverloads.GetChild(functionNames[k]);
if (!sig.IsArray())
{
ErrorExit("Bad overload defintion");
}
Vector<String> values;
for (unsigned x = 0; x < sig.GetSize(); x++)
{
values.Push(sig.GetString(x));
}
JSBFunctionOverride* fo = new JSBFunctionOverride(functionNames[k], values);
klass->AddFunctionOverride(fo);
}
}
}
this->name_ = moduleJSON.GetString("name");
if (this->name_ == "Graphics")
{
#ifdef _MSC_VER
sources.AddString("Graphics/Direct3D9");
#else
sources.AddString("Graphics/OpenGL");
#endif
}
for (unsigned j = 0; j < sources.GetSize(); j++)
{
String sourceFolder = sources.GetString(j);
Vector<String> fileNames;
String sourceRoot = "Atomic";
if (sourceFolder == "Javascript")
sourceRoot = "AtomicJS";
JSBind::fileSystem_->ScanDir(fileNames, JSBind::ROOT_FOLDER + "/Source/" + sourceRoot + "/" + sourceFolder, "*.h", SCAN_FILES, false);
for (unsigned k = 0; k < fileNames.Size(); k++)
{
// TODO: filter
String filepath = JSBind::ROOT_FOLDER + "/Source/" + sourceRoot + "/" + sourceFolder + "/" + fileNames[k];
this->headerFiles_.Push(filepath);
}
}
}
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::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 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 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 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::WriteNativeFunction(String& source)
{
JSBClass* klass = function_->GetClass();
JSBPackage* package = klass->GetPackage();
String fname = function_->IsConstructor() ? "Constructor" : function_->GetName();
String returnType;
String functionSig = CSTypeHelper::GetNativeFunctionSignature(function_, returnType);
String line;
line = ToString("ATOMIC_EXPORT_API %s %s\n",
returnType.CString(), functionSig.CString());
source += IndentLine(line);
source += IndentLine("{\n");
Indent();
source += "\n";
bool returnValue = false;
bool sharedPtrReturn = false;
String returnStatement;
if (returnType == "const char*")
{
returnValue = true;
source += IndentLine("static String returnValue;\n");
returnStatement = "returnValue = ";
}
else if (function_->GetReturnClass() && function_->GetReturnClass()->IsNumberArray())
{
returnStatement = "*returnValue = ";
}
else if (function_->GetReturnClass() && function_->GetReturnType()->isSharedPtr_)
{
returnStatement = ToString("SharedPtr<%s> returnValue = ", function_->GetReturnClass()->GetNativeName().CString());
sharedPtrReturn = true;
}
else
{
if (returnType != "void")
{
returnStatement = "return ";
}
}
String callSig;
GenNativeCallParameters(callSig);
if (!function_->isConstructor_)
{
if (function_->IsStatic())
{
line = ToString("%s%s::%s(%s);\n", returnStatement.CString(), klass->GetNativeName().CString(), function_->GetName().CString(), callSig.CString());
}
else
{
line = ToString("%sself->%s(%s);\n", returnStatement.CString(), function_->GetName().CString(), callSig.CString());
}
}
else
{
if (klass->IsAbstract())
{
line = "return 0; // Abstract Class\n";
}
else if (klass->IsObject())
{
if (callSig.Length())
line = ToString("return new %s(NETCore::GetContext(), %s);\n", klass->GetNativeName().CString(), callSig.CString());
else
line = ToString("return new %s(NETCore::GetContext());\n", klass->GetNativeName().CString());
}
else
{
line = ToString("return new %s(%s);\n", klass->GetNativeName().CString(), callSig.CString());
}
}
source += IndentLine(line);
if (sharedPtrReturn)
{
source += IndentLine("returnValue->AddRef();\n");
source += IndentLine("return returnValue;\n");
}
else if (returnType == "const char*")
{
source += IndentLine("return returnValue.CString();\n");
}
Dedent();
source += IndentLine("}\n");
source += "\n";
}
void CSClassWriter::WriteManagedProperties(String& sourceOut)
{
String source;
if (klass_->HasProperties())
{
Vector<String> pnames;
klass_->GetPropertyNames(pnames);
for (unsigned j = 0; j < pnames.Size(); j++)
{
JSBProperty* prop = klass_->GetProperty(pnames[j]);
JSBFunctionType* fType = NULL;
JSBFunctionType* getType = NULL;
JSBFunctionType* setType = NULL;
if (CSTypeHelper::OmitFunction(prop->getter_) || CSTypeHelper::OmitFunction(prop->setter_))
continue;
if (prop->getter_ && !prop->getter_->Skip())
{
fType = getType = prop->getter_->GetReturnType();
}
if (prop->setter_ && !prop->setter_->Skip())
{
setType = prop->setter_->GetParameters()[0];
if (!fType)
fType = setType;
else if (fType->type_->ToString() != setType->type_->ToString())
continue;
}
if (!fType)
continue;
String line = klass_->IsInterface() ? "" : "public ";
JSBClass* baseClass = klass_->GetBaseClass();
if (baseClass)
{
if (baseClass->MatchProperty(prop, true))
{
// always new so we don't have to deal with virtual/override on properties
line += "new ";
}
}
String type = CSTypeHelper::GetManagedTypeString(fType, false);
line += ToString("%s %s\n", type.CString(), prop->name_.CString());
source += IndentLine(line);
source += IndentLine("{\n");
Indent();
if (prop->getter_)
{
if (klass_->IsInterface())
{
source += IndentLine("get;\n");
}
else
{
source += IndentLine("get\n");
source += IndentLine("{\n");
Indent();
source += IndentLine(ToString("return %s();\n", prop->getter_->GetName().CString()));
Dedent();
source += IndentLine("}\n");
}
}
if (prop->setter_)
{
if (klass_->IsInterface())
{
source += IndentLine("set;\n");
}
else
{
source += IndentLine("set\n");
source += IndentLine("{\n");
Indent();
source += IndentLine(ToString("%s(value);\n", prop->setter_->GetName().CString()));
Dedent();
source += IndentLine("}\n");
}
}
Dedent();
source += IndentLine("}\n\n");
}
}
sourceOut += source;
}
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";
}
