diff --git a/.formatter.exs b/.formatter.exs
index f6db0ce..d666525 100644
--- a/.formatter.exs
+++ b/.formatter.exs
@@ -1,5 +1,6 @@
 # Used by "mix format"
 [
   inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"],
-  line_length: 130
+  line_length: 130,
+  locals_without_parens: [defhalt: 1]
 ]
diff --git a/lib/saxy/buffering_helper.ex b/lib/saxy/buffering_helper.ex
index 8178a75..948b683 100644
--- a/lib/saxy/buffering_helper.ex
+++ b/lib/saxy/buffering_helper.ex
@@ -7,15 +7,20 @@ defmodule Saxy.BufferingHelper do
 
   @parser_config Application.get_env(:saxy, :parser, [])
 
-  defmacro defhalt(fun_name, arity, token) do
+  defmacro defhalt(call) do
     if streaming_enabled?(@parser_config) do
-      params_splice = build_params_splice(token, arity)
-      context_fun = build_context_fun(fun_name, token, arity)
-
-      quote do
-        defp unquote(fun_name)(unquote_splicing(params_splice)) do
-          {:halted, unquote(context_fun)}
-        end
+      case Macro.decompose_call(call) do
+        {name, args} ->
+          context_fun = build_context_fun(name, args)
+
+          quote do
+            defp unquote(name)(unquote_splicing(args)) do
+              {:halted, unquote(context_fun)}
+            end
+          end
+
+        _invalid ->
+          raise ArgumentError, "invalid syntax in defhalt #{Macro.to_string(call)}"
       end
     end
   end
@@ -32,27 +37,16 @@ defmodule Saxy.BufferingHelper do
     Keyword.get(config, :streaming, true)
   end
 
-  defp build_context_fun(fun_name, token, arity) do
-    default_params = quote(do: [unquote(token) <> cont_buffer, more?, original <> cont_buffer, pos, state])
-
-    params = append_acc_variables(default_params, arity)
-
+  defp build_context_fun(fun_name, [token, _more?, original | args]) do
     quote do
       fn cont_buffer, more? ->
-        unquote(fun_name)(unquote_splicing(params))
+        unquote(fun_name)(
+          unquote(token) <> cont_buffer,
+          more?,
+          unquote(original) <> cont_buffer,
+          unquote_splicing(args)
+        )
       end
     end
   end
-
-  defp build_params_splice(token, arity) do
-    default_params = quote(do: [unquote(token), true, original, pos, state])
-
-    append_acc_variables(default_params, arity)
-  end
-
-  defp append_acc_variables(vars, arity) do
-    acc_count = arity - length(vars)
-
-    for(i <- 0..acc_count, i > 0, into: vars, do: Macro.var(:"acc#{i}", __MODULE__))
-  end
 end
diff --git a/lib/saxy/parser/element.ex b/lib/saxy/parser/element.ex
index 72da508..6770adf 100644
--- a/lib/saxy/parser/element.ex
+++ b/lib/saxy/parser/element.ex
@@ -3,7 +3,7 @@ defmodule Saxy.Parser.Element do
 
   import Saxy.Guards
 
-  import Saxy.BufferingHelper, only: [defhalt: 3, utf8_binaries: 0]
+  import Saxy.BufferingHelper, only: [defhalt: 1, utf8_binaries: 0]
 
   alias Saxy.Emitter
 
@@ -17,7 +17,7 @@ defmodule Saxy.Parser.Element do
     open_tag(rest, more?, original, pos + 1, state)
   end
 
-  defhalt(:element, 5, "")
+  defhalt element(<<>>, true, original, pos, state)
 
   defp element(<<_buffer::bits>>, _more?, original, pos, state) do
     Utils.parse_error(original, pos, state, {:token, :lt})
@@ -33,7 +33,7 @@ defmodule Saxy.Parser.Element do
     open_tag_name(rest, more?, original, pos, state, Utils.compute_char_len(charcode))
   end
 
-  defhalt(:open_tag, 5, "")
+  defhalt open_tag(<<>>, true, original, pos, state)
 
   defp open_tag(<<_buffer::bits>>, _more?, original, pos, state) do
     Utils.parse_error(original, pos, state, {:token, :name_start_char})
@@ -49,7 +49,7 @@ defmodule Saxy.Parser.Element do
     open_tag_name(rest, more?, original, pos, state, len + Utils.compute_char_len(charcode))
   end
 
-  defhalt(:open_tag_name, 6, "")
+  defhalt open_tag_name(<<>>, true, original, pos, state, len)
 
   defp open_tag_name(<<buffer::bits>>, more?, original, pos, state, len) do
     name = binary_part(original, pos, len)
@@ -113,8 +113,8 @@ defmodule Saxy.Parser.Element do
     sattribute(rest, more?, original, pos + 1, state, attributes)
   end
 
-  defhalt(:sattribute, 6, "")
-  defhalt(:sattribute, 6, "/")
+  defhalt sattribute(<<>>, true, original, pos, state, attributes)
+  defhalt sattribute("/", true, original, pos, state, attributes)
 
   defp sattribute(<<_buffer::bits>>, _more?, original, pos, state, _attributes) do
     Utils.parse_error(original, pos, state, {:token, :name_start_char})
@@ -130,7 +130,7 @@ defmodule Saxy.Parser.Element do
     attribute_name(rest, more?, original, pos, state, attributes, len + Utils.compute_char_len(charcode))
   end
 
-  defhalt(:attribute_name, 7, "")
+  defhalt attribute_name(<<>>, true, original, pos, state, attributes, len)
 
   defp attribute_name(<<rest::bits>>, more?, original, pos, state, attributes, len) do
     att_name = binary_part(original, pos, len)
