herb 0.10.4-aarch64-linux-gnu → 0.11.0-aarch64-linux-gnu

data/src/parser_options_defaults.c

@@ -0,0 +1,30 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See templates/src/parser_options_defaults.c.erb
+
+#include "include/parser/parser_options.h"
+
+#include <stddef.h>
+
+const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .action_view_helpers = false,
+                                                       .analyze = true,
+                                                       .dot_notation_tags = false,
+                                                       .erb_openers = NULL,
+                                                       .erb_opener_count = 0,
+                                                       .herb_directives = false,
+                                                       .html = true,
+                                                       .iteration_nodes = false,
+                                                       .max_errors = 25,
+                                                       .prism_nodes = false,
+                                                       .prism_nodes_deep = false,
+                                                       .prism_program = false,
+                                                       .render_nodes = false,
+                                                       .strict = true,
+                                                       .strict_locals = false,
+                                                       .timeout_ms = 1000,
+                                                       .track_locations = true,
+                                                       .track_whitespace = false,
+                                                       .transform_conditionals = false,
+                                                       .deadline_ms = 0,
+                                                       .error_count = NULL,
+                                                       .start_column = 0,
+                                                       .start_line = 0 };

data/src/prism/prism_helpers.c

@@ -74,6 +74,9 @@ static bool search_then_keyword_location(const pm_node_t* node, void* data) {
   switch (node->type) {
     case PM_IF_NODE: {
       const pm_if_node_t* if_node = (const pm_if_node_t*) node;
+
+      if (!has_pm_location(if_node->if_keyword_loc)) { break; }
+
       if (has_pm_location(if_node->then_keyword_loc)) {
         context->then_keyword_loc = if_node->then_keyword_loc;
         context->found = true;

data/src/prism/ruby_parser.c

@@ -2,6 +2,7 @@
 
 #include <prism.h>
 #include <stdbool.h>
+#include <stdlib.h>
 #include <string.h>
 
 static bool herb_prism_visit(const pm_node_t* node, void* data) {
@@ -47,3 +48,51 @@ void herb_parse_ruby_to_stdout(char* source) {
   pm_node_destroy(&parser, root);
   pm_parser_free(&parser);
 }
+
+static const char* const RUBY_FRAGMENT_PREFIXES[] = {
+  "", "", "if __herb__\n", "if __herb__\n", "begin\n", "case __herb__\n"
+};
+
+static const char* const RUBY_FRAGMENT_SUFFIXES[] = { "", "\nend", "", "\nend", "\nend", "\nend" };
+
+static bool ruby_source_parses(const char* source, size_t length) {
+  pm_parser_t parser;
+  pm_parser_init(&parser, (const uint8_t*) source, length, NULL);
+
+  pm_node_t* root = pm_parse(&parser);
+  bool parses = (parser.error_list.size == 0);
+
+  if (root != NULL) { pm_node_destroy(&parser, root); }
+  pm_parser_free(&parser);
+
+  return parses;
+}
+
+bool herb_ruby_fragment_is_parseable(hb_string_T source) {
+  if (source.data == NULL) { return false; }
+
+  for (size_t index = 0; index < sizeof(RUBY_FRAGMENT_PREFIXES) / sizeof(RUBY_FRAGMENT_PREFIXES[0]); index++) {
+    const char* prefix = RUBY_FRAGMENT_PREFIXES[index];
+    const char* suffix = RUBY_FRAGMENT_SUFFIXES[index];
+
+    size_t prefix_length = strlen(prefix);
+    size_t suffix_length = strlen(suffix);
+    size_t length = prefix_length + source.length + suffix_length;
+
+    char* wrapped = malloc(length + 1);
+    if (wrapped == NULL) { return false; }
+
+    memcpy(wrapped, prefix, prefix_length);
+    memcpy(wrapped + prefix_length, source.data, source.length);
+    memcpy(wrapped + prefix_length + source.length, suffix, suffix_length);
+    wrapped[length] = '\0';
+
+    bool parses = ruby_source_parses(wrapped, length);
+
+    free(wrapped);
+
+    if (parses) { return true; }
+  }
+
+  return false;
+}

data/src/util/html_util.c

@@ -2,6 +2,7 @@
 #include "../include/lib/hb_allocator.h"
 #include "../include/lib/hb_buffer.h"
 #include "../include/lib/hb_string.h"
+#include "../include/util/html_elements.h"
 
 #include <ctype.h>
 #include <stdbool.h>
@@ -9,64 +10,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-// https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-static hb_string_T void_tags[] = HB_STRING_LIST(
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-);
-
-// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
-static hb_string_T boolean_attributes[] = HB_STRING_LIST(
-  "allowfullscreen",
-  "async",
-  "autofocus",
-  "autoplay",
-  "checked",
-  "compact",
-  "controls",
-  "declare",
-  "default",
-  "defer",
-  "disabled",
-  "formnovalidate",
-  "hidden",
-  "inert",
-  "ismap",
-  "itemscope",
-  "loop",
-  "multiple",
-  "muted",
-  "nomodule",
-  "nohref",
-  "noresize",
-  "noshade",
-  "novalidate",
-  "nowrap",
-  "open",
-  "playsinline",
-  "readonly",
-  "required",
-  "reversed",
-  "scoped",
-  "seamless",
-  "selected",
-  "sortable",
-  "truespeed",
-  "typemustmatch"
-);
-
 // https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
 static hb_string_T optional_end_tags[] = HB_STRING_LIST(
   "li",
@@ -152,6 +95,16 @@ bool is_void_element(hb_string_T tag_name) {
   return false;
 }
 
+bool is_whitespace_preserving_element(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return false; }
+
+  for (size_t i = 0; i < sizeof(whitespace_preserving_tags) / sizeof(whitespace_preserving_tags[0]); i++) {
+    if (hb_string_equals_case_insensitive(tag_name, whitespace_preserving_tags[i])) { return true; }
+  }
+
+  return false;
+}
+
 bool is_boolean_attribute(hb_string_T attribute_name) {
   if (hb_string_is_empty(attribute_name)) { return false; }
 

data/src/visitor.c

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /home/runner/work/herb/herb/templates/src/visitor.c.erb
+// be modified manually. See templates/src/visitor.c.erb
 
 #include <stdio.h>
 
@@ -187,6 +187,17 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_XML_PROCESSING_INSTRUCTION_NODE: {
+      const AST_XML_PROCESSING_INSTRUCTION_NODE_T* xml_processing_instruction_node = ((const AST_XML_PROCESSING_INSTRUCTION_NODE_T *) node);
+
+      if (xml_processing_instruction_node->children != NULL) {
+        for (size_t index = 0; index < hb_array_size(xml_processing_instruction_node->children); index++) {
+          herb_visit_node(hb_array_get(xml_processing_instruction_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
     case AST_CDATA_NODE: {
       const AST_CDATA_NODE_T* cdata_node = ((const AST_CDATA_NODE_T *) node);
 
@@ -261,6 +272,45 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_ERB_ITERATION_BLOCK_NODE: {
+      const AST_ERB_ITERATION_BLOCK_NODE_T* erb_iteration_block_node = ((const AST_ERB_ITERATION_BLOCK_NODE_T *) node);
+
+      if (erb_iteration_block_node->arguments != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_iteration_block_node->arguments); index++) {
+          herb_visit_node(hb_array_get(erb_iteration_block_node->arguments, index), visitor, data);
+        }
+      }
+
+      if (erb_iteration_block_node->body != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_iteration_block_node->body); index++) {
+          herb_visit_node(hb_array_get(erb_iteration_block_node->body, index), visitor, data);
+        }
+      }
+
+      if (erb_iteration_block_node->block_arguments != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_iteration_block_node->block_arguments); index++) {
+          herb_visit_node(hb_array_get(erb_iteration_block_node->block_arguments, index), visitor, data);
+        }
+      }
+
+      if (erb_iteration_block_node->rescue_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_iteration_block_node->rescue_clause, visitor, data);
+      }
+
+      if (erb_iteration_block_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_iteration_block_node->else_clause, visitor, data);
+      }
+
+      if (erb_iteration_block_node->ensure_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_iteration_block_node->ensure_clause, visitor, data);
+      }
+
+      if (erb_iteration_block_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_iteration_block_node->end_node, visitor, data);
+      }
+
+    } break;
+
     case AST_ERB_WHEN_NODE: {
       const AST_ERB_WHEN_NODE_T* erb_when_node = ((const AST_ERB_WHEN_NODE_T *) node);
 
@@ -457,6 +507,12 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
         }
       }
 
