herb 0.7.5 → 0.8.0

data/src/visitor.c

@@ -3,10 +3,10 @@
 
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/visitor.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
+#include "include/util/hb_array.h"
+#include "include/visitor.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data) {
   if (visitor(node, data) && node != NULL) {
@@ -24,8 +24,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_DOCUMENT_NODE_T* document_node = ((const AST_DOCUMENT_NODE_T *) node);
 
       if (document_node->children != NULL) {
-        for (size_t index = 0; index < array_size(document_node->children); index++) {
-          herb_visit_node(array_get(document_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(document_node->children); index++) {
+          herb_visit_node(hb_array_get(document_node->children, index), visitor, data);
         }
       }
 
@@ -35,8 +35,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = ((const AST_HTML_OPEN_TAG_NODE_T *) node);
 
       if (html_open_tag_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_open_tag_node->children); index++) {
-          herb_visit_node(array_get(html_open_tag_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_open_tag_node->children); index++) {
+          herb_visit_node(hb_array_get(html_open_tag_node->children, index), visitor, data);
         }
       }
 
@@ -46,8 +46,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = ((const AST_HTML_CLOSE_TAG_NODE_T *) node);
 
       if (html_close_tag_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_close_tag_node->children); index++) {
-          herb_visit_node(array_get(html_close_tag_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_close_tag_node->children); index++) {
+          herb_visit_node(hb_array_get(html_close_tag_node->children, index), visitor, data);
         }
       }
 
@@ -61,8 +61,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       }
 
       if (html_element_node->body != NULL) {
-        for (size_t index = 0; index < array_size(html_element_node->body); index++) {
-          herb_visit_node(array_get(html_element_node->body, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_element_node->body); index++) {
+          herb_visit_node(hb_array_get(html_element_node->body, index), visitor, data);
         }
       }
 
@@ -76,8 +76,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
 
       if (html_attribute_value_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_attribute_value_node->children); index++) {
-          herb_visit_node(array_get(html_attribute_value_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_attribute_value_node->children); index++) {
+          herb_visit_node(hb_array_get(html_attribute_value_node->children, index), visitor, data);
         }
       }
 
@@ -87,8 +87,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = ((const AST_HTML_ATTRIBUTE_NAME_NODE_T *) node);
 
       if (html_attribute_name_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_attribute_name_node->children); index++) {
-          herb_visit_node(array_get(html_attribute_name_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_attribute_name_node->children); index++) {
+          herb_visit_node(hb_array_get(html_attribute_name_node->children, index), visitor, data);
         }
       }
 
@@ -111,8 +111,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);
 
       if (html_comment_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_comment_node->children); index++) {
-          herb_visit_node(array_get(html_comment_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_comment_node->children); index++) {
+          herb_visit_node(hb_array_get(html_comment_node->children, index), visitor, data);
         }
       }
 
@@ -122,8 +122,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = ((const AST_HTML_DOCTYPE_NODE_T *) node);
 
       if (html_doctype_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_doctype_node->children); index++) {
-          herb_visit_node(array_get(html_doctype_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_doctype_node->children); index++) {
+          herb_visit_node(hb_array_get(html_doctype_node->children, index), visitor, data);
         }
       }
 
@@ -133,8 +133,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = ((const AST_XML_DECLARATION_NODE_T *) node);
 
       if (xml_declaration_node->children != NULL) {
-        for (size_t index = 0; index < array_size(xml_declaration_node->children); index++) {
-          herb_visit_node(array_get(xml_declaration_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(xml_declaration_node->children); index++) {
+          herb_visit_node(hb_array_get(xml_declaration_node->children, index), visitor, data);
         }
       }
 
@@ -144,8 +144,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_CDATA_NODE_T* cdata_node = ((const AST_CDATA_NODE_T *) node);
 
       if (cdata_node->children != NULL) {
-        for (size_t index = 0; index < array_size(cdata_node->children); index++) {
-          herb_visit_node(array_get(cdata_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(cdata_node->children); index++) {
+          herb_visit_node(hb_array_get(cdata_node->children, index), visitor, data);
         }
       }
 
@@ -155,8 +155,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ELSE_NODE_T* erb_else_node = ((const AST_ERB_ELSE_NODE_T *) node);
 
       if (erb_else_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_else_node->statements); index++) {
-          herb_visit_node(array_get(erb_else_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_else_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_else_node->statements, index), visitor, data);
         }
       }
 
@@ -166,8 +166,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IF_NODE_T* erb_if_node = ((const AST_ERB_IF_NODE_T *) node);
 
       if (erb_if_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_if_node->statements); index++) {
-          herb_visit_node(array_get(erb_if_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_if_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_if_node->statements, index), visitor, data);
         }
       }
 