@@ -146,7 +146,7 @@ defmodule Saxy.Parser.Element do
     attribute_quote(rest, more?, original, pos + 1, state, attributes, att_name)
   end
 
-  defhalt(:attribute_eq, 7, "")
+  defhalt attribute_eq(<<>>, true, original, pos, state, attributes, att_name)
 
   defp attribute_eq(<<_buffer::bits>>, _more?, original, pos, state, _attributes, _att_name) do
     Utils.parse_error(original, pos, state, {:token, :eq})
@@ -162,7 +162,7 @@ defmodule Saxy.Parser.Element do
     att_value(rest, more?, original, pos + 1, state, attributes, quote, att_name, "", 0)
   end
 
-  defhalt(:attribute_quote, 7, "")
+  defhalt attribute_quote(<<>>, true, original, pos, state, attributes, att_name)
 
   defp attribute_quote(<<_buffer::bits>>, _more?, original, pos, state, _attributes, _att_name) do
     Utils.parse_error(original, pos, state, {:token, :quote})
@@ -176,9 +176,9 @@ defmodule Saxy.Parser.Element do
     sattribute(rest, more?, original, pos + len + 1, state, attributes)
   end
 
-  defhalt(:att_value, 10, "")
-  defhalt(:att_value, 10, "&")
-  defhalt(:att_value, 10, "&#")
+  defhalt att_value(<<>>, true, original, pos, state, attributes, q, att_name, acc, len)
+  defhalt att_value(<<?&>>, true, original, pos, state, attributes, q, att_name, acc, len)
+  defhalt att_value(<<?&, ?#>>, true, original, pos, state, attributes, q, att_name, acc, len)
 
   defp att_value(<<"&#x", rest::bits>>, more?, original, pos, state, attributes, q, att_name, acc, len) do
     att_value = binary_part(original, pos, len)
@@ -203,7 +203,9 @@ defmodule Saxy.Parser.Element do
     att_value(rest, more?, original, pos, state, attributes, q, att_name, acc, len + 1)
   end
 
-  Enum.each(utf8_binaries(), &defhalt(:att_value, 10, unquote(&1)))
+  Enum.each(utf8_binaries(), fn token ->
+    defhalt att_value(unquote(token), true, original, pos, state, attributes, q, att_name, acc, len)
+  end)
 
   defp att_value(<<charcode::utf8, rest::bits>>, more?, original, pos, state, attributes, q, att_name, acc, len) do
     att_value(rest, more?, original, pos, state, attributes, q, att_name, acc, len + Utils.compute_char_len(charcode))
@@ -246,7 +248,7 @@ defmodule Saxy.Parser.Element do
     att_value(rest, more?, original, pos + len + 1, state, attributes, q, att_name, acc, 0)
   end
 
-  defhalt(:att_value_entity_ref, 10, "")
+  defhalt att_value_entity_ref(<<>>, true, original, pos, state, attributes, q, att_name, acc, len)
 
   defp att_value_entity_ref(<<_buffer::bits>>, _more?, original, pos, state, _attributes, _q, _att_name, _acc, len) do
     Utils.parse_error(original, pos + len, state, {:token, :entity_ref})
@@ -263,7 +265,7 @@ defmodule Saxy.Parser.Element do
     att_value(rest, more?, original, pos + len + 1, state, attributes, q, att_name, [acc | <<char::utf8>>], 0)
   end
 
-  defhalt(:att_value_char_dec_ref, 10, "")
+  defhalt att_value_char_dec_ref(<<>>, true, original, pos, state, attributes, q, att_name, acc, len)
 
   defp att_value_char_dec_ref(<<_buffer::bits>>, _more?, original, pos, state, _attributes, _q, _att_name, _acc, len) do
     Utils.parse_error(original, pos + len, state, {:token, :char_ref})
@@ -280,7 +282,7 @@ defmodule Saxy.Parser.Element do
     att_value(rest, more?, original, pos + len + 1, state, attributes, q, att_name, [acc | <<char::utf8>>], 0)
   end
 
-  defhalt(:att_value_char_hex_ref, 10, "")
+  defhalt att_value_char_hex_ref(<<>>, true, original, pos, state, attributes, q, att_name, acc, len)
 
   defp att_value_char_hex_ref(<<_buffer::bits>>, _more?, original, pos, state, _attributes, _q, _att_name, _acc, len) do
     Utils.parse_error(original, pos + len, state, {:token, :char_ref})
@@ -299,14 +301,16 @@ defmodule Saxy.Parser.Element do
     chardata_whitespace(rest, more?, original, pos, state, 1)
   end
 
-  defhalt(:element_content, 5, "")
+  defhalt element_content(<<>>, true, original, pos, state)
 
   defp element_content(<<charcode, rest::bits>>, more?, original, pos, state)
        when is_ascii(charcode) do
     chardata(rest, more?, original, pos, state, "", 1)
   end
 
-  Enum.each(utf8_binaries(), &defhalt(:element_content, 5, unquote(&1)))
+  Enum.each(utf8_binaries(), fn token ->
+    defhalt element_content(unquote(token), true, original, pos, state)
+  end)
 
   defp element_content(<<charcode::utf8, rest::bits>>, more?, original, pos, state) do
     chardata(rest, more?, original, pos, state, "", Utils.compute_char_len(charcode))
@@ -342,15 +346,15 @@ defmodule Saxy.Parser.Element do
     element_processing_instruction(buffer, more?, original, pos + 1, state, 0)
   end
 
-  defhalt(:element_content_rest, 5, "")
-  defhalt(:element_content_rest, 5, "!")
-  defhalt(:element_content_rest, 5, "!-")
-  defhalt(:element_content_rest, 5, "![")
-  defhalt(:element_content_rest, 5, "![C")
-  defhalt(:element_content_rest, 5, "![CD")
-  defhalt(:element_content_rest, 5, "![CDA")
-  defhalt(:element_content_rest, 5, "![CDAT")
-  defhalt(:element_content_rest, 5, "![CDATA")
+  defhalt element_content_rest(<<>>, true, original, pos, state)
+  defhalt element_content_rest(<<?!>>, true, original, pos, state)
+  defhalt element_content_rest(<<?!, ?->>, true, original, pos, state)
+  defhalt element_content_rest(<<?!, ?[>>, true, original, pos, state)
+  defhalt element_content_rest(<<?!, ?[, ?C>>, true, original, pos, state)
+  defhalt element_content_rest(<<?!, ?[, ?C, ?D>>, true, original, pos, state)
+  defhalt element_content_rest(<<?!, ?[, ?C, ?D, ?A>>, true, original, pos, state)
+  defhalt element_content_rest(<<?!, ?[, ?C, ?D, ?A, ?T>>, true, original, pos, state)
+  defhalt element_content_rest(<<?!, ?[, ?C, ?D, ?A, ?T, ?A>>, true, original, pos, state)
 
   defp element_content_rest(<<_buffer::bits>>, _more?, original, pos, state) do
     Utils.parse_error(original, pos, state, {:token, :lt})
@@ -371,9 +375,9 @@ defmodule Saxy.Parser.Element do
     end
   end
 
-  defhalt(:element_cdata, 6, "")
-  defhalt(:element_cdata, 6, "]")
-  defhalt(:element_cdata, 6, "]]")
+  defhalt element_cdata(<<>>, true, original, pos, state, len)
+  defhalt element_cdata(<<?]>>, true, original, pos, state, len)
+  defhalt element_cdata(<<?], ?]>>, true, original, pos, state, len)
 
   defp element_cdata(<<charcode, rest::bits>>, more?, original, pos, state, len)
        when is_ascii(charcode) do
@@ -407,13 +411,15 @@ defmodule Saxy.Parser.Element do
     chardata(rest, more?, original, pos, state, "", len + 1)
   end
 
-  Enum.each(utf8_binaries(), &defhalt(:chardata_whitespace, 6, unquote(&1)))
+  Enum.each(utf8_binaries(), fn token ->
+    defhalt chardata_whitespace(unquote(token), true, original, pos, state, len)
+  end)
 
   defp chardata_whitespace(<<charcode::utf8, rest::bits>>, more?, original, pos, state, len) do
     chardata(rest, more?, original, pos, state, "", len + Utils.compute_char_len(charcode))
   end
 
-  defhalt(:chardata_whitespace, 6, "")
+  defhalt chardata_whitespace(<<>>, true, original, pos, state, len)
 
   defp chardata_whitespace(<<_buffer::bits>>, _more?, original, pos, state, len) do
     Utils.parse_error(original, pos + len, state, {:token, :chardata})
@@ -445,20 +451,22 @@ defmodule Saxy.Parser.Element do
     chardata(rest, more?, original, pos, state, acc, len + 1)
   end
 
-  Enum.each(utf8_binaries(), &defhalt(:chardata, 7, unquote(&1)))
+  Enum.each(utf8_binaries(), fn token ->
+    defhalt chardata(unquote(token), true, original, pos, state, acc, len)
+  end)
 
   defp chardata(<<charcode::utf8, rest::bits>>, more?, original, pos, state, acc, len) do
     chardata(rest, more?, original, pos, state, acc, len + Utils.compute_char_len(charcode))
   end
 
-  defhalt(:chardata, 7, "")
+  defhalt chardata(<<>>, true, original, pos, state, acc, len)
 
   defp chardata(<<_buffer::bits>>, _more?, original, pos, state, _acc, len) do
     Utils.parse_error(original, pos + len, state, {:token, :chardata})
   end
 
-  defhalt(:element_content_reference, 6, "")
-  defhalt(:element_content_reference, 6, "#")
+  defhalt element_content_reference(<<>>, true, original, pos, state, acc)
+  defhalt element_content_reference(<<?#>>, true, original, pos, state, acc)
 
   defp element_content_reference(<<charcode, rest::bits>>, more?, original, pos, state, acc)
        when is_name_start_char(charcode) do
@@ -498,7 +506,7 @@ defmodule Saxy.Parser.Element do
     chardata(rest, more?, original, pos + len + 1, state, [acc | char], 0)
   end
 
-  defhalt(:element_entity_ref, 7, "")
+  defhalt element_entity_ref(<<>>, true, original, pos, state, acc, len)
 
   defp element_entity_ref(<<_buffer::bits>>, _more?, original, pos, state, _acc, len) do
     Utils.parse_error(original, pos + len, state, {:token, :entity_ref})
@@ -519,7 +527,7 @@ defmodule Saxy.Parser.Element do
     element_char_dec_ref(rest, more?, original, pos, state, acc, len + 1)
   end
 
-  defhalt(:element_char_dec_ref, 7, "")
+  defhalt element_char_dec_ref(<<>>, true, original, pos, state, acc, len)
 
   defp element_char_dec_ref(<<_buffer::bits>>, _more?, original, pos, state, _acc, len) do
     Utils.parse_error(original, pos + len, state, {:token, :char_ref})
@@ -540,7 +548,7 @@ defmodule Saxy.Parser.Element do
     element_char_hex_ref(rest, more?, original, pos, state, acc, len + 1)
   end
 
-  defhalt(:element_char_hex_ref, 7, "")
+  defhalt element_char_hex_ref(<<>>, true, original, pos, state, acc, len)
 
   defp element_char_hex_ref(<<_buffer::bits>>, _more?, original, pos, state, _acc, len) do
     Utils.parse_error(original, pos + len, state, {:token, :char_ref})
@@ -556,7 +564,7 @@ defmodule Saxy.Parser.Element do
     element_processing_instruction(rest, more?, original, pos, state, Utils.compute_char_len(charcode))
   end
 
-  defhalt(:element_processing_instruction, 6, "")
+  defhalt element_processing_instruction(<<>>, true, original, pos, state, len)
 
   defp element_processing_instruction(<<_buffer::bits>>, _more?, original, pos, state, 0) do
     Utils.parse_error(original, pos, state, {:token, :processing_instruction})
@@ -586,8 +594,8 @@ defmodule Saxy.Parser.Element do
     element_content(rest, more?, original, pos + len + 2, state)
   end
 
-  defhalt(:element_processing_instruction_content, 7, "")
-  defhalt(:element_processing_instruction_content, 7, "?")
+  defhalt element_processing_instruction_content(<<>>, true, original, pos, state, name, len)
+  defhalt element_processing_instruction_content(<<??>>, true, original, pos, state, name, len)
 
   defp element_processing_instruction_content(<<charcode, rest::bits>>, more?, original, pos, state, name, len)
        when is_ascii(charcode) do
@@ -606,10 +614,10 @@ defmodule Saxy.Parser.Element do
     element_content(rest, more?, original, pos + len + 3, state)
   end
 
-  defhalt(:element_content_comment, 6, "")
-  defhalt(:element_content_comment, 6, "-")
-  defhalt(:element_content_comment, 6, "--")
-  defhalt(:element_content_comment, 6, "---")
+  defhalt element_content_comment(<<>>, true, original, pos, state, len)
+  defhalt element_content_comment(<<?->>, true, original, pos, state, len)
+  defhalt element_content_comment(<<?-, ?->>, true, original, pos, state, len)
+  defhalt element_content_comment(<<?-, ?-, ?->>, true, original, pos, state, len)
 
   defp element_content_comment(<<"--->", _rest::bits>>, _more?, original, pos, state, len) do
     Utils.parse_error(original, pos + len, state, {:token, :comment})
@@ -633,7 +641,7 @@ defmodule Saxy.Parser.Element do
     close_tag_name(rest, more?, original, pos, state, Utils.compute_char_len(charcode))
   end
 
-  defhalt(:close_tag_name, 6, "")
+  defhalt close_tag_name(<<>>, true, original, pos, state, len)
 
   defp close_tag_name(<<_buffer::bits>>, _more?, original, pos, state, 0) do
     Utils.parse_error(original, pos, state, {:token, :end_tag})
@@ -682,7 +690,7 @@ defmodule Saxy.Parser.Element do
     Utils.parse_error(original, pos + len, state, {:token, :end_tag})
   end
 
-  defhalt(:element_misc, 5, "")
+  defhalt element_misc(<<>>, true, original, pos, state)
 
   defp element_misc(<<>>, _more?, _original, _pos, state) do
     case Emitter.emit(:end_document, {}, state) do
@@ -701,7 +709,7 @@ defmodule Saxy.Parser.Element do
     element_misc_rest(rest, more?, original, pos + 1, state)
   end
 
-  defhalt(:element_misc_rest, 5, "")
+  defhalt element_misc_rest(<<>>, true, original, pos, state)
 
   defp element_misc_rest(<<?!, rest::bits>>, more?, original, pos, state) do
     element_misc_comment(rest, more?, original, pos + 1, state)
@@ -711,8 +719,8 @@ defmodule Saxy.Parser.Element do
     element_misc_pi(rest, more?, original, pos + 1, state)
   end
 
-  defhalt(:element_misc_comment, 5, "")
-  defhalt(:element_misc_comment, 5, "-")
+  defhalt element_misc_comment(<<>>, true, original, pos, state)
+  defhalt element_misc_comment(<<?->>, true, original, pos, state)
 
   defp element_misc_comment(<<"--", rest::bits>>, more?, original, pos, state) do
     element_misc_comment_char(rest, more?, original, pos + 2, state, 0)
@@ -722,10 +730,10 @@ defmodule Saxy.Parser.Element do
     Utils.parse_error(original, pos, state, {:token, :--})
   end
 
-  defhalt(:element_misc_comment_char, 6, "")
-  defhalt(:element_misc_comment_char, 6, "-")
-  defhalt(:element_misc_comment_char, 6, "--")
-  defhalt(:element_misc_comment_char, 6, "---")
+  defhalt element_misc_comment_char(<<>>, true, original, pos, state, len)
+  defhalt element_misc_comment_char(<<?->>, true, original, pos, state, len)
+  defhalt element_misc_comment_char(<<?-, ?->>, true, original, pos, state, len)
+  defhalt element_misc_comment_char(<<?-, ?-, ?->>, true, original, pos, state, len)
 
   defp element_misc_comment_char(<<"--->", _rest::bits>>, _more?, original, pos, state, len) do
     Utils.parse_error(original, pos + len, state, {:token, :comment})
@@ -748,7 +756,7 @@ defmodule Saxy.Parser.Element do
     Utils.parse_error(original, pos + len, state, {:token, :"-->"})
   end
 
-  defhalt(:element_misc_pi, 5, "")
+  defhalt element_misc_pi(<<>>, true, original, pos, state)
 
   defp element_misc_pi(<<char, rest::bits>>, more?, original, pos, state)
        when is_name_start_char(char) do
@@ -784,8 +792,8 @@ defmodule Saxy.Parser.Element do
     end
   end
 
-  defhalt(:element_misc_pi_content, 6, "")
-  defhalt(:element_misc_pi_content, 6, "?")
+  defhalt element_misc_pi_content(<<>>, true, original, pos, state, len)
+  defhalt element_misc_pi_content(<<??>>, true, original, pos, state, len)
 
   defp element_misc_pi_content(<<"?>", rest::bits>>, more?, original, pos, state, len) do
     element_misc(rest, more?, original, pos + len + 2, state)
diff --git a/lib/saxy/parser/prolog.ex b/lib/saxy/parser/prolog.ex
index 918f328..7021a03 100644
--- a/lib/saxy/parser/prolog.ex
+++ b/lib/saxy/parser/prolog.ex
@@ -3,7 +3,7 @@ defmodule Saxy.Parser.Prolog do
 
   import Saxy.Guards
 
-  import Saxy.BufferingHelper, only: [defhalt: 3]
+  import Saxy.BufferingHelper, only: [defhalt: 1]
 
   alias Saxy.Emitter
 
@@ -20,11 +20,11 @@ defmodule Saxy.Parser.Prolog do
     xml_decl(rest, more?, original, pos + 5, state)
   end
 
-  defhalt(:prolog, 5, "")
-  defhalt(:prolog, 5, "<")
-  defhalt(:prolog, 5, "<?")
-  defhalt(:prolog, 5, "<?x")
-  defhalt(:prolog, 5, "<?xm")
+  defhalt prolog(<<>>, true, original, pos, state)
+  defhalt prolog(<<?<>>, true, original, pos, state)
+  defhalt prolog(<<?<, ??>>, true, original, pos, state)
+  defhalt prolog(<<?<, ??, ?x>>, true, original, pos, state)
+  defhalt prolog(<<?<, ??, ?x, ?m>>, true, original, pos, state)
 
   defp prolog(<<buffer::bits>>, more?, original, pos, state) do
     prolog_misc(buffer, more?, original, pos, state, [])
@@ -39,13 +39,13 @@ defmodule Saxy.Parser.Prolog do
     xml_ver_eq(rest, more?, original, pos + 7, state)
   end
 
-  defhalt(:xml_decl, 5, "")
-  defhalt(:xml_decl, 5, "v")
-  defhalt(:xml_decl, 5, "ve")
-  defhalt(:xml_decl, 5, "ver")
-  defhalt(:xml_decl, 5, "vers")
-  defhalt(:xml_decl, 5, "versi")
-  defhalt(:xml_decl, 5, "versio")
+  defhalt xml_decl(<<>>, true, original, pos, state)
+  defhalt xml_decl(<<?v>>, true, original, pos, state)
+  defhalt xml_decl(<<?v, ?e>>, true, original, pos, state)
+  defhalt xml_decl(<<?v, ?e, ?r>>, true, original, pos, state)
+  defhalt xml_decl(<<?v, ?e, ?r, ?s>>, true, original, pos, state)
+  defhalt xml_decl(<<?v, ?e, ?r, ?s, ?i>>, true, original, pos, state)
+  defhalt xml_decl(<<?v, ?e, ?r, ?s, ?i, ?o>>, true, original, pos, state)
 
   defp xml_decl(<<_buffer::bits>>, _more?, original, pos, state) do
     Utils.parse_error(original, pos, state, {:token, :version})
@@ -59,7 +59,7 @@ defmodule Saxy.Parser.Prolog do
     xml_ver_quote(rest, more?, original, pos + 1, state)
   end
 
-  defhalt(:xml_ver_eq, 5, "")
+  defhalt xml_ver_eq(<<>>, true, original, pos, state)
 
   defp xml_ver_quote(<<whitespace::integer, rest::bits>>, more?, original, pos, state)
        when is_whitespace(whitespace) do
@@ -70,7 +70,7 @@ defmodule Saxy.Parser.Prolog do
     xml_ver_one_dot(rest, more?, original, pos + 1, state, quote)
   end
 
-  defhalt(:xml_ver_quote, 5, "")
+  defhalt xml_ver_quote(<<>>, true, original, pos, state)
 
   defp xml_ver_quote(<<_buffer::bits>>, _more?, original, pos, state) do
     Utils.parse_error(original, pos, state, {:token, :quote})
@@ -80,8 +80,8 @@ defmodule Saxy.Parser.Prolog do
     xml_ver_num(rest, more?, original, pos, state, quote, 2)
   end
 
-  defhalt(:xml_ver_one_dot, 6, "")
-  defhalt(:xml_ver_one_dot, 6, "1")
+  defhalt xml_ver_one_dot(<<>>, true, original, pos, state, quote)
+  defhalt xml_ver_one_dot(<<?1>>, true, original, pos, state, quote)
 
   defp xml_ver_one_dot(<<_buffer::bits>>, _more?, original, pos, state, _quote) do
     Utils.parse_error(original, pos, state, {:token, :"1."})
@@ -100,7 +100,7 @@ defmodule Saxy.Parser.Prolog do
     xml_ver_num(rest, more?, original, pos, state, open_quote, len + 1)
   end
 
-  defhalt(:xml_ver_num, 7, "")
+  defhalt xml_ver_num(<<>>, true, original, pos, state, open_quote, len)
 
   defp xml_ver_num(<<_buffer::bits>>, _more?, original, pos, state, _open_quote, len) do
     Utils.parse_error(original, pos + len, state, {:token, :version_num})
@@ -115,14 +115,14 @@ defmodule Saxy.Parser.Prolog do
     encoding_decl_eq(rest, more?, original, pos + 8, state, prolog)
   end
 
-  defhalt(:encoding_decl, 6, "")
-  defhalt(:encoding_decl, 6, "e")
-  defhalt(:encoding_decl, 6, "en")
-  defhalt(:encoding_decl, 6, "enc")
-  defhalt(:encoding_decl, 6, "enco")
-  defhalt(:encoding_decl, 6, "encod")
-  defhalt(:encoding_decl, 6, "encodi")
-  defhalt(:encoding_decl, 6, "encodin")
+  defhalt encoding_decl(<<>>, true, original, pos, state, prolog)
+  defhalt encoding_decl(<<?e>>, true, original, pos, state, prolog)
+  defhalt encoding_decl(<<?e, ?n>>, true, original, pos, state, prolog)
+  defhalt encoding_decl(<<?e, ?n, ?c>>, true, original, pos, state, prolog)
+  defhalt encoding_decl(<<?e, ?n, ?c, ?o>>, true, original, pos, state, prolog)
+  defhalt encoding_decl(<<?e, ?n, ?c, ?o, ?d>>, true, original, pos, state, prolog)
+  defhalt encoding_decl(<<?e, ?n, ?c, ?o, ?d, ?i>>, true, original, pos, state, prolog)
+  defhalt encoding_decl(<<?e, ?n, ?c, ?o, ?d, ?i, ?n>>, true, original, pos, state, prolog)
 
   defp encoding_decl(<<buffer::bits>>, more?, original, pos, state, prolog) do
     standalone(buffer, more?, original, pos, state, prolog)
@@ -137,7 +137,7 @@ defmodule Saxy.Parser.Prolog do
     encoding_decl_eq_quote(rest, more?, original, pos + 1, state, prolog)
   end
 
-  defhalt(:encoding_decl_eq, 6, "")
+  defhalt encoding_decl_eq(<<>>, true, original, pos, state, prolog)
 
   defp encoding_decl_eq(<<_buffer::bits>>, _more?, original, pos, state, _prolog) do
     Utils.parse_error(original, pos, state, {:token, :eq})
@@ -156,7 +156,7 @@ defmodule Saxy.Parser.Prolog do
     encoding_decl_enc_name(rest, more?, original, pos + 1, state, prolog, ?', 0)
   end
 
-  defhalt(:encoding_decl_eq_quote, 6, "")
+  defhalt encoding_decl_eq_quote(<<>>, true, original, pos, state, prolog)
 
   defp encoding_decl_eq_quote(<<_buffer::bits>>, _more?, original, pos, state, _prolog) do
     Utils.parse_error(original, pos, state, {:token, :quote})
@@ -178,7 +178,7 @@ defmodule Saxy.Parser.Prolog do
     encoding_decl_enc_name(rest, more?, original, pos, state, prolog, open_quote, len + 1)
   end
 
-  defhalt(:encoding_decl_enc_name, 8, "")
+  defhalt encoding_decl_enc_name(<<>>, true, original, pos, state, prolog, open_quote, len)
 
   defp encoding_decl_enc_name(<<_buffer::bits>>, _more?, original, pos, state, _prolog, _open_quote, len) do
     Utils.parse_error(original, pos + len, state, {:token, :encoding_name})
@@ -193,16 +193,16 @@ defmodule Saxy.Parser.Prolog do
     standalone_eq(rest, more?, original, pos + 10, state, prolog)
   end
 
-  defhalt(:standalone, 6, "")
-  defhalt(:standalone, 6, "s")
-  defhalt(:standalone, 6, "st")
-  defhalt(:standalone, 6, "sta")
-  defhalt(:standalone, 6, "stan")
-  defhalt(:standalone, 6, "stand")
-  defhalt(:standalone, 6, "standa")
-  defhalt(:standalone, 6, "standal")
-  defhalt(:standalone, 6, "standalo")
-  defhalt(:standalone, 6, "standalon")
+  defhalt standalone(<<>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t, ?a>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t, ?a, ?n>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t, ?a, ?n, ?d>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t, ?a, ?n, ?d, ?a>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t, ?a, ?n, ?d, ?a, ?l>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t, ?a, ?n, ?d, ?a, ?l, ?o>>, true, original, pos, state, prolog)
+  defhalt standalone(<<?s, ?t, ?a, ?n, ?d, ?a, ?l, ?o, ?n>>, true, original, pos, state, prolog)
 
   defp standalone(<<buffer::bits>>, more?, original, pos, state, prolog) do
     xml_decl_close(buffer, more?, original, pos, state, prolog)
@@ -217,7 +217,7 @@ defmodule Saxy.Parser.Prolog do
     standalone_eq_quote(rest, more?, original, pos + 1, state, prolog)
   end
 
-  defhalt(:standalone_eq, 6, "")
+  defhalt standalone_eq(<<>>, true, original, pos, state, prolog)
 
   defp standalone_eq(<<_buffer::bits>>, _more?, original, pos, state, _prolog) do
     Utils.parse_error(original, pos, state, {:token, :standalone})
@@ -228,7 +228,7 @@ defmodule Saxy.Parser.Prolog do
     standalone_bool(rest, more?, original, pos + 1, state, prolog, quote)
   end
 
-  defhalt(:standalone_eq_quote, 6, "")
+  defhalt standalone_eq_quote(<<>>, true, original, pos, state, prolog)
 
   defp standalone_eq_quote(<<_buffer::bits>>, _more?, original, pos, state, _prolog) do
     Utils.parse_error(original, pos, state, {:token, :quote})
@@ -242,10 +242,10 @@ defmodule Saxy.Parser.Prolog do
     standalone_end_quote(rest, more?, original, pos + 2, state, [{:standalone, false} | prolog], open_quote)
   end
 
-  defhalt(:standalone_bool, 7, "")
-  defhalt(:standalone_bool, 7, "y")
-  defhalt(:standalone_bool, 7, "n")
-  defhalt(:standalone_bool, 7, "ye")
+  defhalt standalone_bool(<<>>, true, original, pos, state, prolog, open_quote)
+  defhalt standalone_bool(<<?y>>, true, original, pos, state, prolog, open_quote)
+  defhalt standalone_bool(<<?n>>, true, original, pos, state, prolog, open_quote)
+  defhalt standalone_bool(<<?y, ?e>>, true, original, pos, state, prolog, open_quote)
 
   defp standalone_bool(<<_buffer::bits>>, _more?, original, pos, state, _prolog, _open_quote) do
     Utils.parse_error(original, pos, state, {:token, :yes_or_no})
@@ -256,7 +256,7 @@ defmodule Saxy.Parser.Prolog do
     xml_decl_close(rest, more?, original, pos + 1, state, prolog)
   end
 
-  defhalt(:standalone_end_quote, 7, "")
+  defhalt standalone_end_quote(<<>>, true, original, pos, state, prolog, open_quote)
 
   defp standalone_end_quote(<<_buffer::bits>>, _more?, original, pos, state, _prolog, _open_quote) do
     Utils.parse_error(original, pos, state, {:token, :quote})
@@ -271,8 +271,8 @@ defmodule Saxy.Parser.Prolog do
     prolog_misc(rest, more?, original, pos + 2, state, prolog)
   end
 
-  defhalt(:xml_decl_close, 6, "")
-  defhalt(:xml_decl_close, 6, "?")
+  defhalt xml_decl_close(<<>>, true, original, pos, state, prolog)
+  defhalt xml_decl_close(<<??>>, true, original, pos, state, prolog)
 
   defp xml_decl_close(<<_buffer::bits>>, _more?, original, pos, state, _prolog) do
     Utils.parse_error(original, pos, state, {:token, :xml_decl_close})
@@ -291,10 +291,10 @@ defmodule Saxy.Parser.Prolog do
     prolog_processing_instruction(rest, more?, original, pos + 2, state, prolog)
   end
 
-  defhalt(:prolog_misc, 6, "")
-  defhalt(:prolog_misc, 6, "<")
-  defhalt(:prolog_misc, 6, "<!")
-  defhalt(:prolog_misc, 6, "<!-")
+  defhalt prolog_misc(<<>>, true, original, pos, state, prolog)
+  defhalt prolog_misc(<<?<>>, true, original, pos, state, prolog)
+  defhalt prolog_misc(<<?<, ?!>>, true, original, pos, state, prolog)
+  defhalt prolog_misc(<<?<, ?!, ?->>, true, original, pos, state, prolog)
 
   defp prolog_misc(<<rest::bits>>, more?, original, pos, state, prolog) do
     state = %{state | prolog: prolog}
@@ -319,9 +319,9 @@ defmodule Saxy.Parser.Prolog do
     prolog_misc(rest, more?, original, pos + len + 3, state, prolog)
   end
 
-  defhalt(:prolog_misc_comment, 7, "")
-  defhalt(:prolog_misc_comment, 7, "-")
-  defhalt(:prolog_misc_comment, 7, "--")
+  defhalt prolog_misc_comment(<<>>, true, original, pos, state, prolog, len)
+  defhalt prolog_misc_comment(<<?->>, true, original, pos, state, prolog, len)
+  defhalt prolog_misc_comment(<<?-, ?->>, true, original, pos, state, prolog, len)
 
   defp prolog_misc_comment(<<charcode, rest::bits>>, more?, original, pos, state, prolog, len)
        when is_ascii(charcode) do
@@ -342,7 +342,7 @@ defmodule Saxy.Parser.Prolog do
     prolog_pi_name(rest, more?, original, pos, state, prolog, Utils.compute_char_len(charcode))
   end
 
-  defhalt(:prolog_processing_instruction, 6, "")
+  defhalt prolog_processing_instruction(<<>>, true, original, pos, state, prolog)
 
   defp prolog_processing_instruction(<<_buffer::bits>>, _more?, original, pos, state, _prolog) do
     Utils.parse_error(original, pos, state, {:token, :processing_instruction})
@@ -358,7 +358,7 @@ defmodule Saxy.Parser.Prolog do
     prolog_pi_name(rest, more?, original, pos, state, prolog, len + Utils.compute_char_len(charcode))
   end
 
-  defhalt(:prolog_pi_name, 7, "")
+  defhalt prolog_pi_name(<<>>, true, original, pos, state, prolog, len)
 
   defp prolog_pi_name(<<rest::bits>>, more?, original, pos, state, prolog, len) do
     pi_name = binary_part(original, pos, len)
@@ -374,8 +374,8 @@ defmodule Saxy.Parser.Prolog do
     prolog_misc(rest, more?, original, pos + len + 2, state, prolog)
   end
 
-  defhalt(:prolog_pi_content, 7, "")
-  defhalt(:prolog_pi_content, 7, "?")
+  defhalt prolog_pi_content(<<>>, true, original, pos, state, prolog, len)
+  defhalt prolog_pi_content(<<??>>, true, original, pos, state, prolog, len)
 
   defp prolog_pi_content(<<charcode, rest::bits>>, more?, original, pos, state, prolog, len)
        when is_ascii(charcode) do
@@ -390,15 +390,15 @@ defmodule Saxy.Parser.Prolog do
     dtd_content(rest, more?, original, pos + 9, state, 0, 1)
   end
 
-  defhalt(:dtd, 5, "")
-  defhalt(:dtd, 5, "<")
-  defhalt(:dtd, 5, "<!")
-  defhalt(:dtd, 5, "<!D")
-  defhalt(:dtd, 5, "<!DO")
-  defhalt(:dtd, 5, "<!DOC")
-  defhalt(:dtd, 5, "<!DOCT")
-  defhalt(:dtd, 5, "<!DOCTY")
-  defhalt(:dtd, 5, "<!DOCTYP")
+  defhalt dtd(<<>>, true, original, pos, state)
+  defhalt dtd(<<?<>>, true, original, pos, state)
+  defhalt dtd(<<?<, ?!>>, true, original, pos, state)
+  defhalt dtd(<<?<, ?!, ?D>>, true, original, pos, state)
+  defhalt dtd(<<?<, ?!, ?D, ?O>>, true, original, pos, state)
+  defhalt dtd(<<?<, ?!, ?D, ?O, ?C>>, true, original, pos, state)
+  defhalt dtd(<<?<, ?!, ?D, ?O, ?C, ?T>>, true, original, pos, state)
+  defhalt dtd(<<?<, ?!, ?D, ?O, ?C, ?T, ?Y>>, true, original, pos, state)
+  defhalt dtd(<<?<, ?!, ?D, ?O, ?C, ?T, ?Y, ?P>>, true, original, pos, state)
 
   defp dtd(<<rest::bits>>, more?, original, pos, state) do
     Element.parse(rest, more?, original, pos, state)
@@ -425,7 +425,7 @@ defmodule Saxy.Parser.Prolog do
     dtd_content(rest, more?, original, pos, state, len + Utils.compute_char_len(charcode), count)
   end
 
-  defhalt(:dtd_content, 7, "")
+  defhalt dtd_content(<<>>, true, original, pos, state, len, count)
 
   defp dtd_content(<<_::bits>>, _more?, original, pos, state, _len, _count) do
     Utils.parse_error(original, pos, state, {:token, :dtd_content})
@@ -444,10 +444,10 @@ defmodule Saxy.Parser.Prolog do
     dtd_processing_instruction(rest, more?, original, pos + 2, state)
   end
 
-  defhalt(:dtd_misc, 5, "")
-  defhalt(:dtd_misc, 5, "<")
-  defhalt(:dtd_misc, 5, "<!")
-  defhalt(:dtd_misc, 5, "<!-")
+  defhalt dtd_misc(<<>>, true, original, pos, state)
+  defhalt dtd_misc(<<?<>>, true, original, pos, state)
+  defhalt dtd_misc(<<?<, ?!>>, true, original, pos, state)
+  defhalt dtd_misc(<<?<, ?!, ?->>, true, original, pos, state)
 
   defp dtd_misc(<<rest::bits>>, more?, original, pos, state) do
     Element.parse(rest, more?, original, pos, state)
@@ -461,9 +461,9 @@ defmodule Saxy.Parser.Prolog do
     dtd_misc(rest, more?, original, pos + len + 3, state)
   end
 
-  defhalt(:dtd_misc_comment, 6, "")
-  defhalt(:dtd_misc_comment, 6, "-")
-  defhalt(:dtd_misc_comment, 6, "--")
+  defhalt dtd_misc_comment(<<>>, true, original, pos, state, len)
+  defhalt dtd_misc_comment(<<?->>, true, original, pos, state, len)
+  defhalt dtd_misc_comment(<<?-, ?->>, true, original, pos, state, len)
 
   defp dtd_misc_comment(<<charcode, rest::bits>>, more?, original, pos, state, len)
        when is_ascii(charcode) do
@@ -484,7 +484,7 @@ defmodule Saxy.Parser.Prolog do
     dtd_pi_name(rest, more?, original, pos, state, Utils.compute_char_len(charcode))
   end
 
-  defhalt(:dtd_processing_instruction, 5, "")
+  defhalt dtd_processing_instruction(<<>>, true, original, pos, state)
 
   defp dtd_processing_instruction(<<_buffer::bits>>, _more?, original, pos, state) do
     Utils.parse_error(original, pos, state, {:token, :processing_instruction})
@@ -500,7 +500,7 @@ defmodule Saxy.Parser.Prolog do
     dtd_pi_name(rest, more?, original, pos, state, len + Utils.compute_char_len(charcode))
   end
 
-  defhalt(:prolog_pi_name, 6, "")
+  defhalt dtd_pi_name(<<>>, true, original, pos, state, len)
 
   defp dtd_pi_name(<<rest::bits>>, more?, original, pos, state, len) do
     pi_name = binary_part(original, pos, len)
@@ -516,8 +516,8 @@ defmodule Saxy.Parser.Prolog do
     dtd_misc(rest, more?, original, pos + len + 2, state)
   end
 
-  defhalt(:dtd_pi_content, 6, "")
-  defhalt(:dtd_pi_content, 6, "?")
+  defhalt dtd_pi_content(<<>>, true, original, pos, state, len)
+  defhalt dtd_pi_content(<<??>>, true, original, pos, state, len)
 
   defp dtd_pi_content(<<charcode, rest::bits>>, more?, original, pos, state, len)
        when is_ascii(charcode) do