+      if (ruby_render_keywords_node->state != NULL) {
+        for (size_t index = 0; index < hb_array_size(ruby_render_keywords_node->state); index++) {
+          herb_visit_node(hb_array_get(ruby_render_keywords_node->state, index), visitor, data);
+        }
+      }
+
     } break;
 
     case AST_ERB_RENDER_NODE: {
@@ -527,6 +583,26 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_HERB_STATE_DECLARATION_NODE: {
+      const AST_HERB_STATE_DECLARATION_NODE_T* herb_state_declaration_node = ((const AST_HERB_STATE_DECLARATION_NODE_T *) node);
+
+      if (herb_state_declaration_node->default_value != NULL) {
+        herb_visit_node((AST_NODE_T *) herb_state_declaration_node->default_value, visitor, data);
+      }
+
+    } break;
+
+    case AST_HERB_STATE_DIRECTIVE_NODE: {
+      const AST_HERB_STATE_DIRECTIVE_NODE_T* herb_state_directive_node = ((const AST_HERB_STATE_DIRECTIVE_NODE_T *) node);
+
+      if (herb_state_directive_node->states != NULL) {
+        for (size_t index = 0; index < hb_array_size(herb_state_directive_node->states); index++) {
+          herb_visit_node(hb_array_get(herb_state_directive_node->states, index), visitor, data);
+        }
+      }
+
+    } break;
+
     default: break;
   }
 }

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