@@ -185,8 +185,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BLOCK_NODE_T* erb_block_node = ((const AST_ERB_BLOCK_NODE_T *) node);
 
       if (erb_block_node->body != NULL) {
-        for (size_t index = 0; index < array_size(erb_block_node->body); index++) {
-          herb_visit_node(array_get(erb_block_node->body, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_block_node->body); index++) {
+          herb_visit_node(hb_array_get(erb_block_node->body, index), visitor, data);
         }
       }
 
@@ -200,8 +200,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHEN_NODE_T* erb_when_node = ((const AST_ERB_WHEN_NODE_T *) node);
 
       if (erb_when_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_when_node->statements); index++) {
-          herb_visit_node(array_get(erb_when_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_when_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_when_node->statements, index), visitor, data);
         }
       }
 
@@ -211,14 +211,14 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_NODE_T* erb_case_node = ((const AST_ERB_CASE_NODE_T *) node);
 
       if (erb_case_node->children != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_node->children); index++) {
-          herb_visit_node(array_get(erb_case_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_node->children); index++) {
+          herb_visit_node(hb_array_get(erb_case_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_node->conditions != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_node->conditions); index++) {
-          herb_visit_node(array_get(erb_case_node->conditions, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_node->conditions); index++) {
+          herb_visit_node(hb_array_get(erb_case_node->conditions, index), visitor, data);
         }
       }
 
@@ -236,14 +236,14 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = ((const AST_ERB_CASE_MATCH_NODE_T *) node);
 
       if (erb_case_match_node->children != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_match_node->children); index++) {
-          herb_visit_node(array_get(erb_case_match_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->children); index++) {
+          herb_visit_node(hb_array_get(erb_case_match_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_match_node->conditions != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_match_node->conditions); index++) {
-          herb_visit_node(array_get(erb_case_match_node->conditions, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->conditions); index++) {
+          herb_visit_node(hb_array_get(erb_case_match_node->conditions, index), visitor, data);
         }
       }
 
@@ -261,8 +261,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHILE_NODE_T* erb_while_node = ((const AST_ERB_WHILE_NODE_T *) node);
 
       if (erb_while_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_while_node->statements); index++) {
-          herb_visit_node(array_get(erb_while_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_while_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_while_node->statements, index), visitor, data);
         }
       }
 
@@ -276,8 +276,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNTIL_NODE_T* erb_until_node = ((const AST_ERB_UNTIL_NODE_T *) node);
 
       if (erb_until_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_until_node->statements); index++) {
-          herb_visit_node(array_get(erb_until_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_until_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_until_node->statements, index), visitor, data);
         }
       }
 
@@ -291,8 +291,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_FOR_NODE_T* erb_for_node = ((const AST_ERB_FOR_NODE_T *) node);
 
       if (erb_for_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_for_node->statements); index++) {
-          herb_visit_node(array_get(erb_for_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_for_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_for_node->statements, index), visitor, data);
         }
       }
 
@@ -306,8 +306,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = ((const AST_ERB_RESCUE_NODE_T *) node);
 
       if (erb_rescue_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_rescue_node->statements); index++) {
-          herb_visit_node(array_get(erb_rescue_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_rescue_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_rescue_node->statements, index), visitor, data);
         }
       }
 
@@ -321,8 +321,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = ((const AST_ERB_ENSURE_NODE_T *) node);
 
       if (erb_ensure_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_ensure_node->statements); index++) {
-          herb_visit_node(array_get(erb_ensure_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_ensure_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_ensure_node->statements, index), visitor, data);
         }
       }
 
@@ -332,8 +332,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = ((const AST_ERB_BEGIN_NODE_T *) node);
 
       if (erb_begin_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_begin_node->statements); index++) {
-          herb_visit_node(array_get(erb_begin_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_begin_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_begin_node->statements, index), visitor, data);
         }
       }
 
