jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor emitter and code templates to use defined template variables.

Browse source 
Also switched from "${...}" to $..., which is swig's common notation
of typemap variables.

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/oliverb-javascript-v8@13787 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Oliver Buchtala 2012-09-08 01:05:11 +00:00
commit 8d72616e65
2 changed files with 175 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

154
Lib/javascript/jsc/javascriptcode.swg
View file

@ -6,10 +6,12 @@
%fragment ("JS_getproperty", "templates")
%{
JSValueRef ${getname}(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef* exception)
JSValueRef $jsgetter(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef* exception)
{
${LOCALS}
${CODE}
$jslocals
JSValueRef jsresult;
$jscode
return jsresult;
goto fail;
@ -26,10 +28,10 @@ JSValueRef ${getname}(JSContextRef context, JSObjectRef thisObject, JSStringRef
%fragment ("JS_setproperty", "templates")
%{
bool ${setname}(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
bool $jssetter(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
{
${LOCALS}
${CODE}
$jslocals
$jscode
return true;
@ -46,10 +48,12 @@ bool ${setname}(JSContextRef context, JSObjectRef thisObject, JSStringRef proper
************************************************************************************/
%fragment ("JS_functionwrapper", "templates")
%{
JSValueRef ${functionname}(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
JSValueRef $jswrapper(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
{
${LOCALS}
${CODE}
$jslocals
JSValueRef jsresult;
$jscode
return jsresult;
goto fail;
@ -60,10 +64,12 @@ JSValueRef ${functionname}(JSContextRef context, JSObjectRef function, JSObjectR
%fragment ("JS_functionwrapper_overload", "templates")
%{
int ${functionname}(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception, JSValueRef* result)
int $jswrapper(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception, JSValueRef* result)
{
${LOCALS}
${CODE}
$jslocals
JSValueRef jsresult;
$jscode
*result = jsresult;
return SWIG_OK;
@ -80,83 +86,81 @@ int ${functionname}(JSContextRef context, JSObjectRef function, JSObjectRef this
***********************************************************************/
%fragment ("JS_function_dispatch_case", "templates")
%{if(argc == ${argcount}) {
res = ${functionwrapper}(context, function, thisObject, argc, argv, exception, &jsresult);
%{if(argc == $jsargcount) {
res = $jswrapper(context, function, thisObject, argc, argv, exception, &jsresult);
if(res == SWIG_OK) { *exception = 0; return jsresult; }
}
%}
%fragment ("JS_function_dispatch_case_default", "templates")
%{
SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function ${functionname}.");
SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function $jsname.");
%}
/* Added template for function declaration */
%fragment ("JS_variabledecl", "templates")
%{{"${propertyname}",${getname}, ${setname},kJSPropertyAttributeNone},%}
%{{"$jsname", $jsgetter, $jssetter, kJSPropertyAttributeNone},%}
/* Added template for function declaration */
%fragment ("JS_functiondecl", "templates")
%{{"${functionname}",${functionwrapper}, kJSPropertyAttributeNone},%}
%{{"$jsname",$jswrapper, kJSPropertyAttributeNone},%}
%fragment ("JS_globaldefn", "templates")
%{
JSStaticValue ${namespace}_values[] = {
${jsglobalvariables}
JSStaticValue $jsnspace_values[] = {
$jsglobalvariables
{ 0, 0, 0, 0 }
};
JSStaticFunction ${namespace}_functions[] = {
${jsglobalfunctions}
JSStaticFunction $jsnspace_functions[] = {
$jsglobalfunctions
{ 0, 0, 0 }
};
JSClassDefinition ${namespace}_classDefinition;
JSClassDefinition $jsnspace_classDefinition;
%}
/******************************************************************************************
* class_definition:
* This code template is used for wrapper of classes definition.
* ${classname_mangled}:the mangled name of the qualified class name, e.g., foo::A -> foo_A
*****************************************************************************************/
/***********************************************************************
* class_definition:
* declarations of javascript class definition objects.
***********************************************************************/
%fragment ("JS_class_definition", "templates")
%{
JSClassDefinition ${classname_mangled}_classDefinition;
JSClassDefinition $jsmangledname_classDefinition;
JSClassDefinition ${classname_mangled}_objectDefinition;
JSClassDefinition $jsmangledname_objectDefinition;
JSClassRef ${classname_mangled}_classRef;
JSClassRef $jsmangledname_classRef;
%}
/*********************************************************************
* class_table:
* This code template is used to add the wrapper for class declaration
* ${classname_mangled}: The mangled name of the qualified class name, e.g., foo::A -> foo_A
/***********************************************************************
* class_table:
* function and variable tables for class and object creation.
***********************************************************************/
%fragment ("JS_class_tables", "templates")
%{
JSStaticValue ${classname_mangled}_staticValues[] = {
${jsstaticclassvariables}
JSStaticValue $jsmangledname_staticValues[] = {
$jsstaticclassvariables
{ 0, 0, 0, 0 }
};
JSStaticFunction ${classname_mangled}_staticFunctions[] = {
${jsstaticclassfunctions}
JSStaticFunction $jsmangledname_staticFunctions[] = {
$jsstaticclassfunctions
{ 0, 0, 0 }
};
JSStaticValue ${classname_mangled}_values[] = {
${jsclassvariables}
JSStaticValue $jsmangledname_values[] = {
$jsclassvariables
{ 0, 0, 0, 0 }
};
JSStaticFunction ${classname_mangled}_functions[] = {
${jsclassfunctions}
JSStaticFunction $jsmangledname_functions[] = {
$jsclassfunctions
{ 0, 0, 0 }
};
%}
@ -164,15 +168,14 @@ JSStaticFunction ${classname_mangled}_functions[] = {
/*********************************************************************
* destructordefn:
* This code template is used to adds the destructor wrapper function
* ${classname_mangled}: The mangled name of the qualified class name, e.g., foo::A -> foo_A
***********************************************************************/
%fragment ("JS_destructordefn", "templates")
%{
void _wrap_${classname_mangled}_finalize(JSObjectRef thisObject)
void _wrap_$jsmangledname_finalize(JSObjectRef thisObject)
{
SWIG_PRV_DATA* t = (SWIG_PRV_DATA*)JSObjectGetPrivate(thisObject);
if(t && t->swigCMemOwn) free ((${type}*)t->swigCObject);
if(t && t->swigCMemOwn) free (($jstype*)t->swigCObject);
if(t) free(t);
}
%}
@ -180,22 +183,21 @@ void _wrap_${classname_mangled}_finalize(JSObjectRef thisObject)
/*********************************************************************
* constructor_definition:
* This code template is used to adds the main constructor wrapper function
* ${classname_mangled}: The mangled name of the qualified class name, e.g., foo::A -> foo_A
***********************************************************************/
%fragment ("JS_mainctordefn", "templates")
%{
JSObjectRef _wrap_create_${classname_mangled}(JSContextRef context, JSObjectRef ctorObject,
JSObjectRef _wrap_create_$jsmangledname(JSContextRef context, JSObjectRef ctorObject,
size_t argc, const JSValueRef argv[], JSValueRef* exception)
{
JSObjectRef thisObject = NULL;
// switch all cases by means of series of if-returns.
${DISPATCH_CASES}
$jsdispatchcases
// default:
SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for contruction of ${classname_mangled}");
SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for contruction of $jsmangledname");
fail:
return thisObject;
@ -207,8 +209,8 @@ ctor_dispatch_case: This template is used for the constructor which is overloade
***************************************************************************************/
%fragment ("JS_ctor_dispatch_case", "templates")
%{if(argc == ${argcount}) {
thisObject = _wrap_create_${classname_mangled}${overloadext}(context, NULL, argc, argv, exception);
%{if(argc == $jsargcount) {
thisObject = _wrap_create_$jsmangledname$jsoverloadext(context, NULL, argc, argv, exception);
if(thisObject != NULL) { *exception=0; return thisObject; } /* reset exception and return */
}
%}
@ -216,12 +218,12 @@ ctor_dispatch_case: This template is used for the constructor which is overloade
%fragment ("JS_ctordefn", "templates")
%{
JSObjectRef _wrap_create_${classname_mangled}${overloadext}(JSContextRef context, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
JSObjectRef _wrap_create_$jsmangledname$jsoverloadext(JSContextRef context, JSObjectRef thisObject, size_t argc, const JSValueRef argv[], JSValueRef* exception)
{
${LOCALS}
${CODE}
$jslocals
$jscode
return SWIG_JSC_NewPointerObj(context, result, SWIGTYPE_${type_mangled}, SWIG_POINTER_OWN);
return SWIG_JSC_NewPointerObj(context, result, SWIGTYPE_$jsmangledtype, SWIG_POINTER_OWN);
goto fail;
fail:
@ -237,7 +239,7 @@ initializer:This template is dynamic growing and aggregates everything
extern "C" {
#endif
bool ${modulename}_initialize(JSGlobalContextRef context) {
bool $jsname_initialize(JSGlobalContextRef context) {
SWIG_InitializeModule(0);
JSObjectRef global_object = JSContextGetGlobalObject(context);
@ -248,13 +250,13 @@ bool ${modulename}_initialize(JSGlobalContextRef context) {
_SwigObject_classRef = JSClassCreate(&_SwigObject_objectDefinition);
/* Create objects for namespaces */
${create_namespaces}
$jscreatenamespaces
/* Create classes */
${initializercode}
$jsinitializercode
/* Register namespaces */
${register_namespaces}
$jsregisternamespaces
return true;
}
@ -268,41 +270,35 @@ bool ${modulename}_initialize(JSGlobalContextRef context) {
/*****************************************************************************************
*create_class_template:
*This template is used to add a Static references to class templates.
*${classname_mangled}: The mangled name of the qualified class name, e.g., foo::A -> foo_A
*****************************************************************************************/
%fragment ("JS_create_class_template", "templates")
%{ ${classname_mangled}_classDefinition.staticFunctions = ${classname_mangled}_staticFunctions;
${classname_mangled}_classDefinition.staticValues = ${classname_mangled}_staticValues;
${classname_mangled}_classDefinition.callAsConstructor = _wrap_create_${classname_mangled};
${classname_mangled}_objectDefinition.staticValues = ${classname_mangled}_values;
${classname_mangled}_objectDefinition.staticFunctions = ${classname_mangled}_functions;
${classname_mangled}_objectDefinition.parentClass = ${base_classname}_classRef;
JSClassRef ${classname_mangled}_classRef = JSClassCreate(&${classname_mangled}_objectDefinition);
SWIGTYPE_${classtype_mangled}->clientdata = ${classname_mangled}_classRef;%}
%{ $jsmangledname_classDefinition.staticFunctions = $jsmangledname_staticFunctions;
$jsmangledname_classDefinition.staticValues = $jsmangledname_staticValues;
$jsmangledname_classDefinition.callAsConstructor = _wrap_create_$jsmangledname;
$jsmangledname_objectDefinition.staticValues = $jsmangledname_values;
$jsmangledname_objectDefinition.staticFunctions = $jsmangledname_functions;
$jsmangledname_objectDefinition.parentClass = $jsbaseclass_classRef;
JSClassRef $jsmangledname_classRef = JSClassCreate(&$jsmangledname_objectDefinition);
SWIGTYPE_$jsmangledtype->clientdata = $jsmangledname_classRef;%}
/*****************************************************************************************
*register_class:
*This template is used to adds a class registration statement to initializer function
*${classname_mangled}: The mangled name of the qualified class name, e.g., foo::A -> foo_A
* This template is used to adds a class registration statement to initializer function
*****************************************************************************************/
%fragment ("JS_register_class", "templates")
%{JS_registerClass(context, ${namespace_mangled}_object, "${classname}", &${classname_mangled}_classDefinition);%}
/* register global function */
%fragment ("JS_register_global_function", "templates")
%{JS_registerFunction(${context}, ${context_object}, "${functionname}", ${functionwrapper});%}
%{JS_registerClass(context, $jsnspace_object, "$jsname", &$jsmangledname_classDefinition);%}
/* create and register namespaces */
%fragment ("JS_create_namespace", "templates")
%{ ${namespace}_classDefinition.staticFunctions = ${namespace}_functions;
${namespace}_classDefinition.staticValues = ${namespace}_values;
JSObjectRef ${namespace}_object = JSObjectMake(context, JSClassCreate(&${namespace}_classDefinition), NULL);
%{ $jsmangledname_classDefinition.staticFunctions = $jsmangledname_functions;
$jsmangledname_classDefinition.staticValues = $jsmangledname_values;
JSObjectRef $jsmangledname_object = JSObjectMake(context, JSClassCreate(&$jsmangledname_classDefinition), NULL);
%}
%fragment ("JS_register_namespace", "templates")
%{
JS_registerNamespace(context, ${namespace_mangled}_object, ${parent_namespace}_object, "${namespace}"); %}
JS_registerNamespace(context, $jsmangledname_object, $jsparent_object, "$jsname"); %}

178
Source/Modules/javascript.cxx
View file

@ -13,6 +13,27 @@ bool js_template_enable_debug = false;
#define WRAPPER_NAME "wrapper"
#define IS_IMMUTABLE "is_immutable"
#define IS_STATIC "is_static"
#define GETTER "getter"
#define SETTER "setter"
#define PARENT "parent"
// variables used in code templates
// ATTENTION: be aware of prefix collisions when defining those variables
#define T_NAME "$jsname"
#define T_NAME_MANGLED "$jsmangledname"
#define T_TYPE "$jstype"
#define T_TYPE_MANGLED "$jsmangledtype"
#define T_WRAPPER "$jswrapper"
#define T_GETTER "$jsgetter"
#define T_SETTER "$jssetter"
#define T_DISPATCH_CASES "$jsdispatchcases"
#define T_BASECLASS "$jsbaseclass"
#define T_NAMESPACE "$jsnspace"
#define T_PARENT "$jsparent"
#define T_OVERLOAD "$jsoverloadext"
#define T_ARGCOUNT "$jsargcount"
#define T_LOCALS "$jslocals"
#define T_CODE "$jscode"
/**
* A convenience class to manage state variables for emitters.
@ -569,6 +590,8 @@ JSEmitter::~JSEmitter() {
/* -----------------------------------------------------------------------------
* JSEmitter::RegisterTemplate() : Registers a code template
*
* Note: this is used only by JAVASCRIPT::fragmentDirective().
* ----------------------------------------------------------------------------- */
int JSEmitter::registerTemplate(const String *name, const String *code) {
@ -576,7 +599,7 @@ int JSEmitter::registerTemplate(const String *name, const String *code) {
}
/* -----------------------------------------------------------------------------
* JSEmitter::getTemplate() : Retrieves a registered a code template
* JSEmitter::getTemplate() : Provides a registered code template
* ----------------------------------------------------------------------------- */
Template JSEmitter::getTemplate(const String *name) {
@ -624,6 +647,9 @@ Parm *JSEmitter::skipIgnoredArgs(Parm *p) {
/* -----------------------------------------------------------------------------
* JSEmitter::getBaseClass() : the node of the base class or NULL
*
* Note: the first base class is provided. Multiple inheritance is not
* supported.
* ----------------------------------------------------------------------------- */
Node *JSEmitter::getBaseClass(Node *n) {
@ -640,7 +666,10 @@ Node *JSEmitter::getBaseClass(Node *n) {
}
/* -----------------------------------------------------------------------------
* JSEmitter::emitWrapperFunction() : dispatches emitter functions
* JSEmitter::emitWrapperFunction() : dispatches emitter functions.
*
* This allows to have small sized, dedicated emitting functions.
* All state dependent branching is done here.
* ----------------------------------------------------------------------------- */
int JSEmitter::emitWrapperFunction(Node *n) {
@ -737,7 +766,7 @@ int JSEmitter::switchNamespace(Node *n) {
String *scope = Swig_scopename_prefix(Getattr(n, "name"));
if (scope) {
// if the scope is not yet registered
// create all scopes/namespaces recursively
// create (parent) namespaces recursively
if (!Getattr(namespaces, scope)) {
createNamespace(scope);
}
@ -774,9 +803,9 @@ int JSEmitter::createNamespace(String *scope) {
Hash *JSEmitter::createNamespaceEntry(const char *_name, const char *parent) {
Hash *entry = NewHash();
String *name = NewString(_name);
Setattr(entry, "name", Swig_scopename_last(name));
Setattr(entry, "name_mangled", Swig_name_mangle(name));
Setattr(entry, "parent", NewString(parent));
Setattr(entry, NAME, Swig_scopename_last(name));
Setattr(entry, NAME_MANGLED, Swig_name_mangle(name));
Setattr(entry, PARENT, NewString(parent));
Delete(name);
return entry;
@ -851,8 +880,6 @@ private:
// keys for function scoped state variables
#define FUNCTION_DISPATCHERS "function_dispatchers"
#define GETTER "getter"
#define SETTER "setter"
JSCEmitter::JSCEmitter()
: JSEmitter(),
@ -988,10 +1015,10 @@ int JSCEmitter::dump(Node *n) {
// compose the initializer function using a template
Template initializer(getTemplate("JS_initializer"));
initializer.replace("${modulename}", module)
.replace("${initializercode}", state.global(INITIALIZER))
.replace("${create_namespaces}", state.global(CREATE_NAMESPACES))
.replace("${register_namespaces}", state.global(REGISTER_NAMESPACES))
initializer.replace(T_NAME, module)
.replace("$jsinitializercode", state.global(INITIALIZER))
.replace("$jscreatenamespaces", state.global(CREATE_NAMESPACES))
.replace("$jsregisternamespaces", state.global(REGISTER_NAMESPACES))
.pretty_print(f_init);
Printv(f_wrap_cpp, f_init, 0);
@ -1046,8 +1073,8 @@ int JSCEmitter::exitFunction(Node *n) {
}
}
t_function.replace("${functionname}", state.function(NAME))
.replace("${functionwrapper}", state.function(WRAPPER_NAME));
t_function.replace(T_NAME, state.function(NAME))
.replace(T_WRAPPER, state.function(WRAPPER_NAME));
if (is_member) {
if (GetFlag(state.function(), IS_STATIC)) {
@ -1074,9 +1101,9 @@ int JSCEmitter::enterVariable(Node *n) {
int JSCEmitter::exitVariable(Node *n) {
Template t_variable(getTemplate("JS_variabledecl"));
t_variable.replace("${setname}", state.variable(SETTER))
.replace("${getname}", state.variable(GETTER))
.replace("${propertyname}", state.variable(NAME));
t_variable.replace(T_NAME, state.variable(NAME))
.replace(T_GETTER, state.variable(GETTER))
.replace(T_SETTER, state.variable(SETTER));
if (GetFlag(n, "ismember")) {
if (GetFlag(state.function(), IS_STATIC)
@ -1103,7 +1130,7 @@ int JSCEmitter::enterClass(Node *n) {
state.clazz(CTOR_DISPATCHERS, NewString(""));
Template t_class_defn = getTemplate("JS_class_definition");
t_class_defn.replace("${classname_mangled}", state.clazz(NAME_MANGLED))
t_class_defn.replace(T_NAME_MANGLED, state.clazz(NAME_MANGLED))
.pretty_print(f_wrappers);
return SWIG_OK;
@ -1112,11 +1139,11 @@ int JSCEmitter::enterClass(Node *n) {
int JSCEmitter::exitClass(Node *n) {
Template t_class_tables(getTemplate("JS_class_tables"));
t_class_tables.replace("${classname_mangled}", state.clazz(NAME_MANGLED))
.replace("${jsclassvariables}", state.clazz(MEMBER_VARIABLES))
.replace("${jsclassfunctions}", state.clazz(MEMBER_FUNCTIONS))
.replace("${jsstaticclassfunctions}", state.clazz(STATIC_FUNCTIONS))
.replace("${jsstaticclassvariables}", state.clazz(STATIC_VARIABLES))
t_class_tables.replace(T_NAME_MANGLED, state.clazz(NAME_MANGLED))
.replace("$jsclassvariables", state.clazz(MEMBER_VARIABLES))
.replace("$jsclassfunctions", state.clazz(MEMBER_FUNCTIONS))
.replace("$jsstaticclassfunctions", state.clazz(STATIC_FUNCTIONS))
.replace("$jsstaticclassvariables", state.clazz(STATIC_VARIABLES))
.pretty_print(f_wrappers);
/* adds the ctor wrappers at this position */
@ -1125,8 +1152,8 @@ int JSCEmitter::exitClass(Node *n) {
/* adds the main constructor wrapper function */
Template t_mainctor(getTemplate("JS_mainctordefn"));
t_mainctor.replace("${classname_mangled}", state.clazz(NAME_MANGLED))
.replace("${DISPATCH_CASES}", state.clazz(CTOR_DISPATCHERS))
t_mainctor.replace(T_NAME_MANGLED, state.clazz(NAME_MANGLED))
.replace(T_DISPATCH_CASES, state.clazz(CTOR_DISPATCHERS))
.pretty_print(f_wrappers);
/* adds a class template statement to initializer function */
@ -1139,9 +1166,9 @@ int JSCEmitter::exitClass(Node *n) {
Delete(base_name_mangled);
base_name_mangled = SwigType_manglestr(Getattr(base_class, "name"));
}
t_classtemplate.replace("${classname_mangled}", state.clazz(NAME_MANGLED))
.replace("${classtype_mangled}", state.clazz(TYPE_MANGLED))
.replace("${base_classname}", base_name_mangled)
t_classtemplate.replace(T_NAME_MANGLED, state.clazz(NAME_MANGLED))
.replace(T_TYPE_MANGLED, state.clazz(TYPE_MANGLED))
.replace(T_BASECLASS, base_name_mangled)
.pretty_print(state.global(INITIALIZER));
Delete(base_name_mangled);
@ -1150,9 +1177,9 @@ int JSCEmitter::exitClass(Node *n) {
/* adds a class registration statement to initializer function */
Template t_registerclass(getTemplate("JS_register_class"));
t_registerclass.replace("${classname}", state.clazz(NAME))
.replace("${classname_mangled}", state.clazz(NAME_MANGLED))
.replace("${namespace_mangled}", Getattr(current_namespace, "name_mangled"))
t_registerclass.replace(T_NAME, state.clazz(NAME))
.replace(T_NAME_MANGLED, state.clazz(NAME_MANGLED))
.replace(T_NAMESPACE, Getattr(current_namespace, NAME_MANGLED))
.pretty_print(state.global(INITIALIZER));
return SWIG_OK;
@ -1180,19 +1207,19 @@ int JSEmitter::emitCtor(Node *n) {
marshalInputArgs(n, params, wrapper, Ctor, true, false);
Printv(wrapper->code, action, "\n", 0);
t_ctor.replace("${classname_mangled}", mangled_name)
.replace("${overloadext}", overname)
.replace("${LOCALS}", wrapper->locals)
.replace("${CODE}", wrapper->code)
.replace("${type_mangled}", state.clazz(TYPE_MANGLED))
t_ctor.replace(T_NAME_MANGLED, mangled_name)
.replace(T_OVERLOAD, overname)
.replace(T_LOCALS, wrapper->locals)
.replace(T_CODE, wrapper->code)
.replace(T_TYPE_MANGLED, state.clazz(TYPE_MANGLED))
.pretty_print(state.clazz(CTORS));
String *argcount = NewString("");
Printf(argcount, "%d", num_args);
Template t_ctor_case(getTemplate("JS_ctor_dispatch_case"));
t_ctor_case.replace("${classname_mangled}", mangled_name)
.replace("${overloadext}", overname)
.replace("${argcount}", argcount);
t_ctor_case.replace(T_NAME_MANGLED, mangled_name)
.replace(T_OVERLOAD, overname)
.replace(T_ARGCOUNT, argcount);
Append(state.clazz(CTOR_DISPATCHERS), t_ctor_case.str());
Delete(argcount);
@ -1204,8 +1231,8 @@ int JSEmitter::emitCtor(Node *n) {
int JSEmitter::emitDtor(Node *) {
Template t_dtor = getTemplate("JS_destructordefn");
t_dtor.replace("${classname_mangled}", state.clazz(NAME_MANGLED))
.replace("${type}", state.clazz(TYPE))
t_dtor.replace(T_NAME_MANGLED, state.clazz(NAME_MANGLED))
.replace(T_TYPE, state.clazz(TYPE))
.pretty_print(f_wrappers);
return SWIG_OK;
@ -1224,16 +1251,15 @@ int JSEmitter::emitGetter(Node *n, bool is_member, bool is_static) {
ParmList *params = Getattr(n, "parms");
emit_parameter_variables(params, wrapper);
emit_attach_parmmaps(params, wrapper);
Wrapper_add_local(wrapper, "jsresult", "JSValueRef jsresult");
// prepare code part
String *action = emit_action(n);
marshalInputArgs(n, params, wrapper, Getter, is_member, is_static);
marshalOutput(n, action, wrapper);
t_getter.replace("${getname}", wrap_name)
.replace("${LOCALS}", wrapper->locals)
.replace("${CODE}", wrapper->code)
t_getter.replace(T_GETTER, wrap_name)
.replace(T_LOCALS, wrapper->locals)
.replace(T_CODE, wrapper->code)
.pretty_print(f_wrappers);
DelWrapper(wrapper);
@ -1267,9 +1293,9 @@ int JSEmitter::emitSetter(Node *n, bool is_member, bool is_static) {
marshalInputArgs(n, params, wrapper, Setter, is_member, is_static);
Append(wrapper->code, action);
t_setter.replace("${setname}", wrap_name)
.replace("${LOCALS}", wrapper->locals)
.replace("${CODE}", wrapper->code)
t_setter.replace(T_SETTER, wrap_name)
.replace(T_LOCALS, wrapper->locals)
.replace(T_CODE, wrapper->code)
.pretty_print(f_wrappers);
DelWrapper(wrapper);
@ -1296,9 +1322,6 @@ int JSEmitter::emitConstant(Node *n) {
state.variable(GETTER, wrap_name);
Setattr(n, "wrap:name", wrap_name);
// prepare local variables
Wrapper_add_local(wrapper, "jsresult", "JSValueRef jsresult");
// prepare code part
String *action = NewString("");
String *value = Getattr(n, "rawval");
@ -1312,9 +1335,9 @@ int JSEmitter::emitConstant(Node *n) {
Setattr(n, "wrap:action", action);
marshalOutput(n, action, wrapper);
t_getter.replace("${getname}", wrap_name)
.replace("${LOCALS}", wrapper->locals)
.replace("${CODE}", wrapper->code)
t_getter.replace(T_GETTER, wrap_name)
.replace(T_LOCALS, wrapper->locals)
.replace(T_CODE, wrapper->code)
.pretty_print(f_wrappers);
exitVariable(n);
@ -1334,8 +1357,8 @@ int JSEmitter::emitFunction(Node *n, bool is_member, bool is_static) {
// prepare the function wrapper name
String *wrap_name = Swig_name_wrapper(Getattr(n, "sym:name"));
if (is_overloaded) {
Append(wrap_name, Getattr(n, "sym:overname"));
t_function = getTemplate("JS_functionwrapper_overload");
Append(wrap_name, Getattr(n, "sym:overname"));
}
Setattr(n, "wrap:name", wrap_name);
state.function(WRAPPER_NAME, wrap_name);
@ -1344,16 +1367,15 @@ int JSEmitter::emitFunction(Node *n, bool is_member, bool is_static) {
ParmList *params = Getattr(n, "parms");
emit_parameter_variables(params, wrapper);
emit_attach_parmmaps(params, wrapper);
Wrapper_add_local(wrapper, "jsresult", "JSValueRef jsresult");
// prepare code part
String *action = emit_action(n);
marshalInputArgs(n, params, wrapper, Function, is_member, is_static);
marshalOutput(n, action, wrapper);
t_function.replace("${functionname}", wrap_name)
.replace("${LOCALS}", wrapper->locals)
.replace("${CODE}", wrapper->code)
t_function.replace(T_WRAPPER, wrap_name)
.replace(T_LOCALS, wrapper->locals)
.replace(T_CODE, wrapper->code)
.pretty_print(f_wrappers);
// handle function overloading
@ -1364,8 +1386,8 @@ int JSEmitter::emitFunction(Node *n, bool is_member, bool is_static) {
String *argcount = NewString("");
Printf(argcount, "%d", argc);
t_dispatch_case.replace("${functionwrapper}", wrap_name)
.replace("${argcount}", argcount);
t_dispatch_case.replace(T_WRAPPER, wrap_name)
.replace(T_ARGCOUNT, argcount);
Append(state.global(FUNCTION_DISPATCHERS), t_dispatch_case.str());
@ -1386,16 +1408,16 @@ int JSEmitter::emitFunctionDispatcher(Node *n, bool /*is_member */ ) {
Setattr(n, "wrap:name", wrap_name);
Wrapper_add_local(wrapper, "res", "int res");
Wrapper_add_local(wrapper, "jsresult", "JSValueRef jsresult");
Append(wrapper->code, state.global(FUNCTION_DISPATCHERS));
Append(wrapper->code, getTemplate("JS_function_dispatch_case_default").str());
t_function.replace("${LOCALS}", wrapper->locals)
.replace("${CODE}", wrapper->code);
t_function.replace(T_LOCALS, wrapper->locals)
.replace(T_CODE, wrapper->code);
// call this here, to replace all variables
t_function.replace("${functionname}", wrap_name)
t_function.replace(T_WRAPPER, wrap_name)
.replace(T_NAME, state.function(NAME))
.pretty_print(f_wrappers);
// Delete the state variable
@ -1446,27 +1468,27 @@ int JSCEmitter::emitNamespaces() {
Iterator it;
for (it = First(namespaces); it.item; it = Next(it)) {
Hash *entry = it.item;
String *name = Getattr(entry, "name");
String *parent = Getattr(entry, "parent");
String *name = Getattr(entry, NAME);
String *name_mangled = Getattr(entry, NAME_MANGLED);
String *parent = Getattr(entry, PARENT);
String *parent_mangled = Swig_name_mangle(parent);
String *functions = Getattr(entry, "functions");
String *variables = Getattr(entry, "values");
String *name_mangled = Getattr(entry, "name_mangled");
String *parent_mangled = Swig_name_mangle(parent);
Template namespace_definition(getTemplate("JS_globaldefn"));
namespace_definition.replace("${jsglobalvariables}", variables)
.replace("${jsglobalfunctions}", functions)
.replace("${namespace}", name_mangled)
namespace_definition.replace("$jsglobalvariables", variables)
.replace("$jsglobalfunctions", functions)
.replace(T_NAMESPACE, name_mangled)
.pretty_print(f_wrap_cpp);
Template t_createNamespace(getTemplate("JS_create_namespace"));
t_createNamespace.replace("${namespace}", name_mangled);
t_createNamespace.replace(T_NAME_MANGLED, name_mangled);
Append(state.global(CREATE_NAMESPACES), t_createNamespace.str());
Template t_registerNamespace(getTemplate("JS_register_namespace"));
t_registerNamespace.replace("${namespace_mangled}", name_mangled)
.replace("${namespace}", name)
.replace("${parent_namespace}", parent_mangled);
t_registerNamespace.replace(T_NAME_MANGLED, name_mangled)
.replace(T_NAME, name)
.replace(T_PARENT, parent_mangled);
Append(state.global(REGISTER_NAMESPACES), t_registerNamespace.str());
}
@ -1575,8 +1597,8 @@ private:
#define KW_REGISTER_CLASSES "${PART_REGISTER_CLASSES}"
#define KW_REGISTER_NS "${PART_REGISTER_NS}"
#define KW_LOCALS "${LOCALS}"
#define KW_CODE "${CODE}"
#define KW_LOCALS T_LOCALS
#define KW_CODE T_CODE
V8Emitter::V8Emitter()
: JSEmitter(),