@@ -40,7 +40,7 @@ static VALUE rb_<%= error.human %>_from_c_struct(<%= error.struct_type %>* <%= e
   <%- when Herb::Template::PositionField -%>
   VALUE <%= error.human %>_<%= field.name %> = rb_position_from_c_struct(<%= error.human %>-><%= field.name %>);
   <%- when Herb::Template::TokenField -%>
-  VALUE <%= error.human %>_<%= field.name %> = rb_token_from_c_struct(<%= error.human %>-><%= field.name %>);
+  VALUE <%= error.human %>_<%= field.name %> = rb_token_from_c_struct(<%= error.human %>-><%= field.name %>, &HERB_DEFAULT_PARSER_OPTIONS);
   <%- when Herb::Template::TokenTypeField -%>
   hb_string_T _<%= field.name %>_string = token_type_to_string(<%= error.human %>-><%= field.name %>);
   VALUE <%= error.human %>_<%= field.name %> = rb_utf8_str_new(_<%= field.name %>_string.data, _<%= field.name %>_string.length);

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

@@ -9,8 +9,8 @@
 #include "../../src/include/herb.h"
 #include "../../src/include/lexer/token.h"
 
-VALUE rb_node_from_c_struct(AST_NODE_T* node);
-static VALUE rb_nodes_array_from_c_array(hb_array_T* array);
+VALUE rb_node_from_c_struct(AST_NODE_T* node, const parser_options_T* options);
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array, const parser_options_T* options);
 
 static VALUE mAST;
 static VALUE cNode;
@@ -27,13 +27,18 @@ void rb_init_node_classes(void) {
 }
 
 <%- nodes.each do |node| -%>
-static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= node.human %>) {
+static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= node.human %>, const parser_options_T* options) {
   if (<%= node.human %> == NULL) { return Qnil; }
 
   AST_NODE_T* node = &<%= node.human %>->base;
 
-  VALUE type = rb_string_from_hb_string(ast_node_type_to_string(node));
-  VALUE location = rb_location_from_c_struct(node->location);
+  static VALUE type = 0;
+
+  if (type == 0) {
+    type = rb_interned_string_from_hb_string(ast_node_type_to_string(node));
+    rb_gc_register_mark_object(type);
+  }
+  VALUE location = options->track_locations ? rb_location_from_c_struct(node->location) : Qnil;
   VALUE errors = rb_errors_array_from_c_array(node->errors);
 
   <%- node.fields.each do |field| -%>
@@ -41,17 +46,17 @@ static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= nod
   <%- when Herb::Template::StringField -%>
   VALUE <%= node.human %>_<%= field.name %> = rb_string_from_hb_string(<%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
-  VALUE <%= node.human %>_<%= field.name %> = rb_node_from_c_struct((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
+  VALUE <%= node.human %>_<%= field.name %> = rb_node_from_c_struct((AST_NODE_T*) <%= node.human %>-><%= field.name %>, options);
   <%- when Herb::Template::TokenField -%>
-  VALUE <%= node.human %>_<%= field.name %> = rb_token_from_c_struct(<%= node.human %>-><%= field.name %>);
+  VALUE <%= node.human %>_<%= field.name %> = rb_token_from_c_struct(<%= node.human %>-><%= field.name %>, options);
   <%- when Herb::Template::BooleanField -%>
   VALUE <%= node.human %>_<%= field.name %> = (<%= node.human %>-><%= field.name %>) ? Qtrue : Qfalse;
   <%- when Herb::Template::ArrayField -%>
-  VALUE <%= node.human %>_<%= field.name %> = rb_nodes_array_from_c_array(<%= node.human %>-><%= field.name %>);
+  VALUE <%= node.human %>_<%= field.name %> = rb_nodes_array_from_c_array(<%= node.human %>-><%= field.name %>, options);
   <%- when Herb::Template::ElementSourceField -%>
   VALUE <%= node.human %>_<%= field.name %> = rb_string_from_hb_string(<%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::LocationField -%>
-  VALUE <%= node.human %>_<%= field.name %> = (<%= node.human %>-><%= field.name %> != NULL) ? rb_location_from_c_struct(*<%= node.human %>-><%= field.name %>) : Qnil;
+  VALUE <%= node.human %>_<%= field.name %> = (options->track_locations && <%= node.human %>-><%= field.name %> != NULL) ? rb_location_from_c_struct(*<%= node.human %>-><%= field.name %>) : Qnil;
   <%- when Herb::Template::PrismSerializedField -%>
   VALUE <%= node.human %>_<%= field.name %>;
   if (<%= node.human %>-><%= field.name %>.data != NULL && <%= node.human %>-><%= field.name %>.length > 0) {
@@ -101,19 +106,19 @@ static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= nod
 
 <%- end -%>
 
-VALUE rb_node_from_c_struct(AST_NODE_T* node) {
+VALUE rb_node_from_c_struct(AST_NODE_T* node, const parser_options_T* options) {
   if (!node) { return Qnil; }
 
   switch (node->type) {
   <%- nodes.each do |node| -%>
-    case <%= node.type %>: return rb_<%= node.human %>_from_c_struct((<%= node.struct_type %>*) node); break;
+    case <%= node.type %>: return rb_<%= node.human %>_from_c_struct((<%= node.struct_type %>*) node, options); break;
   <%- end -%>
   }
 
   return Qnil;
 }
 
-static VALUE rb_nodes_array_from_c_array(hb_array_T* array) {
+static VALUE rb_nodes_array_from_c_array(hb_array_T* array, const parser_options_T* options) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
@@ -121,7 +126,7 @@ static VALUE rb_nodes_array_from_c_array(hb_array_T* array) {
       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);
+        VALUE rb_child = rb_node_from_c_struct(child_node, options);
         rb_ary_push(rb_array, rb_child);
       }
     }

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

@@ -3,8 +3,9 @@
 
 #include "../../src/include/herb.h"
 #include <ruby.h>
+#include <stdbool.h>
 
 void rb_init_node_classes(void);
-VALUE rb_node_from_c_struct(AST_NODE_T* node);
+VALUE rb_node_from_c_struct(AST_NODE_T* node, const parser_options_T* options);
 
 #endif

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

@@ -0,0 +1,69 @@
+#include "parser_options_helpers.h"
+
+void herb_extract_parser_options(VALUE options, parser_options_T* parser_options) {
+  if (NIL_P(options)) { return; }
+<%- parser_options.extractable_fields_for(:ruby).each do |field| -%>
+
+<%- if field.boolean? -%>
+  {
+    VALUE value = rb_hash_lookup(options, rb_utf8_str_new_cstr("<%= field.snake_case %>"));
+    if (NIL_P(value)) { value = rb_hash_lookup(options, ID2SYM(rb_intern("<%= field.snake_case %>"))); }
+    if (!NIL_P(value)) { parser_options-><%= field.c_name %> = RTEST(value); }
+  }
+<%- elsif field.ruby_unit == "seconds" -%>
+  {
+    VALUE value = rb_hash_lookup(options, rb_utf8_str_new_cstr("<%= field.snake_case %>"));
+    if (NIL_P(value)) { value = rb_hash_lookup(options, ID2SYM(rb_intern("<%= field.snake_case %>"))); }
+    if (!NIL_P(value)) { parser_options-><%= field.c_name %> = (uint32_t) (NUM2DBL(value) * 1000); }
+  }
+<%- elsif field.nullable? -%>
+  {
+    VALUE sentinel = ID2SYM(rb_intern("__not_set__"));
+    VALUE value = rb_hash_lookup2(options, rb_utf8_str_new_cstr("<%= field.snake_case %>"), sentinel);
+    if (value == sentinel) { value = rb_hash_lookup2(options, ID2SYM(rb_intern("<%= field.snake_case %>")), sentinel); }
+
+    if (value != sentinel) { parser_options-><%= field.c_name %> = NIL_P(value) ? <%= field.null_sentinel %> : (uint32_t) NUM2UINT(value); }
+  }
+<%- else -%>
+  {
+    VALUE value = rb_hash_lookup(options, rb_utf8_str_new_cstr("<%= field.snake_case %>"));
+    if (NIL_P(value)) { value = rb_hash_lookup(options, ID2SYM(rb_intern("<%= field.snake_case %>"))); }
+    if (!NIL_P(value)) { parser_options-><%= field.c_name %> = (uint32_t) NUM2UINT(value); }
+  }
+<%- end -%>
+<%- end -%>
+}
+
+VALUE herb_build_parser_options_hash(const parser_options_T* options) {
+  VALUE kwargs = rb_hash_new();
+
+<%- parser_options.fields_for(:c).each do |field| -%>
+<%- if field.boolean? -%>
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("<%= field.snake_case %>")), options-><%= field.c_name %> ? Qtrue : Qfalse);
+<%- elsif field.string_array? -%>
+  {
+    VALUE <%= field.snake_case %> = rb_ary_new_capa((long) options-><%= field.count_name %>);
+
+    for (size_t index = 0; index < options-><%= field.count_name %>; index++) {
+      hb_string_T item = options-><%= field.c_name %>[index];
+
+      rb_ary_push(<%= field.snake_case %>, rb_utf8_str_new(item.data, (long) item.length));
+    }
+
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("<%= field.snake_case %>")), <%= field.snake_case %>);
+  }
+<%- elsif field.ruby_unit == "seconds" -%>
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("<%= field.snake_case %>")), DBL2NUM((double) options-><%= field.c_name %> / 1000.0));
+<%- elsif field.nullable? -%>
+  rb_hash_aset(
+    kwargs,
+    ID2SYM(rb_intern("<%= field.snake_case %>")),
+    options-><%= field.c_name %> == <%= field.null_sentinel %> ? Qnil : UINT2NUM(options-><%= field.c_name %>)
+  );
+<%- else -%>
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("<%= field.snake_case %>")), UINT2NUM(options-><%= field.c_name %>));
+<%- end -%>
+<%- end -%>
+
+  return kwargs;
+}

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

@@ -0,0 +1,11 @@
+#ifndef HERB_RUBY_PARSER_OPTIONS_HELPERS_H
+#define HERB_RUBY_PARSER_OPTIONS_HELPERS_H
+
+#include "../../src/include/parser/parser_options.h"
+
+#include <ruby.h>
+
+void herb_extract_parser_options(VALUE options, parser_options_T* parser_options);
+VALUE herb_build_parser_options_hash(const parser_options_T* options);
+
+#endif

data/templates/java/nodes.c.erb

@@ -9,35 +9,35 @@
 
 #include <stdlib.h>
 
-jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node);
-jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array);
+jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options);
+jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array, const parser_options_T* options);
 
 <%- nodes.each do |node| -%>
-jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>) {
+jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>, const parser_options_T* options) {
   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 location = options->track_locations ? CreateLocation(env, <%= node.human %>->base.location) : NULL;
   jobject errors = ErrorsArrayFromCArray(env, <%= node.human %>->base.errors);
 
   <%- node.fields.each do |field| -%>
   <%- if field.is_a?(Herb::Template::StringField) -%>
   jstring <%= field.name %> = CreateStringFromHbString(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;
+  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? CreateToken(env, <%= node.human %>-><%= field.name %>, options) : 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 %>);
+  jobject <%= field.name %> = NodesArrayFromCArray(env, <%= node.human %>-><%= field.name %>, options);
   <%- elsif field.is_a?(Herb::Template::NodeField) || field.is_a?(Herb::Template::BorrowedNodeField) -%>
-  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>) : NULL;
+  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>, options) : NULL;
   <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
   jstring <%= field.name %> = <%= node.human %>-><%= field.name %>.data ? (*env)->NewStringUTF(env, <%= node.human %>-><%= field.name %>.data) : NULL;
   <%- elsif field.is_a?(Herb::Template::LocationField) -%>
