Combyne templates are almost finished

tbranyen · Oct 7, 2014 · Jul 19, 2014 · Jul 22, 2014 · Sep 24, 2014 · Sep 25, 2014
commit e57b390579e0890f8e15e4882039baba620b58bb
diff --git a/generate/filters/is_pointer.js b/generate/filters/is_pointer.js
diff --git a/generate/index.js b/generate/index.js
@@ -33,7 +33,6 @@ var filters = {
   or: require("./filters/or"),
   and: require("./filters/and"),
   isV8Value: require("./filters/is_v8_value"),
-  isPointer: require("./filters/is_pointer"),
   unPointer: require("./filters/un_pointer"),
   defaultValue: require("./filters/default_value")
 };
@@ -58,7 +57,8 @@ Object.keys(partials).forEach(function(partial) {
 var enabled = idefs.filter(function(idef) {
   // Additionally provide a friendly name to the actual filename.
   idef.name = path.basename(idef.filename, ".h");
-
+  idef.cTypeIsUndefined = typeof idef.cType == 'undefined';
+
   // We need some custom data on each of the functions
   idef.functions.forEach(function(fn) {
     fn.cppClassName = idef.cppClassName;
@@ -102,6 +102,7 @@ var enabled = idefs.filter(function(idef) {
       arg.cArg = cArg;
       arg.v8ValueClassName = cppToV8(arg.cppClassName);
       arg.isCppClassStringOrArray = ~["String", "Array"].indexOf(arg.cppClassName);
+      arg.isPointer = /\s*\*\s*/.test(arg.cType);
       arg.isDoublePointer = /\s*\*\*\s*/.test(arg.cType);
       arg.isV8Value = ~v8Values.indexOf(arg.cppClassName);
 
@@ -113,7 +114,7 @@ var enabled = idefs.filter(function(idef) {
     fn.returns = [];
 
     // generate returns data
-    fn.args.forEach(function(arg) {
+    fn.argsInfo.forEach(function(arg) {
       if (!arg.isReturn) return;
 
       var _return = {};
@@ -134,6 +135,21 @@ var enabled = idefs.filter(function(idef) {
     if (!fn.returns.length
         && !fn.return.isErrorCode
         && fn.return.cType != "void") {
+      var _return = {};
+
+      _return = fn.return;
+
+      _return.v8ValueClassName = cppToV8(_return.cppClassName);
+      _return.isCppClassStringOrArray = ~["String", "Array"].indexOf(_return.cppClassName);
+      _return.isPointer = /\s*\*\s*/.test(_return.cType);
+      _return.isDoublePointer = /\s*\*\*\s*/.test(_return.cType);
+      _return.isV8Value = ~v8Values.indexOf(_return.cppClassName);
+      _return.parsedName = 'result';
+      _return.jsOrCppClassName = _return.jsClassName || _return.cppClassName;
+      _return.isCppClassIntType = ~["Uint32", "Int32"].indexOf(_return.cppClassName);
+      _return.parsedClassName = (_return.cppClassName || '').toLowerCase() + "_t";
+      _return.jsNameOrName = _return.jsName | _return.name;
+
       fn.returns.push(fn.return);
     }
 
@@ -155,6 +171,7 @@ var enabled = idefs.filter(function(idef) {
       fieldInfo.parsedName = field.name || "result";
       fieldInfo.isCppClassIntType = ~["Uin32", "Int32"].indexOf(field.cppClassName);
       fieldInfo.parsedClassName = (field.cppClassName || '').toLowerCase() + "_t";
+      fieldInfo.isV8Value = ~v8Values.indexOf(field.cppClassName);
 
       fn.fieldInfos.push(fieldInfo);
     });

diff --git a/generate/partials/convert_from_v8.cc b/generate/partials/convert_from_v8.cc
@@ -1,7 +1,7 @@
 {%if not isPayload %}
   {{ cType }} from_{{ name }};
   {%if isOptional %}
-    if (args{{[ jsArg }}]->Is{{ v8ValueClassName }}()) {
+    if (args[{{ jsArg }}]->Is{{ v8ValueClassName }}()) {
   {%endif%}
   {%if cppClassName == 'String' %}
       String::Utf8Value {{ name }}(args[{{ jsArg }}]->ToString());

diff --git a/generate/partials/convert_to_v8.cc b/generate/partials/convert_to_v8.cc
@@ -10,7 +10,7 @@ to = NanNew<String>({{{ parsedName }}});
   {%if freeFunctionName %}
     {{ freeFunctionName }}({{{ parsedName }}});
   {%endif%}
-{%elsif cppClassName|isV8Value %}
+{%elsif isV8Value %}
   {%if isCppClassIntType %}
 to = NanNew<{{ cppClassName }}>(({{ parsedClassName }}){{{ parsedName }}});
   {%else%}
@@ -19,7 +19,9 @@ to = NanNew<{{ cppClassName }}>({{{ parsedName }}});
 {%elsif cppClassName == 'External' %}
 to = NanNew<External>((void *){{{ parsedName }}});
 {%elsif cppClassName == 'Array' %}
-{%--  // FIXME this is not general purpose enough. --%}
+{%--
+  // FIXME this is not general purpose enough.
+--%}
 Local<Array> tmpArray = NanNew<Array>({{{ parsedName }}}->{{ size }});
 for (unsigned int i = 0; i < {{{ parsedName }}}->{{ size }}; i++) {
   tmpArray->Set(NanNew<Number>(i), NanNew<String>({{{ parsedName }}}->{{ key }}[i]));
@@ -28,7 +30,7 @@ to = tmpArray;
 {%else%}
   {%if copy %}
 if ({{{ parsedName }}} != NULL) {
-  {{{ parsedName }}} = ({{ cType|replace '**' '*' }} {%if cType|isPointer %}*{%endif%}){{ copy }}({{{ parsedName }}});
+  {{{ parsedName }}} = ({{ cType|replace '**' '*' }} {%if isPointer %}*{%endif%}){{ copy }}({{{ parsedName }}});
 }
   {%endif%}
 if ({{{ parsedName }}} != NULL) {

diff --git a/generate/partials/fields.cc b/generate/partials/fields.cc
@@ -5,8 +5,8 @@ NAN_METHOD({{ cppClassName }}::{{ field.cppFunctionName }}) {
   NanScope();
   Handle<Value> to;
 
-  {{ field.cType }} {%if field.cppClassName|isV8Value %}*{%endif%}{{ field.name }} =
-    {%if not field.cppClassName|isV8Value %}&{%endif%}ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue()->{{ field.name }};
+  {{ field.cType }} {%if field.isV8Value %}*{%endif%}{{ field.name }} =
+    {%if not field.isV8Value %}&{%endif%}ObjectWrap::Unwrap<{{ cppClassName }}>(args.This())->GetValue()->{{ field.name }};
 
   {%partial convertToV8 field %}
   NanReturnValue(to);

diff --git a/generate/partials/sync_function.cc b/generate/partials/sync_function.cc
@@ -81,5 +81,6 @@ from_{{ arg.name }}
   NanReturnValue(to);
   {%else%}
   NanReturnValue(toReturn);
+  {%endif%}
 {%endif%}
 }
diff --git a/generate/templates/class.cc b/generate/templates/class.cc
@@ -103,6 +103,6 @@ void {{ cppClassName }}::Initialize(Handle<v8::Object> target) {
 
 {%partial fields .%}
 
-{%if cType%}
+{%if not cTypeIsUndefined %}
 Persistent<Function> {{ cppClassName }}::constructor_template;
 {%endif%}