diff --git a/.gitignore b/.gitignore
index a946354..d6b9e8c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+.\#*
+\#*
 *~
-*.beam
-ebin
+/_build/
+/rebar.lock
diff --git a/Makefile b/Makefile
old mode 100755
new mode 100644
index 0dffbd7..6f654ab
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,37 @@
-SUBDIRS=src \
-	samples/sip
-#	samples/sdp \
+.PHONY: clean distclean upgrade compile test dialyzer eunit xref
+.PHONY: release
 
-include ./subdir.mk
-include ./vsn.mk
+default: compile
 
-APPNAME=abnf
+clean:
+	./rebar3 clean
+	rm -rf _build/*/rel
+	rm -f _build/*/lib/*/ebin/*
+	find . -name "erlcinfo" -exec rm {} \;
+
+distclean: clean
+	rm -rf _build
+	rm -f rebar.lock
+	rm -rf .release
+
+upgrade:
+	./rebar3 upgrade
+
+compile:
+	./rebar3 compile
+
+test: xref eunit dialyzer
+
+dialyzer:
+	./rebar3 dialyzer
+
+eunit:
+	./rebar3 eunit
+
+xref:
+	./rebar3 xref
+
+release: clean
+	./rebar3 xref
+	./rebar3 eunit
+	./rebar3 release
diff --git a/ebin/.gitignore b/ebin/.gitignore
deleted file mode 100644
index e69de29..0000000
diff --git a/include.mk b/include.mk
deleted file mode 100644
index a3a0d64..0000000
--- a/include.mk
+++ /dev/null
@@ -1,58 +0,0 @@
-## -*- makefile -*-
-
-######################################################################
-## Erlang
-
-ERL	:= /usr/local/bin/erl
-ERLC	:= /usr/local/bin/erlc
-ABNFC   := ../../bin/abnfc
-
-ERLDIR	:= /usr/local/lib/erlang
-ERL_C_INCLUDE_DIR := $(ERLDIR)/usr/include
-
-ERLC_FLAGS := -W  -I ../include
-
-ifndef no_debug_info
-  ERLC_FLAGS += +debug_info
-endif
-
-ifdef debug
-  ERLC_FLAGS += -Ddebug
-endif
-
-EBIN_DIR := ../ebin
-DOC_DIR  := ../doc
-EMULATOR := beam
-
-ERL_SOURCES := $(wildcard *.erl)
-ERL_HEADERS := $(wildcard *.hrl) $(wildcard ../include/*.hrl)
-ERL_OBJECTS := $(ERL_SOURCES:%.erl=$(EBIN_DIR)/%.$(EMULATOR))
-ERL_DOCUMENTS := $(ERL_SOURCES:%.erl=$(DOC_DIR)/%.html)
-MODULES = $(ERL_SOURCES:%.erl=%)
-
-# Hmm, don't know if you are supposed to like this better... ;-)
-APPSCRIPT = '$$vsn=shift; $$mods=""; while(@ARGV){ $$_=shift; s/^([A-Z].*)$$/\'\''$$1\'\''/; $$mods.=", " if $$mods; $$mods .= $$_; } while(<>) { s/%VSN%/$$vsn/; s/\"MODULES\"/$$mods/; print; }'
-
-
-../ebin/%.app: %.app.src ../vsn.mk Makefile                 
-	perl -e $(APPSCRIPT) "$(VSN)" $(MODULES) < $< > $@  
-
-../ebin/%.appup: %.appup
-	cp $< $@
-
-
-$(EBIN_DIR)/%.$(EMULATOR): %.erl
-	$(ERLC) $(ERLC_FLAGS) -o $(EBIN_DIR) $<
-
-$(EBIN_DIR)/%.$(EMULATOR): %.abnf
-	$(ABNFC) -o $(EBIN_DIR) $<
-
-
-# generate documentation with edoc:
-# this is still not the proper way to do it, but it works
-# (see the wumpus application for an example)
-
-$(DOC_DIR)/%.html: %.erl
-	${ERL} -noshell \
-          -run edoc file $< -run init stop
-	mv *.html $(DOC_DIR)
diff --git a/rebar.config b/rebar.config
new file mode 100644
index 0000000..3670402
--- /dev/null
+++ b/rebar.config
@@ -0,0 +1,5 @@
+%-*- mode: erlang; erlang-indent-level: 2 -*-
+{erl_opts,            [debug_info, warnings_as_errors]}.
+{xref_checks,         [undefined_function_calls]}.
+{cover_enabled,       true}.
+{cover_print_enabled, true}.
diff --git a/src/Makefile b/src/Makefile
deleted file mode 100755
index a0a4fae..0000000
--- a/src/Makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-include ../vsn.mk
-
-VSN=$(ABNFC_VSN)
-
-include ../include.mk
-
-all: $(ERL_OBJECTS) ../ebin/abnfc.app
-
-clean:
-	-rm $(ERL_OBJECTS)
-
-$(EBIN_DIR)/abnf_gen.beam: ../include/abnfc_ast.hrl
-$(EBIN_DIR)/abnfc_rfc4234.beam: abnfc_rfc4234.hrl ../include/abnfc_ast.hrl
-$(EBIN_DIR)/rfc4234_core.beam: rfc4234_core.hrl
diff --git a/src/abnfc.app.src b/src/abnfc.app.src
old mode 100755
new mode 100644
index cf3f1bf..5763270
--- a/src/abnfc.app.src
+++ b/src/abnfc.app.src
@@ -1,9 +1,8 @@
 %% -*- erlang -*-
 {application, abnfc,
  [{description,"ABNF parser generator"},
-  {vsn,"0.3"},
-  {modules, "MODULES"},
+  {vsn,"0.3.1"},
+  {modules, []},
   {applications,[kernel,stdlib]},
-  {registered,[]},
   {env,[]}
  ]}.
diff --git a/src/abnfc.erl b/src/abnfc.erl
index 7815217..8293c56 100644
--- a/src/abnfc.erl
+++ b/src/abnfc.erl
@@ -1,19 +1,18 @@
 %%%-------------------------------------------------------------------
 %%% @copyright 2009 Anders Nygren
-%%% @version  {@vsn} 
+%%% @version  {@vsn}
 %%% @author Anders Nygren <anders.nygren@gmail.com>
-%%% @doc 
-%%% @end 
+%%% @doc
+%%% @end
 %%%-------------------------------------------------------------------
 -module(abnfc).
 
 %% API
 -export([file/1, file/2,
-	 parse/1, parse/2]).
+         parse/1, parse/2]).
 
 -export([erlangcode/0]).
 
--compile(export_all).
 %%====================================================================
 %% API
 %%====================================================================
@@ -34,27 +33,18 @@ file(File) ->
 %% @end
 %%--------------------------------------------------------------------
 file(File, Opts) when is_list(Opts) ->
-    case read_file(File) of
-	{ok, Name, Text} ->
-	    POpts = [],
-	    GenOpts = gen_opts(Name, Opts),
-	    COpts = compiler_opts(Opts),
-	    case parse(Text, POpts) of
-		{ok, AST, _Rest} ->
-		    AST1 = abnfc_ast:ast_to_int_form(AST),
-		    case proplists:get_bool(verbose,Opts) of
-			true -> io:format("~p~n",[AST1]);
-			false -> ok
-		    end,
-		    {ok, Code} = abnfc_gen:generate(AST1, GenOpts),
-		    {ok, GenFile} = write_file(Code, GenOpts ++ Opts),
-		    compile_file(GenFile, COpts, Opts);
-		Error ->
-		    Error
-	    end;
-	Error ->
-	    Error
-    end.
+    {ok, Name, Text} = read_file(File),
+    GenOpts = gen_opts(Name, Opts),
+    COpts = compiler_opts(Opts),
+    {ok, AST, []} = parse(Text, []),
+    AST1 = abnfc_ast:ast_to_int_form(AST),
+    case proplists:get_bool(verbose,Opts) of
+        true -> io:format("~p~n",[AST1]);
+        false -> ok
+    end,
+    {ok, Code} = abnfc_gen:generate(AST1, GenOpts),
+    {ok, GenFile} = write_file(Code, GenOpts ++ Opts),
+    compile_file(GenFile, COpts, Opts).
 
 %%--------------------------------------------------------------------
 %% @spec (Text) -> {ok, AST, Rest::binary()} | fail
@@ -84,64 +74,39 @@ parse(String, _Opts) when is_list(String) ->
 %%--------------------------------------------------------------------
 erlangcode() ->
     fun (T) ->
-	    scan(T)
+            scan(T)
     end.
 
 scan(Input) ->
     case erl_scan:tokens([], Input, 1) of
-	{done, {ok, Toks, _EndLine}, Extra} ->
-	    {ok,Abs} = erl_parse:parse_exprs(Toks),
-	    {ok, Abs, Extra};
-	{more, _Cont} ->
-	    throw(end_of_input)
+        {done, {ok, Toks, _EndLine}, Extra} ->
+            {ok,Abs} = erl_parse:parse_exprs(Toks),
+            {ok, Abs, Extra};
+        {more, _Cont} ->
+            throw(end_of_input)
     end.
 
-%%--------------------------------------------------------------------
-%% @private 
-%% @spec (Tokens) -> list()
-%% @doc Convert tokens returned by erl_scan to a string again.
-%% @end
-%%--------------------------------------------------------------------
-toks_to_list(Tokens) ->
-    lists:foldl(fun({atom,L,Name},{Line, Acc}) ->
-			{L,["'",Name,"'",sep(L,Line)|Acc]};
-		   ({string,L,Name},{Line, Acc}) ->
-			{L,["\"",Name,"\"",sep(L,Line)|Acc]};
-		   ({_Type,L,Name},{Line, Acc}) ->
-			{L,[Name,sep(L,Line)|Acc]};
-		   ({dot,_L},{_Line,Acc}) ->
-			lists:concat(lists:reverse(Acc));
-		   ({Reserved, L},{Line,Acc}) ->
-			{L,[Reserved,sep(L,Line)|Acc]}
-		end, {1,[]}, Tokens).
-
-sep(L,L) ->
-    " ";
-sep(_,_) ->
-    "\n".
-
-%%====================================================================
 %% Internal functions
 %%====================================================================
 read_file(File) ->
     case string:tokens(filename:basename(File), ".") of
-	[Name,"set","abnf"] ->
-	    {ok, Files} = file:consult(File),
-	    {ok, Name, lists:flatten([read_file1(F) || F <- Files])};
-	[Name, "abnf"] ->
-	    {ok, Name, read_file1(File)}
+        [Name,"set","abnf"] ->
+            {ok, Files} = file:consult(File),
+            {ok, Name, lists:flatten([read_file1(F) || F <- Files])};
+        [Name, "abnf"] ->
+            {ok, Name, read_file1(File)}
     end.
 
 read_file1(File) ->
     {ok, Bin} = file:read_file(File),
     binary_to_list(Bin).
-    
+
 gen_opts(Name, Opts) ->
     Mod = proplists:get_value(mod, Opts, Name),
     Type = case proplists:get_bool(binary, Opts) of
-	       true -> binary;
-	       false -> list
-	   end,
+               true -> binary;
+               false -> list
+           end,
     Verbose = proplists:get_bool(verbose,Opts),
     [{mod,Mod},{verbose,Verbose},Type].
 
@@ -149,11 +114,11 @@ compiler_opts(Opts) ->
     OutDir = proplists:get_value(o, Opts, "./"),
     IncludeDirs = [{i,Dir}||Dir <- proplists:get_all_values(i, Opts)],
     [report,{outdir,OutDir}|IncludeDirs].
-    
+
 write_file(Code, Opts) ->
     Name = filename:join(proplists:get_value(o, Opts, "."),
-			 proplists:get_value(mod, Opts))++".erl",
-    
+                         proplists:get_value(mod, Opts))++".erl",
+
     maybe_write("abnfc: writing to ~p~n",[Name],Opts),
     file:write_file(Name, Code),
     erl_tidy:file(Name,[{paper, 95},{backups,false}]),
@@ -162,12 +127,12 @@ write_file(Code, Opts) ->
 compile_file(File, COpts, MyOpts) ->
     maybe_write("abnfc: compiling ~p opts = ~p~n",[File, COpts],MyOpts),
     case proplists:get_bool(noobj,MyOpts) of
-	true -> ok;
-	false -> compile:file(File, COpts)
+        true -> ok;
+        false -> compile:file(File, COpts)
     end.
 
 maybe_write(Fmt,Args,Opts) ->
     case proplists:get_bool(verbose,Opts) of
-	true -> io:format(Fmt,Args);
-	false -> ok
+        true -> io:format(Fmt,Args);
+        false -> ok
     end.
diff --git a/src/abnfc_ast.erl b/src/abnfc_ast.erl
index 7bf3cd6..588dacf 100644
--- a/src/abnfc_ast.erl
+++ b/src/abnfc_ast.erl
@@ -1,17 +1,19 @@
 %%%-------------------------------------------------------------------
 %%% @copyright 2009 Anders Nygren
-%%% @version  {@vsn} 
+%%% @version  {@vsn}
 %%% @author Anders Nygren <anders.nygren@gmail.com>
-%%% @doc 
-%%% @end 
+%%% @doc
+%%% @end
 %%%-------------------------------------------------------------------
 -module(abnfc_ast).
 
 %% API
-%%-export([transform/2]).
--compile(export_all).
+-export(
+   [ast_to_int_form/1,
+    int_transform/2
+   ]).
 
--include("abnfc_ast.hrl").
+-include("../include/abnfc_ast.hrl").
 
 %%====================================================================
 %% API
@@ -24,7 +26,6 @@
 ast_to_int_form(#rulelist{rules=Rules}) ->
     [R#rule{body=transform(R#rule.body)}||R <- Rules].
 
-
 int_transform(INT, Fun) ->
     [R#rule{body=Fun(R#rule.body)} || R <- INT].
 
@@ -37,10 +38,10 @@ transform(#rule{body=Body}=R) ->
 transform(#alt{alts=Alts}=A) ->
     Alts1 = [transform(Alt)||Alt <- Alts],
     case char_alts(Alts1) of
-	[C] when is_record(C,char_alt) ->
-	    C;
-	Alts2 ->
-	    A#alt{alts=Alts2}
+        [C] when is_record(C,char_alt) ->
+            C;
+        Alts2 ->
+            A#alt{alts=Alts2}
     end;
 transform(#seq{elements=Elems}=S) ->
     Elems1 = [transform(Elem)||Elem <- Elems],
@@ -54,7 +55,7 @@ char_alts(Alts) ->
     char_alts(Alts, {[],[]}).
 
 char_alts([Alt|Alts], {Chars,Others}) when is_record(Alt, char_val);
-					   is_record(Alt, char_range) ->
+                                           is_record(Alt, char_range) ->
     char_alts(Alts,{Chars++[Alt], Others});
 char_alts([Alt|Alts], {Chars,Others}) ->
     char_alts(Alts,{Chars, Others++[Alt]});
diff --git a/src/abnfc_gen.erl b/src/abnfc_gen.erl
index d2d9e20..72d1ec0 100644
--- a/src/abnfc_gen.erl
+++ b/src/abnfc_gen.erl
@@ -1,53 +1,51 @@
 %%%-------------------------------------------------------------------
 %%% @copyright 2009 Anders Nygren
-%%% @version  {@vsn} 
+%%% @version  {@vsn}
 %%% @author Anders Nygren <anders.nygren@gmail.com>
 %%% @doc Code generation.
-%%% @end 
+%%% @end
 %%%-------------------------------------------------------------------
 -module(abnfc_gen).
 
 %% API
 -export([generate/2]).
 
--compile(export_all).
-
 -import(erl_syntax, [application/2,
-		     arity_qualifier/2,
-		     atom/1,
-		     attribute/2,
-		     binary/1,
-		     binary_field/1,
-		     binary_field/2,
-		     case_expr/2,
-		     class_qualifier/2,
-		     clause/3,
-		     comment/1,
-		     conjunction/1,
-		     eof_marker/0,
-		     form_list/1,
-		     fun_expr/1,
-		     function/2,
-		     infix_expr/3,
-		     integer/1,
-		     list/1,list/2,
-		     match_expr/2,
-		     nil/0,
-		     operator/1,
-		     string/1,
-		     try_expr/3,
-		     tuple/1,
-		     variable/1
-		     ]).
-
--include("abnfc_ast.hrl").
+                     arity_qualifier/2,
+                     atom/1,
+                     attribute/2,
+                     binary/1,
+                     binary_field/1,
+                     binary_field/2,
+                     case_expr/2,
+                     class_qualifier/2,
+                     clause/3,
+                     comment/1,
+                     conjunction/1,
+                     eof_marker/0,
+                     form_list/1,
+                     fun_expr/1,
+                     function/2,
+                     infix_expr/3,
+                     integer/1,
+                     list/1,list/2,
+                     match_expr/2,
+                     nil/0,
+                     operator/1,
+                     string/1,
+                     try_expr/3,
+                     tuple/1,
+                     variable/1
+                    ]).
+
+-include("../include/abnfc_ast.hrl").
 
 %%====================================================================
 %% API
 %%====================================================================
 %%--------------------------------------------------------------------
-%% @spec 
-%% @doc 
+%% @spec
+%% @doc
 %% @end
 %%--------------------------------------------------------------------
 generate(AST, Opts) ->
@@ -55,22 +53,22 @@ generate(AST, Opts) ->
     maybe_write("Opts ~p~n",[Opts],Verbose),
     Module = proplists:get_value(mod,Opts),
     Type = case proplists:get_bool(binary, Opts) of
-	       true -> binary;
-	       false -> list
-	   end,
+               true -> binary;
+               false -> list
+           end,
     Names = [R#rule.name||R<-AST],
     Res=form_list([header_comments(),
-		   attribute(atom(module), [atom(Module)]),
-		   exports(Names),
-		   attribute(atom(include),[string(lists:concat([Module,".hrl"]))]),
-		   gen_dec(Names),
-		   form_list([form_list([gen_rule(R, Type, Verbose)]) || R <- AST]),
-		   mk__alt(),
-		   mk__do_alt(),
-		   mk__repeat(),
-		   mk__seq(),
-		   mk__do_seq(),
-		   eof_marker()]),
+                   attribute(atom(module), [atom(Module)]),
+                   exports(Names),
+                   attribute(atom(include),[string(lists:concat([Module,".hrl"]))]),
+                   gen_dec(Names),
+                   form_list([form_list([gen_rule(R, Type, Verbose)]) || R <- AST]),
+                   mk__alt(),
+                   mk__do_alt(),
+                   mk__repeat(),
+                   mk__seq(),
+                   mk__do_seq(),
+                   eof_marker()]),
     {ok, erl_prettypr:format(Res)}.
 
 %%====================================================================
@@ -79,21 +77,21 @@ generate(AST, Opts) ->
 header_comments() ->
     {{Year,Month,Day},{Hour,Min,Sec}} = erlang:localtime(),
     DT = lists:flatten(
-    	   io_lib:format("~w-~2.2.0w-~2.2.0w ~2.2.0w:~2.2.0w:~2.2.0w", 
-    			 [Year,Month,Day,Hour,Min,Sec])),
+           io_lib:format("~w-~2.2.0w-~2.2.0w ~2.2.0w:~2.2.0w:~2.2.0w",
+                         [Year,Month,Day,Hour,Min,Sec])),
     comment(["%% Do not modify this file, it is automatically generated by abnfc.",
-	     "%% All changes will be lost when it is regenerated.",
-	     "%% Generated by abnfc_gen on "++DT]).
+             "%% All changes will be lost when it is regenerated.",
+             "%% Generated by abnfc_gen on "++DT]).
 
 exports(Funs) ->
     attribute(atom(export),
-	      [list([arity_qualifier(atom(decode),integer(2))]++
-		    [arity_qualifier(atom(F),integer(0))||F<-Funs])]).
+              [list([arity_qualifier(atom(decode),integer(2))]++
+                        [arity_qualifier(atom(F),integer(0))||F<-Funs])]).
 
 gen_dec(Names) ->
     function(atom(decode),
-	     [clause([atom(Name),variable('Str')],[],
-		     [application(application(atom(Name),[]),[variable('Str')])])||Name<-Names]).
+             [clause([atom(Name),variable('Str')],[],
+                     [application(application(atom(Name),[]),[variable('Str')])])||Name<-Names]).
 
 gen_rule(#rule{name=Name, body=Element, code=nocode}, Type, Verbose) ->
     maybe_write("abnfc_gen: generating rule ~p~n",[Name],Verbose),
@@ -110,48 +108,48 @@ mk_rule_fun(Name, {tree, fun_expr, _, _}=Body) ->
     function(
       atom(Name),
       [clause([],[],
-	      [Body])]);
+              [Body])]);
 
 mk_rule_fun(Name, Body) ->
     function(
       atom(Name),
       [clause([],[],
-	      [Body])]).
+              [Body])]).
 
-mk_rule_fun(Name, Body, Vars, Code) -> 
+mk_rule_fun(Name, Body, Vars, Code) ->
     function(
       atom(Name),
       [clause([],[],
-	      [fun_expr([clause([variable('T')],
-	      			[],
-				[match_expr(variable('__P'),Body),
-				 case_expr(
-				   application(variable('__P'),[variable('T')]),
-				   [clause([tuple([atom(ok),Vars,variable('_T1')])],
-					   [],
-					   [case is_safe(Code, Vars) of
-						true ->
-						    tuple([atom(ok), hd(Code), variable('_T1')]);
-						false ->
-						    try_expr(Code,
-							     [clause([variable('__Ret')],[],
-								     [tuple([atom(ok), variable('__Ret'),
-									     variable('_T1')])])],
-							     %% Handlers
-							     [clause([class_qualifier(atom(throw),
-										      atom(fail))],
-								     [],
-								     [atom(fail)])
-							     ]
-							    )
-					    end]
-					  ),
-				    clause([atom(fail)],[],[atom(fail)])])])])])]).
+              [fun_expr([clause([variable('T')],
+                                [],
+                                [match_expr(variable('__P'),Body),
+                                 case_expr(
+                                   application(variable('__P'),[variable('T')]),
+                                   [clause([tuple([atom(ok),Vars,variable('_T1')])],
+                                           [],
+                                           [case is_safe(Code, Vars) of
+                                                true ->
+                                                    tuple([atom(ok), hd(Code), variable('_T1')]);
+                                                false ->
+                                                    try_expr(Code,
+                                                             [clause([variable('__Ret')],[],
+                                                                     [tuple([atom(ok), variable('__Ret'),
+                                                                             variable('_T1')])])],
+                                                             %% Handlers
+                                                             [clause([class_qualifier(atom(throw),
+                                                                                      atom(fail))],
+                                                                     [],
+                                                                     [atom(fail)])
+                                                             ]
+                                                            )
+                                            end]
+                                          ),
+                                    clause([atom(fail)],[],[atom(fail)])])])])])]).
 
 is_safe(L, Vars) when is_list(L) ->
     lists:all(fun (T) ->
-		      is_safe(T, Vars)
-	      end, L);
+                      is_safe(T, Vars)
+              end, L);
 is_safe({atom,_,_Val}, _Vars) ->
     true;
 is_safe({char,_,_Val}, _Vars) ->
@@ -166,12 +164,12 @@ is_safe({nil,_}, _Vars) ->
     true;
 is_safe({tuple,_,Es}, Vars) ->
     is_safe(Es, Vars);
-is_safe({var,_,Var}, Vars) ->
+is_safe({var,_,_Var}, _Vars) ->
     true; %lists:member(Var,Vars);
 is_safe(_, _Vars) ->
     false.
 
-    
+
 gen_elem(#seq{elements=Elements}, Type) ->
     Body = [gen_elem(Element, Type)||Element <- Elements],
     application(atom('__seq'),[list(Body)]);
@@ -181,18 +179,18 @@ gen_elem(#alt{alts=Elements}, Type) ->
     application(atom('__alt'),[list(Alts)]);
 
 gen_elem(#repeat{min=Min, max=infinity, body=Elem}, Type) ->
-    application(atom('__repeat'), 
-		[integer(Min), atom(infinity), gen_elem(Elem, Type)]);
+    application(atom('__repeat'),
+                [integer(Min), atom(infinity), gen_elem(Elem, Type)]);
 gen_elem(#repeat{min=Min, max=Max, body=Elem}, Type) ->
-    application(atom('__repeat'), 
-		[integer(Min), integer(Max), gen_elem(Elem, Type)]);
+    application(atom('__repeat'),
+                [integer(Min), integer(Max), gen_elem(Elem, Type)]);
 
 gen_elem(#char_val{value=Num}, Type) ->
     PList=mk_plist(Num,Type),
     fun_expr(
       [clause(PList,
-	      [],
-	      [tuple([atom(ok), integer(Num), variable('Tl')])]),
+              [],
+              [tuple([atom(ok), integer(Num), variable('Tl')])]),
        clause([variable('_')], [], [atom(fail)])]);
 
 
@@ -200,24 +198,24 @@ gen_elem(#char_range{from=From, to=To}, Type) ->
     PList=mk_plist('C',Type),
     fun_expr(
       [clause(
-	 PList,
-	 [range_test(variable('C'), From, To)],
-	 [tuple([atom(ok), variable('C'), variable('Tl')])]),
+         PList,
+         [range_test(variable('C'), From, To)],
+         [tuple([atom(ok), variable('C'), variable('Tl')])]),
        clause([variable('_')], [], [atom(fail)])]);
 
 gen_elem(#char_alt{alts=Alts}, Type) ->
     PList=mk_plist('C',Type),
     fun_expr([clause(PList,[char_guard(variable('C'),A)],
-		     [tuple([atom(ok),variable('C'),variable('Tl')])])||A<-Alts]
-	     ++[clause([variable('_')],[],[atom(fail)])]);
+                     [tuple([atom(ok),variable('C'),variable('Tl')])])||A<-Alts]
+             ++[clause([variable('_')],[],[atom(fail)])]);
 
 gen_elem(#char_seq{elements=Nums}, Type) ->
     ParList = num_par_list(length(Nums), Type),
     Guard = num_guard(Nums),
     Result=[variable(list_to_atom(lists:concat(["C",N]))) || N <- lists:seq(1,length(Nums))],
     fun_expr([clause([ParList],Guard,
-		     [tuple([atom(ok), list(Result), variable('Tl')])]),
-	      clause([variable('_')],[],[atom(fail)])]);
+                     [tuple([atom(ok), list(Result), variable('Tl')])]),
+              clause([variable('_')],[],[atom(fail)])]);
 
 gen_elem(#rulename{name=Rule}, _Type) when is_atom(Rule) ->
     application(atom(Rule),[]).
@@ -233,42 +231,42 @@ mk_plist(Var, list) ->
 
 gen_vars(#seq{elements=Es}) ->
     Vs = list([variable(list_to_atom(lists:concat(["_YY",N])))
-	       ||N<-lists:seq(1,length(Es))]),
+               ||N<-lists:seq(1,length(Es))]),
     match_expr(Vs,variable('_YY'));
 gen_vars(_) ->
     variable('_YY').
 
 num_guard(Cs) ->
     {_,R} = lists:foldl(
-	      fun (#char_range{from=From,to=To},{Pos,Acc}) ->
-		      Var=variable(list_to_atom(lists:concat(["C",Pos]))),
-		      {Pos+1, [range_test(Var, From, To)|Acc]};
-		  (#char_val{value=C}, {Pos,Acc}) ->
-		      Var=variable(list_to_atom(lists:concat(["C",Pos]))),
-		      {Pos+1, [val_test(Var, C)|Acc]};
-		  (#char_alt{alts=Alts}, {Pos,Acc}) ->
-		      {Pos+1,[num_alt_guard(Pos,Alts)|Acc]}
-	      end, {1,[]}, Cs),
+              fun (#char_range{from=From,to=To},{Pos,Acc}) ->
+                      Var=variable(list_to_atom(lists:concat(["C",Pos]))),
+                      {Pos+1, [range_test(Var, From, To)|Acc]};
+                  (#char_val{value=C}, {Pos,Acc}) ->
+                      Var=variable(list_to_atom(lists:concat(["C",Pos]))),
+                      {Pos+1, [val_test(Var, C)|Acc]};
+                  (#char_alt{alts=Alts}, {Pos,Acc}) ->
+                      {Pos+1,[num_alt_guard(Pos,Alts)|Acc]}
+              end, {1,[]}, Cs),
     conjunction(lists:reverse(R)).
 
 num_par_list(Len, binary) ->
     binary([binary_field(variable(list_to_atom("C"++integer_to_list(N))))||
-	       N <- lists:seq(1,Len)]++
-	   [binary_field(variable('Tl'),[atom('binary')])]);
+               N <- lists:seq(1,Len)]++
+               [binary_field(variable('Tl'),[atom('binary')])]);
 num_par_list(Len, list) ->
     list([variable(list_to_atom("C"++integer_to_list(N))) ||
-    	     N <- lists:seq(1,Len)],variable('Tl')).
+             N <- lists:seq(1,Len)],variable('Tl')).
 
 
 num_alt_guard(Var, Alts) ->
     R = lists:foldl(
-	  fun (#char_range{from=From,to=To},Acc) ->
-		  VarT=variable(list_to_atom(lists:concat(["C",Var]))),
-		  [range_test(VarT, From, To) |Acc];
-	      (#char_val{value=C}, Acc) ->
-		  VarT=variable(list_to_atom(lists:concat(["C",Var]))),
-		  [val_test(VarT, C)|Acc]
-	  end, [], Alts),
+          fun (#char_range{from=From,to=To},Acc) ->
+                  VarT=variable(list_to_atom(lists:concat(["C",Var]))),
+                  [range_test(VarT, From, To) |Acc];
+              (#char_val{value=C}, Acc) ->
+                  VarT=variable(list_to_atom(lists:concat(["C",Var]))),
+                  [val_test(VarT, C)|Acc]
+          end, [], Alts),
     disjunction(lists:reverse(R)).
 
 
@@ -279,8 +277,8 @@ char_guard(Var, #char_range{from=From,to=To}) ->
 
 range_test(Var, From, To) ->
     infix_expr(infix_expr(Var,operator('>='),integer(From)),
-	       operator('and'),
-	       infix_expr(Var,operator('=<'),integer(To))).
+               operator('and'),
+               infix_expr(Var,operator('=<'),integer(To))).
 val_test(Var, Val) ->
     infix_expr(Var, operator('=='), integer(Val)).
 
@@ -296,166 +294,166 @@ disjunction([As]) ->
 
 mk__alt() ->
     function(atom('__alt'),
-	     [clause(
-		[variable('Ps')],
-		[],
-		[fun_expr(
-		   [clause(
-		      [variable('T')],
-		      [],
-		      [application(atom('__do_alt'), [variable('Ps'),variable('T')])]
-		     )]
-		  )]
-	       )]
-	    ).
+             [clause(
+                [variable('Ps')],
+                [],
+                [fun_expr(
+                   [clause(
+                      [variable('T')],
+                      [],
+                      [application(atom('__do_alt'), [variable('Ps'),variable('T')])]
+                     )]
+                  )]
+               )]
+            ).
 
 mk__do_alt() ->
     function(atom('__do_alt'),
-	     [clause(
-		[list([variable('P')],variable('Ps')),variable('T')],
-		[],
-		[
-		 case_expr(
-		   application(variable('P'),[variable('T')]),
-		   [clause([match_expr(tuple([atom(ok),variable('_R'),variable('_T1')]),
-				       variable('Res'))],[],
-			   [variable('Res')]),
-		    clause([atom(fail)],[],
-			   [application(atom('__do_alt'), [variable('Ps'),variable('T')])
-			   ]
-			  )]
-		  )]
-	       ),
-	      clause([nil(),variable('_')],[],[atom(fail)])
-	     ]
-	    ).
+             [clause(
+                [list([variable('P')],variable('Ps')),variable('T')],
+                [],
+                [
+                 case_expr(
+                   application(variable('P'),[variable('T')]),
+                   [clause([match_expr(tuple([atom(ok),variable('_R'),variable('_T1')]),
+                                       variable('Res'))],[],
+                           [variable('Res')]),
+                    clause([atom(fail)],[],
+                           [application(atom('__do_alt'), [variable('Ps'),variable('T')])
+                           ]
+                          )]
+                  )]
+               ),
+              clause([nil(),variable('_')],[],[atom(fail)])
+             ]
+            ).
 
 
 %% Match between Min and Max repetitions of parser P
 mk__repeat() ->
     form_list([mk__repeat_3(),
-	       mk__repeat_4(),
-	       mk__do_repeat()]).
+               mk__repeat_4(),
+               mk__do_repeat()]).
 
 mk__repeat_3() ->
     function(atom('__repeat'),
-	     [clause(
-		[variable('Min'),variable('Max'),variable('P')],
-		[],
-		[application(atom('__repeat'),
-			     [variable('Min'),
-			      variable('Max'),
-			      variable('P'),
-			      integer(0)])])]).
+             [clause(
+                [variable('Min'),variable('Max'),variable('P')],
+                [],
+                [application(atom('__repeat'),
+                             [variable('Min'),
+                              variable('Max'),
+                              variable('P'),
+                              integer(0)])])]).
 
 mk__repeat_4() ->
     function(atom('__repeat'),
-	     [clause(
-		[variable('Min'),variable('Max'),variable('P'), variable('Found')],
-		[],
-		[fun_expr(
-		   [clause(
-		      [variable('T')],
-		      [],
-		      [application(atom('__do_repeat'), [variable('Min'),
-							 variable('Max'),
-							 variable('P'),
-							 variable('Found'),
-							 variable('T')])]
-		     )]
-		  )]
-	       )]
-	    ).
-
-
-mk__do_repeat() ->   
+             [clause(
+                [variable('Min'),variable('Max'),variable('P'), variable('Found')],
+                [],
+                [fun_expr(
+                   [clause(
+                      [variable('T')],
+                      [],
+                      [application(atom('__do_repeat'), [variable('Min'),
+                                                         variable('Max'),
+                                                         variable('P'),
+                                                         variable('Found'),
+                                                         variable('T')])]
+                     )]
+                  )]
+               )]
+            ).
+
+
+mk__do_repeat() ->
     function(atom('__do_repeat'),
-	     [clause(
-		[variable('Min'),variable('Max'),variable('P'), variable('Found'),variable('T')],
-		[],
-		[case_expr(
-		   application(variable('P'),[variable('T')]),
-		   [
-		    clause([tuple([atom(ok),variable('R1'),variable('T1')])],
-			   [infix_expr(variable('Max'),operator('=='),
-				       infix_expr(variable('Found'),operator('+'),
-						  integer(1)))],
-			   [tuple([atom(ok),list([variable('R1')]),variable('T1')])]),
-		    clause([tuple([atom(ok),variable('R1'),variable('T1')])],
-			   [],
-			   [
-			    case_expr(application(atom('__do_repeat'),
-						  [variable('Min'),
-						   variable('Max'),
-						   variable('P'),
-						   infix_expr(variable('Found'),
-							      operator('+'),
-							      integer(1)),
-						   variable('T1')]),
-				      [clause([tuple([atom(ok),variable('R2'),
-						      variable('T2')])],
-					      [],
-					      [tuple([atom(ok),
-						      list([variable('R1')],variable('R2')),
-						      variable('T2')])]),
-				       clause([atom(fail)],
-					      [infix_expr(variable('Found'),
-							  operator('>='),
-							  variable('Min'))],
-					      [tuple([atom(ok),list([variable('R1')]),
-						      variable('T1')])]),
-				       clause([atom(fail)],
-					      [],[atom(fail)])
-				      ])]),
-		    clause([atom(fail)],
-			   [infix_expr(variable('Found'),operator('>='),variable('Min'))],
-			   [tuple([atom(ok),nil(),variable('T')])]),
-		    clause([atom(fail)],
-			   [],[atom(fail)])
-		   ])
-		])]).
+             [clause(
+                [variable('Min'),variable('Max'),variable('P'), variable('Found'),variable('T')],
+                [],
+                [case_expr(
+                   application(variable('P'),[variable('T')]),
+                   [
+                    clause([tuple([atom(ok),variable('R1'),variable('T1')])],
+                           [infix_expr(variable('Max'),operator('=='),
+                                       infix_expr(variable('Found'),operator('+'),
+                                                  integer(1)))],
+                           [tuple([atom(ok),list([variable('R1')]),variable('T1')])]),
+                    clause([tuple([atom(ok),variable('R1'),variable('T1')])],
+                           [],
+                           [
+                            case_expr(application(atom('__do_repeat'),
+                                                  [variable('Min'),
+                                                   variable('Max'),
+                                                   variable('P'),
+                                                   infix_expr(variable('Found'),
+                                                              operator('+'),
+                                                              integer(1)),
+                                                   variable('T1')]),
+                                      [clause([tuple([atom(ok),variable('R2'),
+                                                      variable('T2')])],
+                                              [],
+                                              [tuple([atom(ok),
+                                                      list([variable('R1')],variable('R2')),
+                                                      variable('T2')])]),
+                                       clause([atom(fail)],
+                                              [infix_expr(variable('Found'),
+                                                          operator('>='),
+                                                          variable('Min'))],
+                                              [tuple([atom(ok),list([variable('R1')]),
+                                                      variable('T1')])]),
+                                       clause([atom(fail)],
+                                              [],[atom(fail)])
+                                      ])]),
+                    clause([atom(fail)],
+                           [infix_expr(variable('Found'),operator('>='),variable('Min'))],
+                           [tuple([atom(ok),nil(),variable('T')])]),
+                    clause([atom(fail)],
+                           [],[atom(fail)])
+                   ])
+                ])]).
 
 %% Match a sequence of parsers.
 mk__seq() ->
     function(atom('__seq'),
-	     [clause(
-		[variable('Ps')],
-		[],
-		[fun_expr(
-		   [clause(
-		      [variable('T')],
-		      [],
-		      [application(atom('__do_seq'), [variable('Ps'),variable('T')])]
-		     )]
-		  )]
-	       )]
-	    ).
+             [clause(
+                [variable('Ps')],
+                [],
+                [fun_expr(
+                   [clause(
+                      [variable('T')],
+                      [],
+                      [application(atom('__do_seq'), [variable('Ps'),variable('T')])]
+                     )]
+                  )]
+               )]
+            ).
 
 
 
 mk__do_seq() ->
     function(atom('__do_seq'),
-	     [clause(
-		[list([variable('P')],variable('Ps')),variable('T')],
-		[],
-		[
-
-		 case_expr(
-		   application(variable('P'),[variable('T')]),
-		   [clause([tuple([atom(ok),variable('R1'),variable('T1')])],
-			   [],
-			   [
-			    case_expr(
-			      application(atom('__do_seq'),[variable('Ps'),variable('T1')]),
-			      [clause([tuple([atom(ok),variable('R2'),variable('T2')])],
-				      [],
-				      [tuple([atom(ok),list([variable('R1')],
-							    variable('R2')),
-					      variable('T2')])]),
-			       clause([atom(fail)],[],[atom(fail)])])]),
-		    clause([atom(fail)],[],[atom(fail)])])]),
-	      clause([nil(),variable('T')],[],
-		     [tuple([atom(ok),list([]),variable('T')])])]).
+             [clause(
+                [list([variable('P')],variable('Ps')),variable('T')],
+                [],
+                [
+
+                 case_expr(
+                   application(variable('P'),[variable('T')]),
+                   [clause([tuple([atom(ok),variable('R1'),variable('T1')])],
+                           [],
+                           [
+                            case_expr(
+                              application(atom('__do_seq'),[variable('Ps'),variable('T1')]),
+                              [clause([tuple([atom(ok),variable('R2'),variable('T2')])],
+                                      [],
+                                      [tuple([atom(ok),list([variable('R1')],
+                                                            variable('R2')),
+                                              variable('T2')])]),
+                               clause([atom(fail)],[],[atom(fail)])])]),
+                    clause([atom(fail)],[],[atom(fail)])])]),
+              clause([nil(),variable('T')],[],
+                     [tuple([atom(ok),list([]),variable('T')])])]).
 
 maybe_write(Fmt,Args,true) ->
     io:format(Fmt,Args);
diff --git a/src/abnfc_rfc4234.abnf b/src/abnfc_rfc4234.abnf
index 7579e4e..ffca651 100644
--- a/src/abnfc_rfc4234.abnf
+++ b/src/abnfc_rfc4234.abnf
@@ -1,19 +1,19 @@
-rulelist       =  1*( rule/ (*c-wsp c-nl)) : 
+rulelist       =  1*( rule/ (*c-wsp c-nl)) :
     #rulelist{rules=[Rule || Rule <- _YY, is_tuple(Rule)]}.
 
 rule           =  rulename defined-as elements [*WSP ":" *WSP erlangcode] c-nl :
-    #rule{type=_YY2, name=element(2,_YY1), body=_YY3, 
+    #rule{type=_YY2, name=element(2,_YY1), body=_YY3,
           code=case _YY4 of
                    [[_,_,_,Code]] -> Code;
-                   [] -> nocode 
+                   [] -> nocode
                end}.
 
-rulename       =  ALPHA *(ALPHA/ DIGIT/ "-") : 
+rulename       =  ALPHA *(ALPHA/ DIGIT/ "-") :
     #rulename{name=list_to_atom(lists:flatten(_YY))}.
 
-defined-as     =  *c-wsp ("="/ "=/") *c-wsp : 
+defined-as     =  *c-wsp ("="/ "=/") *c-wsp :
     case _YY2 of
-	$= -> def_rule;
+        $= -> def_rule;
         _ -> app_rule
     end.
 
@@ -34,21 +34,21 @@ alternation    =  concatenation *(*c-wsp "/" *c-wsp concatenation) :
 concatenation  =  repetition *(1*c-wsp repetition) :
     case [Rule || [_,Rule] <- _YY2] of
         [] -> _YY1;
-        More ->	#seq{elements=[_YY1 | More]}
+        More -> #seq{elements=[_YY1 | More]}
     end.
 
-repetition     =  [repeat] element : 
+repetition     =  [repeat] element :
     case _YY1 of
         [{Min,Max}] -> #repeat{min=Min,max=Max,body=_YY2};
-	[] -> _YY2
-    end. 
+        [] -> _YY2
+    end.
 
-repeat         =  (*DIGIT "*" *DIGIT)/ 1*DIGIT : 
+repeat         =  (*DIGIT "*" *DIGIT)/ 1*DIGIT :
     case _YY of
         [[],$*,[]] -> {0, infinity};
-	[Min, $*, []] -> {list_to_integer(Min), infinity};
-	[[], $*, Max] -> {0, list_to_integer(Max)};
-	[Min, $*, Max] -> {list_to_integer(Min), list_to_integer(Max)};
+        [Min, $*, []] -> {list_to_integer(Min), infinity};
+        [[], $*, Max] -> {0, list_to_integer(Max)};
+        [Min, $*, Max] -> {list_to_integer(Min), list_to_integer(Max)};
         Number -> {list_to_integer(Number), list_to_integer(Number)}
     end.
 
@@ -56,10 +56,10 @@ element        =  rulename/ group/ option/ char-val/ num-val/ prose-val
 
 group          =  "(" *c-wsp alternation *c-wsp ")" : _YY3.
 
-option         =  "[" *c-wsp alternation *c-wsp "]" : 
+option         =  "[" *c-wsp alternation *c-wsp "]" :
     {repeat, 0, 1, _YY3}.
 
-char-val       =  DQUOTE *(%x20-21/ %x23-7E) DQUOTE : 
+char-val       =  DQUOTE *(%x20-21/ %x23-7E) DQUOTE :
     F = fun (Char) ->
                   case {string:to_lower(Char),string:to_upper(Char)} of
                       {Char,Char} -> #char_val{value=Char};
@@ -99,6 +99,5 @@ hex-val        =  "x" 1*HEXDIG [ 1*("." 1*HEXDIG)/ ("-" 1*HEXDIG)] :
     end.
 
 
-prose-val      =  "<" *(%x20-3D/ %x3F-7E) ">" : 
+prose-val      =  "<" *(%x20-3D/ %x3F-7E) ">" :
     {'prose-val', lists:flatten(_YY2)}.
-
diff --git a/src/abnfc_rfc4234.erl b/src/abnfc_rfc4234.erl
index abd0c51..7659623 100644
--- a/src/abnfc_rfc4234.erl
+++ b/src/abnfc_rfc4234.erl
@@ -5,11 +5,11 @@
 -module(abnfc_rfc4234).
 
 -export([alternation/0, 'bin-val'/0, 'c-nl'/0,
-	 'c-wsp'/0, 'char-val'/0, comment/0, concatenation/0,
-	 'dec-val'/0, decode/2, 'defined-as'/0, element/0,
-	 elements/0, group/0, 'hex-val'/0, 'num-val'/0, option/0,
-	 'prose-val'/0, repeat/0, repetition/0, rule/0,
-	 rulelist/0, rulename/0]).
+         'c-wsp'/0, 'char-val'/0, comment/0, concatenation/0,
+         'dec-val'/0, decode/2, 'defined-as'/0, element/0,
+         elements/0, group/0, 'hex-val'/0, 'num-val'/0, option/0,
+         'prose-val'/0, repeat/0, repetition/0, rule/0,
+         rulelist/0, rulename/0]).
 
 -include("abnfc_rfc4234.hrl").
 
@@ -37,472 +37,472 @@ decode('prose-val', Str) -> ('prose-val'())(Str).
 
 rulelist() ->
     fun (T) ->
-	    __P = '__repeat'(1, infinity,
-			     '__alt'([rule(),
-				      '__seq'(['__repeat'(0, infinity, 'c-wsp'()),
-					       'c-nl'()])])),
-	    case __P(T) of
-	      {ok, _YY, _T1} ->
-		  try #rulelist{rules =
-				    [Rule || Rule <- _YY, is_tuple(Rule)]}
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__repeat'(1, infinity,
+                             '__alt'([rule(),
+                                      '__seq'(['__repeat'(0, infinity, 'c-wsp'()),
+                                               'c-nl'()])])),
+            case __P(T) of
+              {ok, _YY, _T1} ->
+                  try #rulelist{rules =
+                                    [Rule || Rule <- _YY, is_tuple(Rule)]}
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 rule() ->
     fun (T) ->
-	    __P = '__seq'([rulename(), 'defined-as'(), elements(),
-			   '__repeat'(0, 1,
-				      '__seq'(['__repeat'(0, infinity, 'WSP'()),
-					       fun ([58 | Tl]) -> {ok, 58, Tl};
-						   (_) -> fail
-					       end,
-					       '__repeat'(0, infinity, 'WSP'()),
-					       erlangcode()])),
-			   'c-nl'()]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3, _YY4, _YY5] = _YY, _T1} ->
-		  try #rule{type = _YY2, name = element(2, _YY1),
-			    body = _YY3,
-			    code =
-				case _YY4 of
-				  [[_, _, _, Code]] -> Code;
-				  [] -> nocode
-				end}
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'([rulename(), 'defined-as'(), elements(),
+                           '__repeat'(0, 1,
+                                      '__seq'(['__repeat'(0, infinity, 'WSP'()),
+                                               fun ([58 | Tl]) -> {ok, 58, Tl};
+                                                   (_) -> fail
+                                               end,
+                                               '__repeat'(0, infinity, 'WSP'()),
+                                               erlangcode()])),
+                           'c-nl'()]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3, _YY4, _YY5] = _YY, _T1} ->
+                  try #rule{type = _YY2, name = element(2, _YY1),
+                            body = _YY3,
+                            code =
+                                case _YY4 of
+                                  [[_, _, _, Code]] -> Code;
+                                  [] -> nocode
+                                end}
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 rulename() ->
     fun (T) ->
-	    __P = '__seq'(['ALPHA'(),
-			   '__repeat'(0, infinity,
-				      '__alt'([fun ([C | Tl]) when C == 45 -> {ok, C, Tl};
-						   (_) -> fail
-					       end,
-					       'ALPHA'(), 'DIGIT'()]))]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2] = _YY, _T1} ->
-		  try #rulename{name = list_to_atom(lists:flatten(_YY))}
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'(['ALPHA'(),
+                           '__repeat'(0, infinity,
+                                      '__alt'([fun ([C | Tl]) when C == 45 -> {ok, C, Tl};
+                                                   (_) -> fail
+                                               end,
+                                               'ALPHA'(), 'DIGIT'()]))]),
+            case __P(T) of
+              {ok, [_YY1, _YY2] = _YY, _T1} ->
+                  try #rulename{name = list_to_atom(lists:flatten(_YY))}
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 'defined-as'() ->
     fun (T) ->
-	    __P = '__seq'(['__repeat'(0, infinity, 'c-wsp'()),
-			   '__alt'([fun ([C | Tl]) when C == 61 -> {ok, C, Tl};
-					(_) -> fail
-				    end,
-				    fun ([C1, C2 | Tl]) when C1 == 61, C2 == 47 ->
-					    {ok, [C1, C2], Tl};
-					(_) -> fail
-				    end]),
-			   '__repeat'(0, infinity, 'c-wsp'())]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
-		  try case _YY2 of
-			$= -> def_rule;
-			_ -> app_rule
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'(['__repeat'(0, infinity, 'c-wsp'()),
+                           '__alt'([fun ([C | Tl]) when C == 61 -> {ok, C, Tl};
+                                        (_) -> fail
+                                    end,
+                                    fun ([C1, C2 | Tl]) when C1 == 61, C2 == 47 ->
+                                            {ok, [C1, C2], Tl};
+                                        (_) -> fail
+                                    end]),
+                           '__repeat'(0, infinity, 'c-wsp'())]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
+                  try case _YY2 of
+                        $= -> def_rule;
+                        _ -> app_rule
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 elements() ->
     fun (T) ->
-	    __P = '__seq'([alternation(),
-			   '__repeat'(0, infinity, 'c-wsp'())]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2] = _YY, _T1} -> {ok, _YY1, _T1};
-	      fail -> fail
-	    end
+            __P = '__seq'([alternation(),
+                           '__repeat'(0, infinity, 'c-wsp'())]),
+            case __P(T) of
+              {ok, [_YY1, _YY2] = _YY, _T1} -> {ok, _YY1, _T1};
+              fail -> fail
+            end
     end.
 
 'c-wsp'() ->
     fun (T) ->
-	    __P = '__alt'(['WSP'(), '__seq'(['c-nl'(), 'WSP'()])]),
-	    case __P(T) of
-	      {ok, _YY, _T1} -> {ok, 'c-wsp', _T1};
-	      fail -> fail
-	    end
+            __P = '__alt'(['WSP'(), '__seq'(['c-nl'(), 'WSP'()])]),
+            case __P(T) of
+              {ok, _YY, _T1} -> {ok, 'c-wsp', _T1};
+              fail -> fail
+            end
     end.
 
 'c-nl'() ->
     fun (T) ->
-	    __P = '__alt'([comment(), 'CRLF'()]),
-	    case __P(T) of
-	      {ok, _YY, _T1} -> {ok, 'c-nl', _T1};
-	      fail -> fail
-	    end
+            __P = '__alt'([comment(), 'CRLF'()]),
+            case __P(T) of
+              {ok, _YY, _T1} -> {ok, 'c-nl', _T1};
+              fail -> fail
+            end
     end.
 
 comment() ->
     fun (T) ->
-	    __P = '__seq'([fun ([59 | Tl]) -> {ok, 59, Tl};
-			       (_) -> fail
-			   end,
-			   '__repeat'(0, infinity, '__alt'(['WSP'(), 'VCHAR'()])),
-			   'CRLF'()]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
-		  {ok, comment, _T1};
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([59 | Tl]) -> {ok, 59, Tl};
+                               (_) -> fail
+                           end,
+                           '__repeat'(0, infinity, '__alt'(['WSP'(), 'VCHAR'()])),
+                           'CRLF'()]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
+                  {ok, comment, _T1};
+              fail -> fail
+            end
     end.
 
 alternation() ->
     fun (T) ->
-	    __P = '__seq'([concatenation(),
-			   '__repeat'(0, infinity,
-				      '__seq'(['__repeat'(0, infinity, 'c-wsp'()),
-					       fun ([47 | Tl]) -> {ok, 47, Tl};
-						   (_) -> fail
-					       end,
-					       '__repeat'(0, infinity, 'c-wsp'()),
-					       concatenation()]))]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2] = _YY, _T1} ->
-		  try case [Alt || [_, _, _, Alt] <- _YY2] of
-			[] -> _YY1;
-			Alts -> #alt{alts = [_YY1 | Alts]}
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'([concatenation(),
+                           '__repeat'(0, infinity,
+                                      '__seq'(['__repeat'(0, infinity, 'c-wsp'()),
+                                               fun ([47 | Tl]) -> {ok, 47, Tl};
+                                                   (_) -> fail
+                                               end,
+                                               '__repeat'(0, infinity, 'c-wsp'()),
+                                               concatenation()]))]),
+            case __P(T) of
+              {ok, [_YY1, _YY2] = _YY, _T1} ->
+                  try case [Alt || [_, _, _, Alt] <- _YY2] of
+                        [] -> _YY1;
+                        Alts -> #alt{alts = [_YY1 | Alts]}
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 concatenation() ->
     fun (T) ->
-	    __P = '__seq'([repetition(),
-			   '__repeat'(0, infinity,
-				      '__seq'(['__repeat'(1, infinity, 'c-wsp'()),
-					       repetition()]))]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2] = _YY, _T1} ->
-		  try case [Rule || [_, Rule] <- _YY2] of
-			[] -> _YY1;
-			More -> #seq{elements = [_YY1 | More]}
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'([repetition(),
+                           '__repeat'(0, infinity,
+                                      '__seq'(['__repeat'(1, infinity, 'c-wsp'()),
+                                               repetition()]))]),
+            case __P(T) of
+              {ok, [_YY1, _YY2] = _YY, _T1} ->
+                  try case [Rule || [_, Rule] <- _YY2] of
+                        [] -> _YY1;
+                        More -> #seq{elements = [_YY1 | More]}
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 repetition() ->
     fun (T) ->
-	    __P = '__seq'(['__repeat'(0, 1, repeat()), element()]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2] = _YY, _T1} ->
-		  try case _YY1 of
-			[{Min, Max}] ->
-			    #repeat{min = Min, max = Max, body = _YY2};
-			[] -> _YY2
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'(['__repeat'(0, 1, repeat()), element()]),
+            case __P(T) of
+              {ok, [_YY1, _YY2] = _YY, _T1} ->
+                  try case _YY1 of
+                        [{Min, Max}] ->
+                            #repeat{min = Min, max = Max, body = _YY2};
+                        [] -> _YY2
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 repeat() ->
     fun (T) ->
-	    __P = '__alt'(['__seq'(['__repeat'(0, infinity,
-					       'DIGIT'()),
-				    fun ([42 | Tl]) -> {ok, 42, Tl};
-					(_) -> fail
-				    end,
-				    '__repeat'(0, infinity, 'DIGIT'())]),
-			   '__repeat'(1, infinity, 'DIGIT'())]),
-	    case __P(T) of
-	      {ok, _YY, _T1} ->
-		  try case _YY of
-			[[], $*, []] -> {0, infinity};
-			[Min, $*, []] -> {list_to_integer(Min), infinity};
-			[[], $*, Max] -> {0, list_to_integer(Max)};
-			[Min, $*, Max] ->
-			    {list_to_integer(Min), list_to_integer(Max)};
-			Number ->
-			    {list_to_integer(Number), list_to_integer(Number)}
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__alt'(['__seq'(['__repeat'(0, infinity,
+                                               'DIGIT'()),
+                                    fun ([42 | Tl]) -> {ok, 42, Tl};
+                                        (_) -> fail
+                                    end,
+                                    '__repeat'(0, infinity, 'DIGIT'())]),
+                           '__repeat'(1, infinity, 'DIGIT'())]),
+            case __P(T) of
+              {ok, _YY, _T1} ->
+                  try case _YY of
+                        [[], $*, []] -> {0, infinity};
+                        [Min, $*, []] -> {list_to_integer(Min), infinity};
+                        [[], $*, Max] -> {0, list_to_integer(Max)};
+                        [Min, $*, Max] ->
+                            {list_to_integer(Min), list_to_integer(Max)};
+                        Number ->
+                            {list_to_integer(Number), list_to_integer(Number)}
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 element() ->
     '__alt'([rulename(), group(), option(), 'char-val'(),
-	     'num-val'(), 'prose-val'()]).
+             'num-val'(), 'prose-val'()]).
 
 group() ->
     fun (T) ->
-	    __P = '__seq'([fun ([40 | Tl]) -> {ok, 40, Tl};
-			       (_) -> fail
-			   end,
-			   '__repeat'(0, infinity, 'c-wsp'()), alternation(),
-			   '__repeat'(0, infinity, 'c-wsp'()),
-			   fun ([41 | Tl]) -> {ok, 41, Tl};
-			       (_) -> fail
-			   end]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3, _YY4, _YY5] = _YY, _T1} ->
-		  {ok, _YY3, _T1};
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([40 | Tl]) -> {ok, 40, Tl};
+                               (_) -> fail
+                           end,
+                           '__repeat'(0, infinity, 'c-wsp'()), alternation(),
+                           '__repeat'(0, infinity, 'c-wsp'()),
+                           fun ([41 | Tl]) -> {ok, 41, Tl};
+                               (_) -> fail
+                           end]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3, _YY4, _YY5] = _YY, _T1} ->
+                  {ok, _YY3, _T1};
+              fail -> fail
+            end
     end.
 
 option() ->
     fun (T) ->
-	    __P = '__seq'([fun ([91 | Tl]) -> {ok, 91, Tl};
-			       (_) -> fail
-			   end,
-			   '__repeat'(0, infinity, 'c-wsp'()), alternation(),
-			   '__repeat'(0, infinity, 'c-wsp'()),
-			   fun ([93 | Tl]) -> {ok, 93, Tl};
-			       (_) -> fail
-			   end]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3, _YY4, _YY5] = _YY, _T1} ->
-		  {ok, {repeat, 0, 1, _YY3}, _T1};
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([91 | Tl]) -> {ok, 91, Tl};
+                               (_) -> fail
+                           end,
+                           '__repeat'(0, infinity, 'c-wsp'()), alternation(),
+                           '__repeat'(0, infinity, 'c-wsp'()),
+                           fun ([93 | Tl]) -> {ok, 93, Tl};
+                               (_) -> fail
+                           end]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3, _YY4, _YY5] = _YY, _T1} ->
+                  {ok, {repeat, 0, 1, _YY3}, _T1};
+              fail -> fail
+            end
     end.
 
 'char-val'() ->
     fun (T) ->
-	    __P = '__seq'(['DQUOTE'(),
-			   '__repeat'(0, infinity,
-				      fun ([C | Tl]) when (C >= 35) and (C =< 126) ->
-					      {ok, C, Tl};
-					  ([C | Tl]) when (C >= 32) and (C =< 33) ->
-					      {ok, C, Tl};
-					  (_) -> fail
-				      end),
-			   'DQUOTE'()]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
-		  try F = fun (Char) ->
-				  case {string:to_lower(Char), string:to_upper(Char)} of
-				    {Char, Char} -> #char_val{value = Char};
-				    {Low, Up} ->
-					#char_alt{alts =
-						      [#char_val{value = Low},
-						       #char_val{value = Up}]}
-				  end
-			  end,
-		      case _YY2 of
-			[C] -> F(C);
-			Chars -> #char_seq{elements = [F(C) || C <- Chars]}
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'(['DQUOTE'(),
+                           '__repeat'(0, infinity,
+                                      fun ([C | Tl]) when (C >= 35) and (C =< 126) ->
+                                              {ok, C, Tl};
+                                          ([C | Tl]) when (C >= 32) and (C =< 33) ->
+                                              {ok, C, Tl};
+                                          (_) -> fail
+                                      end),
+                           'DQUOTE'()]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
+                  try F = fun (Char) ->
+                                  case {string:to_lower(Char), string:to_upper(Char)} of
+                                    {Char, Char} -> #char_val{value = Char};
+                                    {Low, Up} ->
+                                        #char_alt{alts =
+                                                      [#char_val{value = Low},
+                                                       #char_val{value = Up}]}
+                                  end
+                          end,
+                      case _YY2 of
+                        [C] -> F(C);
+                        Chars -> #char_seq{elements = [F(C) || C <- Chars]}
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 'num-val'() ->
     fun (T) ->
-	    __P = '__seq'([fun ([37 | Tl]) -> {ok, 37, Tl};
-			       (_) -> fail
-			   end,
-			   '__alt'(['bin-val'(), 'dec-val'(), 'hex-val'()])]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2] = _YY, _T1} -> {ok, _YY2, _T1};
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([37 | Tl]) -> {ok, 37, Tl};
+                               (_) -> fail
+                           end,
+                           '__alt'(['bin-val'(), 'dec-val'(), 'hex-val'()])]),
+            case __P(T) of
+              {ok, [_YY1, _YY2] = _YY, _T1} -> {ok, _YY2, _T1};
+              fail -> fail
+            end
     end.
 
 'bin-val'() ->
     fun (T) ->
-	    __P = '__seq'([fun ([C | Tl]) when C == 98 ->
-				   {ok, C, Tl};
-			       ([C | Tl]) when C == 66 -> {ok, C, Tl};
-			       (_) -> fail
-			   end,
-			   '__repeat'(1, infinity, 'BIT'()),
-			   '__repeat'(0, 1,
-				      '__alt'(['__repeat'(1, infinity,
-							  '__seq'([fun ([46 | Tl]) ->
-									   {ok, 46, Tl};
-								       (_) -> fail
-								   end,
-								   '__repeat'(1, infinity,
-									      'BIT'())])),
-					       '__seq'([fun ([45 | Tl]) -> {ok, 45, Tl};
-							    (_) -> fail
-							end,
-							'__repeat'(1, infinity,
-								   'BIT'())])]))]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
-		  try First = bin_to_int(_YY2),
-		      case _YY3 of
-			[] -> #char_val{value = First};
-			[[$-, To]] ->
-			    #char_range{from = First, to = bin_to_int(To)};
-			[Vals] ->
-			    #char_seq{elements =
-					  [#char_val{value = First} | [#char_val{value =
-										     bin_to_int(Val)}
-								       || [$., Val] <- Vals]]}
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([C | Tl]) when C == 98 ->
+                                   {ok, C, Tl};
+                               ([C | Tl]) when C == 66 -> {ok, C, Tl};
+                               (_) -> fail
+                           end,
+                           '__repeat'(1, infinity, 'BIT'()),
+                           '__repeat'(0, 1,
+                                      '__alt'(['__repeat'(1, infinity,
+                                                          '__seq'([fun ([46 | Tl]) ->
+                                                                           {ok, 46, Tl};
+                                                                       (_) -> fail
+                                                                   end,
+                                                                   '__repeat'(1, infinity,
+                                                                              'BIT'())])),
+                                               '__seq'([fun ([45 | Tl]) -> {ok, 45, Tl};
+                                                            (_) -> fail
+                                                        end,
+                                                        '__repeat'(1, infinity,
+                                                                   'BIT'())])]))]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
+                  try First = bin_to_int(_YY2),
+                      case _YY3 of
+                        [] -> #char_val{value = First};
+                        [[$-, To]] ->
+                            #char_range{from = First, to = bin_to_int(To)};
+                        [Vals] ->
+                            #char_seq{elements =
+                                          [#char_val{value = First} | [#char_val{value =
+                                                                                     bin_to_int(Val)}
+                                                                       || [$., Val] <- Vals]]}
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 'dec-val'() ->
     fun (T) ->
-	    __P = '__seq'([fun ([C | Tl]) when C == 100 ->
-				   {ok, C, Tl};
-			       ([C | Tl]) when C == 68 -> {ok, C, Tl};
-			       (_) -> fail
-			   end,
-			   '__repeat'(1, infinity, 'DIGIT'()),
-			   '__repeat'(0, 1,
-				      '__alt'(['__repeat'(1, infinity,
-							  '__seq'([fun ([46 | Tl]) ->
-									   {ok, 46, Tl};
-								       (_) -> fail
-								   end,
-								   '__repeat'(1, infinity,
-									      'DIGIT'())])),
-					       '__seq'([fun ([45 | Tl]) -> {ok, 45, Tl};
-							    (_) -> fail
-							end,
-							'__repeat'(1, infinity,
-								   'DIGIT'())])]))]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
-		  try First = list_to_integer(_YY2),
-		      case _YY3 of
-			[] -> #char_val{value = First};
-			[[$-, To]] ->
-			    #char_range{from = First, to = list_to_integer(To)};
-			[Vals] ->
-			    #char_seq{elements =
-					  [#char_val{value = First} | [#char_val{value =
-										     list_to_integer(Val)}
-								       || [$., Val] <- Vals]]}
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([C | Tl]) when C == 100 ->
+                                   {ok, C, Tl};
+                               ([C | Tl]) when C == 68 -> {ok, C, Tl};
+                               (_) -> fail
+                           end,
+                           '__repeat'(1, infinity, 'DIGIT'()),
+                           '__repeat'(0, 1,
+                                      '__alt'(['__repeat'(1, infinity,
+                                                          '__seq'([fun ([46 | Tl]) ->
+                                                                           {ok, 46, Tl};
+                                                                       (_) -> fail
+                                                                   end,
+                                                                   '__repeat'(1, infinity,
+                                                                              'DIGIT'())])),
+                                               '__seq'([fun ([45 | Tl]) -> {ok, 45, Tl};
+                                                            (_) -> fail
+                                                        end,
+                                                        '__repeat'(1, infinity,
+                                                                   'DIGIT'())])]))]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
+                  try First = list_to_integer(_YY2),
+                      case _YY3 of
+                        [] -> #char_val{value = First};
+                        [[$-, To]] ->
+                            #char_range{from = First, to = list_to_integer(To)};
+                        [Vals] ->
+                            #char_seq{elements =
+                                          [#char_val{value = First} | [#char_val{value =
+                                                                                     list_to_integer(Val)}
+                                                                       || [$., Val] <- Vals]]}
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 'hex-val'() ->
     fun (T) ->
-	    __P = '__seq'([fun ([C | Tl]) when C == 120 ->
-				   {ok, C, Tl};
-			       ([C | Tl]) when C == 88 -> {ok, C, Tl};
-			       (_) -> fail
-			   end,
-			   '__repeat'(1, infinity, 'HEXDIG'()),
-			   '__repeat'(0, 1,
-				      '__alt'(['__repeat'(1, infinity,
-							  '__seq'([fun ([46 | Tl]) ->
-									   {ok, 46, Tl};
-								       (_) -> fail
-								   end,
-								   '__repeat'(1, infinity,
-									      'HEXDIG'())])),
-					       '__seq'([fun ([45 | Tl]) -> {ok, 45, Tl};
-							    (_) -> fail
-							end,
-							'__repeat'(1, infinity,
-								   'HEXDIG'())])]))]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
-		  try First = hex_to_int(_YY2),
-		      case _YY3 of
-			[] -> #char_val{value = First};
-			[[$-, To]] ->
-			    #char_range{from = First, to = hex_to_int(To)};
-			[Vals] ->
-			    #char_seq{elements =
-					  [#char_val{value = First} | [#char_val{value =
-										     hex_to_int(Val)}
-								       || [$., Val] <- Vals]]}
-		      end
-		  of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([C | Tl]) when C == 120 ->
+                                   {ok, C, Tl};
+                               ([C | Tl]) when C == 88 -> {ok, C, Tl};
+                               (_) -> fail
+                           end,
+                           '__repeat'(1, infinity, 'HEXDIG'()),
+                           '__repeat'(0, 1,
+                                      '__alt'(['__repeat'(1, infinity,
+                                                          '__seq'([fun ([46 | Tl]) ->
+                                                                           {ok, 46, Tl};
+                                                                       (_) -> fail
+                                                                   end,
+                                                                   '__repeat'(1, infinity,
+                                                                              'HEXDIG'())])),
+                                               '__seq'([fun ([45 | Tl]) -> {ok, 45, Tl};
+                                                            (_) -> fail
+                                                        end,
+                                                        '__repeat'(1, infinity,
+                                                                   'HEXDIG'())])]))]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
+                  try First = hex_to_int(_YY2),
+                      case _YY3 of
+                        [] -> #char_val{value = First};
+                        [[$-, To]] ->
+                            #char_range{from = First, to = hex_to_int(To)};
+                        [Vals] ->
+                            #char_seq{elements =
+                                          [#char_val{value = First} | [#char_val{value =
+                                                                                     hex_to_int(Val)}
+                                                                       || [$., Val] <- Vals]]}
+                      end
+                  of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 'prose-val'() ->
     fun (T) ->
-	    __P = '__seq'([fun ([60 | Tl]) -> {ok, 60, Tl};
-			       (_) -> fail
-			   end,
-			   '__repeat'(0, infinity,
-				      fun ([C | Tl]) when (C >= 63) and (C =< 126) ->
-					      {ok, C, Tl};
-					  ([C | Tl]) when (C >= 32) and (C =< 61) ->
-					      {ok, C, Tl};
-					  (_) -> fail
-				      end),
-			   fun ([62 | Tl]) -> {ok, 62, Tl};
-			       (_) -> fail
-			   end]),
-	    case __P(T) of
-	      {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
-		  try {'prose-val', lists:flatten(_YY2)} of
-		    __Ret -> {ok, __Ret, _T1}
-		  catch
-		    fail -> fail
-		  end;
-	      fail -> fail
-	    end
+            __P = '__seq'([fun ([60 | Tl]) -> {ok, 60, Tl};
+                               (_) -> fail
+                           end,
+                           '__repeat'(0, infinity,
+                                      fun ([C | Tl]) when (C >= 63) and (C =< 126) ->
+                                              {ok, C, Tl};
+                                          ([C | Tl]) when (C >= 32) and (C =< 61) ->
+                                              {ok, C, Tl};
+                                          (_) -> fail
+                                      end),
+                           fun ([62 | Tl]) -> {ok, 62, Tl};
+                               (_) -> fail
+                           end]),
+            case __P(T) of
+              {ok, [_YY1, _YY2, _YY3] = _YY, _T1} ->
+                  try {'prose-val', lists:flatten(_YY2)} of
+                    __Ret -> {ok, __Ret, _T1}
+                  catch
+                    fail -> fail
+                  end;
+              fail -> fail
+            end
     end.
 
 '__alt'(Ps) -> fun (T) -> '__do_alt'(Ps, T) end.
@@ -523,11 +523,11 @@ option() ->
     case P(T) of
       {ok, R1, T1} when Max == Found + 1 -> {ok, [R1], T1};
       {ok, R1, T1} ->
-	  case '__do_repeat'(Min, Max, P, Found + 1, T1) of
-	    {ok, R2, T2} -> {ok, [R1 | R2], T2};
-	    fail when Found >= Min -> {ok, [R1], T1};
-	    fail -> fail
-	  end;
+          case '__do_repeat'(Min, Max, P, Found + 1, T1) of
+            {ok, R2, T2} -> {ok, [R1 | R2], T2};
+            fail when Found >= Min -> {ok, [R1], T1};
+            fail -> fail
+          end;
       fail when Found >= Min -> {ok, [], T};
       fail -> fail
     end.
@@ -537,10 +537,10 @@ option() ->
 '__do_seq'([P | Ps], T) ->
     case P(T) of
       {ok, R1, T1} ->
-	  case '__do_seq'(Ps, T1) of
-	    {ok, R2, T2} -> {ok, [R1 | R2], T2};
-	    fail -> fail
-	  end;
+          case '__do_seq'(Ps, T1) of
+            {ok, R2, T2} -> {ok, [R1 | R2], T2};
+            fail -> fail
+          end;
       fail -> fail
     end;
 '__do_seq'([], T) -> {ok, [], T}.
diff --git a/src/abnfc_rfc4234.hrl b/src/abnfc_rfc4234.hrl
index f32569e..46a8c12 100644
--- a/src/abnfc_rfc4234.hrl
+++ b/src/abnfc_rfc4234.hrl
@@ -1,30 +1,30 @@
 -import(abnfc,[erlangcode/0]).
 -import(rfc4234_core, ['ALPHA'/0,
-		       'DIGIT'/0,
-		       'WSP'/0,
-		       'CRLF'/0,
-		       'VCHAR'/0,
-		       'DQUOTE'/0,
-		       'BIT'/0,
-		       'HEXDIG'/0]).
+                       'DIGIT'/0,
+                       'WSP'/0,
+                       'CRLF'/0,
+                       'VCHAR'/0,
+                       'DQUOTE'/0,
+                       'BIT'/0,
+                       'HEXDIG'/0]).
 
--include("abnfc_ast.hrl").
+-include("../include/abnfc_ast.hrl").
 
 hex_to_int(Ds) ->
     lists:foldl(fun(D,Acc) ->
-			Dint = case D of
-				   D when D >= $0, D =< $9 ->
-				       D-$0;
-				   D when D >= $a, D =< $f ->
-				       D-$a+10;
-				   D when D >= $A, D =< $F ->
-				       D-$A+10
-			       end,
-			Acc*16 + Dint
-		end, 0, Ds).
+                        Dint = case D of
+                                   D when D >= $0, D =< $9 ->
+                                       D-$0;
+                                   D when D >= $a, D =< $f ->
+                                       D-$a+10;
+                                   D when D >= $A, D =< $F ->
+                                       D-$A+10
+                               end,
+                        Acc*16 + Dint
+                end, 0, Ds).
 
 bin_to_int(Ds) ->
     lists:foldl(fun(D,Acc) ->
-			Dint = D-$0,
-			Acc*2 + Dint
-		end, 0, Ds).
+                        Dint = D-$0,
+                        Acc*2 + Dint
+                end, 0, Ds).
diff --git a/src/rfc4234_core.abnf b/src/rfc4234_core.abnf
index b8910f0..0cabc79 100644
--- a/src/rfc4234_core.abnf
+++ b/src/rfc4234_core.abnf
@@ -29,4 +29,3 @@ SP             =  %x20
 VCHAR          =  %x21-7E
 
 WSP            =  SP/ HTAB
-
diff --git a/src/rfc4234_core.erl b/src/rfc4234_core.erl
index e68c15b..a02e017 100644
--- a/src/rfc4234_core.erl
+++ b/src/rfc4234_core.erl
@@ -5,9 +5,9 @@
 -module(rfc4234_core).
 
 -export(['ALPHA'/0, 'BIT'/0, 'CHAR'/0, 'CR'/0, 'CRLF'/0,
-	 'CTL'/0, 'DIGIT'/0, 'DQUOTE'/0, 'HEXDIG'/0, 'HTAB'/0,
-	 'LF'/0, 'LWSP'/0, 'OCTET'/0, 'SP'/0, 'VCHAR'/0, 'WSP'/0,
-	 decode/2]).
+         'CTL'/0, 'DIGIT'/0, 'DQUOTE'/0, 'HEXDIG'/0, 'HTAB'/0,
+         'LF'/0, 'LWSP'/0, 'OCTET'/0, 'SP'/0, 'VCHAR'/0, 'WSP'/0,
+         decode/2]).
 
 -include("rfc4234_core.hrl").
 
@@ -30,26 +30,26 @@ decode('WSP', Str) -> ('WSP'())(Str).
 
 'ALPHA'() ->
     fun ([C | Tl]) when (C >= 65) and (C =< 90) ->
-	    {ok, C, Tl};
-	([C | Tl]) when (C >= 97) and (C =< 122) -> {ok, C, Tl};
-	(_) -> fail
+            {ok, C, Tl};
+        ([C | Tl]) when (C >= 97) and (C =< 122) -> {ok, C, Tl};
+        (_) -> fail
     end.
 
 'BIT'() ->
     fun ([C | Tl]) when (C >= 48) and (C =< 49) ->
-	    {ok, C, Tl};
-	(_) -> fail
+            {ok, C, Tl};
+        (_) -> fail
     end.
 
 'CHAR'() ->
     fun ([C | Tl]) when (C >= 1) and (C =< 127) ->
-	    {ok, C, Tl};
-	(_) -> fail
+            {ok, C, Tl};
+        (_) -> fail
     end.
 
 'CR'() ->
     fun ([13 | Tl]) -> {ok, 13, Tl};
-	(_) -> fail
+        (_) -> fail
     end.
 
 'CRLF'() ->
@@ -57,78 +57,78 @@ decode('WSP', Str) -> ('WSP'())(Str).
 
 'CTL'() ->
     fun ([C | Tl]) when (C >= 0) and (C =< 31) ->
-	    {ok, C, Tl};
-	([C | Tl]) when C == 127 -> {ok, C, Tl};
-	(_) -> fail
+            {ok, C, Tl};
+        ([C | Tl]) when C == 127 -> {ok, C, Tl};
+        (_) -> fail
     end.
 
 'DIGIT'() ->
     fun ([C | Tl]) when (C >= 48) and (C =< 57) ->
-	    {ok, C, Tl};
-	(_) -> fail
+            {ok, C, Tl};
+        (_) -> fail
     end.
 
 'DQUOTE'() ->
     fun ([34 | Tl]) -> {ok, 34, Tl};
-	(_) -> fail
+        (_) -> fail
     end.
 
 'HEXDIG'() ->
     '__alt'(['DIGIT'(),
-	     fun ([C | Tl]) when C == 97 -> {ok, C, Tl};
-		 ([C | Tl]) when C == 65 -> {ok, C, Tl};
-		 (_) -> fail
-	     end,
-	     fun ([C | Tl]) when C == 98 -> {ok, C, Tl};
-		 ([C | Tl]) when C == 66 -> {ok, C, Tl};
-		 (_) -> fail
-	     end,
-	     fun ([C | Tl]) when C == 99 -> {ok, C, Tl};
-		 ([C | Tl]) when C == 67 -> {ok, C, Tl};
-		 (_) -> fail
-	     end,
-	     fun ([C | Tl]) when C == 100 -> {ok, C, Tl};
-		 ([C | Tl]) when C == 68 -> {ok, C, Tl};
-		 (_) -> fail
-	     end,
-	     fun ([C | Tl]) when C == 101 -> {ok, C, Tl};
-		 ([C | Tl]) when C == 69 -> {ok, C, Tl};
-		 (_) -> fail
-	     end,
-	     fun ([C | Tl]) when C == 102 -> {ok, C, Tl};
-		 ([C | Tl]) when C == 70 -> {ok, C, Tl};
-		 (_) -> fail
-	     end]).
+             fun ([C | Tl]) when C == 97 -> {ok, C, Tl};
+                 ([C | Tl]) when C == 65 -> {ok, C, Tl};
+                 (_) -> fail
+             end,
+             fun ([C | Tl]) when C == 98 -> {ok, C, Tl};
+                 ([C | Tl]) when C == 66 -> {ok, C, Tl};
+                 (_) -> fail
+             end,
+             fun ([C | Tl]) when C == 99 -> {ok, C, Tl};
+                 ([C | Tl]) when C == 67 -> {ok, C, Tl};
+                 (_) -> fail
+             end,
+             fun ([C | Tl]) when C == 100 -> {ok, C, Tl};
+                 ([C | Tl]) when C == 68 -> {ok, C, Tl};
+                 (_) -> fail
+             end,
+             fun ([C | Tl]) when C == 101 -> {ok, C, Tl};
+                 ([C | Tl]) when C == 69 -> {ok, C, Tl};
+                 (_) -> fail
+             end,
+             fun ([C | Tl]) when C == 102 -> {ok, C, Tl};
+                 ([C | Tl]) when C == 70 -> {ok, C, Tl};
+                 (_) -> fail
+             end]).
 
 'HTAB'() ->
     fun ([9 | Tl]) -> {ok, 9, Tl};
-	(_) -> fail
+        (_) -> fail
     end.
 
 'LF'() ->
     fun ([10 | Tl]) -> {ok, 10, Tl};
-	(_) -> fail
+        (_) -> fail
     end.
 
 'LWSP'() ->
     '__repeat'(0, infinity,
-	       '__alt'(['WSP'(), '__seq'(['CRLF'(), 'WSP'()])])).
+               '__alt'(['WSP'(), '__seq'(['CRLF'(), 'WSP'()])])).
 
 'OCTET'() ->
     fun ([C | Tl]) when (C >= 0) and (C =< 255) ->
-	    {ok, C, Tl};
-	(_) -> fail
+            {ok, C, Tl};
+        (_) -> fail
     end.
 
 'SP'() ->
     fun ([32 | Tl]) -> {ok, 32, Tl};
-	(_) -> fail
+        (_) -> fail
     end.
 
 'VCHAR'() ->
     fun ([C | Tl]) when (C >= 33) and (C =< 126) ->
-	    {ok, C, Tl};
-	(_) -> fail
+            {ok, C, Tl};
+        (_) -> fail
     end.
 
 'WSP'() -> '__alt'(['SP'(), 'HTAB'()]).
@@ -149,13 +149,12 @@ decode('WSP', Str) -> ('WSP'())(Str).
 
 '__do_repeat'(Min, Max, P, Found, T) ->
     case P(T) of
-      {ok, R1, T1} when Max == Found + 1 -> {ok, [R1], T1};
       {ok, R1, T1} ->
-	  case '__do_repeat'(Min, Max, P, Found + 1, T1) of
-	    {ok, R2, T2} -> {ok, [R1 | R2], T2};
-	    fail when Found >= Min -> {ok, [R1], T1};
-	    fail -> fail
-	  end;
+          case '__do_repeat'(Min, Max, P, Found + 1, T1) of
+            {ok, R2, T2} -> {ok, [R1 | R2], T2};
+            fail when Found >= Min -> {ok, [R1], T1};
+            fail -> fail
+          end;
       fail when Found >= Min -> {ok, [], T};
       fail -> fail
     end.
@@ -165,10 +164,10 @@ decode('WSP', Str) -> ('WSP'())(Str).
 '__do_seq'([P | Ps], T) ->
     case P(T) of
       {ok, R1, T1} ->
-	  case '__do_seq'(Ps, T1) of
-	    {ok, R2, T2} -> {ok, [R1 | R2], T2};
-	    fail -> fail
-	  end;
+          case '__do_seq'(Ps, T1) of
+            {ok, R2, T2} -> {ok, [R1 | R2], T2};
+            fail -> fail
+          end;
       fail -> fail
     end;
 '__do_seq'([], T) -> {ok, [], T}.
diff --git a/subdir.mk b/subdir.mk
deleted file mode 100755
index 6ea00be..0000000
--- a/subdir.mk
+++ /dev/null
@@ -1,16 +0,0 @@
-
-ifeq ($(SUBDIRS),)
-SUBDIRS	= src
-endif
-
-all clean:
-	@set -e ; \
-	  for d in $(SUBDIRS) ; do \
-	    if [ -f $$d/Makefile ]; then \
-              ( cd $$d && $(MAKE) $@ ) || exit 1 ; \
-            fi ; \
-	  done
-
-docs:
-	erl -noshell -pa $(BINDIR) -run edoc_run application \
-            "'$(APPNAME)'" '"."' -s init stop
diff --git a/vsn.mk b/vsn.mk
deleted file mode 100755
index e3cd7d6..0000000
--- a/vsn.mk
+++ /dev/null
@@ -1 +0,0 @@
-ABNFC_VSN=0.3