-  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? CreateLocation(env, *<%= node.human %>-><%= field.name %>) : NULL;
+  jobject <%= field.name %> = (options->track_locations && <%= node.human %>-><%= field.name %>) ? CreateLocation(env, *<%= node.human %>-><%= field.name %>) : NULL;
   <%- elsif field.is_a?(Herb::Template::PrismSerializedField) -%>
   jbyteArray <%= field.name %>;
   if (<%= node.human %>-><%= field.name %>.data != NULL && <%= node.human %>-><%= field.name %>.length > 0) {
@@ -66,8 +66,8 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
   <%- 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::PrismContextField) -%><%- 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;<%- elsif f.is_a?(Herb::Template::LocationField) -%>Lorg/herb/Location;<%- elsif f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) -%>[B<%- end -%><%- end -%><%- end -%>)V";
-  jmethodID constructor = (*env)->GetMethodID(env, nodeClass, "<init>", signature);
+  const char* constructor_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::PrismContextField) -%><%- 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;<%- elsif f.is_a?(Herb::Template::LocationField) -%>Lorg/herb/Location;<%- elsif f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) -%>[B<%- end -%><%- end -%><%- end -%>)V";
+  jmethodID constructor = (*env)->GetMethodID(env, nodeClass, "<init>", constructor_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::PrismContextField) -%>, <%= field.name %><%- end -%><%- end -%>);
@@ -77,20 +77,20 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
 
 <%- end -%>
 
-jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node) {
+jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options) {
   if (!node) { return NULL; }
 
   switch (node->type) {
   <%- nodes.each do |node| -%>
   case <%= node.type %>:
-    return <%= node.name %>FromCStruct(env, (<%= node.struct_type %>*) node);
+    return <%= node.name %>FromCStruct(env, (<%= node.struct_type %>*) node, options);
   <%- end -%>
   default:
     return NULL;
   }
 }
 
-jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
+jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array, const parser_options_T* options) {
   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");
@@ -105,7 +105,7 @@ jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
     AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {
-      jobject nodeObj = NodeFromCStruct(env, child_node);
+      jobject nodeObj = NodeFromCStruct(env, child_node, options);
       (*env)->CallBooleanMethod(env, javaList, addMethod, nodeObj);
     }
   }
@@ -113,9 +113,13 @@ jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
   return javaList;
 }
 
+jobject CreateASTNode(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options) {
+  return NodeFromCStruct(env, node, options);
+}
+
 <%- nodes.each do |node| -%>
-jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>) {
-  return <%= node.name %>FromCStruct(env, <%= node.human %>);
+jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>, const parser_options_T* options) {
+  return <%= node.name %>FromCStruct(env, <%= node.human %>, options);
 }
 
 <%- end -%>

data/templates/java/nodes.h.erb

@@ -4,17 +4,18 @@
 #include <jni.h>
 
 #include "../../src/include/ast/ast_nodes.h"
+#include "../../src/include/parser/parser.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 <%- nodes.each do |node| -%>
-jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* node);
+jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* node, const parser_options_T* options);
 <%- end -%>
 
 jobject CreateErrorNode(JNIEnv* env, AST_NODE_T* error_node);
-jobject CreateASTNode(JNIEnv* env, AST_NODE_T* node);
+jobject CreateASTNode(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options);
 
 #ifdef __cplusplus
 }

data/templates/java/org/herb/ParserOptions.java.erb

@@ -0,0 +1,24 @@
+package org.herb;
+
+public class ParserOptions {
+<%- parser_options.fields_for(:java).each do |field| -%>
+  private <%= field.java_type %> <%= field.camel_case %> = <%= field.java_default %>;
+<%- end -%>
+
+  public ParserOptions() {}
+
+<%- parser_options.fields_for(:java).each do |field| -%>
+  public ParserOptions <%= field.camel_case %>(<%= field.java_type %> value) {
+    this.<%= field.camel_case %> = value;
+    return this;
+  }
+
+  public <%= field.java_type %> <%= field.java_getter %>() {
+    return <%= field.camel_case %>;
+  }
+
+<%- end -%>
+  public static ParserOptions create() {
+    return new ParserOptions();
+  }
+}