@@ -359,8 +359,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = ((const AST_ERB_UNLESS_NODE_T *) node);
 
       if (erb_unless_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_unless_node->statements); index++) {
-          herb_visit_node(array_get(erb_unless_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_unless_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_unless_node->statements, index), visitor, data);
         }
       }
 
@@ -378,8 +378,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IN_NODE_T* erb_in_node = ((const AST_ERB_IN_NODE_T *) node);
 
       if (erb_in_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_in_node->statements); index++) {
-          herb_visit_node(array_get(erb_in_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_in_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_in_node->statements, index), visitor, data);
         }
       }
 

data/templates/ext/herb/error_helpers.c.erb

@@ -67,12 +67,12 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
   return Qnil;
 }
 
-VALUE rb_errors_array_from_c_array(array_T* array) {
+VALUE rb_errors_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* child_node = (ERROR_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* child_node = (ERROR_T*) hb_array_get(array, i);
 
       if (child_node) {
         VALUE rb_child = rb_error_from_c_struct(child_node);

data/templates/ext/herb/error_helpers.h.erb

@@ -7,6 +7,6 @@
 #include <ruby.h>
 
 VALUE rb_error_from_c_struct(ERROR_T* error);
-VALUE rb_errors_array_from_c_array(array_T* array);
+VALUE rb_errors_array_from_c_array(hb_array_T* array);
 
 #endif

data/templates/ext/herb/nodes.c.erb

@@ -9,7 +9,7 @@
 #include "../../src/include/token.h"
 
 VALUE rb_node_from_c_struct(AST_NODE_T* node);
-static VALUE rb_nodes_array_from_c_array(array_T* array);
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= node.human %>) {
@@ -22,7 +22,8 @@ static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= nod
   VALUE Node = rb_define_class_under(AST, "Node", rb_cObject);
   VALUE <%= node.name %> = rb_define_class_under(AST, "<%= node.name %>", Node);
 
-  VALUE type = rb_utf8_str_new_cstr(ast_node_type_to_string(node));
+  hb_string_T node_type = ast_node_type_to_string(node);
+  VALUE type = rb_utf8_str_new(node_type.data, node_type.length);
   VALUE location = rb_location_from_c_struct(node->location);
   VALUE errors = rb_errors_array_from_c_array(node->errors);
 
@@ -39,7 +40,11 @@ static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= nod
   <%- when Herb::Template::ArrayField -%>
   VALUE <%= node.human %>_<%= field.name %> = rb_nodes_array_from_c_array(<%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::ElementSourceField -%>
-  VALUE <%= node.human %>_<%= field.name %> = rb_utf8_str_new_cstr(element_source_to_string(<%= node.human %>-><%= field.name %>));
+  VALUE <%= node.human %>_<%= field.name %>;
+  {
+    hb_string_T element_source_string = element_source_to_string(<%= node.human %>-><%= field.name %>);
+    <%= node.human %>_<%= field.name %> = rb_utf8_str_new(element_source_string.data, element_source_string.length);
+  }
   <%- else -%>
   /* <%= field.inspect %> */
   VALUE <%= node.human %>_<%= field.name %> = Qnil;
@@ -72,12 +77,12 @@ VALUE rb_node_from_c_struct(AST_NODE_T* node) {
   return Qnil;
 }
 
-static VALUE rb_nodes_array_from_c_array(array_T* array) {
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
       if (child_node) {
         VALUE rb_child = rb_node_from_c_struct(child_node);

data/templates/java/error_helpers.c.erb

@@ -0,0 +1,75 @@
+#include "error_helpers.h"
+#include "extension_helpers.h"
+
+#include "../../src/include/ast_node.h"
+#include "../../src/include/errors.h"
+
+#include <stdlib.h>
+
+<%- errors.each do |error| -%>
+jobject <%= error.name %>FromCStruct(JNIEnv* env, <%= error.struct_type %>* <%= error.human %>) {
+  if (!<%= error.human %>) { return NULL; }
+
+  jclass errorClass = (*env)->FindClass(env, "org/herb/ast/ErrorNode");
+  if (!errorClass) { return NULL; }
+
+  jmethodID constructor = (*env)->GetMethodID(env, errorClass, "<init>", "(Ljava/lang/String;Lorg/herb/Location;Ljava/lang/String;)V");
+  if (!constructor) { return NULL; }
+
+  jstring jtype = (*env)->NewStringUTF(env, "<%= error.name %>");
+  jobject location = CreateLocation(env, <%= error.human %>->base.location);
+  jstring jmessage = (*env)->NewStringUTF(env, <%= error.human %>->base.message);
+
+  return (*env)->NewObject(env, errorClass, constructor, jtype, location, jmessage);
+}
+
+<%- end -%>
+
+jobject ErrorFromCStruct(JNIEnv* env, ERROR_T* error) {
+  if (!error) { return NULL; }
+
+  switch (error->type) {
+  <%- errors.each do |error| -%>
+  case <%= error.type %>:
+    return <%= error.name %>FromCStruct(env, (<%= error.struct_type %>*) error);
+  <%- end -%>
+  default:
+    return NULL;
+  }
+}
+
+jobject ErrorsArrayFromCArray(JNIEnv* env, hb_array_T* array) {
+  jclass arrayListClass = (*env)->FindClass(env, "java/util/ArrayList");
+  jmethodID arrayListConstructor = (*env)->GetMethodID(env, arrayListClass, "<init>", "(I)V");
+  jmethodID addMethod = (*env)->GetMethodID(env, arrayListClass, "add", "(Ljava/lang/Object;)Z");
+
+  jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, 0);
+
+  if (array) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*) hb_array_get(array, i);
+
+      if (error) {
+        jobject errorObj = ErrorFromCStruct(env, error);
+        if (errorObj) {
+          (*env)->CallBooleanMethod(env, javaList, addMethod, errorObj);
+        }
+      }
+    }
+  }
+
+  return javaList;
+}
+
+jobject CreateErrorNode(JNIEnv* env, AST_NODE_T* error_node) {
+  if (!error_node) { return NULL; }
+
+  switch (error_node->type) {
+  <%- errors.each do |error| -%>
+  case <%= error.type %>:
+    return <%= error.name %>FromCStruct(env, (<%= error.struct_type %>*) error_node);
+  <%- end -%>
+  default:
+    return NULL;
+  }
+}

data/templates/java/error_helpers.h.erb

@@ -0,0 +1,20 @@
+#ifndef HERB_JNI_ERROR_HELPERS_H
+#define HERB_JNI_ERROR_HELPERS_H
+
+#include <jni.h>
+
+#include "../../src/include/ast_node.h"
+#include "../../src/include/util/hb_array.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+jobject CreateErrorNode(JNIEnv* env, AST_NODE_T* error_node);
+jobject ErrorsArrayFromCArray(JNIEnv* env, hb_array_T* array);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/templates/java/nodes.c.erb

@@ -0,0 +1,97 @@
+#include "nodes.h"
+#include "extension_helpers.h"
+#include "error_helpers.h"
+
+#include "../../src/include/ast_node.h"
+#include "../../src/include/ast_nodes.h"
+#include "../../src/include/location.h"
+#include "../../src/include/util/hb_array.h"
+
+#include <stdlib.h>
+
+jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node);
+jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array);
+
+<%- nodes.each do |node| -%>
+jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>) {
+  if (!<%= node.human %>) { return NULL; }
+
+  jclass nodeClass = (*env)->FindClass(env, "org/herb/ast/<%= node.name %>");
+  if (!nodeClass) { return NULL; }
+
+  jstring type = (*env)->NewStringUTF(env, "<%= node.name %>");
+  jobject location = CreateLocation(env, <%= node.human %>->base.location);
+  jobject errors = ErrorsArrayFromCArray(env, <%= node.human %>->base.errors);
+
+  <%- node.fields.each do |field| -%>
+  <%- if field.is_a?(Herb::Template::StringField) -%>
+  jstring <%= field.name %> = (*env)->NewStringUTF(env, <%= node.human %>-><%= field.name %>);
+  <%- elsif field.is_a?(Herb::Template::TokenField) -%>
+  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? CreateToken(env, <%= node.human %>-><%= field.name %>) : NULL;
+  <%- elsif field.is_a?(Herb::Template::BooleanField) -%>
+  jboolean <%= field.name %> = <%= node.human %>-><%= field.name %> ? JNI_TRUE : JNI_FALSE;
+  <%- elsif field.is_a?(Herb::Template::ArrayField) -%>
+  jobject <%= field.name %> = NodesArrayFromCArray(env, <%= node.human %>-><%= field.name %>);
+  <%- elsif field.is_a?(Herb::Template::NodeField) -%>
+  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>) : NULL;
+  <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
+  // TODO: Convert element_source to string
+  jstring <%= field.name %> = (*env)->NewStringUTF(env, "");
+  <%- elsif field.is_a?(Herb::Template::AnalyzedRubyField) || field.is_a?(Herb::Template::PrismNodeField) -%>
+  // Skip <%= field.name %> (<%= field.class.name.split('::').last %>) - not supported in Java yet
+  <%- end -%>
+  <%- end -%>
+
+  const char* signature = "(Ljava/lang/String;Lorg/herb/Location;Ljava/util/List;<%- node.fields.each do |f| -%><%- unless f.is_a?(Herb::Template::AnalyzedRubyField) || f.is_a?(Herb::Template::PrismNodeField) -%><%- if f.is_a?(Herb::Template::StringField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::TokenField) -%>Lorg/herb/Token;<%- elsif f.is_a?(Herb::Template::BooleanField) -%>Z<%- elsif f.is_a?(Herb::Template::ArrayField) -%>Ljava/util/List;<%- elsif f.is_a?(Herb::Template::NodeField) -%>Lorg/herb/ast/<%= f.specific_kind || 'Node' %>;<%- elsif f.is_a?(Herb::Template::ElementSourceField) -%>Ljava/lang/String;<%- end -%><%- end -%><%- end -%>)V";
+  jmethodID constructor = (*env)->GetMethodID(env, nodeClass, "<init>", signature);
+  if (!constructor) { return NULL; }
+
+  jobject result = (*env)->NewObject(env, nodeClass, constructor, type, location, errors<%- node.fields.each do |field| -%><%- unless field.is_a?(Herb::Template::AnalyzedRubyField) || field.is_a?(Herb::Template::PrismNodeField) -%>, <%= field.name %><%- end -%><%- end -%>);
+
+  return result;
+}
+
+<%- end -%>
+
+jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node) {
+  if (!node) { return NULL; }
+
+  switch (node->type) {
+  <%- nodes.each do |node| -%>
+  case <%= node.type %>:
+    return <%= node.name %>FromCStruct(env, (<%= node.struct_type %>*) node);
+  <%- end -%>
+  default:
+    return NULL;
+  }
+}
+
+jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
+  jclass arrayListClass = (*env)->FindClass(env, "java/util/ArrayList");
+  jmethodID arrayListConstructor = (*env)->GetMethodID(env, arrayListClass, "<init>", "(I)V");
+  jmethodID addMethod = (*env)->GetMethodID(env, arrayListClass, "add", "(Ljava/lang/Object;)Z");
+
+  if (!array) {
+    return (*env)->NewObject(env, arrayListClass, arrayListConstructor, 0);
+  }
+
+  jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, (jint) hb_array_size(array));
+
+  for (size_t i = 0; i < hb_array_size(array); i++) {
+    AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
+
+    if (child_node) {
+      jobject nodeObj = NodeFromCStruct(env, child_node);
+      (*env)->CallBooleanMethod(env, javaList, addMethod, nodeObj);
+    }
+  }
+
+  return javaList;
+}
+
+<%- nodes.each do |node| -%>
+jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>) {
+  return <%= node.name %>FromCStruct(env, <%= node.human %>);
+}
+
+<%- end -%>

data/templates/java/nodes.h.erb

@@ -0,0 +1,23 @@
+#ifndef HERB_JNI_NODES_H
+#define HERB_JNI_NODES_H
+
+#include <jni.h>
+
+#include "../../src/include/ast_nodes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+<%- nodes.each do |node| -%>
+jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* node);
+<%- end -%>
+
+jobject CreateErrorNode(JNIEnv* env, AST_NODE_T* error_node);
+jobject CreateASTNode(JNIEnv* env, AST_NODE_T* node);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif